joe-merb-core 0.9.8

data/lib/merb-core/dispatch/router/cached_proc.rb

@@ -0,0 +1,52 @@
+module Merb
+  
+  class Router
+    # Cache procs for future reference in eval statement
+    class CachedProc
+      @@index = 0
+      @@list = []
+
+      attr_accessor :cache, :index
+
+      # ==== Parameters
+      # cache<Proc>:: The block of code to cache.
+      def initialize(cache)
+        @cache, @index = cache, CachedProc.register(self)
+      end
+
+      # ==== Returns
+      # String:: The CachedProc object in a format embeddable within a string.
+      def to_s
+        "CachedProc[#{@index}].cache"
+      end
+
+      class << self
+
+        # ==== Parameters
+        # cached_code<CachedProc>:: The cached code to register.
+        #
+        # ==== Returns
+        # Fixnum:: The index of the newly registered CachedProc.
+        def register(cached_code)
+          CachedProc[@@index] = cached_code
+          @@index += 1
+          @@index - 1
+        end
+
+        # Sets the cached code for a specific index.
+        #
+        # ==== Parameters
+        # index<Fixnum>:: The index of the cached code to set.
+        # code<CachedProc>:: The cached code to set.
+        def []=(index, code) @@list[index] = code end
+
+        # ==== Parameters
+        # index<Fixnum>:: The index of the cached code to retrieve.
+        #
+        # ==== Returns
+        # CachedProc:: The cached code at index.
+        def [](index) @@list[index] end
+      end
+    end # CachedProc
+  end
+end

data/lib/merb-core/dispatch/router/resources.rb

