rack-mount 0.0.1

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

@@ -0,0 +1,163 @@
+require 'rack/mount/utils'
+require 'forwardable'
+
+module Rack::Mount
+  module Generation
+    module RouteSet
+      # Adds generation related concerns to RouteSet.new.
+      def initialize(*args)
+        @named_routes = {}
+        @generation_key_analyzer = Analysis::Frequency.new
+
+        super
+      end
+
+      # Adds generation aspects to RouteSet#add_route.
+      def add_route(*args)
+        route = super
+        @named_routes[route.name] = route if route.name
+        @generation_key_analyzer << route.generation_keys
+        route
+      end
+
+      # Generates path from identifiers or significant keys.
+      #
+      # To generate a url by named route, pass the name in as a +Symbol+.
+      #   url(:dashboard) # => "/dashboard"
+      #
+      # Additional parameters can be passed in as a hash
+      #   url(:people, :id => "1") # => "/people/1"
+      #
+      # If no name route is given, it will fall back to a slower
+      # generation search.
+      #   url(:controller => "people", :action => "show", :id => "1")
+      #     # => "/people/1"
+      def url(*args)
+        named_route, params, recall = extract_params!(*args)
+
+        params = URISegment.wrap_values(params)
+        recall = URISegment.wrap_values(recall)
+
+        unless result = generate(:path_info, named_route, params, recall)
+          return
+        end
+
+        uri, params = result
+        params.each do |k, v|
+          if v._value
+            params[k] = v._value
+          else
+            params.delete(k)
+          end
+        end
+
+        uri << "?#{Utils.build_nested_query(params)}" if uri && params.any?
+        uri
+      end
+
+      def generate(method, *args) #:nodoc:
+        raise 'route set not finalized' unless @generation_graph
+
+        named_route, params, recall = 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, params]
+          else
+            raise RoutingError, "#{named_route} failed to generate from #{params.inspect}"
+          end
+        else
+          keys = @generation_keys.map { |key|
+            if k = merged[key]
+              k.to_s
+            else
+              nil
+            end
+          }
+          @generation_graph[*keys].each do |r|
+            if url = r.generate(method, params, recall)
+              return [url, params]
+            end
+          end
+
+          raise RoutingError, "No route matches #{params.inspect}"
+        end
+      end
+
+      def rehash #:nodoc:
+        @generation_keys  = build_generation_keys
+        @generation_graph = build_generation_graph
+
+        super
+      end
+
+      private
+        def expire!
+          @generation_keys = @generation_graph = nil
+          super
+        end
+
+        def build_generation_graph
+          build_nested_route_set(@generation_keys) { |k, i|
+            if k = @generation_key_analyzer.possible_keys[i][k]
+              k.to_s
+            else
+              nil
+            end
+          }
+        end
+
+        def build_generation_keys
+          @generation_key_analyzer.report
+        end
+
+        def extract_params!(*args)
+          case args.length
+          when 3
+            named_route, params, recall = args
+          when 2
+            if args[0].is_a?(Hash) && args[1].is_a?(Hash)
+              params, recall = args
+            else
+              named_route, params = args
+            end
+          when 1
+            if args[0].is_a?(Hash)
+              params = args[0]
+            else
+              named_route = args[0]
+            end
+          else
+            raise ArgumentError
+          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
+
+          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
+        end
+    end
+  end
+end

data/lib/rack/mount/meta_method.rb

