grape-extra_validators 1.0.0

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/pattern_cache.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'set'
+require 'thread'
+require 'mustermann'
+
+module Mustermann
+  # A simple, persistent cache for creating repositories.
+  #
+  # @example
+  #   require 'mustermann/pattern_cache'
+  #   cache = Mustermann::PatternCache.new
+  #
+  #   # use this instead of Mustermann.new
+  #   pattern = cache.create_pattern("/:name", type: :rails)
+  #
+  # @note
+  #   {Mustermann::Pattern.new} (which is used by {Mustermann.new}) will reuse instances that have
+  #   not yet been garbage collected. You only need an extra cache if you do not keep a reference to
+  #   the patterns around.
+  #
+  # @api private
+  class PatternCache
+    # @param [Hash] pattern_options default options used for {#create_pattern}
+    def initialize(**pattern_options)
+      @cached          = Set.new
+      @mutex           = Mutex.new
+      @pattern_options = pattern_options
+    end
+
+    # @param (see Mustermann.new)
+    # @return (see Mustermann.new)
+    # @raise (see Mustermann.new)
+    # @see Mustermann.new
+    def create_pattern(string, **pattern_options)
+      pattern = Mustermann.new(string, **pattern_options, **@pattern_options)
+      @mutex.synchronize { @cached.add(pattern) } unless @cached.include? pattern
+      pattern
+    end
+
+    # Removes all pattern instances from the cache.
+    def clear
+      @mutex.synchronize { @cached.clear }
+    end
+
+    # @return [Integer] number of currently cached patterns
+    def size
+      @mutex.synchronize { @cached.size }
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/regexp.rb

