rack-mount 0.0.1 → 0.0.2

data/lib/rack/mount/vendor/multimap/multimap.rb

@@ -164,6 +164,7 @@ class Multimap < Hash
   # Ignore alias_method since the definition above serves
   # as its documentation.
   #++
+  undef :each_association
   module_eval "alias_method :each_association, :each_pair"
 
   # call-seq:

data/lib/rack/mount/vendor/reginald/reginald.rb

@@ -0,0 +1,55 @@
+module Reginald
+  autoload :Alternation, 'reginald/alternation'
+  autoload :Anchor, 'reginald/anchor'
+  autoload :Character, 'reginald/character'
+  autoload :CharacterClass, 'reginald/character_class'
+  autoload :Expression, 'reginald/expression'
+  autoload :Group, 'reginald/group'
+  autoload :Parser, 'reginald/parser'
+
+  begin
+    eval('/(?<foo>.*)/').named_captures
+
+    def self.regexp_supports_named_captures?
+      true
+    end
+  rescue SyntaxError, NoMethodError
+    def self.regexp_supports_named_captures?
+      false
+    end
+  end
+
+  def self.parse(regexp)
+    # TODO: The parser should be aware of extended expressions
+    # instead of having to sanitize them before.
+    if regexp.options & Regexp::EXTENDED != 0
+      source = regexp.source
+      source.gsub!(/#.+$/, '')
+      source.gsub!(/\s+/, '')
+      source.gsub!(/\\\//, '/')
+      regexp = Regexp.compile(source)
+    end
+
+    parser = Parser.new
+    expression = parser.scan_str(regexp.source)
+    expression.ignorecase = regexp.casefold?
+
+    capture_index = 0
+    tag_captures = Proc.new do |expr|
+      expr.each do |atom|
+        if atom.is_a?(Group)
+          if atom.capture
+            atom.index = capture_index
+            capture_index += 1
+          end
+          tag_captures.call(atom)
+        elsif atom.is_a?(Expression)
+          tag_captures.call(atom)
+        end
+      end
+    end
+    tag_captures.call(expression)
+
+    expression
+  end
+end

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

@@ -0,0 +1,50 @@
+module Reginald
+  class Alternation < Array
+    def self.reduce(alternation_or_expression, expression)
+      if alternation_or_expression.first.is_a?(Alternation)
+        alternation_or_expression = alternation_or_expression.first
+        alternation_or_expression << expression
+        new(*alternation_or_expression)
+      else
+        new(alternation_or_expression, expression)
+      end
+    end
+
+    def initialize(*args)
+      if args.length == 1 && args.first.is_a?(Array)
+        super(args.first)
+      else
+        super(args)
+      end
+    end
+
+    def literal?
+      false
+    end
+
+    def to_s
+      map { |e| e.to_s }.join('|')
+    end
+
+    def to_regexp
+      Regexp.compile("\\A#{to_s}\\Z")
+    end
+
+    def inspect
+      to_s.inspect
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      any? { |e| e.include?(char) }
+    end
+
+    def freeze
+      each { |e| e.freeze }
+      super
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Reginald
+  class Anchor < Struct.new(:value)
+    def to_s
+      "#{value}"
+    end
+
+    def inspect
+      to_s.inspect
+    end
+
+    def literal?
+      false
+    end
+
+    def freeze
+      value.freeze
+      super
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Reginald
+  class Character < String
+    attr_accessor :quantifier
+
+    def initialize(char)
+      raise ArgumentError if char.length != 1
+      super
+    end
+
+    def literal?
+      quantifier.nil?
+    end
+
+    def to_s
+      "#{super}#{quantifier}"
+    end
+
+    def to_regexp
+      Regexp.compile("\\A#{to_s}\\Z")
+    end
+
+    def inspect
+      to_s.inspect
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      to_str == char
+    end
+
+    def ==(other)
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && super &&
+        self.quantifier == other.quantifier
+    end
+
+    def freeze
+      quantifier.freeze
+      super
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Reginald
+  class CharacterClass < Struct.new(:value)
+    attr_accessor :negate, :quantifier
+
+    def negated?
+      negate ? true : false
+    end
+
+    def literal?
+      false
+    end
+
+    def to_s
+      if value == '.' || value == '\d'
+        "#{value}#{quantifier}"
+      else
+        "[#{negate && '^'}#{value}]#{quantifier}"
+      end
+    end
+
+    def to_regexp
+      Regexp.compile("\\A#{to_s}\\Z")
+    end
+
+    def inspect
+      to_s.inspect
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      re = quantifier ? to_s.sub(/#{Regexp.escape(quantifier)}$/, '') : to_s
+      Regexp.compile("\\A#{re}\\Z").match(char)
+    end
+
+    def ==(other)
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        self.value == other.value &&
+        self.negate == other.negate &&
+        self.quantifier == other.quantifier
+    end
+
+    def freeze
+      value.freeze
+      negate.freeze
+      quantifier.freeze
+      super
+    end
+  end
+end

data/lib/rack/mount/vendor/reginald/reginald/expression.rb

@@ -0,0 +1,75 @@
+module Reginald
+  class Expression < Array
+    attr_accessor :ignorecase
+
+    def self.reduce(expression_or_atom, atom = nil)
+      if expression_or_atom.is_a?(Expression)
+        expression_or_atom << atom if atom
+        new(*expression_or_atom)
+      elsif atom.nil?
+        new(expression_or_atom)
+      else
+        new(expression_or_atom, atom)
+      end
+    end
+
+    def initialize(*args)
+      @ignorecase = false
+
+      if args.length == 1 && args.first.is_a?(Array)
+        super(args.first)
+      else
+        super(args)
+      end
+    end
+
+    def literal?
+      ignorecase == false && all? { |e| e.literal? }
+    end
+
+    def to_s
+      map { |e| e.to_s }.join
+    end
+
+    def to_regexp
+      Regexp.compile("\\A#{to_s}\\Z")
+    end
+
+    def inspect
+      "#<Expression #{to_s.inspect}>"
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      any? { |e| e.include?(char) }
+    end
+
+    def casefold?
+      ignorecase
+    end
+
+    def ==(other)
+      case other
+      when String
+        other == to_s
+      when Array
+        super
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && super &&
+        self.ignorecase == other.ignorecase
+    end
+
+    def freeze
+      each { |e| e.freeze }
+      super
+    end
+  end
+end

data/lib/rack/mount/vendor/reginald/reginald/group.rb

@@ -0,0 +1,61 @@
+module Reginald
+  class Group < Struct.new(:expression)
+    attr_accessor :quantifier, :capture, :index, :name
+
+    def initialize(*args)
+      @capture = true
+      super
+    end
+
+    def literal?
+      quantifier.nil? && expression.literal?
+    end
+
+    def to_s
+      "(#{capture ? '' : '?:'}#{expression.to_s})#{quantifier}"
+    end
+
+    def to_regexp
+      Regexp.compile("\\A#{to_s}\\Z")
+    end
+
+    def inspect
+      to_s.inspect
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      expression.include?(char)
+    end
+
+    def capture?
+      capture
+    end
+
+    def ==(other)
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        self.expression == other.expression &&
+        self.quantifier == other.quantifier &&
+        self.capture == other.capture &&
+        self.index == other.index &&
+        self.name == other.name
+    end
+
+    def freeze
+      expression.freeze
+      super
+    end
+  end
+end

data/lib/rack/mount/vendor/reginald/reginald/parser.rb

@@ -0,0 +1,306 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+require 'reginald/tokenizer'
+module Reginald
+  class Parser < Racc::Parser
+##### State transition tables begin ###
+
+racc_action_table = [
+     5,    31,    11,     6,     7,     9,    40,    10,    45,    14,
+     5,    12,    11,     6,     7,     9,    41,    10,    37,    14,
+     5,    12,    11,     6,     7,     9,    28,    10,    47,    14,
+     5,    12,    11,     6,     7,     9,    48,    10,    46,   nil,
+     5,    12,    11,     6,     7,     9,    13,    10,    14,   nil,
+     5,    12,    11,     6,     7,     9,    27,    10,    38,    39,
+     5,    12,    11,     6,     7,     9,    19,    10,   nil,    19,
+   nil,    12,    17,    18,    20,    17,    18,    20,    32,   nil,
+   nil,    34,    33,    35,    42,   nil,   nil,    34,    33,    35,
+    22,   nil,    24,    23,    25,    24,    23,    25 ]
+
+racc_action_check = [
+     0,    20,     0,     0,     0,     0,    31,     0,    40,    26,
+    39,     0,    39,    39,    39,    39,    31,    39,    26,    44,
+     2,    39,     2,     2,     2,     2,    13,     2,    44,    43,
+    14,     2,    14,    14,    14,    14,    45,    14,    43,   nil,
+    29,    14,    29,    29,    29,    29,     1,    29,     1,   nil,
+    10,    29,    10,    10,    10,    10,    10,    10,    27,    27,
+    38,    10,    38,    38,    38,    38,     3,    38,   nil,    15,
+   nil,    38,     3,     3,     3,    15,    15,    15,    21,   nil,
+   nil,    21,    21,    21,    36,   nil,   nil,    36,    36,    36,
+     5,   nil,     5,     5,     5,    22,    22,    22 ]
+
+racc_action_pointer = [
+    -3,    46,    17,    57,   nil,    85,   nil,   nil,   nil,   nil,
+    47,   nil,   nil,    26,    27,    60,   nil,   nil,   nil,   nil,
+    -7,    74,    88,   nil,   nil,   nil,     7,    46,   nil,    37,
+   nil,    -2,   nil,   nil,   nil,   nil,    80,   nil,    57,     7,
+     0,   nil,   nil,    27,    17,    18,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -30,   -30,    -2,    -6,    -7,   -30,   -10,   -11,   -12,   -13,
+   -30,   -23,   -24,   -30,   -30,    -4,    -5,   -25,   -26,   -27,
+   -30,   -30,   -30,   -17,   -18,   -19,   -30,   -30,    49,    -1,
+    -3,   -30,    -8,   -14,   -15,   -16,   -30,   -20,   -30,   -30,
+   -30,   -29,    -9,   -30,   -30,   -30,   -21,   -22,   -28 ]
+
+racc_goto_table = [
+     1,    15,    21,    16,    29,   nil,   nil,   nil,   nil,   nil,
+    26,   nil,   nil,   nil,   nil,    30,   nil,   nil,   nil,    36,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    15,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    43,    44 ]
+
+racc_goto_check = [
+     1,     3,     6,     4,     2,   nil,   nil,   nil,   nil,   nil,
+     1,   nil,   nil,   nil,   nil,     4,   nil,   nil,   nil,     6,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     3,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     1,     1 ]
+
+racc_goto_pointer = [
+   nil,     0,   -10,    -1,     0,   nil,    -3,   nil ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,   nil,     4,   nil,     8 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 20, :_reduce_1,
+  1, 20, :_reduce_2,
+  3, 21, :_reduce_3,
+  2, 21, :_reduce_4,
+  2, 21, :_reduce_5,
+  1, 21, :_reduce_none,
+  1, 22, :_reduce_none,
+  3, 22, :_reduce_8,
+  4, 22, :_reduce_9,
+  1, 22, :_reduce_10,
+  1, 22, :_reduce_11,
+  1, 22, :_reduce_12,
+  1, 22, :_reduce_13,
+  2, 25, :_reduce_14,
+  2, 25, :_reduce_15,
+  2, 25, :_reduce_16,
+  1, 25, :_reduce_none,
+  1, 25, :_reduce_none,
+  1, 25, :_reduce_none,
+  3, 24, :_reduce_20,
+  5, 24, :_reduce_21,
+  5, 24, :_reduce_22,
+  1, 26, :_reduce_none,
+  1, 26, :_reduce_none,
+  1, 23, :_reduce_none,
+  1, 23, :_reduce_none,
+  1, 23, :_reduce_none,
+  5, 23, :_reduce_28,
+  3, 23, :_reduce_29 ]
+
+racc_reduce_n = 30
+
+racc_shift_n = 49
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :BAR => 2,
+  :LBRACK => 3,
+  :RBRACK => 4,
+  :L_ANCHOR => 5,
+  :CHAR_CLASS => 6,
+  :DOT => 7,
+  :CHAR => 8,
+  :QMARK => 9,
+  :LPAREN => 10,
+  :RPAREN => 11,
+  :COLON => 12,
+  :NAME => 13,
+  :R_ANCHOR => 14,
+  :STAR => 15,
+  :PLUS => 16,
+  :LCURLY => 17,
+  :RCURLY => 18 }
+
+racc_nt_base = 19
+
+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",
+  "BAR",
+  "LBRACK",
+  "RBRACK",
+  "L_ANCHOR",
+  "CHAR_CLASS",
+  "DOT",
+  "CHAR",
+  "QMARK",
+  "LPAREN",
+  "RPAREN",
+  "COLON",
+  "NAME",
+  "R_ANCHOR",
+  "STAR",
+  "PLUS",
+  "LCURLY",
+  "RCURLY",
+  "$start",
+  "expression",
+  "branch",
+  "atom",
+  "quantifier",
+  "group",
+  "bracket_expression",
+  "anchor" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+def _reduce_1(val, _values, result)
+ result = Expression.new([Alternation.reduce(val[0], val[2])]) 
+    result
+end
+
+def _reduce_2(val, _values, result)
+ result = Expression.reduce(val[0]) 
+    result
+end
+
+def _reduce_3(val, _values, result)
+            val[1].quantifier = val[2]
+            result = Expression.reduce(val[0], val[1])
+          
+    result
+end
+
+def _reduce_4(val, _values, result)
+ result = Expression.reduce(val[0], val[1]) 
+    result
+end
+
+def _reduce_5(val, _values, result)
+            val[0].quantifier = val[1]
+            result = val[0]
+          
+    result
+end
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+def _reduce_8(val, _values, result)
+ result = CharacterClass.new(val[1]) 
+    result
+end
+
+def _reduce_9(val, _values, result)
+ result = CharacterClass.new(val[2]); result.negate = true 
+    result
+end
+
+def _reduce_10(val, _values, result)
+ result = CharacterClass.new(val[0]) 
+    result
+end
+
+def _reduce_11(val, _values, result)
+ result = CharacterClass.new(val[0]) 
+    result
+end
+
+def _reduce_12(val, _values, result)
+ result = Anchor.new(val[0]) 
+    result
+end
+
+def _reduce_13(val, _values, result)
+ result = Character.new(val[0]) 
+    result
+end
+
+def _reduce_14(val, _values, result)
+ result = val.join 
+    result
+end
+
+def _reduce_15(val, _values, result)
+ result = val.join 
+    result
+end
+
+def _reduce_16(val, _values, result)
+ result = val.join 
+    result
+end
+
+# reduce 17 omitted
+
+# reduce 18 omitted
+
+# reduce 19 omitted
+
+def _reduce_20(val, _values, result)
+ result = Group.new(val[1]) 
+    result
+end
+
+def _reduce_21(val, _values, result)
+ result = Group.new(val[3]); result.capture = false 
+    result
+end
+
+def _reduce_22(val, _values, result)
+ result = Group.new(val[3]); result.name = val[2] 
+    result
+end
+
+# reduce 23 omitted
+
+# reduce 24 omitted
+
+# reduce 25 omitted
+
+# reduce 26 omitted
+
+# reduce 27 omitted
+
+def _reduce_28(val, _values, result)
+ result = val.join 
+    result
+end
+
+def _reduce_29(val, _values, result)
+ result = val.join 
+    result
+end
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+end   # module Reginald