bangmyhead.com

cd $project
ruby script/generate rspec

emacs $project/stories/display_article_with_content_story.rb

cd $project
export RAILS_ENV=test && rake db:migrate
ruby stories/display_article_with_content_story.rb

require File.expand_path(File.dirname(__FILE__) + "/helper")

Story "Display an article", %{
     As a user
     I want to view an article
     So that I can read its contents easily
  }, :type => RailsStory do


  Scenario "anonymous user" do

    Given "there is the following article in the system", "Article Numero Unero" do | title |
      article = Article.create(:title => title )
      @article_id = article.id
    end

    Given "this article contains a note", @article_id, "some note contents" do | article_id, note_contents |
      note = Note.create(:title => "My Note", :description => note_contents)
      ArticleSection.create( :article_id => @article_id, :content_id => note.id, :content_type => note.content_type)
    end

    Given "this article contains a link", @article_id, "http://some.domain.com" do | article_id, url |
      link = Link.create(:title => "My Link", :url => url )
      ArticleSection.create( :article_id => article_id, :content_id => link.id, :content_type => link.content_type)
    end

    Then  "we do not know yet, well just jump into debugger mode and have a look around", @article_id do | article_id |
      require "rubygems"; require "ruby-debug"; debugger 
      # The following line was added because here the debugger is the last statement and it will load with
      # out the test environment we've just created
      false
    end

  end
end

gem instal ruby-debug

it "should find note, given id" do
      note_id = 1
      do_get note_id
      Note.should_receive(:find).with(note_id).and_return(mock_note)
      get :edit 1
      require "rubygems"; require "ruby-debug"; debugger      
    end

(rdb:1) p note_id
1
(rdb:1) p params[:id]
"1"

myobj.name = tim

eval myobj.name = tim

set autoeval

set autolist

set autolist
set autoeval
set autoreload
set forcestep

# Install rspec and rspec_on_rails plugins
cd $project
ruby script/plugin install <a href="http://rspec.rubyforge.org/svn/tags/CURRENT/rspec">http://rspec.rubyforge.org/svn/tags/CURRENT/rspec</a>
ruby script/plugin install <a href="http://rspec.rubyforge.org/svn/tags/CURRENT/rspec_on_rails">http://rspec.rubyforge.org/svn/tags/CURRENT/rspec_on_rails</a></p>

# Once the plugin is installed, you must bootstrap your Rails app with RSpec.
cd $project
ruby script/generate rspec

require File.dirname(__FILE__) + '/../spec_helper'

script/generate rspec_scaffold blog title:string description:text

cd $project
# Test the behaviour of file app/models/credit_card.rb
# -fs makes the output be displayed in format called specdoc
script/spec -fs spec/models/credit_card_spec.rb

gem install ZenTest

cd $project
autotest

class Person < ActiveRecord::Base
has_many_polymorphs :ownables, :from => [:dvds, :cars, :books], :through => :ownerships
end

cd $PROJECT
ruby script/console development 

# You can download the latest docs from here.
wget -r -w 1 http://api.rubyonrails.com

class ArticleSection < ActiveRecord::Base
  belongs_to :article

  has_many :article_contents
#   This code is better than that below and it works
#   has_many :notes,    :through => :article_contents, :source => :contentizable,
#                       :source_type => 'Note'
  has_many :notes,    :through => :article_contents, :source => :note,
                      :conditions => "article_contents.contentizable_type = 'Note'"
  has_many :links,    :through => :article_contents, :source => :link,
                      :conditions => "article_contents.contentizable_type = 'Link'"

  def contentizables
  self.notes + self.links
 end

end

class ArticleContent < ActiveRecord::Base

   belongs_to :article_sections
   belongs_to :contentizable, :polymorphic => true
   #  This code is better than that below and works.
   #  has_many :notes, :as => :contentizable
   belongs_to :note,  :class_name => "Note",
                         :foreign_key => "contentizable_id"
   belongs_to :link,     :class_name => "Link",
                         :foreign_key => "contentizable_id"
end

class Note < ActiveRecord::Base
  has_many :article_contents, :as => :contentizable
  has_many :article_sections, :through => :article_contents
