def foo(args)
  args.to_a.join(',')
end

def foo(args)
  [*args].join(',')
end

require 'active_yahoo'
y = ActiveYahoo::WebSearch.new(‘YOUR_APP_ID’, ‘ruby’, { :results => 2 })
y.result.total_results_returned  # => 2
y.result.records[0].title  # => "Ruby-lang.org"
y.result.records.map { |r| r.url }
#  => ["http://www.ruby-lang.org/en",
#      "http://en.wikipedia.org/wiki/Ruby_programming_language"]

# Normal call chain
post.comments.first.commented_at
 
# Dynamically with send?  Have to call three times.
post.send(:comments).send(:first).send(:commented_at)

class Object
  def rsend(*args, &block)
    obj = self
    args.each do |a|
      b = (a.is_a?(Array) && a.last.is_a?(Proc) ? a.pop : block)
      obj = obj.__send__(*a, &b)
    end
    obj
  end
  alias_method :__rsend__, :rsend
end

post.rsend([:comments],[:first],[:commented_at])

post.rsend(:comments, :first, :commented_at)

the_date = [:comments, :first, :commented_at]
 
#...somewhere else in your code you've passed the_date along:
post.rsend(*the_date)

a = [0,1,2,3,4,5,6,7,8,9]
 
a.rsend([:slice, 2, 8]) #=> [2, 3, 4, 5, 6, 7, 8, 9]
 
a.rsend([:slice, 2, 8], [:slice, 1, 3]) #=> [3, 4, 5]

a.rsend([:map, (proc { |x| x*2 })])
  #=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
 
a.rsend([:map, (proc { |x| x*2 })],
        [:select, (proc { |x| x % 4 == 0})])
  #=> [0, 4, 8, 12, 16]

a.rsend(:map) { |x| x*2 }
  #=> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

a.rsend(:slice, 2, 8) # wrong, does not work like Object#send
 
a.rsend([:slice, 2, 8]) # right

a.rsend(:map, :map) { |x| x*2 }
  #=> [0, 4, 8, 12, 16, 20, 24, 28, 32, 36]
 
a.rsend(:map, [:map, (proc { |x| x+5 })], :map) { |x| x*2 }
  #=> [10, 14, 18, 22, 26, 30, 34, 38, 42, 46]
  #outer block was called on first and third :map

class Comment < ActiveRecord::Base
#...
  def before_save
    self.text = self.text.strip_tags.auto_link.simple_format
  end
end

# ActionView Text Helpers are great!
# Let's extend the String class to allow us to call
# some of these methods directly on a String.
# Note:
#  - cycle-related methods are not included
#  - concat is not included
#  - pluralize is not included because it is in
#       ActiveSupport String extensions already
#       (though they differ).
#  - markdown requires BlueCloth
#  - textilize methods require RedCloth
# Example:
# "<b>coolness</b>".strip_tags -> "coolness"
 
require 'singleton'
 
# Singleton to be called in wrapper module
class TextHelperSingleton
  include Singleton
  include ActionView::Helpers::TextHelper
  include ActionView::Helpers::TagHelper #tag_options needed by auto_link
end
 
# Wrapper module
module MyExtensions #:nodoc:
  module CoreExtensions #:nodoc:
    module String #:nodoc:
      module TextHelper
 
        def auto_link(link = :all, href_options = {}, &block)
          TextHelperSingleton.instance.auto_link(self, link, href_options, &block)
        end
 
        def excerpt(phrase, radius = 100, excerpt_string = "...")
          TextHelperSingleton.instance.excerpt(self, phrase, radius, excerpt_string)
        end
 
        def highlight(phrase, highlighter = '<strong class="highlight">\1</strong>')
          TextHelperSingleton.instance.highlight(self, phrase, highlighter)
        end
 
        begin
          require_library_or_gem 'bluecloth'
 
          def markdown
            TextHelperSingleton.instance.markdown(self)
          end
        rescue LoadError
          # do nothing.  method will be undefined
        end
 
        def sanitize
          TextHelperSingleton.instance.sanitize(self)
        end
 
        def simple_format
          TextHelperSingleton.instance.simple_format(self)
        end
 
        def strip_tags
          TextHelperSingleton.instance.strip_tags(self)
        end
 
        begin
          require_library_or_gem 'redcloth'
 
          def textilize
            TextHelperSingleton.instance.textilize(self)
          end
 
          def textilize_without_paragraph
            TextHelperSingleton.instance.textilize_without_paragraph(self)
          end
        rescue LoadError
          # do nothing.  methods will be undefined
        end
 
        def truncate(length = 30, truncate_string = "...")
          TextHelperSingleton.instance.truncate(self, length, truncate_string)
        end
 
        def word_wrap(line_width = 80)
          TextHelperSingleton.instance.word_wrap(self, line_width)
        end
 
      end
    end
  end
end
 
# extend String with the TextHelper functions
class String #:nodoc:
  include MyExtensions::CoreExtensions::String::TextHelper
end