@@ -0,0 +1 @@
+require 'mustermann/regular'

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/regexp_based.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'mustermann/pattern'
+require 'forwardable'
+
+module Mustermann
+  # Superclass for patterns that internally compile to a regular expression.
+  # @see Mustermann::Pattern
+  # @abstract
+  class RegexpBased < Pattern
+    # @return [Regexp] regular expression equivalent to the pattern.
+    attr_reader :regexp
+    alias_method :to_regexp, :regexp
+
+    # @param (see Mustermann::Pattern#initialize)
+    # @return (see Mustermann::Pattern#initialize)
+    # @see (see Mustermann::Pattern#initialize)
+    def initialize(string, **options)
+      super
+      regexp       = compile(**options)
+      @peek_regexp = /\A#{regexp}/
+      @regexp      = /\A#{regexp}\Z/
+    end
+
+    # @param (see Mustermann::Pattern#peek_size)
+    # @return (see Mustermann::Pattern#peek_size)
+    # @see (see Mustermann::Pattern#peek_size)
+    def peek_size(string)
+      return unless match = peek_match(string)
+      match.to_s.size
+    end
+
+    # @param (see Mustermann::Pattern#peek_match)
+    # @return (see Mustermann::Pattern#peek_match)
+    # @see (see Mustermann::Pattern#peek_match)
+    def peek_match(string)
+      @peek_regexp.match(string)
+    end
+
+    extend Forwardable
+    def_delegators :regexp, :===, :=~, :match, :names, :named_captures
+
+    def compile(**options)
+      raise NotImplementedError, 'subclass responsibility'
+    end
+
+    private :compile
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/regular.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'mustermann'
+require 'mustermann/regexp_based'
+require 'strscan'
+
+module Mustermann
+  # Regexp pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/.*', type: :regexp) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#simple Syntax description in the README
+  class Regular < RegexpBased
+    include Concat::Native
+    register :regexp, :regular
+    supported_options :check_anchors
+
+    # @param (see Mustermann::Pattern#initialize)
+    # @return (see Mustermann::Pattern#initialize)
+    # @see (see Mustermann::Pattern#initialize)
+    def initialize(string, check_anchors: true, **options)
+      string = $1 if string.to_s =~ /\A\(\?\-mix\:(.*)\)\Z/ && string.inspect == "/#$1/"
+      string = string.source.gsub!(/(?<!\\)(?:\s|#.*$)/, '') if extended_regexp?(string)
+      @check_anchors = check_anchors
+      super(string, **options)
+    end
+
+    def compile(**options)
+      if @check_anchors
+        scanner = ::StringScanner.new(@string)
+        check_anchors(scanner) until scanner.eos?
+      end
+
+      /#{@string}/
+    end
+
+    def check_anchors(scanner)
+      return scanner.scan_until(/\]/) if scanner.scan(/\[/)
+      return scanner.scan(/\\?./) unless illegal = scanner.scan(/\\[AzZ]|[\^\$]/)
+      raise CompileError, "regular expression should not contain %s: %p" % [illegal.to_s, @string]
+    end
+
+    def extended_regexp?(string)
+      not (Regexp.new(string).options & Regexp::EXTENDED).zero?
+    end
+
+    private :compile, :check_anchors, :extended_regexp?
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/simple_match.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Mustermann
+  # Fakes MatchData for patterns that do not support capturing.
+  # @see http://ruby-doc.org/core-2.0/MatchData.html MatchData
+  class SimpleMatch
+    # @api private
+    def initialize(string = "", names: [], captures: [])
+      @string   = string.dup
+      @names    = names
+      @captures = captures
+    end
+
+    # @return [String] the string that was matched against
+    def to_s
+      @string.dup
+    end
+
+    # @return [Array<String>] empty array for imitating MatchData interface
+    def names
+      @names.dup
+    end
+
+    # @return [Array<String>] empty array for imitating MatchData interface
+    def captures
+      @captures.dup
+    end
+
+    # @return [nil] imitates MatchData interface
+    def [](*args)
+      args.map! do |arg|
+        next arg unless arg.is_a? Symbol or arg.is_a? String
+        names.index(arg.to_s)
+      end
+      @captures[*args]
+    end
+
+    # @!visibility private
+    def +(other)
+      SimpleMatch.new(@string + other.to_s,
+          names:    @names    + other.names,
+          captures: @captures + other.captures)
+    end
+
+    # @return [String] string representation
+    def inspect
+      "#<%p %p>" % [self.class, @string]
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/sinatra.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'mustermann'
+require 'mustermann/identity'
+require 'mustermann/ast/pattern'
+require 'mustermann/sinatra/parser'
+require 'mustermann/sinatra/safe_renderer'
+require 'mustermann/sinatra/try_convert'
+
+module Mustermann
+  # Sinatra 2.0 style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo') === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#sinatra Syntax description in the README
+  class Sinatra < AST::Pattern
+    include Concat::Native
+    register :sinatra
+
+    # Takes a string and espaces any characters that have special meaning for Sinatra patterns.
+    #
+    # @example
+    #   require 'mustermann/sinatra'
+    #   Mustermann::Sinatra.escape("/:name") # => "/\\:name"
+    #
+    # @param [#to_s] string the input string
+    # @return [String] the escaped string
+    def self.escape(string)
+      string.to_s.gsub(/[\?\(\)\*:\\\|\{\}]/) { |c| "\\#{c}" }
+    end
+
+    # Tries to convert the given input object to a Sinatra pattern with the given options, without
+    # changing its parsing semantics.
+    # @return [Mustermann::Sinatra, nil] the converted pattern, if possible
+    # @!visibility private
+    def self.try_convert(input, **options)
+      TryConvert.convert(input, **options)
+    end
+
+    # Creates a pattern that matches any string matching either one of the patterns.
+    # If a string is supplied, it is treated as a fully escaped Sinatra pattern.
+    #
+    # If the other pattern is also a Sintara pattern, it might join the two to a third
+    # sinatra pattern instead of generating a composite for efficiency reasons.
+    #
+    # This only happens if the sinatra pattern behaves exactly the same as a composite
+    # would in regards to matching, parsing, expanding and template generation.
+    #
+    # @example
+    #   pattern = Mustermann.new('/foo/:name') | Mustermann.new('/:first/:second')
+    #   pattern === '/foo/bar' # => true
+    #   pattern === '/fox/bar' # => true
+    #   pattern === '/foo'     # => false
+    #
+    # @param [Mustermann::Pattern, String] other the other pattern
+    # @return [Mustermann::Pattern] a composite pattern
+    # @see Mustermann::Pattern#|
+    def |(other)
+      return super unless converted = self.class.try_convert(other, **options)
+      return super unless converted.names.empty? or names.empty?
+      self.class.new(safe_string + "|" + converted.safe_string, **options)
+    end
+
+    # Generates a string represenation of the pattern that can safely be used for def interpolation
+    # without changing its semantics.
+    #
+    # @example
+    #   require 'mustermann'
+    #   unsafe = Mustermann.new("/:name")
+    #
+    #   Mustermann.new("#{unsafe}bar").params("/foobar") # => { "namebar" => "foobar" }
+    #   Mustermann.new("#{unsafe.safe_string}bar").params("/foobar") # => { "name" => "bar" }
+    #
+    # @return [String] string representatin of the pattern
+    def safe_string
+      @safe_string ||= SafeRenderer.translate(to_ast)
+    end
+
+    # @!visibility private
+    def native_concat(other)
+      return unless converted = self.class.try_convert(other, **options)
+      safe_string + converted.safe_string
+    end
+
+    private :native_concat
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/sinatra/parser.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Mustermann
+  class Sinatra < AST::Pattern
+    # Sinatra syntax definition.
+    # @!visibility private
+    class Parser < AST::Parser
+      on(nil, ??, ?)) { |c| unexpected(c) }
+
+      on(?*)  { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+      on(?:)  { |c| node(:capture) { scan(/\w+/) } }
+      on(?\\) { |c| node(:char, expect(/./)) }
+      on(?()  { |c| node(:group) { read unless scan(?)) } }
+      on(?|)  { |c| node(:or) }
+
+      on ?{ do |char|
+        current_pos = buffer.pos
+        type = scan(?+) ? :named_splat : :capture
+        name = expect(/[\w\.]+/)
+        if type == :capture && scan(?|)
+          buffer.pos = current_pos
+          capture = proc do
+            start = pos
+            match = expect(/(?<capture>[^\|}]+)/)
+            node(:capture, match[:capture], start: start)
+          end
+          grouped_captures = node(:group, [capture[]]) do
+            if scan(?|)
+              [min_size(pos - 1, pos, node(:or)), capture[]]
+            end
+          end
+          grouped_captures if expect(?})
+        else
+          type = :splat if type == :named_splat and name == 'splat'
+          expect(?})
+          node(type, name)
+        end
+      end
+
+      suffix ?? do |char, element|
+        node(:optional, element)
+      end
+    end
+
+    private_constant :Parser
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/sinatra/safe_renderer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Mustermann
+  class Sinatra < AST::Pattern
+    # Generates a string that can safely be concatenated with other strings
+    # without chaning its semantics
+    # @see #safe_string
+    # @!visibility private
+    SafeRenderer = AST::Translator.create do
+      translate(:splat, :named_splat) { "{+#{name}}"                           }
+      translate(:char, :separator)    { Sinatra.escape(payload)                }
+      translate(:root)                { t(payload)                             }
+      translate(:group)               { "(#{t(payload)})"                      }
+      translate(:union)               { "(#{t(payload, join: ?|)})"            }
+      translate(:optional)            { "#{t(payload)}?"                       }
+      translate(:with_look_ahead)     { t([head, payload])                     }
+      translate(Array)                { |join: ""| map { |e| t(e) }.join(join) }
+
+      translate(:capture) do
+        raise Mustermann::Error, 'cannot render variables'      if node.is_a? :variable
+        raise Mustermann::Error, 'cannot translate constraints' if constraint or qualifier or convert
+        prefix = node.is_a?(:splat) ? "+" : ""
+        "{#{prefix}#{name}}"
+      end
+    end
+
+    private_constant :SafeRenderer
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/sinatra/try_convert.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Mustermann
+  class Sinatra < AST::Pattern
+    # Tries to translate objects to Sinatra patterns.
+    # @!visibility private
+    class TryConvert < AST::Translator
+      # @return [Mustermann::Sinatra, nil]
+      # @!visibility private
+      def self.convert(input, **options)
+        new(options).translate(input)
+      end
+
+      # Expected options for the resulting pattern.
+      # @!visibility private
+      attr_reader :options
+
+      # @!visibility private
+      def initialize(options)
+        @options = options
+      end
+
+      # @return [Mustermann::Sinatra]
+      # @!visibility private
+      def new(input, escape = false)
+        input = Mustermann::Sinatra.escape(input) if escape
+        Mustermann::Sinatra.new(input, **options)
+      end
+
+      # @return [true, false] whether or not expected pattern should have uri_decode option set
+      # @!visibility private
+      def uri_decode
+        options.fetch(:uri_decode, true)
+      end
+
+      translate(Object) { nil               }
+      translate(String) { t.new(self, true) }
+
+      translate(Identity) { t.new(self, true) if uri_decode == t.uri_decode }
+      translate(Sinatra)  { node              if options    == t.options    }
+
+      translate AST::Pattern do
+        next unless options == t.options
+        t.new(SafeRenderer.translate(to_ast)) rescue nil
+      end
+    end
+
+    private_constant :TryConvert
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/mustermann-1.0.3/lib/mustermann/to_pattern.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require 'mustermann'
+
+module Mustermann
+  # Mixin for adding {#to_pattern} ducktyping to objects.
+  #
+  # @example
+  #   require 'mustermann/to_pattern'
+  #
+  #   class Foo
+  #     include Mustermann::ToPattern
+  #
+  #     def to_s
+  #       ":foo/:bar"
+  #     end
+  #   end
+  #
+  #   Foo.new.to_pattern # => #<Mustermann::Sinatra:":foo/:bar">
+  #
+  # By default included into String, Symbol, Regexp, Array and {Mustermann::Pattern}.
+  module ToPattern
+    PRIMITIVES = [String, Symbol, Array, Regexp, Mustermann::Pattern]
+    private_constant :PRIMITIVES
+
+    # Converts the object into a {Mustermann::Pattern}.
+    #
+    # @example converting a string
+    #   ":name.png".to_pattern # => #<Mustermann::Sinatra:":name.png">
+    #
+    # @example converting a string with options
+    #   "/*path".to_pattern(type: :rails) # => #<Mustermann::Rails:"/*path">
+    #
+    # @example converting a regexp
+    #   /.*/.to_pattern # => #<Mustermann::Regular:".*">
+    #
+    # @example converting a pattern
+    #   Mustermann.new("foo").to_pattern # => #<Mustermann::Sinatra:"foo">
+    #
+    # @param [Hash] options The options hash.
+    # @return [Mustermann::Pattern] pattern corresponding to object.
+    def to_pattern(**options)
+      input   = self if PRIMITIVES.any? { |p| self.is_a? p }
+      input ||= __getobj__ if respond_to?(:__getobj__)
+      Mustermann.new(input || to_s, **options)
+    end
+
+    PRIMITIVES.each do |klass|
+      append_features(klass)
+    end
+  end
+end