cocRb 0.1.0 → 0.1.2

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/rspec/cop_helper.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'tempfile'
-
-# This module provides methods that make it easier to test Cops.
-module CopHelper
-  extend RSpec::SharedContext
-
-  let(:ruby_version) { 2.5 }
-  let(:rails_version) { false }
-
-  def inspect_source(source, file = nil)
-    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
-    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-    processed_source = parse_source(source, file)
-    unless processed_source.valid_syntax?
-      raise 'Error parsing example code: ' \
-        "#{processed_source.diagnostics.map(&:render).join("\n")}"
-    end
-
-    _investigate(cop, processed_source)
-  end
-
-  def parse_source(source, file = nil)
-    if file.respond_to?(:write)
-      file.write(source)
-      file.rewind
-      file = file.path
-    end
-
-    RuboCop::ProcessedSource.new(source, ruby_version, file)
-  end
-
-  def autocorrect_source_file(source)
-    Tempfile.open('tmp') { |f| autocorrect_source(source, f) }
-  end
-
-  def autocorrect_source(source, file = nil)
-    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
-    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-    cop.instance_variable_get(:@options)[:auto_correct] = true
-    processed_source = parse_source(source, file)
-    _investigate(cop, processed_source)
-
-    @last_corrector.rewrite
-  end
-
-  def _investigate(cop, processed_source)
-    team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
-    report = team.investigate(processed_source)
-    @last_corrector = report.correctors.first || RuboCop::Cop::Corrector.new(processed_source)
-    report.offenses
-  end
-end
-
-module RuboCop
-  module Cop
-    # Monkey-patch Cop for tests to provide easy access to messages and
-    # highlights.
-    class Cop
-      def messages
-        offenses.sort.map(&:message)
-      end
-
-      def highlights
-        offenses.sort.map { |o| o.location.source }
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/rspec/expect_offense.rb