@@ -0,0 +1,220 @@
+module Merb
+  class Router
+    class Behavior
+      module Resources
+
+        # Behavior#+resources+ is a route helper for defining a collection of
+        # RESTful resources. It yields to a block for child routes.
+        #
+        # ==== Parameters
+        # name<String, Symbol>:: The name of the resources
+        # options<Hash>::
+        #   Ovverides and parameters to be associated with the route
+        #
+        # ==== Options (options)
+        # :namespace<~to_s>: The namespace for this route.
+        # :name_prefix<~to_s>:
+        #   A prefix for the named routes. If a namespace is passed and there
+        #   isn't a name prefix, the namespace will become the prefix.
+        # :controller<~to_s>: The controller for this route
+        # :collection<~to_s>: Special settings for the collections routes
+        # :member<Hash>:
+        #   Special settings and resources related to a specific member of this
+        #   resource.
+        # :keys<Array>:
+        #   A list of the keys to be used instead of :id with the resource in the order of the url.
+        # :singular<Symbol>
+        #
+        # ==== Block parameters
+        # next_level<Behavior>:: The child behavior.
+        #
+        # ==== Returns
+        # Array::
+        #   Routes which will define the specified RESTful collection of resources
+        #
+        # ==== Examples
+        #
+        #  r.resources :posts # will result in the typical RESTful CRUD
+        #    # lists resources
+        #    # GET     /posts/?(\.:format)?      :action => "index"
+        #    # GET     /posts/index(\.:format)?  :action => "index"
+        #
+        #    # shows new resource form
+        #    # GET     /posts/new                :action => "new"
+        #
+        #    # creates resource
+        #    # POST    /posts/?(\.:format)?,     :action => "create"
+        #
+        #    # shows resource
+        #    # GET     /posts/:id(\.:format)?    :action => "show"
+        #
+        #    # shows edit form
+        #    # GET     /posts/:id/edit        :action => "edit"
+        #
+        #    # updates resource
+        #    # PUT     /posts/:id(\.:format)?    :action => "update"
+        #
+        #    # shows deletion confirmation page
+        #    # GET     /posts/:id/delete      :action => "delete"
+        #
+        #    # destroys resources
+        #    # DELETE  /posts/:id(\.:format)?    :action => "destroy"
+        #
+        #  # Nesting resources
+        #  r.resources :posts do |posts|
+        #    posts.resources :comments
+        #  end
+        #---
+        # @public
+        def resources(name, *args, &block)
+          name       = name.to_s
+          options    = extract_options_from_args!(args) || {}
+          singular   = options[:singular] ? options[:singular].to_s : Extlib::Inflection.singularize(name)
+          klass      = args.first ? args.first.to_s : Extlib::Inflection.classify(singular)
+          keys       = [ options.delete(:keys) || options.delete(:key) || :id ].flatten
+          params     = { :controller => options.delete(:controller) || name }
+          collection = options.delete(:collection) || {}
+          member     = { :edit => :get, :delete => :get }.merge(options.delete(:member) || {})
+
+          # Try pulling :namespace out of options for backwards compatibility
+          options[:name_prefix]       ||= nil # Don't use a name_prefix if not needed
+          options[:resource_prefix]   ||= nil # Don't use a resource_prefix if not needed
+          options[:controller_prefix] ||= options.delete(:namespace)
+
+          self.namespace(name, options).to(params) do |resource|
+            root_keys = keys.map { |k| ":#{k}" }.join("/")
+            
+            # => index
+            resource.match("(/index)(.:format)", :method => :get).to(:action => "index").
+              name(name).register_resource(name)
+              
+            # => create
+            resource.match("(.:format)", :method => :post).to(:action => "create")
+            
+            # => new
+            resource.match("/new(.:format)", :method => :get).to(:action => "new").
+              name("new", singular).register_resource(name, "new")
+
+            # => user defined collection routes
+            collection.each_pair do |action, method|
+              action = action.to_s
+              resource.match("/#{action}(.:format)", :method => method).to(:action => "#{action}").
+                name(action, name).register_resource(name, action)
+            end
+
+            # => show
+            resource.match("/#{root_keys}(.:format)", :method => :get).to(:action => "show").
+              name(singular).register_resource(klass)
+
+            # => user defined member routes
+            member.each_pair do |action, method|
+              action = action.to_s
+              resource.match("/#{root_keys}/#{action}(.:format)", :method => method).
+                to(:action => "#{action}").name(action, singular).register_resource(klass, action)
+            end
+
+            # => update
+            resource.match("/#{root_keys}(.:format)", :method => :put).
+              to(:action => "update")
+              
+            # => destroy
+            resource.match("/#{root_keys}(.:format)", :method => :delete).
+              to(:action => "destroy")
+
+            if block_given?
+              nested_keys = keys.map { |k| k.to_s == "id" ? ":#{singular}_id" : ":#{k}" }.join("/")
+              resource.options(:name_prefix => singular, :resource_prefix => klass).match("/#{nested_keys}", &block)
+            end
+
+          end
+        end
+
+        # Behavior#+resource+ is a route helper for defining a singular RESTful
+        # resource. It yields to a block for child routes.
+        #
+        # ==== Parameters
+        # name<String, Symbol>:: The name of the resource.
+        # options<Hash>::
+        #   Overides and parameters to be associated with the route.
+        #
+        # ==== Options (options)
+        # :namespace<~to_s>: The namespace for this route.
+        # :name_prefix<~to_s>:
+        #   A prefix for the named routes. If a namespace is passed and there
+        #   isn't a name prefix, the namespace will become the prefix.
+        # :controller<~to_s>: The controller for this route
+        #
+        # ==== Block parameters
+        # next_level<Behavior>:: The child behavior.
+        #
+        # ==== Returns
+        # Array:: Routes which define a RESTful single resource.
+        #
+        # ==== Examples
+        #
+        #  r.resource :account # will result in the typical RESTful CRUD
+        #    # shows new resource form      
+        #    # GET     /account/new                :action => "new"
+        #
+        #    # creates resource      
+        #    # POST    /account/?(\.:format)?,     :action => "create"
+        #
+        #    # shows resource      
+        #    # GET     /account/(\.:format)?       :action => "show"
+        #
+        #    # shows edit form      
+        #    # GET     /account//edit           :action => "edit"
+        #
+        #    # updates resource      
+        #    # PUT     /account/(\.:format)?       :action => "update"
+        #
+        #    # shows deletion confirmation page      
+        #    # GET     /account//delete         :action => "delete"
+        #
+        #    # destroys resources      
+        #    # DELETE  /account/(\.:format)?       :action => "destroy"
+        #
+        # You can optionally pass :namespace and :controller to refine the routing
+        # or pass a block to nest resources.
+        #
+        #   r.resource :account, :namespace => "admin" do |account|
+        #     account.resources :preferences, :controller => "settings"
+        #   end
+        # ---
+        # @public
+        def resource(name, *args, &block)
+          name    = name.to_s
+          options = extract_options_from_args!(args) || {}
+          params  = { :controller => options.delete(:controller) || name.pluralize }
+
+          options[:name_prefix]       ||= nil # Don't use a name_prefix if not needed
+          options[:resource_prefix]   ||= nil # Don't use a resource_prefix if not needed
+          options[:controller_prefix] ||= options.delete(:namespace)
+
+          self.namespace(name, options).to(params) do |resource|
+            resource.match("(.:format)",        :method => :get   ).to(:action => "show"   ).name(name).register_resource(name)
+            resource.match("(.:format)",        :method => :post  ).to(:action => "create" )
+            resource.match("(.:format)",        :method => :put   ).to(:action => "update" )
+            resource.match("(.:format)",        :method => :delete).to(:action => "destroy")
+            resource.match("/new(.:format)",    :method => :get   ).to(:action => "new"    ).name(:new,    name).register_resource(name, "new")
+            resource.match("/edit(.:format)",   :method => :get   ).to(:action => "edit"   ).name(:edit,   name).register_resource(name, "edit")
+            resource.match("/delete(.:format)", :method => :get   ).to(:action => "delete" ).name(:delete, name).register_resource(name, "delete")
+
+            resource.options(:name_prefix => name, :resource_prefix => name,  &block) if block_given?
+          end
+        end
+        
+      protected
+      
+        def register_resource(*key)
+          key = [@options[:resource_prefix], key].flatten.compact
+          @route.resource = key
+          self
+        end
+
+      end
+
+      include Resources
+    end
+  end
+end

