rack-mount 0.0.1 → 0.8.3

data/README.rdoc

@@ -2,7 +2,7 @@
 
 A stackable dynamic tree based Rack router.
 
-Rack::Mount supports Rack's Cascade style of trying several routes until it finds one that is not a 404. This allows multiple routes to be nested or stacked on top of each other. Since the application endpoint can trigger the router to continue matching, middleware can be used to add arbitrary conditions to any route. This allows you to route based on other request attributes, session information, or even data dynamically pulled from a database.
+Rack::Mount supports Rack's +X-Cascade+ convention to continue trying routes if the response returns +pass+. This allows multiple routes to be nested or stacked on top of each other. Since the application endpoint can trigger the router to continue matching, middleware can be used to add arbitrary conditions to any route. This allows you to route based on other request attributes, session information, or even data dynamically pulled from a database.
 
 === Usage
 
@@ -12,17 +12,25 @@ The API is extremely minimal and only 3 methods are exposed as the public API.
 
 <tt>Rack::Mount::RouteSet#add_route</tt>:: builder method for adding routes to the set
 <tt>Rack::Mount::RouteSet#call</tt>:: Rack compatible recognition and dispatching method
-<tt>Rack::Mount::RouteSet#url</tt>:: generates path from identifiers or significant keys
+<tt>Rack::Mount::RouteSet#generate</tt>:: generates a route condition from identifiers or significant keys
 
 === Example
 
   require 'rack/mount'
+
   Routes = Rack::Mount::RouteSet.new do |set|
     # add_route takes a rack application and conditions to match with
-    # conditions may be strings or regexps
+    #
+    # valid conditions methods are any method on Rack::Request
+    # the values to match against 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, { :request_method => 'GET', :path_info => %r{^/foo$} }, {}, :foo
   end
 
   # The route set itself is a simple rack app you mount
   run Routes
+
+
+  # generate path for route named "foo"
+  Routes.generate(:path_info, :foo) #=> "/foo"

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

@@ -6,20 +6,69 @@ module Rack::Mount
       def initialize
         @count = 0
         super(0)
+        expire_caches!
       end
 
       def <<(value)
         @count += 1
         self[value] += 1 if value
+        expire_caches!
+        self
       end
 
-      def select_upper
-        values = sort_by { |_, value| value }
-        values.reverse!
-        values = values.select { |_, value| value >= count / size }
-        values.map! { |key, _| key }
-        values
+      def sorted_by_frequency
+        sort_by { |_, value| value }.reverse!
       end
+
+      def max
+        @max ||= values.max || 0
+      end
+
+      def min
+        @min ||= values.min || 0
+      end
+
+      def mean
+        @mean ||= calculate_mean
+      end
+
+      def standard_deviation
+        @standard_deviation ||= calculate_standard_deviation
+      end
+
+      def upper_quartile_limit
+        @upper_quartile_limit ||= calculate_upper_quartile_limit
+      end
+
+      def keys_in_upper_quartile
+        @keys_in_upper_quartile ||= compute_keys_in_upper_quartile
+      end
+
+      private
+        def calculate_mean
+          count / size
+        end
+
+        def calculate_variance
+          values.inject(0) { |sum, e| sum + (e - mean) ** 2 } / count.to_f
+        end
+
+        def calculate_standard_deviation
+          Math.sqrt(calculate_variance)
+        end
+
+        def calculate_upper_quartile_limit
+          mean + standard_deviation
+        end
+
+        def compute_keys_in_upper_quartile
+          sorted_by_frequency.select { |_, value| value >= upper_quartile_limit }.map! { |key, _| key }
+        end
+
+        def expire_caches!
+          @max = @min = @mean = @standard_deviation = nil
+          @keys_in_upper_quartile = nil
+        end
     end
   end
 end

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

@@ -1,41 +1,69 @@
+require 'rack/mount/utils'
+
 module Rack::Mount
   module Analysis
-    module Splitting
-      class Key < Array
-        def initialize(method, index, separators)
-          replace([method, index, separators])
-        end
+    class Splitting
+      NULL = "\0"
 
+      class Key < Struct.new(:method, :index, :separators)
         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
 
         def call(cache, obj)
-          (cache[self[0]] ||= self.class.split(obj.send(self[0]), self[2]))[self[1]]
+          (cache[method] ||= self.class.split(obj.send(method), separators))[index]
         end
 
         def call_source(cache, obj)
-          "(#{cache}[:#{self[0]}] ||= Analysis::Splitting::Key.split(#{obj}.#{self[0]}, #{self[2].inspect}))[#{self[1]}]"
+          "(#{cache}[:#{method}] ||= Analysis::Splitting::Key.split(#{obj}.#{method}, #{separators.inspect}))[#{index}]"
+        end
+
+        def inspect
+          "#{method}[#{index}].split(#{separators.inspect})"
         end
       end
 
+      def initialize(*keys)
+        clear
+        keys.each { |key| self << key }
+      end
+
       def clear
-        @boundaries = {}
-        super
+        @raw_keys = []
+        @key_frequency = Analysis::Histogram.new
+        self
       end
 
       def <<(key)
-        super
-        key.each_pair do |k, v|
-          analyze_capture_boundaries(v, @boundaries[k] ||= Histogram.new)
+        raise ArgumentError unless key.is_a?(Hash)
+        @raw_keys << key
+        nil
+      end
+
+      def possible_keys
+        @possible_keys ||= begin
+          @raw_keys.map do |key|
+            key.inject({}) { |requirements, (method, requirement)|
+              process_key(requirements, method, requirement)
+              requirements
+            }
+          end
         end
       end
 