@@ -1,329 +0,0 @@
-# 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)
-    #       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)
-    #       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)
-    #     x % 2 == 0
-    #     ^^^^^^^^^^ Replace with `Integer#even?`.
-    #   RUBY
-    #
-    #   expect_correction(<<~RUBY)
-    #     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)
-    #     a do
-    #       b
-    #     end.c
-    #     ^^^^^ Avoid chaining a method call on a do...end block.
-    #   RUBY
-    #
-    #   expect_no_corrections
-    #
-    # If your code has variables of different lengths, you can use `%{foo}`,
-    # `^{foo}`, and `_{foo}` to format your template; you can also abbreviate
-    # offense messages with `[...]`:
-    #
-    #   %w[raise fail].each do |keyword|
-    #     expect_offense(<<~RUBY, keyword: keyword)
-    #       %{keyword}(RuntimeError, msg)
-    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument [...]
-    #     RUBY
-    #
-    #   %w[has_one has_many].each do |type|
-    #     expect_offense(<<~RUBY, type: type)
-    #       class Book
-    #         %{type} :chapter, foreign_key: 'book_id'
-    #         _{type}           ^^^^^^^^^^^^^^^^^^^^^^ Specifying the default [...]
-    #       end
-    #     RUBY
-    #   end
-    #
-    # If you need to specify an offense on a blank line, use the empty `^{}` marker:
-    #
-    # @example `^{}` empty line offense
-    #
-    #   expect_offense(<<~RUBY)
-    #
-    #     ^{} Missing frozen string literal comment.
-    #     puts 1
-    #   RUBY
-    module ExpectOffense
-      def format_offense(source, **replacements)
-        replacements.each do |keyword, value|
-          value = value.to_s
-          source = source.gsub("%{#{keyword}}", value)
-                         .gsub("^{#{keyword}}", '^' * value.size)
-                         .gsub("_{#{keyword}}", ' ' * value.size)
-        end
-        source
-      end
-
-      def expect_offense(source, file = nil, severity: nil, chomp: false, **replacements)
-        expected_annotations = parse_annotations(source, **replacements)
-        source = expected_annotations.plain_source
-        source = source.chomp if chomp
-
-        @processed_source = parse_processed_source(source, file)
-        @offenses = _investigate(cop, @processed_source)
-        actual_annotations = expected_annotations.with_offense_annotations(@offenses)
-
-        expect(actual_annotations).to eq(expected_annotations), ''
-        expect(@offenses.map(&:severity).uniq).to eq([severity]) if severity
-
-        @offenses
-      end
-
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def expect_correction(correction, loop: true, source: nil)
-        if source
-          expected_annotations = parse_annotations(source, raise_error: false)
-          @processed_source = parse_processed_source(expected_annotations.plain_source)
-          _investigate(cop, @processed_source)
-        end
-
-        raise '`expect_correction` must follow `expect_offense`' unless @processed_source
-
-        iteration = 0
-        new_source = loop do
-          iteration += 1
-
-          corrected_source = @last_corrector.rewrite
-
-          break corrected_source unless loop
-          break corrected_source if @last_corrector.empty?
-          break corrected_source if corrected_source == @processed_source.buffer.source
-
-          if iteration > RuboCop::Runner::MAX_ITERATIONS
-            raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
-          end
-
-          # Prepare for next loop
-          @processed_source = parse_source(corrected_source, @processed_source.path)
-          _investigate(cop, @processed_source)
-        end
-
-        expect(new_source).to eq(correction)
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-      def expect_no_corrections
-        raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
-
-        return if @last_corrector.empty?
-
-        # In order to print a nice diff, e.g. what source got corrected to,
-        # we need to run the actual corrections
-
-        new_source = @last_corrector.rewrite
-
-        expect(new_source).to eq(@processed_source.buffer.source)
-      end
-
-      def expect_no_offenses(source, file = nil)
-        offenses = inspect_source(source, file)
-
-        expected_annotations = AnnotatedSource.parse(source)
-        actual_annotations = expected_annotations.with_offense_annotations(offenses)
-        expect(actual_annotations.to_s).to eq(source)
-      end
-
-      def parse_annotations(source, raise_error: true, **replacements)
-        set_formatter_options
-
-        source = format_offense(source, **replacements)
-        annotations = AnnotatedSource.parse(source)
-        return annotations unless raise_error && annotations.plain_source == source
-
-        raise 'Use `expect_no_offenses` to assert that no offenses are found'
-      end
-
-      def parse_processed_source(source, file = nil)
-        processed_source = parse_source(source, file)
-        return processed_source if processed_source.valid_syntax?
-
-        raise 'Error parsing example code: ' \
-          "#{processed_source.diagnostics.map(&:render).join("\n")}"
-      end
-
-      def set_formatter_options
-        RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
-        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-        cop.instance_variable_get(:@options)[:auto_correct] = true
-      end
-
-      # Parsed representation of code annotated with the `^^^ Message` style
-      class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze
-        ABBREV = "[...]\n"
-
-        # @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 ANNOTATION_PATTERN.match?(source_line)
-              annotations << [source.size, source_line]
-            else
-              source << source_line
-            end
-          end
-          annotations.each { |a| a[0] = 1 } if source.empty?
-
-          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
-
-        def ==(other)
-          other.is_a?(self.class) && other.lines == lines && match_annotations?(other)
-        end
-
-        # Dirty hack: expectations with [...] are rewritten when they match
-        # This way the diff is clean.
-        def match_annotations?(other)
-          annotations.zip(other.annotations) do |(_actual_line, actual_annotation),
-                                                 (_expected_line, expected_annotation)|
-            if expected_annotation&.end_with?(ABBREV) &&
-               actual_annotation.start_with?(expected_annotation[0...-ABBREV.length])
-
-              expected_annotation.replace(actual_annotation)
-            end
-          end
-
-          annotations == other.annotations
-        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
-        alias inspect to_s
-
-        # 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
-              carets     = '^{}' if offense.column_length.zero?
-
-              [offense.line, "#{indent}#{carets} #{offense.message}\n"]
-            end
-
-          self.class.new(lines, offense_annotations)
-        end
-
-        protected
-
-        attr_reader :lines, :annotations
-      end
-    end
-  end
-end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/rspec/host_environment_simulation_helper.rb

