rack-mount 0.0.1 → 0.8.3

data/lib/rack/mount/strexp.rb

@@ -1,93 +1,68 @@
-require 'strscan'
+require 'rack/mount/strexp/parser'
 
 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)
+  class Strexp
+    class << self
+      # 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 compile(str, requirements = {}, separators = [], anchor = true)
+        return Regexp.compile(str) if str.is_a?(Regexp)
 
-      re = Regexp.escape(str)
-      requirements = requirements ? requirements.dup : {}
+        requirements = requirements ? requirements.dup : {}
+        normalize_requirements!(requirements, separators)
 
-      normalize_requirements!(requirements, separators)
-      parse_dynamic_segments!(re, requirements)
-      parse_optional_segments!(re)
+        parser = StrexpParser.new
+        parser.anchor = anchor
+        parser.requirements = requirements
 
-      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
+        begin
+          re = parser.scan_str(str)
+        rescue Racc::ParseError => e
+          raise RegexpError, e.message
         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)
+        Regexp.compile(re)
       end
+      alias_method :new, :compile
 
-      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 + ')?'
+      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
-        re << scanner.rest
-        str.replace(re)
-      end
 
-      def regexp_has_modifiers?(regexp)
-        regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
-      end
+        def regexp_has_modifiers?(regexp)
+          regexp.options & (Regexp::IGNORECASE | Regexp::EXTENDED) != 0
+        end
+    end
   end
 end

data/lib/rack/mount/utils.rb

@@ -1,5 +1,10 @@
-require 'rack/mount/regexp_with_named_groups'
-require 'strscan'
+begin
+  require 'regin'
+rescue LoadError
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/regin'))
+  require 'regin'
+end
+
 require 'uri'
 
 module Rack::Mount
@@ -9,6 +14,19 @@ module Rack::Mount
   # more appropriate contexts.
   #++
   module Utils
+    def silence_debug
+      old_debug, $DEBUG = $DEBUG, nil
+      yield
+    ensure
+      $DEBUG = old_debug
+    end
+    module_function :silence_debug
+
+    def debug(msg)
+      warn "Rack::Mount #{msg}" if $DEBUG
+    end
+    module_function :debug
+
     # Normalizes URI path.
     #
     # Strips off trailing slash and ensures there is a leading slash.
@@ -19,25 +37,26 @@ module Rack::Mount
     #   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.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
       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?
+    #   pop_trailing_blanks!([1, 2, 3])           # => [1, 2, 3]
+    #   pop_trailing_blanks!([1, 2, 3, nil, ""])  # => [1, 2, 3]
+    #   pop_trailing_blanks!([nil])               # => []
+    #   pop_trailing_blanks!([""])                # => []
+    def pop_trailing_blanks!(ary)
+      while ary.length > 0 && (ary.last.nil? || ary.last == '')
         ary.pop
       end
       ary
     end
-    module_function :pop_trailing_nils!
+    module_function :pop_trailing_blanks!
 
     RESERVED_PCHAR = ':@&=+$,;%'
     SAFE_PCHAR = "#{URI::REGEXP::PATTERN::UNRESERVED}#{RESERVED_PCHAR}"
@@ -47,14 +66,16 @@ module Rack::Mount
       UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false, 'N').freeze
     end
 
+    Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
     def escape_uri(uri)
-      URI.escape(uri.to_s, UNSAFE_PCHAR)
+      Parser.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')
+        Parser.unescape(uri).force_encoding('utf-8')
       end
     else
       def unescape_uri(uri)
