rack-mount 0.0.1

data/lib/rack/mount/regexp_with_named_groups.rb

@@ -0,0 +1,49 @@
+require 'rack/mount/utils'
+
+module Rack::Mount
+  unless Const::SUPPORTS_NAMED_CAPTURES
+    # 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, @names = Utils.extract_named_captures(regexp)
+        @names.freeze
+        super(regexp)
+      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
+    end
+  else
+    RegexpWithNamedGroups = Regexp
+  end
+end

data/lib/rack/mount/route.rb

@@ -0,0 +1,69 @@
+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
+    extend Mixover
+
+    # Include generation and recognition concerns
+    include Generation::Route, Recognition::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
+
+    def initialize(set, app, conditions, defaults, name)
+      @set = set
+
+      unless app.respond_to?(:call)
+        raise ArgumentError, 'app must be a valid rack application' \
+          ' and respond to call'
+      end
+      @app = app
+
+      @name = name.to_sym if name
+      @defaults = (defaults || {}).freeze
+
+      unless conditions.is_a?(Hash)
+        raise ArgumentError, 'conditions must be a Hash'
+      end
+      @conditions = {}
+
+      conditions.each do |method, pattern|
+        next unless method && pattern
+
+        unless @set.valid_conditions.include?(method)
+          raise ArgumentError, 'conditions may only include ' +
+            @set.valid_conditions.inspect
+        end
+
+        pattern = Regexp.compile("\\A#{Regexp.escape(pattern)}\\Z") if pattern.is_a?(String)
+        pattern = Utils.normalize_extended_expression(pattern)
+        pattern = RegexpWithNamedGroups.new(pattern)
+        pattern.extend(GeneratableRegexp::InstanceMethods)
+        @conditions[method] = pattern.freeze
+      end
+
+      @conditions.freeze
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class.name} @app=#{@app.inspect} @conditions=#{@conditions.inspect} @defaults=#{@defaults.inspect} @name=#{@name.inspect}>"
+    end
+  end
+end

data/lib/rack/mount/route_set.rb

@@ -0,0 +1,109 @@
+require 'rack/mount/multimap'
+require 'rack/mount/route'
+require 'rack/mount/utils'
+
+module Rack::Mount
+  class RouteSet
+    extend Mixover
+
+    # Include generation and recognition concerns
+    include Generation::RouteSet, Recognition::RouteSet
+    include Recognition::CodeGeneration
+
+    # Initialize a new RouteSet without optimizations
+    def self.new_without_optimizations(*args, &block)
+      new_without_module(Recognition::CodeGeneration, *args, &block)
+    end
+
+    # Basic RouteSet initializer.
+    #
+    # If a block is given, the set is yielded and finalized.
+    #
+    # See other aspects for other valid options:
+    # - <tt>Generation::RouteSet.new</tt>
+    # - <tt>Recognition::RouteSet.new</tt>
+    def initialize(options = {}, &block)
+      @request_class = options.delete(:request_class) || Rack::Request
+      @routes = []
+      expire!
+
+      if block_given?
+        yield self
+        rehash
+      end
+    end
+
+    # Builder method to add a route to the set
+    #
+    # <tt>app</tt>:: A valid Rack app to call if the conditions are met.
+    # <tt>conditions</tt>:: A hash of conditions to match against.
+    #                       Conditions may be expressed as strings or
+    #                       regexps to match against.
+    # <tt>defaults</tt>:: A hash of values that always gets merged in
+    # <tt>name</tt>:: Symbol identifier for the route used with named 
+    #                 route generations
+    def add_route(app, conditions = {}, defaults = {}, name = nil)
+      route = Route.new(self, app, conditions, defaults, name)
+      @routes << route
+      expire!
+      route
+    end
+
+    # See <tt>Recognition::RouteSet#call</tt>
+    def call(env)
+      raise NotImplementedError
+    end
+
+    # See <tt>Generation::RouteSet#url</tt>
+    def url(*args)
+      raise NotImplementedError
+    end
+
+    # See <tt>Generation::RouteSet#generate</tt>
+    def generate(*args)
+      raise NotImplementedError
+    end
+
+    # Number of routes in the set
+    def length
+      @routes.length
+    end
+
+    def rehash #:nodoc:
+    end
+
+    # Finalizes the set and builds optimized data structures. You *must*
+    # freeze the set before you can use <tt>call</tt> and <tt>url</tt>.
+    # So remember to call freeze after you are done adding routes.
+    def freeze
+      unless frozen?
+        rehash
+        @routes.each { |route| route.freeze }
+        @routes.freeze
+      end
+
+      super
+    end
+
+    private
+      def expire! #:nodoc:
+      end
+
+      # An internal helper method for constructing a nested set from
+      # the linear route set.
+      #
+      # build_nested_route_set([:request_method, :path_info]) { |route, method|
+      #   route.send(method)
+      # }
+      def build_nested_route_set(keys, &block)
+        graph = Multimap.new
+        @routes.each_with_index do |route, index|
+          k = keys.map { |key| block.call(key, index) }
+          Utils.pop_trailing_nils!(k)
+          k.map! { |key| key || /.+/ }
+          graph[*k] = route
+        end
+        graph
+      end
+  end
+end