@@ -1,28 +0,0 @@
-# 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/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/rspec/shared_contexts.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-require 'tmpdir'
-
-RSpec.shared_context 'isolated environment', :isolated_environment do
-  around do |example|
-    Dir.mktmpdir do |tmpdir|
-      original_home = ENV['HOME']
-      original_xdg_config_home = ENV['XDG_CONFIG_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)
-
-      virtual_home = File.expand_path(File.join(tmpdir, 'home'))
-      Dir.mkdir(virtual_home)
-      ENV['HOME'] = virtual_home
-      ENV.delete('XDG_CONFIG_HOME')
-
-      base_dir = example.metadata[:project_inside_home] ? virtual_home : tmpdir
-      root = example.metadata[:root]
-      working_dir = root ? File.join(base_dir, 'work', root) : File.join(base_dir, 'work')
-
-      # Make upwards search for .rubocop.yml files stop at this directory.
-      RuboCop::FileFinder.root_level = working_dir
-
-      begin
-        FileUtils.mkdir_p(working_dir)
-
-        Dir.chdir(working_dir) { example.run }
-      ensure
-        ENV['HOME'] = original_home
-        ENV['XDG_CONFIG_HOME'] = original_xdg_config_home
-
-        RuboCop::FileFinder.root_level = nil
-      end
-    end
-  end
-end
-
-RSpec.shared_context 'maintain registry', :restore_registry do
-  around(:each) { |example| RuboCop::Cop::Registry.with_temporary_global { example.run } }
-
-  def stub_cop_class(name, inherit: RuboCop::Cop::Base, &block)
-    klass = Class.new(inherit, &block)
-    stub_const(name, klass)
-    klass
-  end
-end
-
-# This context assumes nothing and defines `cop`, among others.
-RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
-  ### Meant to be overridden at will
-
-  let(:cop_class) do
-    unless described_class.is_a?(Class) && described_class < RuboCop::Cop::Base
-      raise 'Specify which cop class to use (e.g `let(:cop_class) { RuboCop::Cop::Base }`, ' \
-            'or RuboCop::Cop::Cop for legacy)'
-    end
-    described_class
-  end
-
-  let(:cop_config) { {} }
-
-  let(:other_cops) { {} }
-
-  let(:cop_options) { {} }
-
-  ### Utilities
-
-  def source_range(range, buffer: source_buffer)
-    Parser::Source::Range.new(buffer, range.begin,
-                              range.exclude_end? ? range.end : range.end + 1)
-  end
-
-  ### Useful intermediary steps (less likely to be overridden)
-
-  let(:processed_source) { parse_source(source, 'test') }
-
-  let(:source_buffer) { processed_source.buffer }
-
-  let(:all_cops_config) do
-    rails = { 'TargetRubyVersion' => ruby_version }
-    rails['TargetRailsVersion'] = rails_version if rails_version
-    rails
-  end
-
-  let(:cur_cop_config) do
-    RuboCop::ConfigLoader
-      .default_configuration.for_cop(cop_class)
-      .merge({
-               'Enabled' => true, # in case it is 'pending'
-               'AutoCorrect' => true # in case defaults set it to false
-             })
-      .merge(cop_config)
-  end
-
-  let(:config) do
-    hash = { 'AllCops' => all_cops_config, cop_class.cop_name => cur_cop_config }.merge!(other_cops)
-
-    RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
-  end
-
-  let(:cop) { cop_class.new(config, cop_options) }
-end
-
-RSpec.shared_context 'mock console output' do
-  before do
-    $stdout = StringIO.new
-    $stderr = StringIO.new
-  end
-
-  after do
-    $stdout = STDOUT
-    $stderr = STDERR
-  end
-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 'ruby 2.7', :ruby27 do
-  let(:ruby_version) { 2.7 }
-end
-
-RSpec.shared_context 'ruby 3.0', :ruby30 do
-  let(:ruby_version) { 3.0 }
-end
-
-RSpec.shared_context 'ruby 3.1', :ruby31 do
-  let(:ruby_version) { 3.1 }
-end