-      def separators(key)
-        @boundaries[key].select_upper
+      def report
+        @report ||= begin
+          possible_keys.each { |keys| keys.each_pair { |key, _| @key_frequency << key } }
+          return [] if @key_frequency.count <= 1
+          @key_frequency.keys_in_upper_quartile
+        end
+      end
+
+      def expire!
+        @possible_keys = @report = nil
       end
 
       def process_key(requirements, method, requirement)
@@ -45,77 +73,71 @@ module Rack::Mount
             requirements[Key.new(method, index, Regexp.union(*separators))] = value
           end
         else
-          super
+          if requirement.is_a?(Regexp)
+            expression = Utils.parse_regexp(requirement)
+
+            if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
+              expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
+              return requirements[method] = expression.to_s if expression.literal?
+            end
+          end
+
+          requirements[method] = requirement
         end
       end
 
       private
-        def analyze_capture_boundaries(regexp, boundaries) #:nodoc:
-          return boundaries unless regexp.is_a?(Regexp)
-
-          parts = Utils.extract_regexp_parts(regexp) rescue []
-          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
-              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
-              end
-              if following.is_a?(String) && following != Const::NULL
-                boundaries << following[0..0] == '\\' ? following[1..1] : following[0..0]
-              end
-            end
-          end
-          boundaries
+        def separators(key)
+          key == :path_info ? ["/", "."] : []
         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
+          parts = Utils.parse_regexp(regexp)
+          parts.each_with_index do |part, index|
+            case part
+            when Regin::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 Regin::CharacterClass
+              break if separators.any? { |s| part.include?(s) }
+              buf = nil
+              segments << part.to_regexp(true)
+            when Regin::Character
+              if separators.any? { |s| part.include?(s) }
+                segments << join_buffer(buf, regexp) if buf
+                peek = parts[index+1]
+                if peek.is_a?(Regin::Character) && separators.include?(peek.value)
+                  segments << ''
+                end
+                buf = nil
+              else
+                buf ||= Regin::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 Regin::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(true)
               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
+            else
+              break
             end
-
-            append_to_segments!(segments, previous, separators, regexp_options)
-          rescue ArgumentError
-            # generation failed somewhere, but lets take what we can get
           end
 
           while segments.length > 0 && (segments.last.nil? || segments.last == '')
@@ -125,21 +147,13 @@ module Rack::Mount
           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?
+            parts.to_s
+          else
+            parts.to_regexp(true)
           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/code_generation.rb

@@ -0,0 +1,120 @@
+module Rack::Mount
+  module CodeGeneration #:nodoc:
+    def _expired_recognize(env) #:nodoc:
+      raise 'route set not finalized'
+    end
+
+    def rehash
+      super
+      optimize_recognize!
+    end
+
+    private
+      def expire!
+        if @optimized_recognize_defined
+          remove_metaclass_method :recognize
+
+          class << self
+            alias_method :recognize, :_expired_recognize
+          end
+
+          @optimized_recognize_defined = false
+        end
+
+        super
+      end
+
+      def optimize_container_iterator(container)
+        Utils.debug "optimizing container - size #{container.size}"
+
+        body = []
+
+        container.each_with_index { |route, i|
+          body << "route = self[#{i}]"
+          body << 'matches = {}'
+          body << 'params = route.defaults.dup'
+
+          conditions = []
+          route.conditions.each do |method, condition|
+            b = []
+            if condition.is_a?(Regexp)
+              b << "if m = obj.#{method}.match(#{condition.inspect})"
+              b << "matches[:#{method}] = m"
+              if (named_captures = route.named_captures[method]) && named_captures.any?
+                b << 'captures = m.captures'
+                b << 'p = nil'
+                b << named_captures.map { |k, j| "params[#{k.inspect}] = p if p = captures[#{j}]" }.join('; ')
+              end
+            else
+              b << "if m = obj.#{method} == route.conditions[:#{method}]"
+            end
+            b << 'true'
+            b << 'end'
+            conditions << "(#{b.join('; ')})"
+          end
+
+          body << <<-RUBY
+            if #{conditions.join(' && ')}
+              yield route, matches, params
+            end
+          RUBY
+        }
+
+        container.instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def optimized_each(obj)
+            #{body.join("\n")}
+            nil
+          end
+        RUBY
+      end
+
+      def optimize_recognize!
+        Utils.debug "optimizing recognize"
+
+        uses_cache = false
+
+        keys = @recognition_keys.map { |key|
+          if key.respond_to?(:call_source)
+            uses_cache = true
+            key.call_source(:cache, :obj)
+          else
+            "obj.#{key}"
+          end
+        }.join(', ')
+
+        @optimized_recognize_defined = true
+
+        remove_metaclass_method :recognize
+
+        instance_eval(<<-RUBY, __FILE__, __LINE__)
+          def recognize(obj)
+            #{"cache = {}" if uses_cache}
+            container = @recognition_graph[#{keys}]
+            optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
+
+            if block_given?
+              container.optimized_each(obj) do |route, matches, params|
+                yield route, matches, params
+              end
+            else
+              container.optimized_each(obj) do |route, matches, params|
+                return route, matches, params
+              end
+            end
+
+            nil
+          end
+        RUBY
+      end
+
+      # method_defined? can't distinguish between instance
+      # and meta methods. So we have to rescue if the method
+      # has not been defined in the metaclass yet.
+      def remove_metaclass_method(symbol)
+        metaclass = class << self; self; end
+        Utils.silence_debug { metaclass.send(:remove_method, symbol) }
+      rescue NameError
+        nil
+      end
+  end
+end