data/lib/merb-core/dispatch/router/route.rb

@@ -0,0 +1,560 @@
+module Merb
+
+  class Router
+    # This entire class is private and should never be accessed outside of
+    # Merb::Router and Behavior
+    class Route #:nodoc:
+      SEGMENT_REGEXP               = /(:([a-z](_?[a-z0-9])*))/
+      OPTIONAL_SEGMENT_REGEX       = /^.*?([\(\)])/i
+      SEGMENT_REGEXP_WITH_BRACKETS = /(:[a-z_]+)(\[(\d+)\])?/
+      JUST_BRACKETS                = /\[(\d+)\]/
+      SEGMENT_CHARACTERS           = "[^\/.,;?]".freeze
+
+      attr_reader :conditions, :params, :segments
+      attr_reader :index, :variables, :name
+      attr_accessor :fixation
+
+      def initialize(conditions, params, deferred_procs, options = {})
+        @conditions, @params = conditions, params
+
+        if options[:redirects]
+          @redirects         = true
+          @redirect_status   = @params[:status]
+          @redirect_url      = @params[:url]
+          @defaults          = {}
+        else
+          @defaults          = options[:defaults] || {}
+        end
+        
+        # @conditional_block = conditional_block
+
+        @identifiers       = options[:identifiers]
+        @deferred_procs    = deferred_procs
+        @segments          = []
+        @symbol_conditions = {}
+        @placeholders      = {}
+        compile
+      end
+
+      def regexp?
+        @regexp
+      end
+
+      def allow_fixation?
+        @fixation
+      end
+      
+      def to_s
+        regexp? ?
+          "/#{conditions[:path].source}/" :
+          segment_level_to_s(segments)
+      end
+      
+      alias_method :inspect, :to_s
+
+      def register
+        @index = Merb::Router.routes.size
+        Merb::Router.routes << self
+        self
+      end
+      
+      # Sets the route as a resource route with the given key as the 
+      # lookup key.
+      def resource=(key)
+        Router.resource_routes[key] = self
+        key
+      end
+      
+      def name=(name)
+        @name = name.to_sym
+        Router.named_routes[@name] = self
+        @name
+      end
+      
+      # === Compiled method ===
+      def generate(args = [], defaults = {})
+        raise GenerationError, "Cannot generate regexp Routes" if regexp?
+        
+        params = extract_options_from_args!(args) || { }
+        
+        # Support for anonymous params
+        unless args.empty?
+          # First, let's determine which variables are missing
+          variables = @variables - params.keys
+          
+          raise GenerationError, "The route has #{@variables.length} variables: #{@variables.inspect}" if args.length > variables.length
+          
+          args.each_with_index do |param, i|
+            params[variables[i]] ||= param
+          end
+        end
+        
+        uri = @generator[params, defaults] or raise GenerationError, "Named route #{name} could not be generated with #{params.inspect}"
+        uri = Merb::Config[:path_prefix] + uri if Merb::Config[:path_prefix]
+        uri
+      end
+
+      def compiled_statement(first)
+        els_if = first ? '  if ' : '  elsif '
+
+        code = ""
+        code << els_if << condition_statements.join(" && ") << "\n"
+        
+        # First, we need to always return the value of the
+        # deferred block if it explicitly matched the route
+        if @redirects && @deferred_procs.any?
+          code << "    return [#{@index.inspect}, block_result] if request.matched?" << "\n" 
+          code << "    request.redirects!" << "\n"
+          code << "    [#{@index.inspect}, { :url => #{@redirect_url.inspect}, :status => #{@redirect_status.inspect} }]" << "\n"
+        elsif @redirects
+          code << "    request.redirects!" << "\n"
+          code << "    [#{@index.inspect}, { :url => #{@redirect_url.inspect}, :status => #{@redirect_status.inspect} }]" << "\n"
+        elsif @deferred_procs.any?
+          code << "    [#{@index.inspect}, block_result]" << "\n"
+        else
+          code << "    [#{@index.inspect}, #{params_as_string}]" << "\n"
+        end
+      end
+
+    private
+      
+    # === Compilation ===
+
+      def compile
+        compile_conditions
+        compile_params
+        @generator = Generator.new(@segments, @symbol_conditions, @identifiers).compiled
+      end
+      
+      # The Generator class handles compiling the route down to a lambda that
+      # can generate the URL from a params hash and a default params hash.
+      class Generator #:nodoc:
+        
+        def initialize(segments, symbol_conditions, identifiers)
+          @segments          = segments
+          @symbol_conditions = symbol_conditions
+          @identifiers       = identifiers
+          @stack             = []
+          @opt_segment_count = 0
+          @opt_segment_stack = [[]]
+        end
+        
+        def compiled
+          ruby  = ""
+          ruby << "lambda do |params, defaults|\n"
+          ruby << "  fragment     = params.delete(:fragment)\n"
+          ruby << "  query_params = params.dup\n"
+          
+          with(@segments) do
+            ruby << "  include_defaults = true\n"
+            ruby << "  return unless url = #{block_for_level}\n"
+          end
+          
+          ruby << "  query_params.delete_if { |key, value| value.nil? }\n"
+          ruby << "  unless query_params.empty?\n"
+          ruby << '    url << "?#{Merb::Request.params_to_query_string(query_params)}"' << "\n"
+          ruby << "  end\n"
+          ruby << '  url << "##{fragment}" if fragment' << "\n"
+          ruby << "  url\n"
+          ruby << "end\n"
+          
+          eval(ruby)
+        end
+        
+      private
+      
+        # Cleans up methods a bunch. We don't need to pass the current segment
+        # level around everywhere anymore. It's kept track for us in the stack.
+        def with(segments, &block)
+          @stack.push(segments)
+          retval = yield
+          @stack.pop
+          retval
+        end
+  
+        def segments
+          @stack.last || []
+        end
+        
+        def symbol_segments
+          segments.flatten.select { |s| s.is_a?(Symbol)  }
+        end
+        
+        def current_segments
+          segments.select { |s| s.is_a?(Symbol) }
+        end
+        
+        def nested_segments
+          segments.select { |s| s.is_a?(Array) }.flatten.select { |s| s.is_a?(Symbol) }
+        end
+      
+        def block_for_level
+          ruby  = ""
+          ruby << "if #{segment_level_matches_conditions}\n"
+          ruby << "  #{remove_used_segments_in_query_path}\n"
+          ruby << "  #{generate_optional_segments}\n"
+          ruby << %{ "#{combine_required_and_optional_segments}"\n}
+          ruby << "end"
+        end
+        
+        def check_if_defaults_should_be_included
+          ruby = ""
+          ruby << "include_defaults = "
+          symbol_segments.each { |s| ruby << "params[#{s.inspect}] || " }
+          ruby << "false"
+        end
+
+        # --- Not so pretty ---
+        def segment_level_matches_conditions
+          conditions = current_segments.map do |segment|
+            condition = "(cached_#{segment} = params[#{segment.inspect}] || include_defaults && defaults[#{segment.inspect}])"
+
+            if @symbol_conditions[segment] && @symbol_conditions[segment].is_a?(Regexp)
+              condition << " =~ #{@symbol_conditions[segment].inspect}"
+            elsif @symbol_conditions[segment]
+              condition << " == #{@symbol_conditions[segment].inspect}"
+            end
+
+            condition
+          end
+          
+          conditions << "true" if conditions.empty?
+          conditions.join(" && ")
+        end
+
+        def remove_used_segments_in_query_path
+          "#{current_segments.inspect}.each { |s| query_params.delete(s) }"
+        end
+
+        def generate_optional_segments
+          optionals = []
+
+          segments.each_with_index do |segment, i|
+            if segment.is_a?(Array) && segment.any? { |s| !s.is_a?(String) }
+              with(segment) do
+                @opt_segment_stack.last << (optional_name = "_optional_segments_#{@opt_segment_count += 1}")
+                @opt_segment_stack.push []
+                optionals << "#{check_if_defaults_should_be_included}\n"
+                optionals << "#{optional_name} = #{block_for_level}"
+                @opt_segment_stack.pop
+              end
+            end
+          end
+
+          optionals.join("\n")
+        end
+
+        def combine_required_and_optional_segments
+          bits = ""
+
+          segments.each_with_index do |segment, i|
+            bits << case
+              when segment.is_a?(String) then segment
+              when segment.is_a?(Symbol) then '#{param_for_route(cached_' + segment.to_s + ')}'
+              when segment.is_a?(Array) && segment.any? { |s| !s.is_a?(String) } then "\#{#{@opt_segment_stack.last.shift}}"
+              else ""
+            end
+          end
+
+          bits
+        end
+        
+        def param_for_route(param)
+          case param
+            when String, Symbol, Numeric, TrueClass, FalseClass, NilClass
+              param
+            else
+              _, identifier = @identifiers.find { |klass, _| param.is_a?(klass) }
+              identifier ? param.send(identifier) : param
+          end
+        end
+        
+      end
+
+    # === Conditions ===
+
+      def compile_conditions
+        @original_conditions = conditions.dup
+
+        if path = conditions[:path]
+          path = [path].flatten.compact
+          if path = compile_path(path)
+            conditions[:path] = Regexp.new("^#{path}$")
+          else
+            conditions.delete(:path)
+          end
+        end
+      end
+
+      # The path is passed in as an array of different parts. We basically have
+      # to concat all the parts together, then parse the path and extract the
+      # variables. However, if any of the parts are a regular expression, then
+      # we abort the parsing and just convert it to a regexp.
+      def compile_path(path)
+        @segments = []
+        compiled  = ""
+
+        return nil if path.nil? || path.empty?
+
+        path.each do |part|
+          case part
+          when Regexp
+            @regexp   = true
+            @segments = []
+            compiled << part.source.sub(/^\^/, '').sub(/\$$/, '')
+          when String
+            segments = segments_with_optionals_from_string(part.dup)
+            compile_path_segments(compiled, segments)
+            # Concat the segments
+            unless regexp?
+              if @segments[-1].is_a?(String) && segments[0].is_a?(String)
+                @segments[-1] << segments.shift
+              end
+              @segments.concat segments
+            end
+          else
+            raise ArgumentError.new("A route path can only be specified as a String or Regexp")
+          end
+        end
+        
+        unless regexp?
+          @variables = @segments.flatten.select { |s| s.is_a?(Symbol)  }
+          compiled.gsub!(%r[/+], '/')
+          compiled.gsub!(%r[(.+)/$], '\1')
+        end
+
+        compiled
+      end
+
+      # Simple nested parenthesis parser
+      def segments_with_optionals_from_string(path, nest_level = 0)
+        segments = []
+
+        # Extract all the segments at this parenthesis level
+        while segment = path.slice!(OPTIONAL_SEGMENT_REGEX)
+          # Append the segments that we came across so far
+          # at this level
+          segments.concat segments_from_string(segment[0..-2]) if segment.length > 1
+          # If the parenthesis that we came across is an opening
+          # then we need to jump to the higher level
+          if segment[-1,1] == '('
+            segments << segments_with_optionals_from_string(path, nest_level + 1)
+          else
+            # Throw an error if we can't actually go back down (aka syntax error)
+            raise "There are too many closing parentheses" if nest_level == 0
+            return segments
+          end
+        end
+
+        # Save any last bit of the string that didn't match the original regex
+        segments.concat segments_from_string(path) unless path.empty?
+
+        # Throw an error if the string should not actually be done (aka syntax error)
+        raise "You have too many opening parentheses" unless nest_level == 0
+
+        segments
+      end
+
+      def segments_from_string(path)
+        segments = []
+
+        while match = (path.match(SEGMENT_REGEXP))
+          segments << match.pre_match unless match.pre_match.empty?
+          segments << match[2].intern
+          path = match.post_match
+        end
+
+        segments << path unless path.empty?
+        segments
+      end
+
+      # --- Yeah, this could probably be refactored
+      def compile_path_segments(compiled, segments)
+        segments.each do |segment|
+          case segment
+          when String
+            compiled << Regexp.escape(segment)
+          when Symbol
+            condition = (@symbol_conditions[segment] ||= @conditions.delete(segment))
+            compiled << compile_segment_condition(condition)
+            # Create a param for the Symbol segment if none already exists
+            @params[segment] = "#{segment.inspect}" unless @params.has_key?(segment)
+            @placeholders[segment] ||= capturing_parentheses_count(compiled)
+          when Array
+            compiled << "(?:"
+            compile_path_segments(compiled, segment)
+            compiled << ")?"
+          else
+            raise ArgumentError, "conditions[:path] segments can only be a Strings, Symbols, or Arrays"
+          end
+        end
+      end
+
+      # Handles anchors in Regexp conditions
+      def compile_segment_condition(condition)
+        return "(#{SEGMENT_CHARACTERS}+)" unless condition
+        return "(#{condition})"           unless condition.is_a?(Regexp)
+
+        condition = condition.source
+        # Handle the start anchor
+        condition = if condition =~ /^\^/
+          condition[1..-1]
+        else
+          "#{SEGMENT_CHARACTERS}*#{condition}"
+        end
+        # Handle the end anchor
+        condition = if condition =~ /\$$/
+          condition[0..-2]
+        else
+          "#{condition}#{SEGMENT_CHARACTERS}*"
+        end
+
+        "(#{condition})"
+      end
+
+      def compile_params
+        # Loop through each param and compile it
+        @defaults.merge(@params).each do |key, value|
+          if value.nil?
+            @params.delete(key)
+          elsif value.is_a?(String)
+            @params[key] = compile_param(value)
+          else
+            @params[key] = value.inspect
+          end
+        end
+      end
+
+      # This was pretty much a copy / paste from the old router
+      def compile_param(value)
+        result = []
+        match  = true
+        while match
+          if match = SEGMENT_REGEXP_WITH_BRACKETS.match(value)
+            result << match.pre_match.inspect unless match.pre_match.empty?
+            placeholder_key = match[1][1..-1].intern
+            if match[2] # has brackets, e.g. :path[2]
+              result << "#{placeholder_key}#{match[3]}"
+            else # no brackets, e.g. a named placeholder such as :controller
+              if place = @placeholders[placeholder_key]
+                # result << "(path#{place} || )" # <- Defaults
+                with_defaults  = ["(path#{place}"]
+                with_defaults << " || #{@defaults[placeholder_key].inspect}" if @defaults[placeholder_key]
+                with_defaults << ")"
+                result << with_defaults.join
+              else
+                raise GenerationError, "Placeholder not found while compiling routes: #{placeholder_key.inspect}. Add it to the conditions part of the route."
+              end
+            end
+            value = match.post_match
+          elsif match = JUST_BRACKETS.match(value)
+            result << match.pre_match.inspect unless match.pre_match.empty?
+            result << "path#{match[1]}"
+            value = match.post_match
+          else
+            result << value.inspect unless value.empty?
+          end
+        end
+
+        result.join(' + ').gsub("\\_", "_")
+      end
+
+      def condition_statements
+        statements = []
+
+        # First, let's build the conditions for the regular 
+        conditions.each_pair do |key, value|
+          statements << case value
+          when Regexp
+            captures = ""
+
+            if (max = capturing_parentheses_count(value)) > 0
+              captures << (1..max).to_a.map { |n| "#{key}#{n}" }.join(", ")
+              captures << " = "
+              captures << (1..max).to_a.map { |n| "$#{n}" }.join(", ")
+            end
+
+            # Note: =~ is slightly faster than .match
+            %{(#{value.inspect} =~ cached_#{key} #{' && ((' + captures + ') || true)' unless captures.empty?})}
+          when Array
+            %{(#{arrays_to_regexps(value).inspect} =~ cached_#{key})}
+          else
+            %{(cached_#{key} == #{value.inspect})}
+          end
+        end
+        
+        # The first one is special, so let's extract it
+        if first = @deferred_procs.first
+          deferred = ""
+          deferred << "(block_result = "
+          deferred <<   "request._process_block_return("
+          deferred <<     "#{first}.call(request, #{params_as_string})"
+          deferred <<   ")"
+          deferred << ")"
+          
+          # Let's build the rest of them now
+          if @deferred_procs.length > 1
+            deferred << deferred_condition_statement(@deferred_procs[1..-1])
+          end
+          
+          statements << deferred
+        end
+
+        statements
+      end
+      
+      # (request.matched? || ((block_result = process(proc.call))))
+      def deferred_condition_statement(deferred)
+        if current = deferred.first
+          html  = " && (request.matched? || ("
+          html <<   "(block_result = "
+          html <<     "request._process_block_return("
+          html <<       "#{current}.call(request, block_result)"
+          html <<     ")"
+          html <<   ")"
+          html <<   "#{deferred_condition_statement(deferred[1..-1])}"
+          html << "))"
+        end
+      end
+
+      def params_as_string
+        elements = params.keys.map do |k|
+          "#{k.inspect} => #{params[k]}"
+        end
+        "{#{elements.join(', ')}}"
+      end
+
+    # ---------- Utilities ----------
+      
+      def arrays_to_regexps(condition)
+        return condition unless condition.is_a?(Array)
+        
+        source = condition.map do |value|
+          value = if value.is_a?(Regexp)
+            value.source
+          else
+            "^#{Regexp.escape(value.to_s)}$"
+          end
+          "(?:#{value})"
+        end
+        
+        Regexp.compile(source.join('|'))
+      end
+    
+      def segment_level_to_s(segments)
+        (segments || []).inject('') do |str, seg|
+          str << case seg
+            when String then seg
+            when Symbol then ":#{seg}"
+            when Array  then "(#{segment_level_to_s(seg)})"
+          end
+        end
+      end
+
+      def capturing_parentheses_count(regexp)
+        regexp = regexp.source if regexp.is_a?(Regexp)
+        regexp.scan(/(?!\\)[(](?!\?[#=:!>-imx])/).length
+      end
+    end
+  end  
+end