rack-mount 0.0.1 → 0.8.3

data/lib/rack/mount/generatable_regexp.rb

@@ -6,7 +6,7 @@ module Rack::Mount
       attr_reader :name, :requirement
 
       def initialize(name, requirement)
-        @name, @requirement = name.to_sym, bound_expression(requirement)
+        @name, @requirement = name.to_sym, requirement
         freeze
       end
 
@@ -25,13 +25,6 @@ module Rack::Mount
       def inspect
         "/(?<#{@name}>#{@requirement.source})/"
       end
-
-      private
-        def bound_expression(regexp)
-          source, options = regexp.source, regexp.options
-          source = "\\A#{source}\\Z"
-          Regexp.compile(source, options).freeze
-        end
     end
 
     module InstanceMethods
@@ -39,20 +32,40 @@ module Rack::Mount
         obj.segments
       end
 
+      def defaults=(defaults)
+        @required_captures = nil
+        @required_params = nil
+        @required_defaults = nil
+        @defaults = defaults
+      end
+
+      def defaults
+        @defaults ||= {}
+      end
+
       def generatable?
         segments.any?
       end
 
-      def generate(params = {}, recall = {}, defaults = {})
+      def generate(params = {}, recall = {}, options = {})
+        return nil unless generatable?
+
         merged = recall.merge(params)
-        generate_from_segments(segments, params, merged, defaults)
+        return nil unless required_params.all? { |p| merged.include?(p) }
+        return nil unless required_defaults.all? { |k, v| merged[k] == v }
+
+        generate_from_segments(segments, params, merged, options)
       end
 
       def segments
         @segments ||= begin
-          parse_segments(Utils.extract_regexp_parts(self))
-        rescue ArgumentError
-          Const::EMPTY_ARRAY
+          defaults
+          segments = []
+          catch(:halt) do
+            expression = Utils.parse_regexp(self)
+            segments = parse_segments(expression)
+          end
+          segments
         end
       end
 
@@ -61,60 +74,86 @@ module Rack::Mount
       end
 
       def required_captures
-        segments.find_all { |s| s.is_a?(DynamicSegment) }
+        @required_captures ||= segments.find_all { |s|
+          s.is_a?(DynamicSegment) && !@defaults.include?(s.name)
+        }.freeze
+      end
+
+      def required_params
+        @required_params ||= required_captures.map { |s| s.name }.freeze
+      end
+
+      def required_defaults
+        @required_defaults ||= begin
+          required_defaults = @defaults.dup
+          captures.inject({}) { |h, s| h.merge!(s.to_hash) }.keys.each { |name|
+            required_defaults.delete(name)
+          }
+          required_defaults
+        end
+      end
+
+      def freeze
+        segments
+        captures
+        required_captures
+        required_params
+        required_defaults
+        super
       end
 
       private
         def parse_segments(segments)
           s = []
-          segments.each do |part|
-            if part.is_a?(String) && part == Const::NULL
-              return s
-            elsif part.is_a?(Utils::Capture)
-              if part.named?
-                source = part.map { |p| p.to_s }.join
-                requirement = Regexp.compile(source)
-                s << DynamicSegment.new(part.name, requirement)
+          segments.each_with_index do |part, index|
+            case part
+            when Regin::Anchor
+              # ignore
+            when Regin::Character
+              throw :halt unless part.literal?
+
+              if s.last.is_a?(String)
+                s.last << part.value.dup
               else
-                s << parse_segments(part)
+                s << part.value.dup
               end
-            else
-              part = part.gsub('\\/', '/')
-              static = Utils.extract_static_regexp(part)
-              if static.is_a?(String)
-                s << static.freeze
+            when Regin::Group
+              if part.name
+                s << DynamicSegment.new(part.name, part.expression.to_regexp(true))
               else
-                raise ArgumentError, "failed to parse #{part.inspect}"
+                s << parse_segments(part.expression)
               end
+            when Regin::Expression
+              return parse_segments(part)
+            else
+              throw :halt
             end
           end
 
-          s.freeze
+          s
         end
 
-        def generate_from_segments(segments, params, merged, defaults, optional = false)
+        EMPTY_STRING = ''.freeze
+
+        def generate_from_segments(segments, params, merged, options, optional = false)
           if optional
