lgierth-rack-mount 0.6.13

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

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

@@ -0,0 +1,77 @@
+module Regin
+  class Collection
+    include Enumerable
+
+    def initialize(*args)
+      @array = Array.new(*args)
+    end
+
+    def each
+      @array.each{ |item| yield item }
+    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?(self.class) ? other.internal_array : other
+      self.class.new(@array + ary)
+    end
+
+    def to_regexp(anchored = false)
+      re = to_s(true)
+      re = "\\A#{re}\\Z" if anchored
+      Regexp.compile(re, 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
+
+    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/regin/regin/expression.rb

@@ -0,0 +1,126 @@
+module Regin
+  class Expression < Collection
+    attr_reader :ignorecase, :multiline, :extended
+
+    def initialize(*args)
+      args, options = extract_options(args)
+
+      @multiline = @ignorecase = @extended = nil
+
+      if args.length == 1 && args.first.instance_of?(Array)
+        super(args.first)
+      else
+        args = args.map { |e| e.instance_of?(String) ? Character.new(e) : e }
+        super(args)
+      end
+
+      self.multiline  = options[:multiline] if options.key?(:multiline)
+      self.ignorecase = options[:ignorecase] if options.key?(:ignorecase)
+      self.extended   = options[:extended] if options.key?(:extended)
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A Expression is literal if all its elements are literal.
+    def literal?
+      !ignorecase && all? { |e| e.literal? }
+    end
+
+    def anchored?
+      anchored_to_start? && anchored_to_end?
+    end
+
+    def anchored_to_start?
+      first.is_a?(Anchor) && first == '\A'
+    end
+
+    def anchored_to_end?
+      last.is_a?(Anchor) && last == '\Z'
+    end
+
+    def anchored_to_line?
+      anchored_to_start_of_line? && anchored_to_end_of_line?
+    end
+
+    def anchored_to_start_of_line?
+      anchored_to_start? || (first.is_a?(Anchor) && first == '^')
+    end
+
+    def anchored_to_end_of_line?
+      anchored_to_end? || (last.is_a?(Anchor) && last == '$')
+    end
+
+    def options?
+      options.any?(true)
+    end
+
+    def flags
+      options.to_i
+    end
+
+    def +(other)
+      ary = other.is_a?(self.class) ? other.internal_array : other
+      ary = @array + ary + [options.to_h(true)]
+      self.class.new(*ary)
+    end
+
+    def dup(options = {})
+      expression = super()
+      expression.multiline  = options[:multiline] if options.key?(:multiline)
+      expression.ignorecase = options[:ignorecase] if options.key?(:ignorecase)
+      expression.extended   = options[:extended] if options.key?(:extended)
+      expression
+    end
+
+    def to_s(parent = false)
+      if parent || !options?
+        map { |e| e.to_s(parent) }.join
+      else
+        with, without = [], []
+        multiline ? (with << 'm') : (without << 'm')
+        ignorecase ? (with << 'i') : (without << 'i')
+        extended ? (with << 'x') : (without << 'x')
+
+        with = with.join
+        without = without.any? ? "-#{without.join}" : ''
+
+        "(?#{with}#{without}:#{map { |e| e.to_s(true) }.join})"
+      end
+    end
+
+    def inspect #:nodoc:
+      "#<Expression #{to_s.inspect}>"
+    end
+
+    def casefold?
+      ignorecase
+    end
+
+    def eql?(other) #:nodoc:
+      super &&
+        !!self.multiline == !!other.multiline &&
+        !!self.ignorecase == !!other.ignorecase &&
+        !!self.extended == !!other.extended
+    end
+
+    protected
+      def options
+        Options.new(multiline, ignorecase, extended)
+      end
+
+      def multiline=(multiline)
+        @multiline = multiline
+      end
+
+      def ignorecase=(ignorecase)
+        if @ignorecase.nil?
+          @array.map! { |e| e.dup(:ignorecase => ignorecase) }
+          @ignorecase = ignorecase
+        end
+      end
+
+      def extended=(extended)
+        @extended = extended
+      end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Regin
+  class Group
+    attr_reader :expression, :quantifier, :capture, :index, :name
+
+    def initialize(expression, options = {})
+      @quantifier = @index = @name = nil
+      @capture = true
+      @expression = expression.dup(options)
+
+      @quantifier = options[:quantifier] if options.key?(:quantifier)
+      @capture    = options[:capture] if options.key?(:capture)
+      @index      = options[:index] if options.key?(:index)
+      @name       = options[:name] if options.key?(:name)
+    end
+
+    def option_names
+      %w( quantifier capture index name )
+    end
+
+    # Returns true if expression could be treated as a literal string.
+    #
+    # A Group is literal if its expression is literal and it has no quantifier.
+    def literal?
+      quantifier.nil? && expression.literal?
+    end
+
+    def to_s(parent = false)
+      if !expression.options?
+        "(#{capture ? '' : '?:'}#{expression.to_s(parent)})#{quantifier}"
+      elsif capture == false
+        "#{expression.to_s}#{quantifier}"
+      else
+        "(#{expression.to_s})#{quantifier}"
+      end
+    end
+
+    def to_regexp(anchored = false)
+      re = to_s
+      re = "\\A#{re}\\Z" if anchored
+      Regexp.compile(re)
+    end
+
+    def dup(options = {})
+      original_options = option_names.inject({}) do |h, m|
+        h[m.to_sym] = send(m)
+        h
+      end
+      self.class.new(expression, original_options.merge(options))
+    end
+
+    def inspect #:nodoc:
+      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) #:nodoc:
+      case other
+      when String
+        other == to_s
+      else
+        eql?(other)
+      end
+    end
+
+    def eql?(other) #:nodoc:
+      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
+  end
+end