@@ -0,0 +1,104 @@
+module Rack::Mount
+  class MetaMethod #:nodoc:
+    class Block < Array #:nodoc:
+      def initialize(*parts)
+        replace(parts)
+        yield(self) if block_given?
+      end
+
+      def multiline?
+        length > 1
+      end
+
+      def inspect(indented = 2)
+        return Const::EMPTY_STRING if empty?
+        space = ' ' * indented
+        space + map { |p|
+          if p.is_a?(Condition)
+            p.inspect(indented)
+          else
+            p
+          end
+        }.join("\n#{space}")
+      end
+
+      def to_str
+        map { |p| p.to_str }.join('; ')
+      end
+    end
+
+    class Condition #:nodoc:
+      attr_accessor :body, :else
+
+      def initialize(*conditions)
+        @conditions = conditions.map { |c| c.is_a?(Block) ? c : Block.new(c) }
+        @body = Block.new
+        @else = Block.new
+        yield(@body) if block_given?
+      end
+
+      def <<(condition)
+        @conditions << condition
+      end
+
+      def inspect(indented = 2)
+        return @body.inspect(indented) if @conditions.empty?
+        space = ' ' * indented
+        str = 'if '
+        str << @conditions.map { |b|
+          b.multiline? ?
+            "begin\n#{b.inspect(indented + 4)}\n#{space}  end" :
+            b.inspect(0)
+        }.join(' && ')
+        str << "\n#{@body.inspect(indented + 2)}" if @body.any?
+        if @else.any?
+          str << "\n#{space}else\n#{@else.inspect(indented + 2)}"
+        end
+        str << "\n#{space}end"
+        str
+      end
+
+      def to_str
+        return @body.to_str if @conditions.empty?
+        str = 'if '
+        str << @conditions.map { |b|
+          b.multiline? ? "(#{b.to_str})" : b.to_str
+        }.join(' && ')
+        str << "; #{@body.to_str}" if @body.any?
+        if @else.any?
+          str << "; else; #{@else.to_str}"
+        end
+        str << "; end"
+        str
+      end
+    end
+
+    def initialize(sym, *args)
+      @sym = sym
+      @args = args
+      @body = Block.new
+    end
+
+    def <<(line)
+      @body << line
+    end
+
+    def inspect
+      str = ""
+      str << "def #{@sym}"
+      str << "(#{@args.join(', ')})" if @args.any?
+      str << "\n#{@body.inspect}" if @body.any?
+      str << "\nend\n"
+      str
+    end
+
+    def to_str
+      str = []
+      str << "def #{@sym}"
+      str << "(#{@args.join(', ')})" if @args.any?
+      str << "\n#{@body.to_str}" if @body.any?
+      str << "\nend"
+      str.join
+    end
+  end
+end

data/lib/rack/mount/mixover.rb

@@ -0,0 +1,47 @@
+module Rack::Mount
+  # A mixin that changes the behavior of +include+. Instead of modules
+  # being chained as a superclass, they are mixed into the objects
+  # metaclass. This allows mixins to be stacked ontop of the instance
+  # methods.
+  module Mixover
+    module InstanceMethods #:nodoc:
+      def dup
+        obj = super
+        included_modules = (class << self; included_modules; end) - (class << obj; included_modules; end)
+        included_modules.reverse.each { |mod| obj.extend(mod) }
+        obj
+      end
+    end
+
+    # Replaces include with a lazy version.
+    def include(*mod)
+      (@included_modules ||= []).push(*mod)
+    end
+
+    def new(*args, &block) #:nodoc:
+      obj = allocate
+      obj.extend(InstanceMethods)
+      (@included_modules ||= []).each { |mod| obj.extend(mod) }
+      obj.send(:initialize, *args, &block)
+      obj
+    end
+
+    # Create a new class without an included module.
+    def new_without_module(mod, *args, &block)
+      old_included_modules = (@included_modules ||= []).dup
+      @included_modules.delete(mod)
+      new(*args, &block)
+    ensure
+      @included_modules = old_included_modules
+    end
+
+    # Create a new class temporarily with a module.
+    def new_with_module(mod, *args, &block)
+      old_included_modules = (@included_modules ||= []).dup
+      include(mod)
+      new(*args, &block)
+    ensure
+      @included_modules = old_included_modules
+    end
+  end
+end

data/lib/rack/mount/multimap.rb

@@ -0,0 +1,94 @@
+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
+
+    def initialize(default = [])
+      @fuzz = {}
+      super
+    end
+
+    def initialize_copy(original)
+      @fuzz = original.instance_variable_get('@fuzz').dup
+      super
+    end
+
+    def store(*args)
+      keys  = args.dup
+      value = keys.pop
+      key   = keys.shift
+
+      raise ArgumentError, 'wrong number of arguments (1 for 2)' unless value
+
+      unless key.respond_to?(:=~)
+        raise ArgumentError, "unsupported key: #{args.first.inspect}"
+      end
+
+      if key.is_a?(Regexp)
+        @fuzz[value] = key
+        if keys.empty?
+          hash_each_pair { |k, l| l << value if k =~ key }
+          self.default << value
+        else
+          hash_each_pair { |k, _|
+            if k =~ key
+              args[0] = k
+              super(*args)
+            end
+          }
+
+          self.default = self.class.new(default) unless default.is_a?(self.class)
+          default[*keys.dup] = value
+        end
+      else
+        super(*args)
+      end
+    end
+    alias_method :[]=, :store
+
+    def freeze
+      @fuzz.clear
+      @fuzz = nil
+      super
+    end
+
+    undef :index, :invert
+
+    def height
+      containers_with_default.max { |a, b| a.length <=> b.length }.length
+    end
+
+    def average_height
+      lengths = containers_with_default.map { |e| e.length }
+      lengths.inject(0) { |sum, len| sum += len }.to_f / lengths.size
+    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
+          end
+          yield container
+        end
+      end
+  end
+end

