rack-mount 0.6.5 → 0.6.6

data/lib/rack/mount/analysis/frequency.rb

@@ -35,8 +35,8 @@ module Rack::Mount
         if requirement.is_a?(Regexp)
           expression = Utils.parse_regexp(requirement)
 
-          if expression.is_a?(Reginald::Expression) && expression.anchored_to_line?
-            expression = expression.reject { |e| e.is_a?(Reginald::Anchor) }
+          if expression.is_a?(Regin::Expression) && expression.anchored_to_line?
+            expression = Regin::Expression.new(expression.reject { |e| e.is_a?(Regin::Anchor) })
             return requirements[method] = expression.to_s if expression.literal?
           end
         end

data/lib/rack/mount/analysis/splitting.rb

@@ -59,23 +59,23 @@ module Rack::Mount
 
           parts = Utils.parse_regexp(regexp)
           parts.each_with_index do |part, index|
-            if part.is_a?(Reginald::Group)
+            if part.is_a?(Regin::Group)
               if index > 0
                 previous = parts[index-1]
-                if previous.is_a?(Reginald::Character) && previous.literal?
+                if previous.is_a?(Regin::Character) && previous.literal?
                   boundaries << previous.to_s
                 end
               end
 
               if inside = part.expression[0]
-                if inside.is_a?(Reginald::Character) && inside.literal?
+                if inside.is_a?(Regin::Character) && inside.literal?
                   boundaries << inside.to_s
                 end
               end
 
               if index < parts.length
                 following = parts[index+1]
-                if following.is_a?(Reginald::Character) && following.literal?
+                if following.is_a?(Regin::Character) && following.literal?
                   boundaries << following.to_s
                 end
               end
@@ -91,30 +91,30 @@ module Rack::Mount
           parts = Utils.parse_regexp(regexp)
           parts.each_with_index do |part, index|
             case part
-            when Reginald::Anchor
+            when Regin::Anchor
               if part.value == '$' || part.value == '\Z'
                 segments << join_buffer(buf, regexp) if buf
                 segments << NULL
                 buf = nil
                 break
               end
-            when Reginald::CharacterClass
+            when Regin::CharacterClass
               break if separators.any? { |s| part.include?(s) }
               buf = nil
               segments << part.to_regexp
-            when Reginald::Character
+            when Regin::Character
               if separators.any? { |s| part.include?(s) }
                 segments << join_buffer(buf, regexp) if buf
                 peek = parts[index+1]
-                if peek.is_a?(Reginald::Character) && separators.include?(peek.value)
+                if peek.is_a?(Regin::Character) && separators.include?(peek.value)
                   segments << ''
                 end
                 buf = nil
               else
-                buf ||= Reginald::Expression.new([])
-                buf << part
+                buf ||= Regin::Expression.new([])
+                buf += [part]
               end
-            when Reginald::Group
+            when Regin::Group
               if part.quantifier == '?'
                 value = part.expression.first
                 if separators.any? { |s| value.include?(s) }

data/lib/rack/mount/generatable_regexp.rb

@@ -107,9 +107,9 @@ module Rack::Mount
           s = []
           segments.each_with_index do |part, index|
             case part
-            when Reginald::Anchor
+            when Regin::Anchor
               # ignore
-            when Reginald::Character
+            when Regin::Character
               throw :halt unless part.literal?
 
               if s.last.is_a?(String)
@@ -117,13 +117,13 @@ module Rack::Mount
               else
                 s << part.value.dup
               end
-            when Reginald::Group
+            when Regin::Group
               if part.name
                 s << DynamicSegment.new(part.name, part.expression.to_regexp)
               else
                 s << parse_segments(part.expression)
               end
-            when Reginald::Expression
+            when Regin::Expression
               return parse_segments(part)
             else
               throw :halt

data/lib/rack/mount/regexp_with_named_groups.rb

@@ -1,5 +1,5 @@
 module Rack::Mount
