rack-mount 0.0.1 → 0.0.2

data/README.rdoc

@@ -21,7 +21,7 @@ The API is extremely minimal and only 3 methods are exposed as the public API.
     # add_route takes a rack application and conditions to match with
     # conditions may be strings or regexps
     # See Rack::Mount::RouteSet#add_route for more options.
-    set.add_route FooApp, :method => 'get' :path => %{/foo}
+    set.add_route FooApp, :method => 'get', :path => %{/foo}
   end
 
   # The route set itself is a simple rack app you mount

data/lib/rack/mount.rb

@@ -2,9 +2,7 @@ require 'rack'
 
 module Rack #:nodoc:
   module Mount #:nodoc:
-    autoload :Const, 'rack/mount/const'
     autoload :GeneratableRegexp, 'rack/mount/generatable_regexp'
-    autoload :MetaMethod, 'rack/mount/meta_method'
     autoload :Mixover, 'rack/mount/mixover'
     autoload :Multimap, 'rack/mount/multimap'
     autoload :Prefix, 'rack/mount/prefix'

data/lib/rack/mount/analysis/frequency.rb

@@ -1,3 +1,5 @@
+require 'rack/mount/utils'
+
 module Rack::Mount
   module Analysis
     class Frequency #:nodoc:
@@ -33,10 +35,15 @@ module Rack::Mount
 
       def process_key(requirements, method, requirement)
         if requirement.is_a?(Regexp)
-          requirements[method] = Utils.extract_static_regexp(requirement)
-        else
-          requirements[method] = requirement
+          expression = Utils.parse_regexp(requirement)
+          expression.reject! { |e| e.is_a?(Reginald::Anchor) }
+
+          if expression.is_a?(Reginald::Expression) && expression.literal?
+            return requirements[method] = expression.to_s
+          end
         end
+
+        requirements[method] = requirement
       end
 
       def report

data/lib/rack/mount/analysis/splitting.rb

@@ -1,6 +1,10 @@
+require 'rack/mount/utils'
+
 module Rack::Mount
   module Analysis
     module Splitting
+      NULL = "\0".freeze
+
       class Key < Array
         def initialize(method, index, separators)
           replace([method, index, separators])
@@ -8,8 +12,8 @@ module Rack::Mount
 
         def self.split(value, separator_pattern)
           keys = value.split(separator_pattern)
-          keys.shift if keys[0] == Const::EMPTY_STRING
-          keys << Const::NULL
+          keys.shift if keys[0] == ''
+          keys << NULL
           keys
         end
 
@@ -53,93 +57,106 @@ module Rack::Mount
         def analyze_capture_boundaries(regexp, boundaries) #:nodoc:
           return boundaries unless regexp.is_a?(Regexp)
 
-          parts = Utils.extract_regexp_parts(regexp) rescue []
+          parts = Utils.parse_regexp(regexp)
           parts.each_with_index do |part, index|
-            break if part == Const::NULL
-
-            if index > 0
-              previous = parts[index-1]
-              if previous.is_a?(Utils::Capture)
-                previous = Utils.extract_static_regexp(previous.last_part) rescue nil
+            if part.is_a?(Reginald::Group)
+              if index > 0
+                previous = parts[index-1]
+                if previous.is_a?(Reginald::Character)
+                  boundaries << previous.to_str
+                end
               end
-              boundaries << previous[-1..-1] if previous.is_a?(String)
-            end
 
-            if index < parts.length
-              following = parts[index+1]
-              if following.is_a?(Utils::Capture)
-                following = Utils.extract_static_regexp(following.first_part) rescue nil
+              if inside = part[0][0]
+                if inside.is_a?(Reginald::Character)
+                  boundaries << inside.to_str
+                end
               end
-              if following.is_a?(String) && following != Const::NULL
-                boundaries << following[0..0] == '\\' ? following[1..1] : following[0..0]
+
+              if index < parts.length
+                following = parts[index+1]
+                if following.is_a?(Reginald::Character)
+                  boundaries << following.to_str
+                end
               end
             end
           end
+
           boundaries
         end
 
         def generate_split_keys(regexp, separators) #:nodoc:
-          escaped_separators = separators.map { |s| Regexp.escape(s) }
-          separators_regexp = Regexp.union(*escaped_separators)
-          segments, previous = [], nil
-          regexp_options = regexp.options
-
-          begin
-            Utils.extract_regexp_parts(regexp).each do |part|
-              if part.respond_to?(:optional?) && part.optional?
-                if escaped_separators.include?(part.first)
-                  append_to_segments!(segments, previous, separators, regexp_options)
-                end
-
-                raise ArgumentError
+          segments = []
+          buf = nil
+          casefold = regexp.casefold?
+          parts = Utils.parse_regexp(regexp)
+          parts.each_with_index do |part, index|
+            case part
+            when Reginald::Anchor
+              if part.value == '$' || part.value == '\Z'
+                segments << join_buffer(buf, regexp) if buf
+                segments << NULL
+                buf = nil
+                break
               end
