lgierth-rack-mount 0.6.13

data/lib/rack/mount/generatable_regexp.rb

@@ -0,0 +1,210 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class GeneratableRegexp < Regexp #:nodoc:
+    class DynamicSegment #:nodoc:
+      attr_reader :name, :requirement
+
+      def initialize(name, requirement)
+        @name, @requirement = name.to_sym, requirement
+        freeze
+      end
+
+      def ==(obj)
+        @name == obj.name && @requirement == obj.requirement
+      end
+
+      def =~(str)
+        @requirement =~ str
+      end
+
+      def to_hash
+        { @name => @requirement }
+      end
+
+      def inspect
+        "/(?<#{@name}>#{@requirement.source})/"
+      end
+    end
+
+    module InstanceMethods
+      def self.extended(obj)
+        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 = {}, options = {})
+        return nil unless generatable?
+
+        merged = recall.merge(params)
+        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
+          defaults
+          segments = []
+          catch(:halt) do
+            expression = Utils.parse_regexp(self)
+            segments = parse_segments(expression)
+          end
+          segments
+        end
+      end
+
+      def captures
+        segments.flatten.find_all { |s| s.is_a?(DynamicSegment) }
+      end
+
+      def required_captures
+        @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_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 << part.value.dup
+              end
+            when Regin::Group
+              if part.name
+                s << DynamicSegment.new(part.name, part.expression.to_regexp(true))
+              else
+                s << parse_segments(part.expression)
+              end
+            when Regin::Expression
+              return parse_segments(part)
+            else
+              throw :halt
+            end
+          end
+
+          s
+        end
+
+        EMPTY_STRING = ''.freeze
+
+        def generate_from_segments(segments, params, merged, options, optional = false)
+          if optional
+            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 EMPTY_STRING if segments.any? { |segment|
+              if segment.is_a?(DynamicSegment)
+                value = merged[segment.name] || @defaults[segment.name]
+                value = parameterize(segment.name, value, options)
+
+                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
+                else
+                  false
+                end
+              end
+            }
+          end
+
+          generated = segments.map do |segment|
+            case segment
+            when String
+              segment
+            when DynamicSegment
+              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, options, true)
+              if value == :clear_remaining_segments
+                segment.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
+                EMPTY_STRING
+              elsif value.nil?
+                EMPTY_STRING
+              else
+                value
+              end
+            end
+          end
+
+          # Delete any used items from the params
+          segments.each { |s| params.delete(s.name) if s.is_a?(DynamicSegment) }
+
+          generated.join
+        end
+
+        def parameterize(name, value, options)
+          if block = options[:parameterize]
+            block.call(name, value)
+          else
+            value
+          end
+        end
+    end
+    include InstanceMethods
+
+    def initialize(regexp)
+      super
+      segments
+    end
+  end
+end

data/lib/rack/mount/multimap.rb

@@ -0,0 +1,53 @@
+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 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)
+        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
+
+    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
+  end
+end

data/lib/rack/mount/prefix.rb

@@ -0,0 +1,36 @@
+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
+      freeze
+    end
+
+    def call(env)
+      if prefix = env[KEY] || @prefix
+        old_path_info = env[PATH_INFO].dup
+        old_script_name = env[SCRIPT_NAME].dup
+
+        begin
+          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[PATH_INFO] = old_path_info
+          env[SCRIPT_NAME] = old_script_name
+        end
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rack/mount/regexp_with_named_groups.rb

@@ -0,0 +1,69 @@
+module Rack::Mount
+  if Regin.regexp_supports_named_captures?
+    RegexpWithNamedGroups = Regexp
+  else
+    require 'strscan'
+
+    # A wrapper that adds shim named capture support to older
+    # versions of Ruby.
+    #
+    # Because the named capture syntax causes a parse error, an
+    # alternate syntax is used to indicate named captures.
+    #
+    # Ruby 1.9+ named capture syntax:
+    #
+    #   /(?<foo>[a-z]+)/
+    #
+    # Ruby 1.8 shim syntax:
+    #
+    #   /(?:<foo>[a-z]+)/
+    class RegexpWithNamedGroups < Regexp
+      def self.new(regexp) #:nodoc:
+        if regexp.is_a?(RegexpWithNamedGroups)
+          regexp
+        else
+          super
+        end
+      end
+
+      # Wraps Regexp with named capture support.
+      def initialize(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(source, options)
+      end
+
+      def names
+        @names.dup
+      end
+
+      def named_captures
+        named_captures = {}
+        names.each_with_index { |n, i|
+          named_captures[n] = [i+1] if n
+        }
+        named_captures
+      end
+
+      def eql?(other)
+        super && @names.eql?(other.names)
+      end
+    end
+  end
+end

data/lib/rack/mount/route.rb

@@ -0,0 +1,130 @@
+require 'rack/mount/generatable_regexp'
+require 'rack/mount/regexp_with_named_groups'
+require 'rack/mount/utils'
+
+module Rack::Mount
+  # Route is an internal class used to wrap a single route attributes.
+  #
+  # Plugins should not depend on any method on this class or instantiate
+  # new Route objects. Instead use the factory method, RouteSet#add_route
+  # to create new routes and add them to the set.
+  class Route
+    # Valid rack application to call if conditions are met
+    attr_reader :app
+
+    # A hash of conditions to match against. Conditions may be expressed
+    # as strings or regexps to match against.
+    attr_reader :conditions
+
+    # A hash of values that always gets merged into the parameters hash
+    attr_reader :defaults
+
+    # Symbol identifier for the route used with named route generations
+    attr_reader :name
+
+    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 ? name.to_sym : nil
+      @defaults = (defaults || {}).freeze
+
+      @conditions = {}
+
+      conditions.each do |method, pattern|
+        next unless method && pattern
+
+        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
+
+        @conditions[method] = pattern.freeze
+      end
+
+      @named_captures = {}
+      @conditions.map { |method, condition|
+        next unless condition.respond_to?(:named_captures)
+        @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
+
+      @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, (method, 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 = @conditions.inject({}) { |h, (m, condition)|
+          if condition.respond_to?(:generate)
+            h[m] = condition.generate(params, recall, options)
+          end
+          h
+        }
+        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
+  end
+end