data/lib/rack/mount/strexp.rb

@@ -0,0 +1,93 @@
+require 'strscan'
+
+module Rack::Mount
+  class Strexp < Regexp
+    # Parses segmented string expression and converts it into a Regexp
+    #
+    #   Strexp.compile('foo')
+    #     # => %r{\Afoo\Z}
+    #
+    #   Strexp.compile('foo/:bar', {}, ['/'])
+    #     # => %r{\Afoo/(?<bar>[^/]+)\Z}
+    #
+    #   Strexp.compile(':foo.example.com')
+    #     # => %r{\A(?<foo>.+)\.example\.com\Z}
+    #
+    #   Strexp.compile('foo/:bar', {:bar => /[a-z]+/}, ['/'])
+    #     # => %r{\Afoo/(?<bar>[a-z]+)\Z}
+    #
+    #   Strexp.compile('foo(.:extension)')
+    #     # => %r{\Afoo(\.(?<extension>.+))?\Z}
+    #
+    #   Strexp.compile('src/*files')
+    #     # => %r{\Asrc/(?<files>.+)\Z}
+    def initialize(str, requirements = {}, separators = [])
+      return super(str) if str.is_a?(Regexp)
+
+      re = Regexp.escape(str)
+      requirements = requirements ? requirements.dup : {}
+
+      normalize_requirements!(requirements, separators)
+      parse_dynamic_segments!(re, requirements)
+      parse_optional_segments!(re)
+
+      super("\\A#{re}\\Z")
+    end
+
+    private
+      def normalize_requirements!(requirements, separators)
+        requirements.each do |key, value|
+          if value.is_a?(Regexp)
+            if regexp_has_modifiers?(value)
+              requirements[key] = value
+            else
+              requirements[key] = value.source
+            end
+          else
+            requirements[key] = Regexp.escape(value)
+          end
+        end
+        requirements.default ||= separators.any? ?
+          "[^#{separators.join}]+" : '.+'
+        requirements
+      end
+
+      def parse_dynamic_segments!(str, requirements)
+        re, pos, scanner = '', 0, StringScanner.new(str)
+        while scanner.scan_until(/(:|\\\*)([a-zA-Z_]\w*)/)
+          pre, pos = scanner.pre_match[pos..-1], scanner.pos
+          if pre =~ /(.*)\\\\\Z/
+            re << $1 + scanner.matched
+          else
+            name = scanner[2].to_sym
+            requirement = scanner[1] == ':' ?
+              requirements[name] : '.+'
+            re << pre + Const::REGEXP_NAMED_CAPTURE % [name, requirement]
+          end
+        end
+        re << scanner.rest
+        str.replace(re)
+      end
+
+      def parse_optional_segments!(str)
+        re, pos, scanner = '', 0, StringScanner.new(str)
+        while scanner.scan_until(/\\\(|\\\)/)
+          pre, pos = scanner.pre_match[pos..-1], scanner.pos
+          if pre =~ /(.*)\\\\\Z/
+            re << $1 + scanner.matched
+          elsif scanner.matched == '\\('
+            # re << pre + '(?:'
+            re << pre + '('
+          elsif scanner.matched == '\\)'
+            re << pre + ')?'
+          end
+        end
+        re << scanner.rest
+        str.replace(re)
+      end
+
+      def regexp_has_modifiers?(regexp)
+        regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
+      end
+  end
+end

data/lib/rack/mount/utils.rb