-  if Reginald.regexp_supports_named_captures?
+  if Regin.regexp_supports_named_captures?
     RegexpWithNamedGroups = Regexp
   else
     require 'strscan'

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

@@ -24,7 +24,7 @@ require 'rack/mount/strexp/tokenizer'
 
 ---- inner
 
-if Reginald.regexp_supports_named_captures?
+if Regin.regexp_supports_named_captures?
   REGEXP_NAMED_CAPTURE = '(?<%s>%s)'.freeze
 else
   REGEXP_NAMED_CAPTURE = '(?:<%s>%s)'.freeze

data/lib/rack/mount/utils.rb

@@ -1,8 +1,8 @@
 begin
-  require 'reginald'
+  require 'regin'
 rescue LoadError
-  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/reginald'))
-  require 'reginald'
+  $: << File.expand_path(File.join(File.dirname(__FILE__), 'vendor/regin'))
+  require 'regin'
 end
 
 require 'uri'
@@ -122,16 +122,16 @@ module Rack::Mount
         regexp = RegexpWithNamedGroups.new(regexp)
       end
 
-      expression = Reginald.parse(regexp)
+      expression = Regin.parse(regexp)
 
-      unless Reginald.regexp_supports_named_captures?
+      unless Regin.regexp_supports_named_captures?
         tag_captures = Proc.new do |group|
           case group
-          when Reginald::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 Reginald::Expression
+          when Regin::Expression
             group.each { |child| tag_captures.call(child) }
           end
         end
@@ -140,7 +140,7 @@ module Rack::Mount
 
       cache[regexp] = expression.freeze
       expression
-    rescue Racc::ParseError, Reginald::Parser::ScanError
+    rescue Racc::ParseError, Regin::Parser::ScanError
       []
     end
     module_function :parse_regexp

data/lib/rack/mount/vendor/{reginald/reginald.rb → regin/regin.rb}

@@ -1,14 +1,14 @@
-module Reginald
-  autoload :Alternation, 'reginald/alternation'
-  autoload :Anchor, 'reginald/anchor'
-  autoload :Atom, 'reginald/atom'
-  autoload :Character, 'reginald/character'
-  autoload :CharacterClass, 'reginald/character_class'
-  autoload :Collection, 'reginald/collection'
-  autoload :Expression, 'reginald/expression'
-  autoload :Group, 'reginald/group'
-  autoload :Options, 'reginald/options'
-  autoload :Parser, 'reginald/parser'
+module Regin
+  autoload :Alternation, 'regin/alternation'
+  autoload :Anchor, 'regin/anchor'
+  autoload :Atom, 'regin/atom'
+  autoload :Character, 'regin/character'
+  autoload :CharacterClass, 'regin/character_class'
+  autoload :Collection, 'regin/collection'
+  autoload :Expression, 'regin/expression'
+  autoload :Group, 'regin/group'
+  autoload :Options, 'regin/options'
+  autoload :Parser, 'regin/parser'
 
   class << self
     begin
@@ -34,7 +34,7 @@ module Reginald
 
     # Recompiles Regexp by parsing it and turning it back into a Regexp.
     #
-    # (In the future Reginald will perform some Regexp optimizations
+    # (In the future Regin will perform some Regexp optimizations
     # such as removing unnecessary captures and options)
     def compile(source)
       regexp = Regexp.compile(source)

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/alternation.rb

@@ -1,9 +1,9 @@
-module Reginald
+module Regin
   class Alternation < Collection
     def self.reduce(alternation_or_expression, expression) #:nodoc:
       if alternation_or_expression.first.is_a?(Alternation)
         alternation_or_expression = alternation_or_expression.first
-        alternation_or_expression << expression
+        alternation_or_expression += [expression]
         new(*alternation_or_expression)
       else
         new(alternation_or_expression, expression)
@@ -20,7 +20,7 @@ module Reginald
       end
 
       if options.key?(:ignorecase)
-        map! { |e| e.dup(:ignorecase => options[:ignorecase]) }
+        @array.map! { |e| e.dup(:ignorecase => options[:ignorecase]) }
       end
     end
 

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/anchor.rb

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

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/atom.rb

