ory-keto-client 0.7.0.alpha0 → 0.8.0.alpha2

data/vendor/bundle/ruby/2.5.0/gems/parser-3.1.1.0/lib/parser/context.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Parser
+  # Context of parsing that is represented by a stack of scopes.
+  #
+  # Supported states:
+  # + :class - in the class body (class A; end)
+  # + :module - in the module body (module M; end)
+  # + :sclass - in the singleton class body (class << obj; end)
+  # + :def - in the method body (def m; end)
+  # + :defs - in the singleton method body (def self.m; end)
+  # + :def_open_args - in the arglist of the method definition
+  #                    keep in mind that it's set **only** after reducing the first argument,
+  #                    if you need to handle the first argument check `lex_state == expr_fname`
+  # + :block - in the block body (tap {})
+  # + :lambda - in the lambda body (-> {})
+  #
+  class Context
+    FLAGS = %i[
+      in_defined
+      in_kwarg
+      in_argdef
+      in_def
+      in_class
+      in_block
+      in_lambda
+    ]
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @in_defined = false
+      @in_kwarg = false
+      @in_argdef = false
+      @in_def = false
+      @in_class = false
+      @in_block = false
+      @in_lambda = false
+    end
+
+    attr_accessor(*FLAGS)
+
+    def in_dynamic_block?
+      in_block || in_lambda
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-3.1.1.0/lib/parser/current.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Parser
+  class << self
+    def warn_syntax_deviation(feature, version)
+      warn "warning: parser/current is loading #{feature}, which recognizes" \
+        "#{version}-compliant syntax, but you are running #{RUBY_VERSION}.\n" \
+        "Please see https://github.com/whitequark/parser#compatibility-with-ruby-mri."
+    end
+    private :warn_syntax_deviation
+  end
+
+  case RUBY_VERSION
+  when /^2\.0\./
+    current_version = '2.0.0'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby20', current_version
+    end
+
+    require 'parser/ruby20'
+    CurrentRuby = Ruby20
+
+  when /^2\.1\./
+    current_version = '2.1.10'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby21', current_version
+    end
+
+    require 'parser/ruby21'
+    CurrentRuby = Ruby21
+
+  when /^2\.2\./
+    current_version = '2.2.10'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby22', current_version
+    end
+
+    require 'parser/ruby22'
+    CurrentRuby = Ruby22
+
+  when /^2\.3\./
+    current_version = '2.3.8'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby23', current_version
+    end
+
+    require 'parser/ruby23'
+    CurrentRuby = Ruby23
+
+  when /^2\.4\./
+    current_version = '2.4.10'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby24', current_version
+    end
+
+    require 'parser/ruby24'
+    CurrentRuby = Ruby24
+
+  when /^2\.5\./
+    current_version = '2.5.9'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby25', current_version
+    end
+
+    require 'parser/ruby25'
+    CurrentRuby = Ruby25
+
+  when /^2\.6\./
+    current_version = '2.6.9'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby26', current_version
+    end
+
+    require 'parser/ruby26'
+    CurrentRuby = Ruby26
+
+  when /^2\.7\./
+    current_version = '2.7.5'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby27', current_version
+    end
+
+    require 'parser/ruby27'
+    CurrentRuby = Ruby27
+
+  when /^3\.0\./
+    current_version = '3.0.3'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby30', current_version
+    end
+
+    require 'parser/ruby30'
+    CurrentRuby = Ruby30
+
+  when /^3\.1\./
+    current_version = '3.1.1'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby31', current_version
+    end
+
+    require 'parser/ruby31'
+    CurrentRuby = Ruby31
+
+  when /^3\.2\./
+    current_version = '3.2.0-dev'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby32', current_version
+    end
+
+    require 'parser/ruby32'
+    CurrentRuby = Ruby32
+
+  else # :nocov:
+    # Keep this in sync with released Ruby.
+    warn_syntax_deviation 'parser/ruby31', '3.1.x'
+    require 'parser/ruby31'
+    CurrentRuby = Ruby31
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-3.1.1.0/lib/parser/lexer/dedenter.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Parser
+
+  class Lexer::Dedenter
+    # Tab (\t) counts as 8 spaces
+    TAB_WIDTH = 8
+
+    def initialize(dedent_level)
+      @dedent_level = dedent_level
+      @at_line_begin = true
+      @indent_level  = 0
+    end
+
+    # For a heredoc like
+    #   <<-HERE
+    #     a
+    #     b
+    #   HERE
+    # this method gets called with "  a\n" and "  b\n"
+    #
+    # However, the following heredoc:
+    #
+    #   <<-HERE
+    #     a\
+    #     b
+    #   HERE
+    # calls this method only once with a string "  a\\\n  b\n"
+    #
+    # This is important because technically it's a single line,
+    # but it has to be concatenated __after__ dedenting.
+    #
+    # It has no effect for non-squiggly heredocs, i.e. it simply removes "\\\n"
+    # Of course, lexer could do it but once again: it's all because of dedenting.
+    #
+    def dedent(string)
+      original_encoding = string.encoding
+      # Prevent the following error when processing binary encoded source.
+      # "\xC0".split # => ArgumentError (invalid byte sequence in UTF-8)
+      lines = string.force_encoding(Encoding::BINARY).split("\\\n")
+      if lines.length == 1
+        # If the line continuation sequence was found but there is no second
+        # line, it was not really a line continuation and must be ignored.
+        lines = [string.force_encoding(original_encoding)]
+      else
+        lines.map! {|s| s.force_encoding(original_encoding) }
+      end
+
+      if @at_line_begin
+        lines_to_dedent = lines
+      else
+        _first, *lines_to_dedent = lines
+      end
+
+      lines_to_dedent.each do |line|
+        left_to_remove = @dedent_level
+        remove = 0
+
+        line.each_char do |char|
+          break if left_to_remove <= 0
+          case char
+          when ?\s
+            remove += 1
+            left_to_remove -= 1
+          when ?\t
+            break if TAB_WIDTH * (remove / TAB_WIDTH + 1) > @dedent_level
+            remove += 1
+            left_to_remove -= TAB_WIDTH
+          else
+            # no more spaces or tabs
+            break
+          end
+        end
+
+        line.slice!(0, remove)
+      end
+
+      string.replace(lines.join)
+
+      @at_line_begin = string.end_with?("\n")
+    end
+
+    def interrupt
+      @at_line_begin = false
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-3.1.1.0/lib/parser/lexer/explanation.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Parser
+
+  module Lexer::Explanation
+
+    def self.included(klass)
+      klass.class_exec do
+        alias_method :state_before_explanation=,  :state=
+        alias_method :advance_before_explanation, :advance
+
+        remove_method :state=, :advance
+      end
+    end
+
+    # Like #advance, but also pretty-print the token and its position
+    # in the stream to `stdout`.
+    def advance
+      type, (val, range) = advance_before_explanation
+
+      more = "(in-kwarg)" if @context.in_kwarg
+
+      puts decorate(range,
+                    Color.green("#{type} #{val.inspect}"),
+                    "#{state.to_s.ljust(12)} #{@cond} #{@cmdarg} #{more}")
+
+      [ type, [val, range] ]
+    end
+
+    def state=(new_state)
+      puts "  #{Color.yellow(">>> STATE SET <<<", bold: true)} " +
+           "#{new_state.to_s.ljust(12)} #{@cond} #{@cmdarg}".rjust(66)
+
+      self.state_before_explanation = new_state
+    end
+
+    private
+
+    def decorate(range, token, info)
+      from, to = range.begin.column, range.end.column
+
+      line = range.source_line + '   '
+      line[from...to] = Color.underline(line[from...to])
+
+      tail_len   = to - from - 1
+      tail       = '~' * (tail_len >= 0 ? tail_len : 0)
+      decoration =  "#{" " * from}#{Color.red("^#{tail}", bold: true)} #{token} ".
+                        ljust(68) + info
+
+      [ line, decoration ]
+    end
+
+  end
+
+end