-            return Const::EMPTY_STRING if segments.all? { |s| s.is_a?(String) }
-            return Const::EMPTY_STRING unless segments.flatten.any? { |s|
-              params[s.name] if s.is_a?(DynamicSegment)
+            return EMPTY_STRING if segments.all? { |s| s.is_a?(String) }
+            return EMPTY_STRING unless segments.flatten.any? { |s|
+              params.has_key?(s.name) if s.is_a?(DynamicSegment)
             }
-            return Const::EMPTY_STRING if segments.any? { |segment|
+            return EMPTY_STRING if segments.any? { |segment|
               if segment.is_a?(DynamicSegment)
-                value = merged[segment.name] || defaults[segment.name]
-                value = value.to_param if value.respond_to?(:to_param)
-
-                merged_value = merged[segment.name]
-                merged_value = merged_value.to_param if merged_value.respond_to?(:to_param)
+                value = merged[segment.name] || @defaults[segment.name]
+                value = parameterize(segment.name, value, options)
 
-                default_value = defaults[segment.name]
-                default_value = default_value.to_param if default_value.respond_to?(:to_param)
+                merged_value  = parameterize(segment.name, merged[segment.name], options)
+                default_value = parameterize(segment.name, @defaults[segment.name], options)
 
                 if value.nil? || segment !~ value
                   true
                 elsif merged_value == default_value
                   # Nasty control flow
                   return :clear_remaining_segments
-                  true
                 else
                   false
                 end
@@ -127,20 +166,20 @@ module Rack::Mount
             when String
               segment
             when DynamicSegment
-              value = params[segment.name] || merged[segment.name] || defaults[segment.name]
-              value = value.to_param if value.respond_to?(:to_param)
+              value = params[segment.name] || merged[segment.name] || @defaults[segment.name]
+              value = parameterize(segment.name, value, options)
               if value && segment =~ value.to_s
                 value
               else
                 return
               end
             when Array
-              value = generate_from_segments(segment, params, merged, defaults, true)
+              value = generate_from_segments(segment, params, merged, options, true)
               if value == :clear_remaining_segments
                 segment.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
-                Const::EMPTY_STRING
+                EMPTY_STRING
               elsif value.nil?
-                Const::EMPTY_STRING
+                EMPTY_STRING
               else
                 value
               end
@@ -152,6 +191,14 @@ module Rack::Mount
 
           generated.join
         end
+
+        def parameterize(name, value, options)
+          if block = options[:parameterize]
+            block.call(name, value)
+          else
+            value
+          end
+        end
     end
     include InstanceMethods
 

data/lib/rack/mount/multimap.rb

@@ -1,26 +1,14 @@
-begin
-  require 'nested_multimap'
-rescue LoadError
-  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/multimap'))
-  require 'nested_multimap'
-end
-
 module Rack::Mount
-  class Multimap < NestedMultimap #:nodoc:
-    def self.[](*args)
-      map = super
-      map.instance_variable_set('@fuzz', {})
-      map
-    end
-
+  class Multimap #:nodoc:
     def initialize(default = [])
-      @fuzz = {}
-      super
+      @hash = Hash.new(default)
     end
 
     def initialize_copy(original)
-      @fuzz = original.instance_variable_get('@fuzz').dup
-      super
+      @hash = Hash.new(original.default.dup)
+      original.hash.each_pair do |key, container|
+        @hash[key] = container.dup
+      end
     end
 
     def store(*args)
@@ -35,15 +23,14 @@ module Rack::Mount
       end
 
       if key.is_a?(Regexp)
-        @fuzz[value] = key
         if keys.empty?
-          hash_each_pair { |k, l| l << value if k =~ key }
+          @hash.each_pair { |k, l| l << value if k =~ key }
           self.default << value
         else
-          hash_each_pair { |k, _|
+          @hash.each_pair { |k, _|
             if k =~ key
               args[0] = k
-              super(*args)
+              _store(*args)
             end
           }
 
@@ -51,19 +38,20 @@ module Rack::Mount
           default[*keys.dup] = value
         end
       else
-        super(*args)
+        _store(*args)
       end
     end
     alias_method :[]=, :store
 
-    def freeze
-      @fuzz.clear
-      @fuzz = nil
-      super
+    def [](*keys)
+      i, l, r, k = 0, keys.length, self, self.class
+      while r.is_a?(k)
+        r = i < l ? r.hash[keys[i]] : r.default
+        i += 1
+      end
+      r
     end
 
-    undef :index, :invert
-
     def height
       containers_with_default.max { |a, b| a.length <=> b.length }.length
     end
@@ -73,20 +61,75 @@ module Rack::Mount
       lengths.inject(0) { |sum, len| sum += len }.to_f / lengths.size
     end
 
+    def containers_with_default
+      containers = []
+      each_container_with_default { |container| containers << container }
+      containers
+    end
+
     protected
-      def update_container(key) #:nodoc:
-        super do |container|
-          if container.is_a?(self.class)
-            container.each_container_with_default do |c|
-              c.delete_if do |value|
-                (requirement = @fuzz[value]) && key !~ requirement
-              end
-            end
-          else
-            container.delete_if do |value|
-              (requirement = @fuzz[value]) && key !~ requirement
-            end
+      def _store(*args)
+        keys  = args
+        value = args.pop
+
+        raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
+
+        if keys.length > 1
+          update_container(keys.shift) do |container|
+            container = self.class.new(container) unless container.is_a?(self.class)
+            container[*keys] = value
+            container
           end
+        elsif keys.length == 1
+          update_container(keys.first) do |container|
+            container << value
+            container
+          end
+        else
+          self << value
+        end
+      end
+
+      def <<(value)
+        @hash.each_value { |container| container << value }
+        self.default << value
+        self
+      end
+
+      def each_container_with_default(&block)
+        @hash.each_value do |container|
+          iterate_over_container(container, &block)
+        end
+        iterate_over_container(default, &block)
+        self
+      end
+
+      def default
+        @hash.default
+      end
+
+      def default=(value)
+        @hash.default = value
+      end
+
+      def hash
+        @hash
+      end
+
+    private
+      def update_container(key)
+        container = @hash[key]
+        container = container.dup if container.equal?(default)
+        container = yield(container)
+        @hash[key] = container
+      end
+
+      def iterate_over_container(container)
+        if container.respond_to?(:each_container_with_default)
+          container.each_container_with_default do |value|
+            yield value
+          end
+        else
           yield container
         end
       end

data/lib/rack/mount/prefix.rb

@@ -2,26 +2,31 @@ require 'rack/mount/utils'
 
 module Rack::Mount
   class Prefix #:nodoc:
+    EMPTY_STRING = ''.freeze
+    PATH_INFO    = 'PATH_INFO'.freeze
+    SCRIPT_NAME  = 'SCRIPT_NAME'.freeze
+    SLASH        = '/'.freeze
+
     KEY = 'rack.mount.prefix'.freeze
 
     def initialize(app, prefix = nil)
-      @app, @prefix = app, prefix.freeze
+      @app, @prefix = app, prefix
       freeze
     end
 
     def call(env)
       if prefix = env[KEY] || @prefix
-        old_path_info = env[Const::PATH_INFO].dup
-        old_script_name = env[Const::SCRIPT_NAME].dup
+        old_path_info = env[PATH_INFO].dup
+        old_script_name = env[SCRIPT_NAME].dup
 
         begin
-          env[Const::PATH_INFO] = Utils.normalize_path(env[Const::PATH_INFO].sub(prefix, Const::EMPTY_STRING))
-          env[Const::PATH_INFO] = Const::EMPTY_STRING if env[Const::PATH_INFO] == Const::SLASH
-          env[Const::SCRIPT_NAME] = Utils.normalize_path(env[Const::SCRIPT_NAME].to_s + prefix)
+          env[PATH_INFO] = env[PATH_INFO].sub(prefix, EMPTY_STRING)
+          env[PATH_INFO] = EMPTY_STRING if env[PATH_INFO] == SLASH
+          env[SCRIPT_NAME] = Utils.normalize_path(env[SCRIPT_NAME].to_s + prefix)
           @app.call(env)
         ensure
-          env[Const::PATH_INFO] = old_path_info
-          env[Const::SCRIPT_NAME] = old_script_name
+          env[PATH_INFO] = old_path_info
+          env[SCRIPT_NAME] = old_script_name
         end
       else
         @app.call(env)

data/lib/rack/mount/regexp_with_named_groups.rb

@@ -1,7 +1,9 @@
-require 'rack/mount/utils'
-
 module Rack::Mount
-  unless Const::SUPPORTS_NAMED_CAPTURES
+  if Regin.regexp_supports_named_captures?
+    RegexpWithNamedGroups = Regexp
+  else
+    require 'strscan'
+
     # A wrapper that adds shim named capture support to older
     # versions of Ruby.
     #
@@ -26,9 +28,25 @@ module Rack::Mount
 
       # Wraps Regexp with named capture support.
       def initialize(regexp)
-        regexp, @names = Utils.extract_named_captures(regexp)
+        regexp = Regexp.compile(regexp) unless regexp.is_a?(Regexp)
+        source, options = regexp.source, regexp.options
+        @names, scanner = [], StringScanner.new(source)
+
+        while scanner.skip_until(/\(/)
+          if scanner.scan(/\?:<([^>]+)>/)
+            @names << scanner[1]
+          elsif scanner.scan(/\?(i?m?x?\-?i?m?x?)?:/)
+            # ignore noncapture
+          else
+            @names << nil
+          end
+        end
+        source.gsub!(/\?:<([^>]+)>/, '')
+
+        @names = [] unless @names.any?
         @names.freeze
-        super(regexp)
+
+        super(source, options)
       end
 
       def names
@@ -42,8 +60,10 @@ module Rack::Mount
         }
         named_captures
       end
+
+      def eql?(other)
+        super && @names.eql?(other.names)
+      end
     end
-  else
-    RegexpWithNamedGroups = Regexp
   end
 end

data/lib/rack/mount/route.rb

@@ -9,11 +9,6 @@ module Rack::Mount
   # new Route objects. Instead use the factory method, RouteSet#add_route
   # to create new routes and add them to the set.
   class Route
-    extend Mixover
-
-    # Include generation and recognition concerns
-    include Generation::Route, Recognition::Route
-
     # Valid rack application to call if conditions are met
     attr_reader :app
 
@@ -27,41 +22,103 @@ module Rack::Mount
     # Symbol identifier for the route used with named route generations
     attr_reader :name
 
-    def initialize(set, app, conditions, defaults, name)
-      @set = set
+    attr_reader :named_captures
 
+    def initialize(app, conditions, defaults, name)
       unless app.respond_to?(:call)
         raise ArgumentError, 'app must be a valid rack application' \
           ' and respond to call'
       end
       @app = app
 
-      @name = name.to_sym if name
+      @name = name ? name.to_sym : nil
       @defaults = (defaults || {}).freeze
 
-      unless conditions.is_a?(Hash)
-        raise ArgumentError, 'conditions must be a Hash'
-      end
       @conditions = {}
 
       conditions.each do |method, pattern|
         next unless method && pattern
 
-        unless @set.valid_conditions.include?(method)
-          raise ArgumentError, 'conditions may only include ' +
-            @set.valid_conditions.inspect
+        pattern = Regexp.compile("\\A#{Regexp.escape(pattern)}\\Z") if pattern.is_a?(String)
+
+        if pattern.is_a?(Regexp)
+          pattern = Utils.normalize_extended_expression(pattern)
+          pattern = RegexpWithNamedGroups.new(pattern)
+          pattern.extend(GeneratableRegexp::InstanceMethods)
+          pattern.defaults = @defaults
         end
 
-        pattern = Regexp.compile("\\A#{Regexp.escape(pattern)}\\Z") if pattern.is_a?(String)
-        pattern = Utils.normalize_extended_expression(pattern)
-        pattern = RegexpWithNamedGroups.new(pattern)
-        pattern.extend(GeneratableRegexp::InstanceMethods)
         @conditions[method] = pattern.freeze
       end
 
+      @named_captures = {}
+      @conditions.map { |method, condition|
+        next unless condition.respond_to?(:named_captures)
+        @named_captures[method] = Hash[condition.named_captures.map { |k, v|
+          [k.to_sym, v.last - 1]
+        }].freeze
+      }
+      @named_captures.freeze
+
+      @has_significant_params = @conditions.any? { |method, condition|
+        (condition.respond_to?(:required_params) && condition.required_params.any?) ||
+          (condition.respond_to?(:required_defaults) && condition.required_defaults.any?)
+      }
+
+      if @conditions.has_key?(:path_info) &&
+          !Utils.regexp_anchored?(@conditions[:path_info])
+        @prefix = true
+        @app = Prefix.new(@app)
+      else
+        @prefix = false
+      end
+
       @conditions.freeze
     end
 
+    def prefix?
+      @prefix
+    end
+
+
+    def generation_keys
+      @conditions.inject({}) { |keys, (_, condition)|
+        if condition.respond_to?(:required_defaults)
+          keys.merge!(condition.required_defaults)
+        else
+          keys
+        end
+      }
+    end
+
+    def significant_params?
+      @has_significant_params
+    end
+
+    def generate(method, params = {}, recall = {}, options = {})
+      if method.nil?
+        result = Hash[@conditions.map { |m, condition|
+          [m, condition.generate(params, recall, options)] if condition.respond_to?(:generate)
+        }]
+        return nil if result.values.compact.empty?
+      else
+        if condition = @conditions[method]
+          if condition.respond_to?(:generate)
+            result = condition.generate(params, recall, options)
+          end
+        end
+      end
+
+      if result
+        @defaults.each do |key, value|
+          params.delete(key) if params[key] == value
+        end
+      end
+
+      result
+    end
+
+
     def inspect #:nodoc:
       "#<#{self.class.name} @app=#{@app.inspect} @conditions=#{@conditions.inspect} @defaults=#{@defaults.inspect} @name=#{@name.inspect}>"
     end