@@ -1,4 +1,4 @@
-module Reginald
+module Regin
   class Atom
     attr_reader :value, :ignorecase
 
@@ -33,7 +33,7 @@ module Reginald
     end
 
     def inspect #:nodoc:
-      "#<#{self.class.to_s.sub('Reginald::', '')} #{to_s.inspect}>"
+      "#<#{self.class.to_s.sub('Regin::', '')} #{to_s.inspect}>"
     end
 
     def ==(other) #:nodoc:

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/character.rb

@@ -1,4 +1,4 @@
-module Reginald
+module Regin
   class Character < Atom
     attr_reader :quantifier
 

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/character_class.rb

@@ -1,4 +1,4 @@
-module Reginald
+module Regin
   class CharacterClass < Character
     def initialize(value, options = {})
       @negate = options[:negate]

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

@@ -0,0 +1,81 @@
+module Regin
+  class Collection
+    include Enumerable
+
+    def initialize(*args)
+      @array = Array.new(*args)
+    end
+
+    def each(&block)
+      @array.each(&block)
+    end
+
+    def [](i)
+      @array[i]
+    end
+
+    def length
+      @array.length
+    end
+    alias_method :size, :length
+
+    def first
+      @array.first
+    end
+
+    def last
+      @array.last
+    end
+
+    def +(other)
+      ary = other.is_a?(Collection) ? other.internal_array : other
+      self.class.new(@array + ary)
+    end
+
+    def to_regexp
+      Regexp.compile("\\A#{to_s(true)}\\Z", flags)
+    end
+
+    def match(char)
+      to_regexp.match(char)
+    end
+
+    def include?(char)
+      any? { |e| e.include?(char) }
+    end
+
+    def ==(other) #:nodoc:
+      case other
+      when String
+        other == to_s
+      when Array
+        other == @array
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      other.instance_of?(self.class) && @array.eql?(other.internal_array)
+    end
+
+    def freeze #:nodoc:
+      each { |e| e.freeze }
+      @array.freeze
+      super
+    end
+
+    protected
+      def internal_array #:nodoc:
+        @array
+      end
+
+      def extract_options(args)
+        if args.last.is_a?(Hash)
+          return args[0..-2], args.last
+        else
+          return args, {}
+        end
+      end
+  end
+end

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/expression.rb

@@ -1,11 +1,11 @@
-module Reginald
+module Regin
   class Expression < Collection
     attr_reader :ignorecase
     attr_accessor :multiline, :extended
 
     def self.reduce(expression_or_atom, atom = nil) #:nodoc:
       if expression_or_atom.is_a?(Expression)
-        expression_or_atom << atom if atom
+        expression_or_atom += [atom] if atom
         new(*expression_or_atom)
       elsif atom.nil?
         new(expression_or_atom)
@@ -116,7 +116,7 @@ module Reginald
 
       def ignorecase=(ignorecase)
         if @ignorecase.nil?
-          map! { |e| e.dup(:ignorecase => ignorecase) }
+          @array.map! { |e| e.dup(:ignorecase => ignorecase) }
           @ignorecase = ignorecase
         end
       end

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/group.rb

@@ -1,4 +1,4 @@
-module Reginald
+module Regin
   class Group
     attr_reader :expression, :quantifier, :capture, :index, :name
 

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/options.rb

@@ -1,4 +1,4 @@
-module Reginald
+module Regin
   class Options
     def self.from_int(flags)
       multiline  = flags & Regexp::MULTILINE != 0

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/parser.rb

@@ -5,7 +5,7 @@
 #
 
 require 'racc/parser.rb'
-module Reginald
+module Regin
   class Parser < Racc::Parser #:nodoc: all
 
 def self.parse_regexp(regexp)
@@ -399,7 +399,7 @@ def _reduce_none(val, _values, result)
 end
 
   end   # class Parser
-end   # module Reginald
+end   # module Regin
 
-require 'reginald/tokenizer'
+require 'regin/tokenizer'
 

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/tokenizer.rb

