rack-mount 0.0.1 → 0.8.3

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

@@ -1,57 +0,0 @@
-require 'rack/mount/utils'
-
-module Rack::Mount
-  module Generation
-    module Route #:nodoc:
-      attr_reader :generation_keys
-
-      def initialize(*args)
-        super
-
-        @required_params = {}
-        @required_defaults = {}
-        @generation_keys = @defaults.dup
-
-        @conditions.each do |method, condition|
-          @required_params[method] = @conditions[method].required_captures.map { |s| s.name }.reject { |s| @defaults.include?(s) }.freeze
-          @required_defaults[method] = @defaults.dup
-          @conditions[method].captures.inject({}) { |h, s| h.merge!(s.to_hash) }.keys.each { |name|
-            @required_defaults[method].delete(name)
-            @generation_keys.delete(name) if @defaults.include?(name)
-          }
-          @required_defaults[method].freeze
-        end
-
-        @required_params.freeze
-        @required_defaults.freeze
-        @generation_keys.freeze
-      end
-
-      def generate(methods, params = {}, recall = {})
-        if methods.is_a?(Array)
-          result = methods.map { |m| generate_method(m, params, recall, @defaults) || (return nil) }
-        else
-          result = generate_method(methods, params, recall, @defaults)
-        end
-
-        if result
-          @defaults.each do |key, value|
-            params.delete(key) if params[key] == value
-          end
-        end
-
-        result
-      end
-
-      private
-        def generate_method(method, params, recall, defaults)
-          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)
-        end
-    end
-  end
-end

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

@@ -1,163 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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/recognition/code_generation.rb

@@ -1,99 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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