-
-              append_to_segments!(segments, previous, separators, regexp_options)
-              previous = nil
-
-              if part == Const::NULL
-                segments << Const::NULL
-                raise ArgumentError
+            when Reginald::Character
+              if separators.any? { |s| part.include?(s) }
+                segments << join_buffer(buf, regexp) if buf
+                peek = parts[index+1]
+                if peek.is_a?(Reginald::Character) && separators.include?(peek)
+                  segments << ''
+                end
+                buf = nil
+              else
+                buf ||= Reginald::Expression.new([])
+                buf << part
               end
-
-              if part.is_a?(Utils::Capture)
-                source = part.map { |p| p.to_s }.join
-                append_to_segments!(segments, source, separators, regexp_options)
+            when Reginald::Group
+              if part.quantifier == '?'
+                value = part.expression.first
+                if separators.any? { |s| value.include?(s) }
+                  segments << join_buffer(buf, regexp) if buf
+                  buf = nil
+                end
+                break
+              elsif part.quantifier == nil
+                break if separators.any? { |s| part.include?(s) }
+                buf = nil
+                segments << part.to_regexp
               else
-                parts = part.split(separators_regexp)
-                parts.shift if parts[0] == Const::EMPTY_STRING
-                previous = parts.pop
-                parts.each { |p| append_to_segments!(segments, p, separators, regexp_options) }
+                break
               end
+            when Reginald::CharacterClass
+              break if separators.any? { |s| part.include?(s) }
+              buf = nil
+              segments << part.to_regexp
+            else
+              break
             end
 
-            append_to_segments!(segments, previous, separators, regexp_options)
-          rescue ArgumentError
-            # generation failed somewhere, but lets take what we can get
+            if index + 1 == parts.size
+              segments << join_buffer(buf, regexp) if buf
+              buf = nil
+              break
+            end
           end
 
           while segments.length > 0 && (segments.last.nil? || segments.last == '')
             segments.pop
           end
 
+          segments.shift if segments[0].nil? || segments[0] == ''
+
           segments
         end
 
-        def append_to_segments!(segments, s, separators, regexp_options) #:nodoc:
-          return unless s
-          separators.each do |separator|
-            if s.gsub(/\[[^\]]+\]/, '').include?(separator)
-              raise ArgumentError
-            end
-
-            if Regexp.compile("\\A#{s}\\Z") =~ separator
-              raise ArgumentError
-            end
+        def join_buffer(parts, regexp)
+          if parts.literal? && !regexp.casefold?
+            parts.to_s
+          else
+            parts.to_regexp
           end
-
-          static = Utils.extract_static_regexp(s, regexp_options)
-          segments << (static.is_a?(String) ? static : static)
         end
-      end
+    end
   end
 end

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
@@ -43,16 +36,19 @@ module Rack::Mount
         segments.any?
       end
 
-      def generate(params = {}, recall = {}, defaults = {})
+      def generate(params = {}, recall = {}, defaults = {}, options = {})
         merged = recall.merge(params)
-        generate_from_segments(segments, params, merged, defaults)
+        generate_from_segments(segments, params, merged, defaults, options)
       end
 
       def segments
         @segments ||= begin
-          parse_segments(Utils.extract_regexp_parts(self))
-        rescue ArgumentError
-          Const::EMPTY_ARRAY
+          segments = []
+          catch(:halt) do
+            expression = Utils.parse_regexp(self)
+            segments = parse_segments(expression)
+          end
+          segments
         end
       end
 
@@ -67,54 +63,53 @@ module Rack::Mount
       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 Reginald::Anchor
+              # ignore
+            when Reginald::Character
+              if s.last.is_a?(String)
+                s.last << part.dup
               else
-                s << parse_segments(part)
+                s << part.dup
               end
-            else
-              part = part.gsub('\\/', '/')
-              static = Utils.extract_static_regexp(part)
-              if static.is_a?(String)
-                s << static.freeze
+            when Reginald::Group
+              if part.name
+                s << DynamicSegment.new(part.name, part.expression.to_regexp)
               else
-                raise ArgumentError, "failed to parse #{part.inspect}"
+                s << parse_segments(part)
               end
+            when Reginald::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, defaults, 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)
+                value = parameterize(segment.name, value, options)
 
-                merged_value = merged[segment.name]
-                merged_value = merged_value.to_param if merged_value.respond_to?(:to_param)
-
-                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
@@ -128,19 +123,19 @@ module Rack::Mount
               segment
             when DynamicSegment
               value = params[segment.name] || merged[segment.name] || defaults[segment.name]
-              value = value.to_param if value.respond_to?(:to_param)
+              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, defaults, 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 +147,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/generation/route.rb

@@ -21,17 +21,22 @@ module Rack::Mount
           }
           @required_defaults[method].freeze
         end