end

class Link < ActiveRecord::Base
  has_many :article_contents, :as => :contentizable
  has_many :article_sections, :through => :article_contents
end

>> a = Article.create(:title => "a1")
=> #<Article id: 12, title: "a1", published_at: nil, author: nil, keywords: nil, state: nil, created_at: "2008-05-01 18:07:41", updated_at: "2008-05-01 18:07:41">
>> as = ArticleSection.create(:article_id => a.id )
=> #<ArticleSection id: 11, article_id: 12, content_id: nil, content_type: nil, order: nil, created_at: "2008-05-01 18:07:44", updated_at: "2008-05-01 18:07:44">
>> as.notes
=> []
>> as.links
=> []
>> l = Link.create(:url => "some.domain.com")
=> #<Link id: 3, content_id: nil, url: "some.domain.com", description: nil, title: nil, contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 18:08:20", updated_at: "2008-05-01 18:08:20">
>> as.links << l
=> [#<Link id: 3, content_id: nil, url: "some.domain.com", description: nil, title: nil, contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 18:08:20", updated_at: "2008-05-01 18:08:20">]
>> n = Note.create(:description => "hi", :title => "something")
=> #<Note id: 9, description: "hi", contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 18:08:41", updated_at: "2008-05-01 18:08:41", title: "something", content_id: nil>
>> as.notes << n
=> [#<Note id: 9, description: "hi", contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 18:08:41", updated_at: "2008-05-01 18:08:41", title: "something", content_id: nil>]
>> as.article_contents
=> [#<ArticleContent id: 1, article_section_id: 11, contentizable_id: 3, contentizable_type: nil, created_at: "2008-05-01 18:08:25", updated_at: "2008-05-01 18:08:25">, #<ArticleContent id: 2, article_section_id: 11, contentizable_id: 9, contentizable_type: nil, created_at: "2008-05-01 18:08:49", updated_at: "2008-05-01 18:08:49">]
>> as.article_contents.length
=> 2

>> n = Note.create(:title => "t", :description => "d")
=> #<Note id: 14, description: "d", contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 19:08:46", updated_at: "2008-05-01 19:08:46", title: "t", content_id: nil>
>> as.notes << n
=> [#<Note id: 12, description: "d", contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 19:07:51", updated_at: "2008-05-01 19:07:51", title: "t", content_id: nil>, #<Note id: 13, description: "d", contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 19:08:06", updated_at: "2008-05-01 19:08:06", title: "t", content_id: nil>, #<Note id: 14, description: "d", contentizable_id: nil, contentizable_type: nil, created_at: "2008-05-01 19:08:46", updated_at: "2008-05-01 19:08:46", title: "t", content_id: nil>]
>> n.article_contents
=> [#<ArticleContent id: 6, article_section_id: 21, contentizable_id: 14, contentizable_type: "Note", created_at: "2008-05-01 19:08:50", updated_at: "2008-05-01 19:08:50">]

require 'utility_belt'


# Tracing irb
# http://blog.bleything.net/2006/12/11/tracing-method-execution


def enable_trace( event_regex = /^(call|return)/, class_regex = /IRB|Wirble|RubyLex|RubyToken/ )
  puts "Enabling method tracing with event regex #{event_regex.inspect} and class exclusion regex #{class_regex.inspect}"

  set_trace_func Proc.new{|event, file, line, id, binding, classname|
    printf "[%8s] %30s %30s (%s:%-2d)\n", event, id, classname, file, line if
      event          =~ event_regex and
      classname.to_s !~ class_regex
  }
  return
end

def disable_trace
  puts "Disabling method tracing"

  set_trace_func nil
end

# ------------------------------------------------------------------

# Wirble - Colors in irb
# http://pablotron.org/software/wirble/

# load libraries
require 'rubygems'
require 'wirble'

# start wirble (with color)
Wirble.init
Wirble.colorize

# ------------------------------------------------------------------

# Tab Completion
# http://whytheluckystiff.net/clog/ruby/tabCompletionInIRb.html
require 'irb/completion'

# ------------------------------------------------------------------

# simple irb prompt
IRB.conf[:PROMPT_MODE] = :SIMPLE

# ------------------------------------------------------------------

# Accessing rails helpers in console
# http://errtheblog.com/posts/41-real-console-helpers

def Object.method_added(method)
  return super(method) unless method == :helper
  (class<<self;self;end).send(:remove_method, :method_added)

  def helper(*helper_names)
    returning $helper_proxy ||= Object.new do |helper|
      helper_names.each { |h| helper.extend "#{h}_helper".classify.constantize }
    end
  end

  helper.instance_variable_set("@controller", ActionController::Integration::Session.new)

  def helper.method_missing(method, *args, &block)
    @controller.send(method, *args, &block) if @controller && method.to_s =~ /_path$|_url$/
  end

  helper :application rescue nil
end if ENV['RAILS_ENV']

# ------------------------------------------------------------------

# Command History
# http://blog.nicksieger.com/articles/2006/04/23/tweaking-irb

module Readline
  module History
    LOG = "#{ENV['HOME']}/.irb-history"

    def self.write_log(line)
      File.open(LOG, 'ab') {|f| f << "#{line}
"}
    end

    def self.start_session_log
      write_log("
# session start: #{Time.now}

")
      at_exit { write_log("
# session stop: #{Time.now}
") }
    end
  end

  alias :old_readline :readline
  def readline(*args)
    ln = old_readline(*args)
    begin
      History.write_log(ln)
    rescue
    end
    ln
  end
end

Readline::History.start_session_log

# ------------------------------------------------------------------

require 'irb/ext/save-history'
IRB.conf[:SAVE_HISTORY] = 10000
IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.irb-save-history"

#------------------------------------------------------------------


def ri arg
   puts `ri #{arg}`
end

class Module
   def ri(meth=nil)
     if meth
       if instance_methods(false).include? meth.to_s
         puts `ri #{self}##{meth}`
       else
         super
       end
     else
       puts `ri #{self}`
     end
   end
end

# ------------------------------------------------------------------

# http://woss.name/2006/07/12/using-the-shell-within-irb/

require 'shell'

# Override the command processor widget for inserting system commands so
# that it behaves more like path-processing: earlier commands take precedence.
require 'shell/command-processor'
module FixAddDelegateCommandToShell
  def self.extended(obj)
    class << obj
      alias_method :add_delegate_command_to_shell_override, :add_delegate_command_to_shell unless method_defined?(:add_delegate_command_to_shell_override)
      alias_method :add_delegate_command_to_shell, :add_delegate_command_to_shell_no_override
    end
  end

  def add_delegate_command_to_shell_no_override(id)
    id = id.intern if id.kind_of?(String)
    name = id.id2name
    if Shell.method_defined?(id) or Shell::Filter.method_defined?(id)
      Shell.notify "warn: Not overriding existing definition of Shell##{name}."
    else
      add_delegate_command_to_shell_override(id)
    end
  end
end
Shell::CommandProcessor.extend(FixAddDelegateCommandToShell)

# Allow Shell system commands to take :symbols too, to save a little typing.
require 'shell/system-command'
class Shell
  class SystemCommand
    alias_method :initialize_orig, :initialize
    def initialize(sh, command, *opts)
      opts.collect! {|opt| opt.to_s }
      initialize_orig sh, command, *opts
    end
  end
end

# Provide me with a shell inside IRB to save quitting and restarting, or
# finding that other terminal window.
def shell
  unless $shell
    Shell.install_system_commands '' # no prefix
    $shell = Shell.new
  end
  $shell
end

#------------------------------------------------------------------

# it loads a rails project into irb, useful if you really should have run ./script/console

def self.load_rails(from="./")
require File.expand_path(File.join(from,"config/boot"))
require File.join(RAILS_ROOT, 'config', 'environment')
end

# ------------------------------------------------------------------

# Iterative development in irb
# http://po-ru.com/diary/iterative-development-in-irb


# To use it, just type:

# loop_execute('myfile.rb')

# in irb. Control-C will return control to the regular irb shell.

def loop_execute(file)
  old_mtime = nil
  loop do
    # print("\e[sWaiting...")
    sleep(0.2) while (mtime = File.stat(file).mtime) == old_mtime
    # print("\e[u\e[K")
    begin
      r = eval(File.read(file))
      puts("=> #{r.inspect}")
    rescue IRB::Abort
      puts("Abort")
      return
    rescue Exception => e
      puts("#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
    end
    old_mtime = mtime
  end
end


# ------------------------------------------------------------------

class Object

  # p30 the rails way
  # set some environment variables, that are normally sent to 
  # the dispatcher.
  # then fool the dispatcher into thinking it is getting a request.
  #
  # The following command will return the contents of the webpage request
  # 
 # request( :controller => "pages", :action => 'show', :id => 'home')
  #
  def request(options = {})
    method = options.delete(:method) || :get
    options.reverse_merge!(:only_path => true)
    ENV['REQUEST_URI'] = app.url_for(options)
    ENV['REQUEST_METHOD'] = method.to_s
    Dispatcher.dispatch
  end
end

# ------------------------------------------------------------------


# pm object
# pm object, :more - shows all methods including base Object methods
# pm object, :more, /to/ - shows all methods filtered by regexp

# Coded by sebastian delmont



    ANSI_BOLD       = "\033[1m"
    ANSI_RESET      = "\033[0m"
    ANSI_LGRAY    = "\033[0;37m"
    ANSI_GRAY     = "\033[1;30m"

    def pm(obj, *options) # Print methods
      methods = obj.methods
      methods -= Object.methods unless options.include? :more
      filter = options.select {|opt| opt.kind_of? Regexp}.first
      methods = methods.select {|name| name =~ filter} if filter

      data = methods.sort.collect do |name|
        method = obj.method(name)
        if method.arity == 0
          args = "()"
        elsif method.arity > 0
          n = method.arity
          args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")})"
        elsif method.arity < 0
          n = -method.arity
          args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")}, ...)"
        end
        klass = $1 if method.inspect =~ /Method: (.*?)#/
        [name, args, klass]
      end
      max_name = data.collect {|item| item[0].size}.max
      max_args = data.collect {|item| item[1].size}.max
      data.each do |item| 
        print " #{ANSI_BOLD}#{item[0].rjust(max_name)}#{ANSI_RESET}"
        print "#{ANSI_GRAY}#{item[1].ljust(max_args)}#{ANSI_RESET}"
        print "   #{ANSI_LGRAY}#{item[2]}#{ANSI_RESET}\n"
      end
      data.size
    end


#------------------------------------------------------------------

# In honor of Labor Day, here's a hack that might save you some. I spend a lot of time in the Rails console, and most of that time I'm finding stuff. Typing find is so... laborious. But drop this in your ~/.irbrc file, and your work is made light.

# # Creates shortcut methods for finding models.
# def define_model_find_shortcuts
#   model_files = Dir.glob("app/models/**/*.rb")
#   table_names = model_files.map { |f| File.basename(f).split('.')[0..-2].join }
#   table_names.each do |table_name|
#     Object.instance_eval do
#       define_method(table_name) do |*args|
#         table_name.camelize.constantize.send(:find, *args)
#       end
#     end
#   end
# end

# # Called when the irb session is ready, after
# # the Rails goodies used above have been loaded.
# IRB.conf[:IRB_RC] = Proc.new { define_model_find_shortcuts }

# Install ri, RDoc, documentation
gem rdoc --all

# Generates RDOC documentation for the given $gemname
gem rdoc $gemname

# Start gem_server
> gem server
# Open web browser
firefox http://localhost:8808

# View the documentation for the method zip from the Enumerable class
ri Enumberable#zip

# View the documentation for the method gsub from the String class
ri -Tf ansi String#gsub

# Unset enviroment variable
unset RUBYOPT
# change to rubygems installation directory
cd /cygdrive/c/rubygems-1.0.1
# Install RubyGems
ruby setup.rb

# Install rails using gems
gem install rails

cd \cygdrive\c\mysql-5.0.51a
./configure
make install