ory-keto-client 0.6.0.alpha3 → 0.8.0.alpha1

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.66.0/lib/rubocop/rspec/expect_offense.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    # Mixin for `expect_offense` and `expect_no_offenses`
+    #
+    # This mixin makes it easier to specify strict offense expectations
+    # in a declarative and visual fashion. Just type out the code that
+    # should generate a offense, annotate code by writing '^'s
+    # underneath each character that should be highlighted, and follow
+    # the carets with a string (separated by a space) that is the
+    # message of the offense. You can include multiple offenses in
+    # one code snippet.
+    #
+    # @example Usage
+    #
+    #     expect_offense(<<-RUBY.strip_indent)
+    #       a do
+    #         b
+    #       end.c
+    #       ^^^^^ Avoid chaining a method call on a do...end block.
+    #     RUBY
+    #
+    # @example Equivalent assertion without `expect_offense`
+    #
+    #     inspect_source(<<-RUBY.strip_indent)
+    #       a do
+    #         b
+    #       end.c
+    #     RUBY
+    #
+    #     expect(cop.offenses.size).to be(1)
+    #
+    #     offense = cop.offenses.first
+    #     expect(offense.line).to be(3)
+    #     expect(offense.column_range).to be(0...5)
+    #     expect(offense.message).to eql(
+    #       'Avoid chaining a method call on a do...end block.'
+    #     )
+    #
+    # Auto-correction can be tested using `expect_correction` after
+    # `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_correction`
+    #
+    #   expect_offense(<<-RUBY.strip_indent)
+    #     x % 2 == 0
+    #     ^^^^^^^^^^ Replace with `Integer#even?`.
+    #   RUBY
+    #
+    #   expect_correction(<<-RUBY.strip_indent)
+    #     x.even?
+    #   RUBY
+    #
+    # If you do not want to specify an offense then use the
+    # companion method `expect_no_offenses`. This method is a much
+    # simpler assertion since it just inspects the source and checks
+    # that there were no offenses. The `expect_offense` method has
+    # to do more work by parsing out lines that contain carets.
+    #
+    # If the code produces an offense that could not be auto-corrected, you can
+    # use `expect_no_corrections` after `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_no_corrections`
+    #
+    #   expect_offense(<<-RUBY.strip_indent)
+    #     a do
+    #       b
+    #     end.c
+    #     ^^^^^ Avoid chaining a method call on a do...end block.
+    #   RUBY
+    #
+    #   expect_no_corrections
+    module ExpectOffense
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def expect_offense(source, file = nil)
+        RuboCop::Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+        cop.instance_variable_get(:@options)[:auto_correct] = true
+
+        expected_annotations = AnnotatedSource.parse(source)
+
+        if expected_annotations.plain_source == source
+          raise 'Use `expect_no_offenses` to assert that no offenses are found'
+        end
+
+        @processed_source = parse_source(expected_annotations.plain_source,
+                                         file)
+
+        unless @processed_source.valid_syntax?
+          raise 'Error parsing example code'
+        end
+
+        _investigate(cop, @processed_source)
+        actual_annotations =
+          expected_annotations.with_offense_annotations(cop.offenses)
+
+        expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def expect_correction(correction)
+        unless @processed_source
+          raise '`expect_correction` must follow `expect_offense`'
+        end
+
+        corrector =
+          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
+        new_source = corrector.rewrite
+
+        expect(new_source).to eq(correction)
+      end
+
+      def expect_no_corrections
+        unless @processed_source
+          raise '`expect_no_corrections` must follow `expect_offense`'
+        end
+
+        return if cop.corrections.empty?
+
+        # In order to print a nice diff, e.g. what source got corrected to,
+        # we need to run the actual corrections
+
+        corrector =
+          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
+        new_source = corrector.rewrite
+
+        expect(new_source).to eq(@processed_source.buffer.source)
+      end
+
+      def expect_no_offenses(source, file = nil)
+        inspect_source(source, file)
+
+        expect(cop.offenses).to be_empty
+      end
+
+      # Parsed representation of code annotated with the `^^^ Message` style
+      class AnnotatedSource
+        ANNOTATION_PATTERN = /\A\s*\^+ /.freeze
+
+        # @param annotated_source [String] string passed to the matchers
+        #
+        # Separates annotation lines from source lines. Tracks the real
+        # source line number that each annotation corresponds to.
+        #
+        # @return [AnnotatedSource]
+        def self.parse(annotated_source)
+          source      = []
+          annotations = []
+
+          annotated_source.each_line do |source_line|
+            if source_line =~ ANNOTATION_PATTERN
+              annotations << [source.size, source_line]
+            else
+              source << source_line
+            end
+          end
+
+          new(source, annotations)
+        end
+
+        # @param lines [Array<String>]
+        # @param annotations [Array<(Integer, String)>]
+        #   each entry is the annotated line number and the annotation text
+        #
+        # @note annotations are sorted so that reconstructing the annotation
+        #   text via {#to_s} is deterministic
+        def initialize(lines, annotations)
+          @lines       = lines.freeze
+          @annotations = annotations.sort.freeze
+        end
+
+        # Construct annotated source string (like what we parse)
+        #
+        # Reconstruct a deterministic annotated source string. This is
+        # useful for eliminating semantically irrelevant annotation
+        # ordering differences.
+        #
+        # @example standardization
+        #
+        #     source1 = AnnotatedSource.parse(<<-RUBY)
+        #     line1
+        #     ^ Annotation 1
+        #      ^^ Annotation 2
+        #     RUBY
+        #
+        #     source2 = AnnotatedSource.parse(<<-RUBY)
+        #     line1
+        #      ^^ Annotation 2
+        #     ^ Annotation 1
+        #     RUBY
+        #
+        #     source1.to_s == source2.to_s # => true
+        #
+        # @return [String]
+        def to_s
+          reconstructed = lines.dup
+
+          annotations.reverse_each do |line_number, annotation|
+            reconstructed.insert(line_number, annotation)
+          end
+
+          reconstructed.join
+        end
+
+        # Return the plain source code without annotations
+        #
+        # @return [String]
+        def plain_source
+          lines.join
+        end
+
+        # Annotate the source code with the RuboCop offenses provided
+        #
+        # @param offenses [Array<RuboCop::Cop::Offense>]
+        #
+        # @return [self]
+        def with_offense_annotations(offenses)
+          offense_annotations =
+            offenses.map do |offense|
+              indent     = ' ' * offense.column
+              carets     = '^' * offense.column_length
+
+              [offense.line, "#{indent}#{carets} #{offense.message}\n"]
+            end
+
+          self.class.new(lines, offense_annotations)
+        end
+
+        private
+
+        attr_reader :lines, :annotations
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.66.0/lib/rubocop/rspec/host_environment_simulation_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# RuboCop can be run in contexts where unexpected other libraries are included,
+# which may interfere with its normal behavior. In order to test those
+# situations, it may be necessary to require another library for the duration
+# of one spec
+module HostEnvironmentSimulatorHelper
+  def in_its_own_process_with(*files)
+    if ::Process.respond_to?(:fork)
+      pid = ::Process.fork do
+        # Need to write coverage result under different name
+        if defined?(SimpleCov)
+          SimpleCov.command_name "rspec-fork-#{Process.pid}"
+          SimpleCov.pid = Process.pid
+        end
+
+        files.each { |file| require file }
+        yield
+      end
+      ::Process.wait(pid)
+
+      # assert that the block did not fail
+      expect($CHILD_STATUS).to be_success
+    else
+      warn 'Process.fork is not available.'
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.66.0/lib/rubocop/rspec/shared_contexts.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.shared_context 'isolated environment', :isolated_environment do
+  around do |example|
+    Dir.mktmpdir do |tmpdir|
+      original_home = ENV['HOME']
+
+      # Make sure to expand all symlinks in the path first. Otherwise we may
+      # get mismatched pathnames when loading config files later on.
+      tmpdir = File.realpath(tmpdir)
+
+      # Make upwards search for .rubocop.yml files stop at this directory.
+      RuboCop::FileFinder.root_level = tmpdir
+
+      begin
+        virtual_home = File.expand_path(File.join(tmpdir, 'home'))
+        Dir.mkdir(virtual_home)
+        ENV['HOME'] = virtual_home
+
+        working_dir = File.join(tmpdir, 'work')
+        Dir.mkdir(working_dir)
+
+        RuboCop::PathUtil.chdir(working_dir) do
+          example.run
+        end
+      ensure
+        ENV['HOME'] = original_home
+
+        RuboCop::FileFinder.root_level = nil
+      end
+    end
+  end
+end
+
+# `cop_config` must be declared with #let.
+RSpec.shared_context 'config', :config do
+  let(:config) do
+    # Module#<
+    unless described_class < RuboCop::Cop::Cop
+      raise '`config` must be used in `describe SomeCopClass do .. end`'
+    end
+
+    hash = { 'AllCops' => { 'TargetRubyVersion' => ruby_version } }
+    hash['Rails'] = { 'Enabled' => true } if enabled_rails
+    hash['AllCops']['TargetRailsVersion'] = rails_version if rails_version
+    if respond_to?(:cop_config)
+      cop_name = described_class.cop_name
+      hash[cop_name] = RuboCop::ConfigLoader
+                       .default_configuration[cop_name]
+                       .merge(cop_config)
+    end
+
+    hash = other_cops.merge hash if respond_to?(:other_cops)
+
+    RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
+  end
+end
+
+RSpec.shared_context 'ruby 2.2', :ruby22 do
+  let(:ruby_version) { 2.2 }
+end
+
+RSpec.shared_context 'ruby 2.3', :ruby23 do
+  let(:ruby_version) { 2.3 }
+end
+
+RSpec.shared_context 'ruby 2.4', :ruby24 do
+  let(:ruby_version) { 2.4 }
+end
+
+RSpec.shared_context 'ruby 2.5', :ruby25 do
+  let(:ruby_version) { 2.5 }
+end
+
+RSpec.shared_context 'ruby 2.6', :ruby26 do
+  let(:ruby_version) { 2.6 }
+end
+
+RSpec.shared_context 'with Rails', :enabled_rails do
+  let(:enabled_rails) { true }
+end
+
+RSpec.shared_context 'with Rails 3', :rails3 do
+  let(:rails_version) { 3.0 }
+end
+
+RSpec.shared_context 'with Rails 4', :rails4 do
+  let(:rails_version) { 4.0 }
+end
+
+RSpec.shared_context 'with Rails 5', :rails5 do
+  let(:rails_version) { 5.0 }
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.66.0/lib/rubocop/rspec/shared_examples.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# `cop` and `source` must be declared with #let.
+
+RSpec.shared_examples_for 'misaligned' do |annotated_source, used_style|
+  config_to_allow_offenses = if used_style
+                               { 'EnforcedStyleAlignWith' => used_style.to_s }
+                             else
+                               { 'Enabled' => false }
+                             end
+  annotated_source.strip_indent.split(/\n\n/).each do |chunk|
+    chunk << "\n" unless chunk.end_with?("\n")
+    source = chunk.lines.reject { |line| line =~ /^ *\^/ }.join
+    name = source.gsub(/\n(?=[a-z ])/, ' <newline> ').gsub(/\s+/, ' ')
+
+    it "registers an offense for mismatched #{name}" do
+      expect_offense(chunk)
+      expect(cop.config_to_allow_offenses).to eq(config_to_allow_offenses)
+    end
+
+    it "auto-corrects mismatched #{name}" do
+      raise if chunk !~
+               /\^\^\^ `end` at (\d), \d is not aligned with `.*` at \d, (\d)./
+
+      line_index = Integer(Regexp.last_match(1)) - 1
+      correct_indentation = ' ' * Integer(Regexp.last_match(2))
+      expect(autocorrect_source(source))
+        .to eq(source.lines[0...line_index].join +
+               "#{correct_indentation}#{source.lines[line_index].strip}\n")
+    end
+  end
+end
+
+RSpec.shared_examples_for 'aligned' do |alignment_base, arg, end_kw, name|
+  name ||= alignment_base
+  name = name.gsub(/\n/, ' <newline>')
+  it "accepts matching #{name} ... end" do
+    inspect_source("#{alignment_base} #{arg}\n#{end_kw}")
+    expect(cop.offenses).to be_empty
+  end
+end
+
+RSpec.shared_examples_for 'debugger' do |name, src|
+  it "reports an offense for a #{name} call" do
+    inspect_source(src)
+    src = [src] if src.is_a? String
+    expect(cop.offenses.size).to eq(src.size)
+    expect(cop.messages)
+      .to eq(src.map { |s| "Remove debugger entry point `#{s}`." })
+    expect(cop.highlights).to eq(src)
+  end
+end
+
+RSpec.shared_examples_for 'non-debugger' do |name, src|
+  it "does not report an offense for #{name}" do
+    inspect_source(src)
+    expect(cop.offenses).to be_empty
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.66.0/lib/rubocop/rspec/support.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Require this file to load code that supports testing using RSpec.
+
+require_relative 'cop_helper'
+require_relative 'host_environment_simulation_helper'
+require_relative 'shared_contexts'
+require_relative 'shared_examples'
+require_relative 'expect_offense'
+
+RSpec.configure do |config|
+  config.include CopHelper
+  config.include HostEnvironmentSimulatorHelper
+end