module ActionDispatch::Routing::PolymorphicRoutes

def action_prefix(options) 

def action_prefix(options)
  options[:action] ? "#{options[:action]}_" : ''
end

def build_named_route_call(records, inflection, options = {}) 

def build_named_route_call(records, inflection, options = {})
  if records.is_a?(Array)
    record = records.pop
    route = records.map do |parent|
      if parent.is_a?(Symbol) || parent.is_a?(String)
        parent
      else
        ActiveModel::Naming.singular_route_key(parent)
      end
    end
  else
    record = extract_record(records)
    route  = []
  end
  if record.is_a?(Symbol) || record.is_a?(String)
    route << record
  elsif record
    if inflection == :singular
      route << ActiveModel::Naming.singular_route_key(record)
    else
      route << ActiveModel::Naming.route_key(record)
    end
  else
    raise ArgumentError, "Nil location provided. Can't build URI."
  end
  route << routing_type(options)
  action_prefix(options) + route.join("_")
end

def extract_record(record_or_hash_or_array) 

def extract_record(record_or_hash_or_array)
  case record_or_hash_or_array
    when Array; record_or_hash_or_array.last
    when Hash;  record_or_hash_or_array[:id]
    else        record_or_hash_or_array
  end
end

def polymorphic_path(record_or_hash_or_array, options = {})

polymorphic_url with :routing_type => :path.
Returns the path component of a URL for the given record. It uses 
def polymorphic_path(record_or_hash_or_array, options = {})
  polymorphic_url(record_or_hash_or_array, options.merge(:routing_type => :path))
end

def polymorphic_url(record_or_hash_or_array, options = {})


polymorphic_url(Comment) # same as comments_url()
# the class of a record will also map to the collection

polymorphic_url(record) # same as comments_url()
record = Comment.new
# it recognizes new records and maps to the collection

polymorphic_url(record) # same as comment_url(record)
# a Comment record

polymorphic_url(record) # same as article_url(record)
# an Article record

==== Examples

Default is :url.
* :routing_type - Allowed values are :path or :url.
:new or :edit. Default is no prefix.
* :action - Specifies the action prefix for the named route:

==== Options

polymorphic_url(Comment) # => "http://example.com/comments"
polymorphic_url([user, :blog, post]) # => "http://example.com/users/1/blog/posts/1"
polymorphic_url([:admin, blog, post]) # => "http://example.com/admin/blogs/1/posts/1"
polymorphic_url([blog, post]) # => "http://example.com/blogs/1/posts/1"
polymorphic_url(post) # => "http://example.com/posts/1"
# calls post_url(post)

resulting URL string. For example:
Constructs a call to a named RESTful route for the given record and returns the 
def polymorphic_url(record_or_hash_or_array, options = {})
  if record_or_hash_or_array.kind_of?(Array)
    record_or_hash_or_array = record_or_hash_or_array.compact
    if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
      proxy = record_or_hash_or_array.shift
    end
    record_or_hash_or_array = record_or_hash_or_array[0] if record_or_hash_or_array.size == 1
  end
  record = extract_record(record_or_hash_or_array)
  record = record.to_model if record.respond_to?(:to_model)
  args = Array === record_or_hash_or_array ?
    record_or_hash_or_array.dup :
    [ record_or_hash_or_array ]
  inflection = if options[:action] && options[:action].to_s == "new"
    args.pop
    :singular
  elsif (record.respond_to?(:persisted?) && !record.persisted?)
    args.pop
    :plural
  elsif record.is_a?(Class)
    args.pop
    :plural
  else
    :singular
  end
  args.delete_if {|arg| arg.is_a?(Symbol) || arg.is_a?(String)}
  named_route = build_named_route_call(record_or_hash_or_array, inflection, options)
  url_options = options.except(:action, :routing_type)
  unless url_options.empty?
    args.last.kind_of?(Hash) ? args.last.merge!(url_options) : args << url_options
  end
  (proxy || self).send(named_route, *args)
end

def routing_type(options) 

def routing_type(options)
  options[:routing_type] || :url
end