@@ -72,33 +93,17 @@ module Rack::Mount
         }.join("&")
       when Hash
         value.map { |k, v|
-          build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
+          build_nested_query(v, prefix ? "#{prefix}[#{Rack::Utils.escape(k)}]" : Rack::Utils.escape(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)
+        "#{prefix}=#{Rack::Utils.escape(value)}"
       else
-        if value.respond_to?(:to_param)
-          build_nested_query(value.to_param.to_s, prefix)
-        else
-          Rack::Utils.escape(prefix)
-        end
+        prefix
       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
@@ -106,166 +111,52 @@ module Rack::Mount
     #   regexp_anchored?(/^foo/)  # => false
     #   regexp_anchored?(/foo$/)  # => false
     def regexp_anchored?(regexp)
-      regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/ ? true : false
+     regexp.source =~ /\A(\\A|\^).*(\\Z|\$)\Z/m ? 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?
-
+    def normalize_extended_expression(regexp)
+      return regexp if (regexp.options & Regexp::EXTENDED) == 0
       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
+      source.gsub!(/#.+$/, '')
+      source.gsub!(/\s+/, '')
+      source.gsub!(/\\\//, '/')
+      Regexp.compile(source)
     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
+    module_function :normalize_extended_expression
 
-      def first_part
-        first.is_a?(Capture) ? first.first_part : first
-      end
+    def parse_regexp(regexp)
+      cache = @@_parse_regexp_cache ||= {}
 
-      def last_part
-        last.is_a?(Capture) ? last.last_part : last
+      if expression = cache[regexp]
+        return expression
       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] == '\\'
+      expression = Regin.parse(regexp)
 
-        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!
+      unless Regin.regexp_supports_named_captures?
+        tag_captures = Proc.new do |group|
+          case group
+          when Regin::Group
+            # TODO: dup instead of mutating
+            group.instance_variable_set('@name', regexp.names[group.index]) if group.index
+            tag_captures.call(group.expression)
+          when Regin::Expression
+            group.each { |child| tag_captures.call(child) }
           end
-        elsif char == '$'
-          cur.push(Const::NULL)
-        else
-          cur.push('') unless cur.last.is_a?(String)
-          cur.last << char
         end
+        tag_captures.call(expression)
       end
 
-      stack.pop
+      cache[regexp] = expression.freeze
+      expression
+    rescue Racc::ParseError, Regin::Parser::ScanError
+      []
     end
-    module_function :extract_regexp_parts
+    module_function :parse_regexp
   end
 end

data/lib/rack/mount/vendor/regin/regin/alternation.rb

@@ -0,0 +1,40 @@
+module Regin
+  class Alternation < Collection
+    def initialize(*args)
+      args, options = extract_options(args)
+
+      if args.length == 1 && args.first.instance_of?(Array)
+        super(args.first)
+      else
+        super(args)
+      end
+
+      if options.key?(:ignorecase)
+        @array.map! { |e| e.dup(:ignorecase => options[:ignorecase]) }
+      end
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # Alternation groups are never literal.
+    def literal?
+      false
+    end
+
+    def flags
+      0
+    end
+
+    def dup(options = {})
+      self.class.new(to_a, options)
+    end
+
+    def to_s(parent = false)
+      map { |e| e.to_s(parent) }.join('|')
+    end
+
+    def inspect #:nodoc:
+      to_s.inspect
+    end
+  end
+end

data/lib/rack/mount/vendor/regin/regin/anchor.rb

@@ -0,0 +1,4 @@
+module Regin
+  class Anchor < Atom
+  end
+end

data/lib/rack/mount/vendor/regin/regin/atom.rb

@@ -0,0 +1,54 @@
+module Regin
+  class Atom
+    attr_reader :value, :ignorecase
+
+    def initialize(value, options = {})
+      @value = value
+      @ignorecase = options[:ignorecase]
+    end
+
+    def option_names
+      %w( ignorecase )
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    def literal?
+      false
+    end
+
+    def casefold?
+      ignorecase ? true : false
+    end
+
+    def dup(options = {})
+      original_options = option_names.inject({}) do |h, m|
+        h[m.to_sym] = send(m)
+        h
+      end
+      self.class.new(value, original_options.merge(options))
+    end
+
+    def to_s(parent = false)
+      "#{value}"
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class.to_s.sub('Regin::', '')} #{to_s.inspect}>"
+    end
+
+    def ==(other) #:nodoc:
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      other.instance_of?(self.class) &&
+        self.value.eql?(other.value) &&
+        (!!self.ignorecase).eql?(!!other.ignorecase)
+    end
+  end
+end

data/lib/rack/mount/vendor/regin/regin/character.rb

@@ -0,0 +1,51 @@
+module Regin
+  class Character < Atom
+    attr_reader :quantifier
+
+    def initialize(value, options = {})
+      @quantifier = options[:quantifier]
+      super
+    end
+
+    def option_names
+      %w( quantifier ) + super
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A Character is literal is there is no quantifier attached to it.
+    def literal?
+      quantifier.nil? && !ignorecase
+    end
+
+    def to_s(parent = false)
+      if !parent && ignorecase
+        "(?i-mx:#{value})#{quantifier}"
+      else
+        "#{value}#{quantifier}"
+      end
+    end
+
+    def to_regexp(anchored = false)
+      re = to_s(true)
+      re = "\\A#{re}\\Z" if anchored
+      Regexp.compile(re, ignorecase)
+    end
+
+    def match(char)
+      to_regexp(true).match(char)
+    end
+
+    def include?(char)
+      if ignorecase
+        value.downcase == char.downcase
+      else
+        value == char
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      super && quantifier.eql?(other.quantifier)
+    end
+  end
+end

data/lib/rack/mount/vendor/regin/regin/character_class.rb

@@ -0,0 +1,50 @@
+module Regin
+  class CharacterClass < Character
+    def initialize(value, options = {})
+      @negate = options[:negate]
+      super
+    end
+
+    def option_names
+      %w( negate ) + super
+    end
+
+    attr_reader :negate
+
+    def negated?
+      negate ? true : false
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A CharacterClass is never literal.
+    def literal?
+      false
+    end
+
+    def bracketed?
+      value != '.' && value !~ /^\\[dDsSwW]$/
+    end
+
+    def to_s(parent = false)
+      if bracketed?
+        if !parent && ignorecase
+          "(?i-mx:[#{negate && '^'}#{value}])#{quantifier}"
+        else
+          "[#{negate && '^'}#{value}]#{quantifier}"
+        end
+      else
+        super
+      end
+    end
+
+    def include?(char)
+      re = quantifier ? to_s.sub(/#{Regexp.escape(quantifier)}$/, '') : to_s
+      Regexp.compile("\\A#{re}\\Z").match(char)
+    end
+
+    def eql?(other) #:nodoc:
+      super && negate == other.negate
+    end
+  end
+end