data/lib/rack/mount/prefix.rb

@@ -0,0 +1,31 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class Prefix #:nodoc:
+    KEY = 'rack.mount.prefix'.freeze
+
+    def initialize(app, prefix = nil)
+      @app, @prefix = app, prefix.freeze
+      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
+
+        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)
+          @app.call(env)
+        ensure
+          env[Const::PATH_INFO] = old_path_info
+          env[Const::SCRIPT_NAME] = old_script_name
+        end
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rack/mount/recognition/code_generation.rb

@@ -0,0 +1,99 @@
+require 'rack/mount/meta_method'
+
+module Rack::Mount
+  module Recognition
+    module CodeGeneration #:nodoc:
+      def _expired_call(env) #:nodoc:
+        raise 'route set not finalized'
+      end
+
+      def rehash
+        super
+        optimize_call!
+      end
+
+      private
+        def expire!
+          class << self
+            alias_method :call, :_expired_call
+          end
+
+          super
+        end
+
+        def optimize_container_iterator(container)
+          m = MetaMethod.new(:optimized_each, :req)
+          m << 'env = req.env'
+
+          container.each_with_index { |route, i|
+            path_info_unanchored = route.conditions[:path_info] &&
+              !Utils.regexp_anchored?(route.conditions[:path_info])
+            m << "route = self[#{i}]"
+            m << 'routing_args = route.defaults.dup'
+
+            m << matchers = MetaMethod::Condition.new do |body|
+              body << "env[#{@parameters_key.inspect}] = routing_args"
+              body << "response = route.app.call(env)"
+              body << "return response unless response[0].to_i == 417"
+            end
+
+            route.conditions.each do |method, condition|
+              matchers << MetaMethod::Block.new do |matcher|
+                matcher << c = MetaMethod::Condition.new("m = req.#{method}.match(#{condition.inspect})") do |b|
+                  b << "matches = m.captures" if route.named_captures[method].any?
+                  route.named_captures[method].each do |k, i|
+                    b << MetaMethod::Condition.new("p = matches[#{i}]") do |c2|
+                      c2 << "routing_args[#{k.inspect}] = Utils.unescape_uri(p)"
+                    end
+                  end
+                  if method == :path_info && !Utils.regexp_anchored?(condition)
+                    b << "env[Prefix::KEY] = m.to_s"
+                  end
+                  b << "true"
+                end
+                c.else = MetaMethod::Block.new("false")
+              end
+            end
+          }
+
+          m << 'nil'
+          # puts "\n#{m.inspect}"
+          container.instance_eval(m, __FILE__, __LINE__)
+        end
+
+        def optimize_call!
+          method = MetaMethod.new(:call, :env)
+
+          if @routes.empty?
+            method << 'env[Const::EXPECT] != Const::CONTINUE ? Const::NOT_FOUND_RESPONSE : Const::EXPECTATION_FAILED_RESPONSE'
+          else
+            method << 'begin'
+            method << 'set_expectation = env[Const::EXPECT] != Const::CONTINUE'
+            method << 'env[Const::EXPECT] = Const::CONTINUE if set_expectation'
+
+            method << 'env[Const::PATH_INFO] = Utils.normalize_path(env[Const::PATH_INFO])'
+            method << "req = #{@request_class.name}.new(env)"
+            cache = false
+            keys = @recognition_keys.map { |key|
+              if key.is_a?(Array)
+                cache = true
+                key.call_source(:cache, :req)
+              else
+                "req.#{key}"
+              end
+            }.join(', ')
+            method << 'cache = {}' if cache
+            method << "container = @recognition_graph[#{keys}]"
+            method << "optimize_container_iterator(container) unless container.respond_to?(:optimized_each)"
+            method << "container.optimized_each(req) || (set_expectation ? Const::NOT_FOUND_RESPONSE : Const::EXPECTATION_FAILED_RESPONSE)"
+            method << 'ensure'
+            method << 'env.delete(Const::EXPECT) if set_expectation'
+            method << 'end'
+          end
+
+          # puts "\n#{method.inspect}"
+          instance_eval(method, __FILE__, __LINE__)
+        end
+    end
+  end
+end

