rack-mount 0.0.1 → 0.8.3

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,90 @@
+module Regin
+  class Group
+    attr_reader :expression, :quantifier, :lookahead, :capture, :index, :name
+
+    def initialize(expression, options = {})
+      @quantifier = @index = @name = nil
+      @capture = true
+      @expression = expression.dup(options)
+
+      @quantifier = options[:quantifier] if options.key?(:quantifier)
+      @lookahead  = options[:lookahead] if options.key?(:lookahead)
+      @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? && lookahead.nil? && expression.literal?
+    end
+
+    def to_s(parent = false)
+      if lookahead == :postive
+        "(?=#{expression.to_s(parent)})#{quantifier}"
+      elsif lookahead == :negative
+        "(?!#{expression.to_s(parent)})#{quantifier}"
+      elsif !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

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

@@ -0,0 +1,55 @@
+module Regin
+  class Options
+    def self.from_int(flags)
+      multiline  = flags & Regexp::MULTILINE != 0
+      ignorecase = flags & Regexp::IGNORECASE != 0
+      extended   = flags & Regexp::EXTENDED != 0
+
+      new(multiline, ignorecase, extended)
+    end
+
+    attr_reader :multiline, :ignorecase, :extended
+
+    def initialize(*args)
+      if args.first.is_a?(Hash)
+        @multiline  = args[0][:multiline]
+        @ignorecase = args[0][:ignorecase]
+        @extended   = args[0][:extended]
+      else
+        @multiline  = args[0]
+        @ignorecase = args[1]
+        @extended   = args[2]
+      end
+    end
+
+    def any?(explicit = false)
+      if explicit
+        !multiline.nil? || !ignorecase.nil? || !extended.nil?
+      else
+        multiline || ignorecase || extended
+      end
+    end
+
+    def to_h(explicit = false)
+      if explicit
+        options = {}
+        options[:multiline]  = multiline  unless multiline.nil?
+        options[:ignorecase] = ignorecase unless ignorecase.nil?
+        options[:extended]   = extended   unless extended.nil?
+        options
+      else
+        { :multiline => multiline,
+          :ignorecase => ignorecase,
+          :extended => extended }
+      end
+    end
+
+    def to_i
+      flag = 0
+      flag |= Regexp::MULTILINE if multiline
+      flag |= Regexp::IGNORECASE if ignorecase
+      flag |= Regexp::EXTENDED if extended
+      flag
+    end
+  end
+end