@@ -1,11 +1,11 @@
 #--
 # DO NOT MODIFY!!!!
 # This file is automatically generated by rex 1.0.5.beta1
-# from lexical definition file "lib/reginald/tokenizer.rex".
+# from lexical definition file "lib/regin/tokenizer.rex".
 #++
 
 require 'racc/parser'
-class Reginald::Parser < Racc::Parser
+class Regin::Parser < Racc::Parser
   require 'strscan'
 
   class ScanError < StandardError ; end

data/lib/rack/mount/vendor/{reginald/reginald → regin/regin}/version.rb

@@ -1,3 +1,3 @@
-module Reginald
+module Regin
   Version = '0.2.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rack-mount
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 0
   - 6
-  - 5
-  version: 0.6.5
+  - 6
+  version: 0.6.6
 platform: ruby
 authors: 
 - Joshua Peek
@@ -90,19 +90,19 @@ files:
 - lib/rack/mount/vendor/multimap/multimap.rb
 - lib/rack/mount/vendor/multimap/multiset.rb
 - lib/rack/mount/vendor/multimap/nested_multimap.rb
-- lib/rack/mount/vendor/reginald/reginald.rb
-- lib/rack/mount/vendor/reginald/reginald/alternation.rb
-- lib/rack/mount/vendor/reginald/reginald/anchor.rb
-- lib/rack/mount/vendor/reginald/reginald/atom.rb
-- lib/rack/mount/vendor/reginald/reginald/character.rb
-- lib/rack/mount/vendor/reginald/reginald/character_class.rb
-- lib/rack/mount/vendor/reginald/reginald/collection.rb
-- lib/rack/mount/vendor/reginald/reginald/expression.rb
-- lib/rack/mount/vendor/reginald/reginald/group.rb
-- lib/rack/mount/vendor/reginald/reginald/options.rb
-- lib/rack/mount/vendor/reginald/reginald/parser.rb
-- lib/rack/mount/vendor/reginald/reginald/tokenizer.rb
-- lib/rack/mount/vendor/reginald/reginald/version.rb
+- lib/rack/mount/vendor/regin/regin.rb
+- lib/rack/mount/vendor/regin/regin/alternation.rb
+- lib/rack/mount/vendor/regin/regin/anchor.rb
+- lib/rack/mount/vendor/regin/regin/atom.rb
+- lib/rack/mount/vendor/regin/regin/character.rb
+- lib/rack/mount/vendor/regin/regin/character_class.rb
+- lib/rack/mount/vendor/regin/regin/collection.rb
+- lib/rack/mount/vendor/regin/regin/expression.rb
+- lib/rack/mount/vendor/regin/regin/group.rb
+- lib/rack/mount/vendor/regin/regin/options.rb
+- lib/rack/mount/vendor/regin/regin/parser.rb
+- lib/rack/mount/vendor/regin/regin/tokenizer.rb
+- lib/rack/mount/vendor/regin/regin/version.rb
 - lib/rack/mount/version.rb
 has_rdoc: true
 homepage: http://github.com/josh/rack-mount

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

@@ -1,44 +0,0 @@
-module Reginald
-  class Collection < Array
-    def to_regexp
-      Regexp.compile("\\A#{to_s(true)}\\Z", flags)
-    end
-
-    def match(char)
-      to_regexp.match(char)
-    end
-
-    def include?(char)
-      any? { |e| e.include?(char) }
-    end
-
-    def ==(other) #:nodoc:
-      case other
-      when String
-        other == to_s
-      when Array
-        super
-      else
-        eql?(other)
-      end
-    end
-
-    def eql?(other) #:nodoc:
-      other.instance_of?(self.class) && super
-    end
-
-    def freeze #:nodoc:
-      each { |e| e.freeze }
-      super
-    end
-
-    protected
-      def extract_options(args)
-        if args.last.is_a?(Hash)
-          return args[0..-2], args.last
-        else
-          return args, {}
-        end
-      end
-  end
-end