data/lib/rack/mount/recognition/route.rb

@@ -0,0 +1,59 @@
+require 'rack/mount/prefix'
+
+module Rack::Mount
+  module Recognition
+    module Route #:nodoc:
+      attr_reader :named_captures
+
+      def initialize(*args)
+        super
+
+        # TODO: Don't explict check for :path_info condition
+        if @conditions.has_key?(:path_info) &&
+            !Utils.regexp_anchored?(@conditions[:path_info])
+          @app = Prefix.new(@app)
+        end
+
+        @named_captures = {}
+        @conditions.map { |method, condition|
+          @named_captures[method] = condition.named_captures.inject({}) { |named_captures, (k, v)|
+            named_captures[k.to_sym] = v.last - 1
+            named_captures
+          }.freeze
+        }
+        @named_captures.freeze
+      end
+
+      def call(req)
+        env = req.env
+
+        routing_args = @defaults.dup
+        if @conditions.all? { |method, condition|
+          value = req.send(method)
+          if m = value.match(condition)
+            matches = m.captures
+            @named_captures[method].each { |k, i|
+              if v = matches[i]
+                # TODO: We only want to unescape params from
+                # uri related methods
+                routing_args[k] = Utils.unescape_uri(v)
+              end
+            }
+            # TODO: Don't explict check for :path_info condition
+            if method == :path_info && !Utils.regexp_anchored?(condition)
+              env[Prefix::KEY] = m.to_s
+            end
+            true
+          else
+            false
+          end
+        }
+          env[@set.parameters_key] = routing_args
+          @app.call(env)
+        else
+          Const::EXPECTATION_FAILED_RESPONSE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  module Recognition
+    module RouteSet
+      attr_reader :parameters_key
+
+      # Adds recognition related concerns to RouteSet.new.
+      def initialize(options = {})
+        @parameters_key = options.delete(:parameters_key) || Const::RACK_ROUTING_ARGS
+        @parameters_key.freeze
+        @recognition_key_analyzer = Analysis::Frequency.new_with_module(Analysis::Splitting)
+
+        super
+      end
+
+      # Adds recognition aspects to RouteSet#add_route.
+      def add_route(*args)
+        route = super
+        @recognition_key_analyzer << route.conditions
+        route
+      end
+
+      # Rack compatible recognition and dispatching method. Routes are
+      # tried until one returns a non-catch status code. If no routes
+      # match, the catch status code is returned.
+      #
+      # This method can only be invoked after the RouteSet has been
+      # finalized.
+      def call(env)
+        raise 'route set not finalized' unless @recognition_graph
+
+        set_expectation = env[Const::EXPECT] != Const::CONTINUE
+        env[Const::EXPECT] = Const::CONTINUE if set_expectation
+
+        env[Const::PATH_INFO] = Utils.normalize_path(env[Const::PATH_INFO])
+
+        cache = {}
+        req = @request_class.new(env)
+        keys = @recognition_keys.map { |key|
+          if key.is_a?(Array)
+            key.call(cache, req)
+          else
+            req.send(key)
+          end
+        }
+        @recognition_graph[*keys].each do |route|
+          result = route.call(req)
+          return result unless result[0].to_i == 417
+        end
+        set_expectation ? Const::NOT_FOUND_RESPONSE : Const::EXPECTATION_FAILED_RESPONSE
+      ensure
+        env.delete(Const::EXPECT) if set_expectation
+      end
+
+      def rehash #:nodoc:
+        @recognition_keys  = build_recognition_keys
+        @recognition_graph = build_recognition_graph
+
+        super
+      end
+
+      def valid_conditions #:nodoc:
+        @valid_conditions ||= begin
+          conditions = @request_class.instance_methods(false)
+          conditions.map! { |m| m.to_sym }
+          conditions.freeze
+        end
+      end
+
+      private
+        def expire!
+          @recognition_keys = @recognition_graph = nil
+          super
+        end
+
+        def build_recognition_graph
+          build_nested_route_set(@recognition_keys) { |k, i|
+            @recognition_key_analyzer.possible_keys[i][k]
+          }
+        end
+
+        def build_recognition_keys
+          @recognition_key_analyzer.report
+        end
+    end
+  end
+end