backbone-queryparams-rails 0.0.1 → 0.0.2

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -1,209 +0,0 @@
-module ActionDispatch
-  module Routing
-    # Polymorphic URL helpers are methods for smart resolution to a named route call when
-    # given an Active Record model instance. They are to be used in combination with
-    # ActionController::Resources.
-    #
-    # These methods are useful when you want to generate correct URL or path to a RESTful
-    # resource without having to know the exact type of the record in question.
-    #
-    # Nested resources and/or namespaces are also supported, as illustrated in the example:
-    #
-    #   polymorphic_url([:admin, @article, @comment])
-    #
-    # results in:
-    #
-    #   admin_article_comment_url(@article, @comment)
-    #
-    # == Usage within the framework
-    #
-    # Polymorphic URL helpers are used in a number of places throughout the \Rails framework:
-    #
-    # * <tt>url_for</tt>, so you can use it with a record as the argument, e.g.
-    #   <tt>url_for(@article)</tt>;
-    # * ActionView::Helpers::FormHelper uses <tt>polymorphic_path</tt>, so you can write
-    #   <tt>form_for(@article)</tt> without having to specify <tt>:url</tt> parameter for the form
-    #   action;
-    # * <tt>redirect_to</tt> (which, in fact, uses <tt>url_for</tt>) so you can write
-    #   <tt>redirect_to(post)</tt> in your controllers;
-    # * ActionView::Helpers::AtomFeedHelper, so you don't have to explicitly specify URLs
-    #   for feed entries.
-    #
-    # == Prefixed polymorphic helpers
-    #
-    # In addition to <tt>polymorphic_url</tt> and <tt>polymorphic_path</tt> methods, a
-    # number of prefixed helpers are available as a shorthand to <tt>:action => "..."</tt>
-    # in options. Those are:
-    #
-    # * <tt>edit_polymorphic_url</tt>, <tt>edit_polymorphic_path</tt>
-    # * <tt>new_polymorphic_url</tt>, <tt>new_polymorphic_path</tt>
-    #
-    # Example usage:
-    #
-    #   edit_polymorphic_path(@post)              # => "/posts/1/edit"
-    #   polymorphic_path(@post, :format => :pdf)  # => "/posts/1.pdf"
-    #
-    # == Using with mounted engines
-    #
-    # If you use mounted engine, there is a possibility that you will need to use
-    # polymorphic_url pointing at engine's routes. To do that, just pass proxy used
-    # to reach engine's routes as a first argument:
-    #
-    # For example:
-    #
-    # polymorphic_url([blog, @post])  # it will call blog.post_path(@post)
-    # form_for([blog, @post])         # => "/blog/posts/1
-    #
-    module PolymorphicRoutes
-      # Constructs a call to a named RESTful route for the given record and returns the
-      # resulting URL string. For example:
-      #
-      #   # calls post_url(post)
-      #   polymorphic_url(post) # => "http://example.com/posts/1"
-      #   polymorphic_url([blog, post]) # => "http://example.com/blogs/1/posts/1"
-      #   polymorphic_url([:admin, blog, post]) # => "http://example.com/admin/blogs/1/posts/1"
-      #   polymorphic_url([user, :blog, post]) # => "http://example.com/users/1/blog/posts/1"
-      #   polymorphic_url(Comment) # => "http://example.com/comments"
-      #
-      # ==== Options
-      #
-      # * <tt>:action</tt> - Specifies the action prefix for the named route:
-      #   <tt>:new</tt> or <tt>:edit</tt>. Default is no prefix.
-      # * <tt>:routing_type</tt> - Allowed values are <tt>:path</tt> or <tt>:url</tt>.
-      #   Default is <tt>:url</tt>.
-      #
-      # ==== Examples
-      #
-      #   # an Article record
-      #   polymorphic_url(record)  # same as article_url(record)
-      #
-      #   # a Comment record
-      #   polymorphic_url(record)  # same as comment_url(record)
-      #
-      #   # it recognizes new records and maps to the collection
-      #   record = Comment.new
-      #   polymorphic_url(record)  # same as comments_url()
-      #
-      #   # the class of a record will also map to the collection
-      #   polymorphic_url(Comment) # same as comments_url()
-      #
-      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 = convert_to_model(record)
-
-        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
-
-        args.collect! { |a| convert_to_model(a) }
-
-        (proxy || self).send(named_route, *args)
-      end
-
-      # Returns the path component of a URL for the given record. It uses
-      # <tt>polymorphic_url</tt> with <tt>:routing_type => :path</tt>.
-      def polymorphic_path(record_or_hash_or_array, options = {})
-        polymorphic_url(record_or_hash_or_array, options.merge(:routing_type => :path))
-      end
-
-      %w(edit new).each do |action|
-        module_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{action}_polymorphic_url(record_or_hash, options = {})         # def edit_polymorphic_url(record_or_hash, options = {})
-            polymorphic_url(                                                  #   polymorphic_url(
-              record_or_hash,                                                 #     record_or_hash,
-              options.merge(:action => "#{action}"))                          #     options.merge(:action => "edit"))
-          end                                                                 # end
-                                                                              #
-          def #{action}_polymorphic_path(record_or_hash, options = {})        # def edit_polymorphic_path(record_or_hash, options = {})
-            polymorphic_url(                                                  #   polymorphic_url(
-              record_or_hash,                                                 #     record_or_hash,
-              options.merge(:action => "#{action}", :routing_type => :path))  #     options.merge(:action => "edit", :routing_type => :path))
-          end                                                                 # end
-        EOT
-      end
-
-      private
-        def action_prefix(options)
-          options[:action] ? "#{options[:action]}_" : ''
-        end
-
-        def convert_to_model(object)
-          object.respond_to?(:to_model) ? object.to_model : object
-        end
-
-        def routing_type(options)
-          options[:routing_type] || :url
-        end
-
-        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)
-          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
-    end
-  end
-end
-

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/routing/redirection.rb