+        @has_significant_params = (@required_params.any? { |k, v| v.any? } || @required_defaults.any? { |k, v| v.any? }) ? true : false
 
         @required_params.freeze
         @required_defaults.freeze
         @generation_keys.freeze
       end
 
-      def generate(methods, params = {}, recall = {})
+      def significant_params?
+        @has_significant_params
+      end
+
+      def generate(methods, params = {}, recall = {}, options = {})
         if methods.is_a?(Array)
-          result = methods.map { |m| generate_method(m, params, recall, @defaults) || (return nil) }
+          result = methods.map { |m| generate_method(m, params, recall, @defaults, options) || (return nil) }
         else
-          result = generate_method(methods, params, recall, @defaults)
+          result = generate_method(methods, params, recall, @defaults, options)
         end
 
         if result
@@ -44,13 +49,13 @@ module Rack::Mount
       end
 
       private
-        def generate_method(method, params, recall, defaults)
+        def generate_method(method, params, recall, defaults, options)
           merged = recall.merge(params)
           return nil unless condition = @conditions[method]
           return nil if condition.segments.empty?
           return nil unless @required_params[method].all? { |p| merged.include?(p) }
           return nil unless @required_defaults[method].all? { |k, v| merged[k] == v }
-          condition.generate(params, recall, defaults)
+          condition.generate(params, recall, defaults, options)
         end
     end
   end

data/lib/rack/mount/generation/route_set.rb

@@ -33,19 +33,18 @@ module Rack::Mount
       #   url(:controller => "people", :action => "show", :id => "1")
       #     # => "/people/1"
       def url(*args)
-        named_route, params, recall = extract_params!(*args)
+        named_route, params, recall, options = extract_params!(*args)
 
-        params = URISegment.wrap_values(params)
-        recall = URISegment.wrap_values(recall)
+        options[:parameterize] ||= lambda { |name, value| Utils.escape_uri(value) }
 
-        unless result = generate(:path_info, named_route, params, recall)
+        unless result = generate(:path_info, named_route, params, recall, options)
           return
         end
 
         uri, params = result
         params.each do |k, v|
-          if v._value
-            params[k] = v._value
+          if v
+            params[k] = v
           else
             params.delete(k)
           end
@@ -58,14 +57,14 @@ module Rack::Mount
       def generate(method, *args) #:nodoc:
         raise 'route set not finalized' unless @generation_graph
 
-        named_route, params, recall = extract_params!(*args)
+        named_route, params, recall, options = extract_params!(*args)
         merged = recall.merge(params)
         route = nil
 
         if named_route
           if route = @named_routes[named_route.to_sym]
             recall = route.defaults.merge(recall)
-            url = route.generate(method, params, recall)
+            url = route.generate(method, params, recall, options)
             [url, params]
           else
             raise RoutingError, "#{named_route} failed to generate from #{params.inspect}"
@@ -79,7 +78,8 @@ module Rack::Mount
             end
           }
           @generation_graph[*keys].each do |r|
-            if url = r.generate(method, params, recall)
+            next unless r.significant_params?
+            if url = r.generate(method, params, recall, options)
               return [url, params]
             end
           end
@@ -103,6 +103,8 @@ module Rack::Mount
 
         def build_generation_graph
           build_nested_route_set(@generation_keys) { |k, i|
+            throw :skip unless @routes[i].significant_params?
+
             if k = @generation_key_analyzer.possible_keys[i][k]
               k.to_s
             else
@@ -117,10 +119,16 @@ module Rack::Mount
 
         def extract_params!(*args)
           case args.length
+          when 4
+            named_route, params, recall, options = args
           when 3
-            named_route, params, recall = args
+            if args[0].is_a?(Hash)
+              params, recall, options = args
+            else
+              named_route, params, recall = args
+            end
           when 2
-            if args[0].is_a?(Hash) && args[1].is_a?(Hash)
+            if args[0].is_a?(Hash)
               params, recall = args
             else
               named_route, params = args
@@ -136,27 +144,11 @@ module Rack::Mount
           end
 
           named_route ||= nil
-          params ||= {}
-          recall ||= {}
-
-          [named_route, params.dup, recall.dup]
-        end
-
-        class URISegment < Struct.new(:_value)
-          def self.wrap_values(hash)
-            hash.inject({}) { |h, (k, v)| h[k] = new(v); h }
-          end
+          params  ||= {}
+          recall  ||= {}
+          options ||= {}
 
-          extend Forwardable
-          def_delegators :_value, :==, :eql?, :hash
-
-          def to_param
-            @to_param ||= begin
-              v = _value.respond_to?(:to_param) ? _value.to_param : _value
-              Utils.escape_uri(v)
-            end
-          end
-          alias_method :to_s, :to_param
+          [named_route, params.dup, recall.dup, options.dup]
         end
     end
   end