@@ -0,0 +1,271 @@
+require 'rack/mount/regexp_with_named_groups'
+require 'strscan'
+require 'uri'
+
+module Rack::Mount
+  # Private utility methods used throughout Rack::Mount.
+  #--
+  # This module is a trash can. Try to move these functions into
+  # more appropriate contexts.
+  #++
+  module Utils
+    # Normalizes URI path.
+    #
+    # Strips off trailing slash and ensures there is a leading slash.
+    #
+    #   normalize_path("/foo")  # => "/foo"
+    #   normalize_path("/foo/") # => "/foo"
+    #   normalize_path("foo")   # => "/foo"
+    #   normalize_path("")      # => "/"
+    def normalize_path(path)
+      path = "/#{path}"
+      path.squeeze!(Const::SLASH)
+      path.sub!(%r{/+\Z}, Const::EMPTY_STRING)
+      path = Const::SLASH if path == Const::EMPTY_STRING
+      path
+    end
+    module_function :normalize_path
+
+    # Removes trailing nils from array.
+    #
+    #   pop_trailing_nils!([1, 2, 3])           # => [1, 2, 3]
+    #   pop_trailing_nils!([1, 2, 3, nil, nil]) # => [1, 2, 3]
+    #   pop_trailing_nils!([nil])               # => []
+    def pop_trailing_nils!(ary)
+      while ary.length > 0 && ary.last.nil?
+        ary.pop
+      end
+      ary
+    end
+    module_function :pop_trailing_nils!
+
+    RESERVED_PCHAR = ':@&=+$,;%'
+    SAFE_PCHAR = "#{URI::REGEXP::PATTERN::UNRESERVED}#{RESERVED_PCHAR}"
+    if RUBY_VERSION >= '1.9'
+      UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false).freeze
+    else
+      UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false, 'N').freeze
+    end
+
+    def escape_uri(uri)
+      URI.escape(uri.to_s, UNSAFE_PCHAR)
+    end
+    module_function :escape_uri
+
+    if ''.respond_to?(:force_encoding)
+      def unescape_uri(uri)
+        URI.unescape(uri).force_encoding('utf-8')
+      end
+    else
+      def unescape_uri(uri)
+        URI.unescape(uri)
+      end
+    end
+    module_function :unescape_uri
+
+    # Taken from Rack 1.1.x to build nested query strings
+    def build_nested_query(value, prefix = nil) #:nodoc:
+      case value
+      when Array
+        value.map { |v|
+          build_nested_query(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
+        }.join("&")
+      when String
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{Rack::Utils.escape(prefix)}=#{Rack::Utils.escape(value)}"
+      when NilClass
+        Rack::Utils.escape(prefix)
+      else
+        if value.respond_to?(:to_param)
+          build_nested_query(value.to_param.to_s, prefix)
+        else
+          Rack::Utils.escape(prefix)
+        end
+      end
+    end
+    module_function :build_nested_query
+
+    def normalize_extended_expression(regexp)
+      return regexp unless regexp.options & Regexp::EXTENDED != 0
+      source = regexp.source
+      source.gsub!(/#.+$/, '')
+      source.gsub!(/\s+/, '')
+      source.gsub!(/\\\//, '/')
+      Regexp.compile(source)
+    end
+    module_function :normalize_extended_expression
+
+    # Determines whether the regexp must match the entire string.
+    #
+    #   regexp_anchored?(/^foo$/) # => true
+    #   regexp_anchored?(/foo/)   # => false
+    #   regexp_anchored?(/^foo/)  # => false
+    #   regexp_anchored?(/foo$/)  # => false
+    def regexp_anchored?(regexp)
+      regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/ ? true : false
+    end
+    module_function :regexp_anchored?
+
+    # Returns static string source of Regexp if it only includes static
+    # characters and no metacharacters. Otherwise the original Regexp is
+    # returned.
+    #
+    #   extract_static_regexp(/^foo$/)      # => "foo"
+    #   extract_static_regexp(/^foo\.bar$/) # => "foo.bar"
+    #   extract_static_regexp(/^foo|bar$/)  # => /^foo|bar$/
+    def extract_static_regexp(regexp, options = nil)
+      if regexp.is_a?(String)
+        regexp = Regexp.compile("\\A#{regexp}\\Z", options)
+      end
+
+      # Just return if regexp is case-insensitive
+      return regexp if regexp.casefold?
+
+      source = regexp.source
+      if regexp_anchored?(regexp)
+        source.sub!(/^(\\A|\^)(.*)(\\Z|\$)$/, '\2')
+        unescaped_source = source.gsub(/\\/, Const::EMPTY_STRING)
+        if source == Regexp.escape(unescaped_source) &&
+            Regexp.compile("\\A(#{source})\\Z") =~ unescaped_source
+          return unescaped_source
+        end
+      end
+      regexp
+    end
+    module_function :extract_static_regexp
+
+    if Const::SUPPORTS_NAMED_CAPTURES
+      NAMED_CAPTURE_REGEXP = /\?<([^>]+)>/
+    else
+      NAMED_CAPTURE_REGEXP = /\?:<([^>]+)>/
+    end
+
+    # Strips shim named capture syntax and returns a clean Regexp and
+    # an ordered array of the named captures.
+    #
+    #   extract_named_captures(/[a-z]+/)          # => /[a-z]+/, []
+    #   extract_named_captures(/(?:<foo>[a-z]+)/) # => /([a-z]+)/, ['foo']
+    #   extract_named_captures(/([a-z]+)(?:<foo>[a-z]+)/)
+    #     # => /([a-z]+)([a-z]+)/, [nil, 'foo']
+    def extract_named_captures(regexp)
+      options = regexp.is_a?(Regexp) ? regexp.options : nil
+      source = Regexp.compile(regexp).source
+      names, scanner = [], StringScanner.new(source)
+
+      while scanner.skip_until(/\(/)
+        if scanner.scan(NAMED_CAPTURE_REGEXP)
+          names << scanner[1]
+        else
+          names << nil
+        end
+      end
+
+      names = [] unless names.any?
+      source.gsub!(NAMED_CAPTURE_REGEXP, Const::EMPTY_STRING)
+      return Regexp.compile(source, options), names
+    end
+    module_function :extract_named_captures
+
+    class Capture < Array #:nodoc:
+      attr_reader :name, :optional
+      alias_method :optional?, :optional
+
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+
+        @name = options.delete(:name)
+        @name = @name.to_s if @name
+
+        @optional = options.delete(:optional) || false
+
+        super(args)
+      end
+
+      def ==(obj)
+        obj.is_a?(Capture) && @name == obj.name && @optional == obj.optional && super
+      end
+
+      def optionalize!
+        @optional = true
+        self
+      end
+
+      def named?
+        name && name != Const::EMPTY_STRING
+      end
+
+      def to_s
+        source = "(#{join})"
+        source << '?' if optional?
+        source
+      end
+
+      def first_part
+        first.is_a?(Capture) ? first.first_part : first
+      end
+
+      def last_part
+        last.is_a?(Capture) ? last.last_part : last
+      end
+    end
+
+    def extract_regexp_parts(regexp) #:nodoc:
+      unless regexp.is_a?(RegexpWithNamedGroups)
+        regexp = RegexpWithNamedGroups.new(regexp)
+      end
+
+      if regexp.source =~ /\?<([^>]+)>/
+        regexp, names = extract_named_captures(regexp)
+      else
+        names = regexp.names
+      end
+      source = regexp.source
+
+      source =~ /^(\\A|\^)/ ? source.gsub!(/^(\\A|\^)/, Const::EMPTY_STRING) :
+        raise(ArgumentError, "#{source} needs to match the start of the string")
+
+      scanner = StringScanner.new(source)
+      stack = [[]]
+
+      capture_index = 0
+      until scanner.eos?
+        char = scanner.getch
+        cur  = stack.last
+
+        escaped = cur.last.is_a?(String) && cur.last[-1, 1] == '\\'
+
+        if char == '\\' && scanner.peek(1) == 'Z'
+          scanner.pos += 1
+          cur.push(Const::NULL)
+        elsif escaped
+          cur.push('') unless cur.last.is_a?(String)
+          cur.last << char
+        elsif char == '('
+          name = names[capture_index]
+          capture = Capture.new(:name => name)
+          capture_index += 1
+          cur.push(capture)
+          stack.push(capture)
+        elsif char == ')'
+          capture = stack.pop
+          if scanner.peek(1) == '?'
+            scanner.pos += 1
+            capture.optionalize!
+          end
+        elsif char == '$'
+          cur.push(Const::NULL)
+        else
+          cur.push('') unless cur.last.is_a?(String)
+          cur.last << char
+        end
+      end
+
+      stack.pop
+    end
+    module_function :extract_regexp_parts
+  end
+end