rack-mount 0.0.1 → 0.0.2

data/lib/rack/mount/strexp/parser.rb

@@ -0,0 +1,158 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+require 'rack/mount/strexp/tokenizer'
+
+module Rack
+  module Mount
+    class StrexpParser < Racc::Parser
+
+
+if RegexpWithNamedGroups.supports_named_captures?
+  REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+else
+  REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+end
+
+attr_accessor :requirements
+##### State transition tables begin ###
+
+racc_action_table = [
+     4,     5,     6,    11,     7,     4,     5,     6,    12,     7,
+     4,     5,     6,     8,     7,     4,     5,     6,   nil,     7 ]
+
+racc_action_check = [
+     0,     0,     0,     8,     0,    10,    10,    10,    10,    10,
+     2,     2,     2,     1,     2,     6,     6,     6,   nil,     6 ]
+
+racc_action_pointer = [
+    -2,    13,     8,   nil,   nil,   nil,    13,   nil,     3,   nil,
+     3,   nil,   nil ]
+
+racc_action_default = [
+    -8,    -8,    -1,    -3,    -4,    -5,    -8,    -7,    -8,    -2,
+    -8,    13,    -6 ]
+
+racc_goto_table = [
+     9,     2,     1,   nil,   nil,   nil,   nil,    10,     9 ]
+
+racc_goto_check = [
+     3,     2,     1,   nil,   nil,   nil,   nil,     2,     3 ]
+
+racc_goto_pointer = [
+   nil,     2,     1,    -2 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     3 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 8, :_reduce_1,
+  2, 9, :_reduce_2,
+  1, 9, :_reduce_none,
+  1, 10, :_reduce_4,
+  1, 10, :_reduce_5,
+  3, 10, :_reduce_6,
+  1, 10, :_reduce_7 ]
+
+racc_reduce_n = 8
+
+racc_shift_n = 13
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :PARAM => 2,
+  :GLOB => 3,
+  :LPAREN => 4,
+  :RPAREN => 5,
+  :CHAR => 6 }
+
+racc_nt_base = 7
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "PARAM",
+  "GLOB",
+  "LPAREN",
+  "RPAREN",
+  "CHAR",
+  "$start",
+  "target",
+  "expr",
+  "token" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+ result = "\\A#{val.join}\\Z" 
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = val.join 
+    result
+end
+
+# reduce 3 omitted
+
+def _reduce_4(val, _values, result)
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, requirement]
+         
+    result
+end
+
+def _reduce_5(val, _values, result)
+           name = val[0].to_sym
+           result = REGEXP_NAMED_CAPTURE % [name, '.+']
+         
+    result
+end
+
+def _reduce_6(val, _values, result)
+ result = "(?:#{val[1]})?" 
+    result
+end
+
+def _reduce_7(val, _values, result)
+ result = Regexp.escape(val[0]) 
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class StrexpParser
+  end   # module Mount
+end   # module Rack

data/lib/rack/mount/strexp/tokenizer.rb

@@ -0,0 +1,84 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.4
+# from lexical definition file "lib/rack/mount/strexp/tokenizer.rex".
+#++
+
+require 'racc/parser'
+module Rack::Mount
+class StrexpParser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action(&block)
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\\(\(|\)|:|\*)/))
+         action { [:CHAR,  @ss[1]] }
+
+      when (text = @ss.scan(/\:([a-zA-Z_]\w*)/))
+         action { [:PARAM, @ss[1]] }
+
+      when (text = @ss.scan(/\*([a-zA-Z_]\w*)/))
+         action { [:GLOB,  @ss[1]] }
+
+      when (text = @ss.scan(/\(/))
+         action { [:LPAREN, text]  }
+
+      when (text = @ss.scan(/\)/))
+         action { [:RPAREN, text]  }
+
+      when (text = @ss.scan(/./))
+         action { [:CHAR,   text]  }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def next_token
+
+end # class
+end # module

data/lib/rack/mount/utils.rb

@@ -1,5 +1,10 @@
-require 'rack/mount/regexp_with_named_groups'
-require 'strscan'
+begin
+  require 'reginald'
+rescue LoadError
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/reginald'))
+  require 'reginald'
+end
+
 require 'uri'
 
 module Rack::Mount
@@ -19,9 +24,9 @@ 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
@@ -99,173 +104,31 @@ module Rack::Mount
     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:
+    def parse_regexp(regexp)
       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 = [[]]
+      expression = Reginald.parse(regexp)
 
-      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!
+      unless RegexpWithNamedGroups.supports_named_captures?
+        tag_captures = Proc.new do |group|
+          group.each do |child|
+            if child.is_a?(Reginald::Group)
+              child.name = regexp.names[child.index] if child.index
+              tag_captures.call(child)
+            elsif child.is_a?(Reginald::Expression)
+              tag_captures.call(child)
+            end
           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
+      expression
+    rescue Racc::ParseError
+      []
     end
-    module_function :extract_regexp_parts
+    module_function :parse_regexp
   end
 end