lgierth-rack-mount 0.6.13

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

@@ -0,0 +1,160 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+require 'rack/mount/utils'
+require 'rack/mount/strexp/tokenizer'
+
+module Rack
+  module Mount
+    class StrexpParser < Racc::Parser
+
+
+if Regin.regexp_supports_named_captures?
+  REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+else
+  REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+end
+
+attr_accessor :anchor, :requirements
+##### State transition tables begin ###
+
+racc_action_table = [
+     1,     2,     3,     9,     4,     1,     2,     3,    12,     4,
+     1,     2,     3,    11,     4,     1,     2,     3,   nil,     4 ]
+
+racc_action_check = [
+     0,     0,     0,     5,     0,     3,     3,     3,     9,     3,
+     8,     8,     8,     8,     8,     6,     6,     6,   nil,     6 ]
+
+racc_action_pointer = [
+    -2,   nil,   nil,     3,   nil,     3,    13,   nil,     8,     8,
+   nil,   nil,   nil ]
+
+racc_action_default = [
+    -8,    -4,    -5,    -8,    -7,    -8,    -1,    -3,    -8,    -8,
+    -2,    -6,    13 ]
+
+racc_goto_table = [
+     6,     5,    10,     8,    10 ]
+
+racc_goto_check = [
+     2,     1,     3,     2,     3 ]
+
+racc_goto_pointer = [
+   nil,     1,     0,    -4 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     7 ]
+
+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 = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" 
+    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
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement]
+         
+    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/parser.y

@@ -0,0 +1,34 @@
+class Rack::Mount::StrexpParser
+rule
+  target: expr { result = anchor ? "\\A#{val.join}\\Z" : "\\A#{val.join}" }
+
+  expr: expr token { result = val.join }
+      | token
+
+  token: PARAM {
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, requirement]
+         }
+       | GLOB {
+           name = val[0].to_sym
+           requirement = requirements[name]
+           result = REGEXP_NAMED_CAPTURE % [name, '.+' || requirement]
+         }
+       | LPAREN expr RPAREN { result = "(?:#{val[1]})?" }
+       | CHAR { result = Regexp.escape(val[0]) }
+end
+
+---- header ----
+require 'rack/mount/utils'
+require 'rack/mount/strexp/tokenizer'
+
+---- inner
+
+if Regin.regexp_supports_named_captures?
+  REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
+else
+  REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze
+end
+
+attr_accessor :anchor, :requirements

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

@@ -0,0 +1,83 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5.beta1
+# from lexical definition file "lib/rack/mount/strexp/tokenizer.rex".
+#++
+
+require 'racc/parser'
+class Rack::Mount::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
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  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

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

@@ -0,0 +1,12 @@
+class Rack::Mount::StrexpParser
+macro
+  RESERVED  \(|\)|:|\*
+  ALPHA_U   [a-zA-Z_]
+rule
+  \\({RESERVED})   { [:CHAR,  @ss[1]] }
+  \:({ALPHA_U}\w*) { [:PARAM, @ss[1]] }
+  \*({ALPHA_U}\w*) { [:GLOB,  @ss[1]] }
+  \(               { [:LPAREN, text]  }
+  \)               { [:RPAREN, text]  }
+  .                { [:CHAR,   text]  }
+end

data/lib/rack/mount/utils.rb

@@ -0,0 +1,162 @@
+begin
+  require 'regin'
+rescue LoadError
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/regin'))
+  require 'regin'
+end
+
+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
+    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.
+    #
+    #   normalize_path("/foo")  # => "/foo"
+    #   normalize_path("/foo/") # => "/foo"
+    #   normalize_path("foo")   # => "/foo"
+    #   normalize_path("")      # => "/"
+    def normalize_path(path)
+      path = "/#{path}"
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
+      path
+    end
+    module_function :normalize_path
+
+    # Removes trailing nils from array.
+    #
+    #   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_blanks!
+
+    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
+
+    Parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+
+    def escape_uri(uri)
+      Parser.escape(uri.to_s, UNSAFE_PCHAR)
+    end
+    module_function :escape_uri
+
+    if ''.respond_to?(:force_encoding)
+      def unescape_uri(uri)
+        Parser.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}[#{Rack::Utils.escape(k)}]" : Rack::Utils.escape(k))
+        }.join("&")
+      when String
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{Rack::Utils.escape(value)}"
+      else
+        prefix
+      end
+    end
+    module_function :build_nested_query
+
+    # 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/m ? true : false
+    end
+    module_function :regexp_anchored?
+
+    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
+
+    def parse_regexp(regexp)
+      cache = @@_parse_regexp_cache ||= {}
+
+      if expression = cache[regexp]
+        return expression
+      end
+
+      unless regexp.is_a?(RegexpWithNamedGroups)
+        regexp = RegexpWithNamedGroups.new(regexp)
+      end
+
+      expression = Regin.parse(regexp)
+
+      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
+        end
+        tag_captures.call(expression)
+      end
+
+      cache[regexp] = expression.freeze
+      expression
+    rescue Racc::ParseError, Regin::Parser::ScanError
+      []
+    end
+    module_function :parse_regexp
+  end
+end