@@ -1,131 +0,0 @@
-require 'action_dispatch/http/request'
-require 'active_support/core_ext/uri'
-require 'rack/utils'
-
-module ActionDispatch
-  module Routing
-    class Redirect # :nodoc:
-      attr_reader :status, :block
-
-      def initialize(status, block)
-        @status = status
-        @block  = block
-      end
-
-      def call(env)
-        req = Request.new(env)
-
-        uri = URI.parse(path(req.symbolized_path_parameters, req))
-        uri.scheme ||= req.scheme
-        uri.host   ||= req.host
-        uri.port   ||= req.port unless req.standard_port?
-
-        body = %(<html><body>You are being <a href="#{ERB::Util.h(uri.to_s)}">redirected</a>.</body></html>)
-
-        headers = {
-          'Location' => uri.to_s,
-          'Content-Type' => 'text/html',
-          'Content-Length' => body.length.to_s
-        }
-
-        [ status, headers, [body] ]
-      end
-
-      def path(params, request)
-        block.call params, request
-      end
-    end
-
-    class OptionRedirect < Redirect # :nodoc:
-      alias :options :block
-
-      def path(params, request)
-        url_options = {
-          :protocol => request.protocol,
-          :host     => request.host,
-          :port     => request.optional_port,
-          :path     => request.path,
-          :params   => request.query_parameters
-        }.merge options
-
-        if !params.empty? && url_options[:path].match(/%\{\w*\}/)
-          url_options[:path] = (url_options[:path] % escape_path(params))
-        end
-
-        ActionDispatch::Http::URL.url_for url_options
-      end
-
-      private
-        def escape_path(params)
-          Hash[params.map{ |k,v| [k, URI.parser.escape(v)] }]
-        end
-    end
-
-    module Redirection
-
-      # Redirect any path to another path:
-      #
-      #   match "/stories" => redirect("/posts")
-      #
-      # You can also use interpolation in the supplied redirect argument:
-      #
-      #   match 'docs/:article', :to => redirect('/wiki/%{article}')
-      #
-      # Alternatively you can use one of the other syntaxes:
-      #
-      # The block version of redirect allows for the easy encapsulation of any logic associated with
-      # the redirect in question. Either the params and request are supplied as arguments, or just
-      # params, depending of how many arguments your block accepts. A string is required as a
-      # return value.
-      #
-      #   match 'jokes/:number', :to => redirect do |params, request|
-      #     path = (params[:number].to_i.even? ? "/wheres-the-beef" : "/i-love-lamp")
-      #     "http://#{request.host_with_port}/#{path}"
-      #   end
-      #
-      # The options version of redirect allows you to supply only the parts of the url which need
-      # to change, it also supports interpolation of the path similar to the first example.
-      #
-      #   match 'stores/:name',       :to => redirect(:subdomain => 'stores', :path => '/%{name}')
-      #   match 'stores/:name(*all)', :to => redirect(:subdomain => 'stores', :path => '/%{name}%{all}')
-      #
-      # Finally, an object which responds to call can be supplied to redirect, allowing you to reuse
-      # common redirect routes. The call method must accept two arguments, params and request, and return
-      # a string.
-      #
-      #   match 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
-      #
-      def redirect(*args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        status  = options.delete(:status) || 301
-
-        return OptionRedirect.new(status, options) if options.any?
-
-        path = args.shift
-
-        block = lambda { |params, request|
-          (params.empty? || !path.match(/%\{\w*\}/)) ? path : (path % escape(params))
-        } if String === path
-
-        block = path if path.respond_to? :call
-
-        # :FIXME: remove in Rails 4.0
-        if block && block.respond_to?(:arity) && block.arity < 2
-          msg = "redirect blocks with arity of #{block.arity} are deprecated. Your block must take 2 parameters: the environment, and a request object"
-          ActiveSupport::Deprecation.warn msg
-          deprecated_block = block
-          block = lambda { |params, _| deprecated_block.call(params) }
-        end
-
-        raise ArgumentError, "redirection argument not supported" unless block
-
-        Redirect.new status, block
-      end
-
-      private
-        def escape(params)
-          Hash[params.map{ |k,v| [k, Rack::Utils.escape(v)] }]
-        end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/routing/route_set.rb

@@ -1,659 +0,0 @@
-require 'journey'
-require 'forwardable'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/hash/slice'
-require 'active_support/core_ext/module/remove_method'
-require 'action_controller/metal/exceptions'
-
-module ActionDispatch
-  module Routing
-    class RouteSet #:nodoc:
-      # Since the router holds references to many parts of the system
-      # like engines, controllers and the application itself, inspecting
-      # the route set can actually be really slow, therefore we default
-      # alias inspect to to_s.
-      alias inspect to_s
-
-      PARAMETERS_KEY = 'action_dispatch.request.path_parameters'
-
-      class Dispatcher #:nodoc:
-        def initialize(options={})
-          @defaults = options[:defaults]
-          @glob_param = options.delete(:glob)
-          @controllers = {}
-        end
-
-        def call(env)
-          params = env[PARAMETERS_KEY]
-          prepare_params!(params)
-
-          # Just raise undefined constant errors if a controller was specified as default.
-          unless controller = controller(params, @defaults.key?(:controller))
-            return [404, {'X-Cascade' => 'pass'}, []]
-          end
-
-          dispatch(controller, params[:action], env)
-        end
-
-        def prepare_params!(params)
-          normalize_controller!(params)
-          merge_default_action!(params)
-          split_glob_param!(params) if @glob_param
-        end
-
-        # If this is a default_controller (i.e. a controller specified by the user)
-        # we should raise an error in case it's not found, because it usually means
-        # a user error. However, if the controller was retrieved through a dynamic
-        # segment, as in :controller(/:action), we should simply return nil and
-        # delegate the control back to Rack cascade. Besides, if this is not a default
-        # controller, it means we should respect the @scope[:module] parameter.
-        def controller(params, default_controller=true)
-          if params && params.key?(:controller)
-            controller_param = params[:controller]
-            controller_reference(controller_param)
-          end
-        rescue NameError => e
-          raise ActionController::RoutingError, e.message, e.backtrace if default_controller
-        end
-
-      private
-
-        def controller_reference(controller_param)
-          controller_name = "#{controller_param.camelize}Controller"
-
-          unless controller = @controllers[controller_param]
-            controller = @controllers[controller_param] =
-              ActiveSupport::Dependencies.reference(controller_name)
-          end
-          controller.get(controller_name)
-        end
-
-        def dispatch(controller, action, env)
-          controller.action(action).call(env)
-        end
-
-        def normalize_controller!(params)
-          params[:controller] = params[:controller].underscore if params.key?(:controller)
-        end
-
-        def merge_default_action!(params)
-          params[:action] ||= 'index'
-        end
-
-        def split_glob_param!(params)
-          params[@glob_param] = params[@glob_param].split('/').map { |v| URI.parser.unescape(v) }
-        end
-      end
-
-      # A NamedRouteCollection instance is a collection of named routes, and also
-      # maintains an anonymous module that can be used to install helpers for the
-      # named routes.
-      class NamedRouteCollection #:nodoc:
-        include Enumerable
-        attr_reader :routes, :helpers, :module
-
-        def initialize
-          clear!
-        end
-
-        def helper_names
-          self.module.instance_methods.map(&:to_s)
-        end
-
-        def clear!
-          @routes = {}
-          @helpers = []
-
-          @module ||= Module.new do
-            instance_methods.each { |selector| remove_method(selector) }
-          end
-        end
-
-        def add(name, route)
-          routes[name.to_sym] = route
-          define_named_route_methods(name, route)
-        end
-
-        def get(name)
-          routes[name.to_sym]
-        end
-
-        alias []=   add
-        alias []    get
-        alias clear clear!
-
-        def each
-          routes.each { |name, route| yield name, route }
-          self
-        end
-
-        def names
-          routes.keys
-        end
-
-        def length
-          routes.length
-        end
-
-        def reset!
-          old_routes = routes.dup
-          clear!
-          old_routes.each do |name, route|
-            add(name, route)
-          end
-        end
-
-        def install(destinations = [ActionController::Base, ActionView::Base], regenerate = false)
-          reset! if regenerate
-          Array(destinations).each do |dest|
-            dest.__send__(:include, @module)
-          end
-        end
-
-        private
-          def url_helper_name(name, kind = :url)
-            :"#{name}_#{kind}"
-          end
-
-          def hash_access_name(name, kind = :url)
-            :"hash_for_#{name}_#{kind}"
-          end
-
-          def define_named_route_methods(name, route)
-            {:url => {:only_path => false}, :path => {:only_path => true}}.each do |kind, opts|
-              hash = route.defaults.merge(:use_route => name).merge(opts)
-              define_hash_access route, name, kind, hash
-              define_url_helper route, name, kind, hash
-            end
-          end
-
-          def define_hash_access(route, name, kind, options)
-            selector = hash_access_name(name, kind)
-
-            # We use module_eval to avoid leaks
-            @module.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-              remove_possible_method :#{selector}
-              def #{selector}(*args)
-                options = args.extract_options!
-                result = #{options.inspect}
-
-                if args.size > 0
-                  result[:_positional_args] = args
-                  result[:_positional_keys] = #{route.segment_keys.inspect}
-                end
-
-                result.merge(options)
-              end
-              protected :#{selector}
-            END_EVAL
-            helpers << selector
-          end
-
-          # Create a url helper allowing ordered parameters to be associated
-          # with corresponding dynamic segments, so you can do:
-          #
-          #   foo_url(bar, baz, bang)
-          #
-          # Instead of:
-          #
-          #   foo_url(:bar => bar, :baz => baz, :bang => bang)
-          #
-          # Also allow options hash, so you can do:
-          #
-          #   foo_url(bar, baz, bang, :sort_by => 'baz')
-          #
-          def define_url_helper(route, name, kind, options)
-            selector = url_helper_name(name, kind)
-            hash_access_method = hash_access_name(name, kind)
-
-            @module.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-              remove_possible_method :#{selector}
-              def #{selector}(*args)
-                url_for(#{hash_access_method}(*args))
-              end
-            END_EVAL
-            helpers << selector
-          end
-      end
-
-      attr_accessor :formatter, :set, :named_routes, :default_scope, :router
-      attr_accessor :disable_clear_and_finalize, :resources_path_names
-      attr_accessor :default_url_options, :request_class, :valid_conditions
-
-      alias :routes :set
-
-      def self.default_resources_path_names
-        { :new => 'new', :edit => 'edit' }
-      end
-
-      def initialize(request_class = ActionDispatch::Request)
-        self.named_routes = NamedRouteCollection.new
-        self.resources_path_names = self.class.default_resources_path_names.dup
-        self.default_url_options = {}
-
-        self.request_class = request_class
-        @valid_conditions = {}
-
-        request_class.public_instance_methods.each { |m|
-          @valid_conditions[m.to_sym] = true
-        }
-        @valid_conditions[:controller] = true
-        @valid_conditions[:action] = true
-
-        self.valid_conditions.delete(:id)
-
-        @append                     = []
-        @prepend                    = []
-        @disable_clear_and_finalize = false
-        @finalized                  = false
-
-        @set    = Journey::Routes.new
-        @router = Journey::Router.new(@set, {
-          :parameters_key => PARAMETERS_KEY,
-          :request_class  => request_class})
-        @formatter = Journey::Formatter.new @set
-      end
-
-      def draw(&block)
-        clear! unless @disable_clear_and_finalize
-        eval_block(block)
-        finalize! unless @disable_clear_and_finalize
-        nil
-      end
-
-      def append(&block)
-        @append << block
-      end
-
-      def prepend(&block)
-        @prepend << block
-      end
-
-      def eval_block(block)
-        if block.arity == 1
-          raise "You are using the old router DSL which has been removed in Rails 3.1. " <<
-            "Please check how to update your routes file at: http://www.engineyard.com/blog/2010/the-lowdown-on-routes-in-rails-3/"
-        end
-        mapper = Mapper.new(self)
-        if default_scope
-          mapper.with_default_scope(default_scope, &block)
-        else
-          mapper.instance_exec(&block)
-        end
-      end
-
-      def finalize!
-        return if @finalized
-        @append.each { |blk| eval_block(blk) }
-        @finalized = true
-      end
-
-      def clear!
-        @finalized = false
-        @url_helpers = nil
-        named_routes.clear
-        set.clear
-        formatter.clear
-        @prepend.each { |blk| eval_block(blk) }
-      end
-
-      def install_helpers(destinations = [ActionController::Base, ActionView::Base], regenerate_code = false)
-        Array(destinations).each { |d| d.module_eval { include Helpers } }
-        named_routes.install(destinations, regenerate_code)
-      end
-
-      module MountedHelpers
-      end
-
-      def mounted_helpers
-        MountedHelpers
-      end
-
-      def define_mounted_helper(name)
-        return if MountedHelpers.method_defined?(name)
-
-        routes = self
-        MountedHelpers.class_eval do
-          define_method "_#{name}" do
-            RoutesProxy.new(routes, self._routes_context)
-          end
-        end
-
-        MountedHelpers.class_eval <<-RUBY
-          def #{name}
-            @#{name} ||= _#{name}
-          end
-        RUBY
-      end
-
-      def url_helpers
-        @url_helpers ||= begin
-          routes = self
-
-          helpers = Module.new do
-            extend ActiveSupport::Concern
-            include UrlFor
-
-            @_routes = routes
-            class << self
-              delegate :url_for, :to => '@_routes'
-            end
-            extend routes.named_routes.module
-
-            # ROUTES TODO: install_helpers isn't great... can we make a module with the stuff that
-            # we can include?
-            # Yes plz - JP
-            included do
-              routes.install_helpers(self)
-              singleton_class.send(:redefine_method, :_routes) { routes }
-            end
-
-            define_method(:_routes) { @_routes || routes }
-          end
-
-          helpers
-        end
-      end
-
-      def empty?
-        routes.empty?
-      end
-
-      def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
-        raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)
-
-        path = build_path(conditions.delete(:path_info), requirements, SEPARATORS, anchor)
-        conditions = build_conditions(conditions, valid_conditions, path.names.map { |x| x.to_sym })
-
-        route = @set.add_route(app, path, conditions, defaults, name)
-        named_routes[name] = route if name
-        route
-      end
-
-      def build_path(path, requirements, separators, anchor)
-        strexp = Journey::Router::Strexp.new(
-            path,
-            requirements,
-            SEPARATORS,
-            anchor)
-
-        pattern = Journey::Path::Pattern.new(strexp)
-
-        builder = Journey::GTG::Builder.new pattern.spec
-
-        # Get all the symbol nodes followed by literals that are not the
-        # dummy node.
-        symbols = pattern.spec.grep(Journey::Nodes::Symbol).find_all { |n|
-          builder.followpos(n).first.literal?
-        }
-
-        # Get all the symbol nodes preceded by literals.
-        symbols.concat pattern.spec.find_all(&:literal?).map { |n|
-          builder.followpos(n).first
-        }.find_all(&:symbol?)
-
-        symbols.each { |x|
-          x.regexp = /(?:#{Regexp.union(x.regexp, '-')})+/
-        }
-
-        pattern
-      end
-      private :build_path
-
-      def build_conditions(current_conditions, req_predicates, path_values)
-        conditions = current_conditions.dup
-
-        verbs = conditions[:request_method] || []
-
-        # Rack-Mount requires that :request_method be a regular expression.
-        # :request_method represents the HTTP verb that matches this route.
-        #
-        # Here we munge values before they get sent on to rack-mount.
-        unless verbs.empty?
-          conditions[:request_method] = %r[^#{verbs.join('|')}$]
-        end
-        conditions.delete_if { |k,v| !(req_predicates.include?(k) || path_values.include?(k)) }
-
-        conditions
-      end
-      private :build_conditions
-
-      class Generator #:nodoc:
-        PARAMETERIZE = lambda do |name, value|
-          if name == :controller
-            value
-          elsif value.is_a?(Array)
-            value.map { |v| v.to_param }.join('/')
-          elsif param = value.to_param
-            param
-          end
-        end
-
-        attr_reader :options, :recall, :set, :named_route
-
-        def initialize(options, recall, set, extras = false)
-          @named_route = options.delete(:use_route)
-          @options     = options.dup
-          @recall      = recall.dup
-          @set         = set
-          @extras      = extras
-
-          normalize_options!
-          normalize_controller_action_id!
-          use_relative_controller!
-          controller.sub!(%r{^/}, '') if controller
-          handle_nil_action!
-        end
-
-        def controller
-          @controller ||= @options[:controller]
-        end
-
-        def current_controller
-          @recall[:controller]
-        end
-
-        def use_recall_for(key)
-          if @recall[key] && (!@options.key?(key) || @options[key] == @recall[key])
-            if named_route_exists?
-              @options[key] = @recall.delete(key) if segment_keys.include?(key)
-            else
-              @options[key] = @recall.delete(key)
-            end
-          end
-        end
-
-        def normalize_options!
-          # If an explicit :controller was given, always make :action explicit
-          # too, so that action expiry works as expected for things like
-          #
-          #   generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
-          #
-          # (the above is from the unit tests). In the above case, because the
-          # controller was explicitly given, but no action, the action is implied to
-          # be "index", not the recalled action of "show".
-
-          if options[:controller]
-            options[:action]     ||= 'index'
-            options[:controller]   = options[:controller].to_s
-          end
-
-          if options[:action]
-            options[:action] = options[:action].to_s
-          end
-        end
-
-        # This pulls :controller, :action, and :id out of the recall.
-        # The recall key is only used if there is no key in the options
-        # or if the key in the options is identical. If any of
-        # :controller, :action or :id is not found, don't pull any
-        # more keys from the recall.
-        def normalize_controller_action_id!
-          @recall[:action] ||= 'index' if current_controller
-
-          use_recall_for(:controller) or return
-          use_recall_for(:action) or return
-          use_recall_for(:id)
-        end
-
-        # if the current controller is "foo/bar/baz" and :controller => "baz/bat"
-        # is specified, the controller becomes "foo/baz/bat"
-        def use_relative_controller!
-          if !named_route && different_controller? && !controller.start_with?("/")
-            old_parts = current_controller.split('/')
-            size = controller.count("/") + 1
-            parts = old_parts[0...-size] << controller
-            @controller = @options[:controller] = parts.join("/")
-          end
-        end
-
-        # This handles the case of :action => nil being explicitly passed.
-        # It is identical to :action => "index"
-        def handle_nil_action!
-          if options.has_key?(:action) && options[:action].nil?
-            options[:action] = 'index'
-          end
-          recall[:action] = options.delete(:action) if options[:action] == 'index'
-        end
-
-        def generate
-          path, params = @set.formatter.generate(:path_info, named_route, options, recall, PARAMETERIZE)
-
-          raise_routing_error unless path
-
-          return [path, params.keys] if @extras
-
-          [path, params]
-        rescue Journey::Router::RoutingError
-          raise_routing_error
-        end
-
-        def raise_routing_error
-          raise ActionController::RoutingError, "No route matches #{options.inspect}"
-        end
-
-        def different_controller?
-          return false unless current_controller
-          controller.to_param != current_controller.to_param
-        end
-
-        private
-          def named_route_exists?
-            named_route && set.named_routes[named_route]
-          end
-
-          def segment_keys
-            set.named_routes[named_route].segment_keys
-          end
-      end
-
-      # Generate the path indicated by the arguments, and return an array of
-      # the keys that were not used to generate it.
-      def extra_keys(options, recall={})
-        generate_extras(options, recall).last
-      end
-
-      def generate_extras(options, recall={})
-        generate(options, recall, true)
-      end
-
-      def generate(options, recall = {}, extras = false)
-        Generator.new(options, recall, self, extras).generate
-      end
-
-      RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
-                          :trailing_slash, :anchor, :params, :only_path, :script_name]
-
-      def _generate_prefix(options = {})
-        nil
-      end
-
-      def url_for(options)
-        finalize!
-        options = (options || {}).reverse_merge!(default_url_options)
-
-        handle_positional_args(options)
-
-        user, password = extract_authentication(options)
-        path_segments  = options.delete(:_path_segments)
-        script_name    = options.delete(:script_name)
-
-        path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s
-
-        path_options = options.except(*RESERVED_OPTIONS)
-        path_options = yield(path_options) if block_given?
-
-        path_addition, params = generate(path_options, path_segments || {})
-        path << path_addition
-        params.merge!(options[:params] || {})
-
-        ActionDispatch::Http::URL.url_for(options.merge!({
-          :path => path,
-          :params => params,
-          :user => user,
-          :password => password
-        }))
-      end
-
-      def call(env)
-        finalize!
-        @router.call(env)
-      end
-
-      def recognize_path(path, environment = {})
-        method = (environment[:method] || "GET").to_s.upcase
-        path = Journey::Router::Utils.normalize_path(path) unless path =~ %r{://}
-
-        begin
-          env = Rack::MockRequest.env_for(path, {:method => method})
-        rescue URI::InvalidURIError => e
-          raise ActionController::RoutingError, e.message
-        end
-
-        req = @request_class.new(env)
-        @router.recognize(req) do |route, matches, params|
-          params.each do |key, value|
-            if value.is_a?(String)
-              value = value.dup.force_encoding(Encoding::BINARY) if value.encoding_aware?
-              params[key] = URI.parser.unescape(value)
-            end
-          end
-
-          dispatcher = route.app
-          while dispatcher.is_a?(Mapper::Constraints) && dispatcher.matches?(env) do
-            dispatcher = dispatcher.app
-          end
-
-          if dispatcher.is_a?(Dispatcher) && dispatcher.controller(params, false)
-            dispatcher.prepare_params!(params)
-            return params
-          end
-        end
-
-        raise ActionController::RoutingError, "No route matches #{path.inspect}"
-      end
-
-      private
-
-        def extract_authentication(options)
-          if options[:user] && options[:password]
-            [options.delete(:user), options.delete(:password)]
-          else
-            nil
-          end
-        end
-
-        def handle_positional_args(options)
-          return unless args = options.delete(:_positional_args)
-
-          keys = options.delete(:_positional_keys)
-          keys -= options.keys if args.size < keys.size - 1 # take format into account
-
-          # Tell url_for to skip default_url_options
-          options.merge!(Hash[args.zip(keys).map { |v, k| [k, v] }])
-        end
-
-    end
-  end
-end