nanumfont-rails 0.0.2 → 0.1

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/routing/polymorphic_routes.rb

@@ -0,0 +1,218 @@
+require 'action_controller/model_naming'
+
+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"
+    #
+    # == Usage with mounted engines
+    #
+    # If you are using a mounted engine and you need to use a polymorphic_url
+    # pointing at the engine's routes, pass in the engine's route proxy as the first
+    # argument to the method. For example:
+    #
+    #   polymorphic_url([blog, @post])  # calls blog.post_path(@post)
+    #   form_for([blog, @post])         # => "/blog/posts/1"
+    #
+    module PolymorphicRoutes
+      include ActionController::ModelNaming
+
+      # 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>.
+      #
+      # Also includes all the options from <tt>url_for</tt>. These include such
+      # things as <tt>:anchor</tt> or <tt>:trailing_slash</tt>. Example usage
+      # is given below:
+      #
+      #   polymorphic_url([blog, post], anchor: 'my_anchor')
+      #     # => "http://example.com/blogs/1/posts/1#my_anchor"
+      #   polymorphic_url([blog, post], anchor: 'my_anchor', script_name: "/my_app")
+      #     # => "http://example.com/my_app/blogs/1/posts/1#my_anchor"
+      #
+      # For all of these options, see the documentation for <tt>url_for</tt>.
+      #
+      # ==== Functionality
+      #
+      #   # 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 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
+                model_name_from_record_or_class(parent).singular_route_key
+              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 << model_name_from_record_or_class(record).singular_route_key
+            else
+              route << model_name_from_record_or_class(record).route_key
+            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/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/routing/redirection.rb

@@ -0,0 +1,193 @@
+require 'action_dispatch/http/request'
+require 'active_support/core_ext/uri'
+require 'active_support/core_ext/array/extract_options'
+require 'rack/utils'
+require 'action_controller/metal/exceptions'
+
+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)
+
+        # If any of the path parameters has an invalid encoding then
+        # raise since it's likely to trigger errors further on.
+        req.symbolized_path_parameters.each do |key, value|
+          unless value.valid_encoding?
+            raise ActionController::BadRequest, "Invalid parameter: #{key} => #{value}"
+          end
+        end
+
+        uri = URI.parse(path(req.symbolized_path_parameters, req))
+        
+        unless uri.host
+          if relative_path?(uri.path)
+            uri.path = "#{req.script_name}/#{uri.path}"
+          elsif uri.path.empty?
+            uri.path = req.script_name.empty? ? "/" : req.script_name
+          end
+        end
+          
+        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
+
+      def inspect
+        "redirect(#{status})"
+      end
+
+      private
+        def relative_path?(path)
+          path && !path.empty? && path[0] != '/'
+        end
+
+        def escape(params)
+          Hash[params.map{ |k,v| [k, Rack::Utils.escape(v)] }]
+        end
+
+        def escape_fragment(params)
+          Hash[params.map{ |k,v| [k, Journey::Router::Utils.escape_fragment(v)] }]
+        end
+
+        def escape_path(params)
+          Hash[params.map{ |k,v| [k, Journey::Router::Utils.escape_path(v)] }]
+        end
+    end
+
+    class PathRedirect < Redirect
+      URL_PARTS = /\A([^?]+)?(\?[^#]+)?(#.+)?\z/
+
+      def path(params, request)
+        if block.match(URL_PARTS)
+          path     = interpolation_required?($1, params) ? $1 % escape_path(params)     : $1
+          query    = interpolation_required?($2, params) ? $2 % escape(params)          : $2
+          fragment = interpolation_required?($3, params) ? $3 % escape_fragment(params) : $3
+
+          "#{path}#{query}#{fragment}"
+        else
+          interpolation_required?(block, params) ? block % escape(params) : block
+        end
+      end
+
+      def inspect
+        "redirect(#{status}, #{block})"
+      end
+
+      private
+        def interpolation_required?(string, params)
+          !params.empty? && string && string.match(/%\{\w*\}/)
+        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
+
+        unless options[:host] || options[:domain]
+          if relative_path?(url_options[:path])
+            url_options[:path] = "/#{url_options[:path]}"
+            url_options[:script_name] = request.script_name
+          elsif url_options[:path].empty?
+            url_options[:path] = request.script_name.empty? ? "/" : ""
+            url_options[:script_name] = request.script_name
+          end
+        end
+        
+        ActionDispatch::Http::URL.url_for url_options
+      end
+
+      def inspect
+        "redirect(#{status}, #{options.map{ |k,v| "#{k}: #{v}" }.join(', ')})"
+      end
+    end
+
+    module Redirection
+
+      # Redirect any path to another path:
+      #
+      #   get "/stories" => redirect("/posts")
+      #
+      # You can also use interpolation in the supplied redirect argument:
+      #
+      #   get 'docs/:article', to: redirect('/wiki/%{article}')
+      #
+      # Note that if you return a path without a leading slash then the url is prefixed with the
+      # current SCRIPT_NAME environment variable. This is typically '/' but may be different in
+      # a mounted engine or where the application is deployed to a subdirectory of a website.
+      #
+      # 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.
+      #
+      #   get 'jokes/:number', to: redirect { |params, request|
+      #     path = (params[:number].to_i.even? ? "wheres-the-beef" : "i-love-lamp")
+      #     "http://#{request.host_with_port}/#{path}"
+      #   }
+      #
+      # Note that the +do end+ syntax for the redirect block wouldn't work, as Ruby would pass
+      # the block to +get+ instead of +redirect+. Use <tt>{ ... }</tt> instead.
+      #
+      # 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.
+      #
+      #   get 'stores/:name',       to: redirect(subdomain: 'stores', path: '/%{name}')
+      #   get '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.
+      #
+      #   get 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
+      #
+      def redirect(*args, &block)
+        options = args.extract_options!
+        status  = options.delete(:status) || 301
+        path    = args.shift
+
+        return OptionRedirect.new(status, options) if options.any?
+        return PathRedirect.new(status, path) if String === path
+
+        block = path if path.respond_to? :call
+        raise ArgumentError, "redirection argument not supported" unless block
+        Redirect.new status, block
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/actionpack-4.1.6/lib/action_dispatch/routing/route_set.rb

@@ -0,0 +1,733 @@
+require 'action_dispatch/journey'
+require 'forwardable'
+require 'thread_safe'
+require 'active_support/concern'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/array/extract_options'
+require 'action_controller/metal/exceptions'
+require 'action_dispatch/http/request'
+
+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)
+          @controller_class_names = ThreadSafe::Cache.new
+        end
+
+        def call(env)
+          params = env[PARAMETERS_KEY]
+
+          # If any of the path parameters has an invalid encoding then
+          # raise since it's likely to trigger errors further on.
+          params.each do |key, value|
+            next unless value.respond_to?(:valid_encoding?)
+
+            unless value.valid_encoding?
+              raise ActionController::BadRequest, "Invalid parameter: #{key} => #{value}"
+            end
+          end
+
+          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)
+          const_name = @controller_class_names[controller_param] ||= "#{controller_param.camelize}Controller"
+          ActiveSupport::Dependencies.constantize(const_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
+          @routes  = {}
+          @helpers = []
+          @module  = Module.new
+        end
+
+        def helper_names
+          @helpers.map(&:to_s)
+        end
+
+        def clear!
+          @helpers.each do |helper|
+            @module.remove_possible_method helper
+          end
+
+          @routes.clear
+          @helpers.clear
+        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
+
+        class UrlHelper # :nodoc:
+          def self.create(route, options)
+            if optimize_helper?(route)
+              OptimizedUrlHelper.new(route, options)
+            else
+              new route, options
+            end
+          end
+
+          def self.optimize_helper?(route)
+            !route.glob? && route.requirements.except(:controller, :action).empty?
+          end
+
+          class OptimizedUrlHelper < UrlHelper # :nodoc:
+            attr_reader :arg_size
+
+            def initialize(route, options)
+              super
+              @klass          = Journey::Router::Utils
+              @required_parts = @route.required_parts
+              @arg_size       = @required_parts.size
+              @optimized_path = @route.optimized_path
+            end
+
+            def call(t, args)
+              if args.size == arg_size && !args.last.is_a?(Hash) && optimize_routes_generation?(t)
+                options = @options.dup
+                options.merge!(t.url_options) if t.respond_to?(:url_options)
+                options[:path] = optimized_helper(args)
+                ActionDispatch::Http::URL.url_for(options)
+              else
+                super
+              end
+            end
+
+            private
+
+            def optimized_helper(args)
+              params = Hash[parameterize_args(args)]
+              missing_keys = missing_keys(params)
+
+              unless missing_keys.empty?
+                raise_generation_error(params, missing_keys)
+              end
+
+              @optimized_path.map{ |segment| replace_segment(params, segment) }.join
+            end
+
+            def replace_segment(params, segment)
+              Symbol === segment ? @klass.escape_segment(params[segment]) : segment
+            end
+
+            def optimize_routes_generation?(t)
+              t.send(:optimize_routes_generation?)
+            end
+
+            def parameterize_args(args)
+              @required_parts.zip(args.map(&:to_param))
+            end
+
+            def missing_keys(args)
+              args.select{ |part, arg| arg.nil? || arg.empty? }.keys
+            end
+
+            def raise_generation_error(args, missing_keys)
+              constraints = Hash[@route.requirements.merge(args).sort]
+              message = "No route matches #{constraints.inspect}"
+              message << " missing required keys: #{missing_keys.sort.inspect}"
+
+              raise ActionController::UrlGenerationError, message
+            end
+          end
+
+          def initialize(route, options)
+            @options      = options
+            @segment_keys = route.segment_keys.uniq
+            @route        = route
+          end
+
+          def call(t, args)
+            t.url_for(handle_positional_args(t, args, @options, @segment_keys))
+          end
+
+          def handle_positional_args(t, args, options, keys)
+            inner_options = args.extract_options!
+            result = options.dup
+
+            if args.size > 0
+              if args.size < keys.size - 1 # take format into account
+                keys -= t.url_options.keys if t.respond_to?(:url_options)
+                keys -= options.keys
+              end
+              keys -= inner_options.keys
+              result.merge!(Hash[keys.zip(args)])
+            end
+
+            result.merge!(inner_options)
+          end
+        end
+
+        private
+        # 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, options)
+          helper = UrlHelper.create(route, options.dup)
+
+          @module.remove_possible_method name
+          @module.module_eval do
+            define_method(name) do |*args|
+              helper.call self, args
+            end
+          end
+
+          helpers << name
+        end
+
+        def define_named_route_methods(name, route)
+          define_url_helper route, :"#{name}_path",
+            route.defaults.merge(:use_route => name, :only_path => true)
+          define_url_helper route, :"#{name}_url",
+            route.defaults.merge(:use_route => name, :only_path => false)
+        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
+
+      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
+
+        @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
+        named_routes.clear
+        set.clear
+        formatter.clear
+        @prepend.each { |blk| eval_block(blk) }
+      end
+
+      module MountedHelpers #:nodoc:
+        extend ActiveSupport::Concern
+        include UrlFor
+      end
+
+      # Contains all the mounted helpers across different
+      # engines and the `main_app` helper for the application.
+      # You can include this in your classes if you want to
+      # access routes for other engines.
+      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, _routes_context)
+          end
+        end
+
+        MountedHelpers.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{name}
+            @_#{name} ||= _#{name}
+          end
+        RUBY
+      end
+
+      def url_helpers
+        @url_helpers ||= begin
+          routes = self
+
+          Module.new do
+            extend ActiveSupport::Concern
+            include UrlFor
+
+            # Define url_for in the singleton level so one can do:
+            # Rails.application.routes.url_helpers.url_for(args)
+            @_routes = routes
+            class << self
+              delegate :url_for, :optimize_routes_generation?, :to => '@_routes'
+            end
+
+            # Make named_routes available in the module singleton
+            # as well, so one can do:
+            # Rails.application.routes.url_helpers.posts_path
+            extend routes.named_routes.module
+
+            # Any class that includes this module will get all
+            # named routes...
+            include routes.named_routes.module
+
+            # plus a singleton class method called _routes ...
+            included do
+              singleton_class.send(:redefine_method, :_routes) { routes }
+            end
+
+            # And an instance method _routes. Note that
+            # UrlFor (included in this module) add extra
+            # conveniences for working with @_routes.
+            define_method(:_routes) { @_routes || routes }
+          end
+        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)
+
+        if name && named_routes[name]
+          raise ArgumentError, "Invalid route name, already in use: '#{name}' \n" \
+            "You may have defined two routes with the same name using the `:as` option, or " \
+            "you may be overriding a route already defined by a resource with the same naming. " \
+            "For the latter, you can restrict the routes created with `resources` as explained here: \n" \
+            "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
+        end
+
+        path = build_path(conditions.delete(:path_info), requirements, SEPARATORS, anchor)
+        conditions = build_conditions(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, path_values)
+        conditions = current_conditions.dup
+
+        # 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.
+        verbs = conditions[:request_method] || []
+        unless verbs.empty?
+          conditions[:request_method] = %r[^#{verbs.join('|')}$]
+        end
+
+        conditions.keep_if do |k, _|
+          k == :action || k == :controller || k == :required_defaults ||
+            @request_class.public_method_defined?(k) || path_values.include?(k)
+        end
+      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)
+          @named_route = options.delete(:use_route)
+          @options     = options.dup
+          @recall      = recall.dup
+          @set         = set
+
+          normalize_recall!
+          normalize_options!
+          normalize_controller_action_id!
+          use_relative_controller!
+          normalize_controller!
+          normalize_action!
+        end
+
+        def 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? || segment_keys.include?(key)
+              @options[key] = @recall.delete(key)
+            end
+          end
+        end
+
+        # Set 'index' as default action for recall
+        def normalize_recall!
+          @recall[:action] ||= 'index'
+        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.key?(:action)
+            options[:action] = (options[:action] || 'index').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!
+          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
+            @options[:controller] = parts.join("/")
+          end
+        end
+
+        # Remove leading slashes from controllers
+        def normalize_controller!
+          @options[:controller] = controller.sub(%r{^/}, '') if controller
+        end
+
+        # Move 'index' action from options to recall
+        def normalize_action!
+          if @options[:action] == 'index'
+            @recall[:action] = @options.delete(:action)
+          end
+        end
+
+        # Generates a path from routes, returns [path, params].
+        # If no route is generated the formatter will raise ActionController::UrlGenerationError
+        def generate
+          @set.formatter.generate(:path_info, named_route, options, recall, PARAMETERIZE)
+        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={})
+        path, params = generate(options, recall)
+        return path, params.keys
+      end
+
+      def generate(options, recall = {})
+        Generator.new(options, recall, self).generate
+      end
+
+      RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
+                          :trailing_slash, :anchor, :params, :only_path, :script_name,
+                          :original_script_name]
+
+      def mounted?
+        false
+      end
+
+      def optimize_routes_generation?
+        !mounted? && default_url_options.empty?
+      end
+
+      def _generate_prefix(options = {})
+        nil
+      end
+
+      # The +options+ argument must be +nil+ or a hash whose keys are *symbols*.
+      def url_for(options)
+        options = default_url_options.merge(options || {})
+
+        user, password = extract_authentication(options)
+        recall  = options.delete(:_recall)
+
+        original_script_name = options.delete(:original_script_name).presence
+        script_name = options.delete(:script_name).presence || _generate_prefix(options)
+
+        if script_name && original_script_name
+          script_name = original_script_name + script_name
+        end
+
+        path_options = options.except(*RESERVED_OPTIONS)
+        path_options = yield(path_options) if block_given?
+
+        path, params = generate(path_options, recall || {})
+        params.merge!(options[:params] || {})
+
+        ActionDispatch::Http::URL.url_for(options.merge!({
+          :path => path,
+          :script_name => script_name,
+          :params => params,
+          :user => user,
+          :password => password
+        }))
+      end
+
+      def call(env)
+        @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{://}
+        extras = environment[:extras] || {}
+
+        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.merge!(extras)
+          params.each do |key, value|
+            if value.is_a?(String)
+              value = value.dup.force_encoding(Encoding::BINARY)
+              params[key] = URI.parser.unescape(value)
+            end
+          end
+          old_params = env[::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
+          env[::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY] = (old_params || {}).merge(params)
+          dispatcher = route.app
+          while dispatcher.is_a?(Mapper::Constraints) && dispatcher.matches?(env) do
+            dispatcher = dispatcher.app
+          end
+
+          if dispatcher.is_a?(Dispatcher)
+            if dispatcher.controller(params, false)
+              dispatcher.prepare_params!(params)
+              return params
+            else
+              raise ActionController::RoutingError, "A route matches #{path.inspect}, but references missing controller: #{params[:controller].camelize}Controller"
+            end
+          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
+
+    end
+  end
+end