cocRb 0.1.0

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/rational_literal.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Rational literals.
+    module RationalLiteral
+      extend NodePattern::Macros
+
+      private
+
+      # @!method rational_literal?(node)
+      def_node_matcher :rational_literal?, <<~PATTERN
+        (send
+          (int _) :/
+          (rational _))
+      PATTERN
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/rescue_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking `rescue` nodes.
+    module RescueNode
+      def on_new_investigation
+        @modifier_locations = processed_source.tokens.select(&:rescue_modifier?).map(&:pos)
+      end
+
+      private
+
+      def rescue_modifier?(node)
+        node&.resbody_type? && @modifier_locations.include?(node.loc.keyword)
+      end
+
+      # @deprecated Use ResbodyNode#exceptions instead
+      def rescued_exceptions(resbody)
+        rescue_group, = *resbody
+        if rescue_group
+          rescue_group.values
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/safe_assignment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for safe assignment. By safe assignment we mean
+    # putting parentheses around an assignment to indicate "I know I'm using an
+    # assignment as a condition. It's not a mistake."
+    module SafeAssignment
+      extend NodePattern::Macros
+
+      private
+
+      # @!method empty_condition?(node)
+      def_node_matcher :empty_condition?, '(begin)'
+
+      # @!method setter_method?(node)
+      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
+
+      # @!method safe_assignment?(node)
+      def_node_matcher :safe_assignment?, '(begin {equals_asgn? #setter_method?})'
+
+      def safe_assignment_allowed?
+        cop_config['AllowSafeAssignment']
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for missing space after
+    # punctuation.
+    module SpaceAfterPunctuation
+      MSG = 'Space missing after %<token>s.'
+
+      def on_new_investigation
+        each_missing_space(processed_source.tokens) do |token|
+          add_offense(token.pos, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.add_space(corrector, token)
+          end
+        end
+      end
+
+      private
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token1)
+          next unless space_missing?(token1, token2)
+          next unless space_required_before?(token2)
+
+          yield token1
+        end
+      end
+
+      def space_missing?(token1, token2)
+        token1.line == token2.line && token2.column == token1.column + offset
+      end
+
+      def space_required_before?(token)
+        !(allowed_type?(token) || (token.right_curly_brace? && space_forbidden_before_rcurly?))
+      end
+
+      def allowed_type?(token)
+        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
+      end
+
+      def space_forbidden_before_rcurly?
+        style = space_style_before_rcurly
+        style == 'no_space'
+      end
+
+      # The normal offset, i.e., the distance from the punctuation
+      # token where a space should be, is 1.
+      def offset
+        1
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for space before
+    # punctuation.
+    module SpaceBeforePunctuation
+      include RangeHelp
+
+      MSG = 'Space found before %<token>s.'
+
+      def on_new_investigation
+        each_missing_space(processed_source.tokens) do |token, pos_before|
+          add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
+            PunctuationCorrector.remove_space(corrector, pos_before)
+          end
+        end
+      end
+
+      private
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token2)
+          next unless space_missing?(token1, token2)
+          next if space_required_after?(token1)
+
+          pos_before_punctuation = range_between(token1.end_pos, token2.begin_pos)
+
+          yield token2, pos_before_punctuation
+        end
+      end
+
+      def space_missing?(token1, token2)
+        token1.line == token2.line && token2.begin_pos > token1.end_pos
+      end
+
+      def space_required_after?(token)
+        token.left_curly_brace? && space_required_after_lcurly?
+      end
+
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
+        style = cfg['EnforcedStyle'] || 'space'
+        style == 'space'
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for modifier cops.
+    module StatementModifier
+      include LineLengthHelp
+
+      private
+
+      def single_line_as_modifier?(node)
+        return false if non_eligible_node?(node) ||
+                        non_eligible_body?(node.body) ||
+                        non_eligible_condition?(node.condition)
+
+        modifier_fits_on_single_line?(node)
+      end
+
+      def non_eligible_node?(node)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
+      end
+
+      def non_eligible_body?(body)
+        body.nil? ||
+          body.empty_source? ||
+          body.begin_type? ||
+          processed_source.contains_comment?(body.source_range)
+      end
+
+      def non_eligible_condition?(condition)
+        condition.each_node.any?(&:lvasgn_type?)
+      end
+
+      def modifier_fits_on_single_line?(node)
+        return true unless max_line_length
+
+        length_in_modifier_form(node) <= max_line_length
+      end
+
+      def length_in_modifier_form(node)
+        keyword_element = node.loc.keyword
+        code_before = keyword_element.source_line[0...keyword_element.column]
+        expression = to_modifier_form(node)
+        line_length("#{code_before}#{expression}#{code_after(node)}")
+      end
+
+      def to_modifier_form(node)
+        expression = [node.body.source, node.keyword, node.condition.source].compact.join(' ')
+        parenthesized = parenthesize?(node) ? "(#{expression})" : expression
+        [parenthesized, first_line_comment(node)].compact.join(' ')
+      end
+
+      def first_line_comment(node)
+        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        return unless comment
+
+        comment_source = comment.loc.expression.source
+        comment_source unless comment_disables_cop?(comment_source)
+      end
+
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..-1]
+        code unless code.empty?
+      end
+
+      def parenthesize?(node)
+        # Parenthesize corrected expression if changing to modifier-if form
+        # would change the meaning of the parent expression
+        # (due to the low operator precedence of modifier-if)
+        parent = node.parent
+        return false if parent.nil?
+        return true if parent.assignment? || parent.operator_keyword?
+        return true if %i[array pair].include?(parent.type)
+
+        node.parent.send_type?
+      end
+
+      def max_line_length
+        return unless config.for_cop('Layout/LineLength')['Enabled']
+
+        config.for_cop('Layout/LineLength')['Max']
+      end
+
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/string_help.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Classes that include this module just implement functions to determine
+    # what is an offense and how to do auto-correction. They get help with
+    # adding offenses for the faulty string nodes, and with filtering out
+    # nodes.
+    module StringHelp
+      def on_str(node)
+        # Constants like __FILE__ are handled as strings,
+        # but don't respond to begin.
+        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return if part_of_ignored_node?(node)
+
+        if offense?(node)
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
+        else
+          correct_style_detected
+        end
+      end
+
+      def on_regexp(node)
+        ignore_node(node)
+      end
+
+      private
+
+      def inside_interpolation?(node)
+        # A :begin node inside a :dstr node is an interpolation.
+        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking single/double quotes.
+    module StringLiteralsHelp
+      include StringHelp
+
+      private
+
+      def wrong_quotes?(node)
+        src = node.source
+        return false if src.start_with?('%', '?')
+
+        if style == :single_quotes
+          !double_quotes_required?(src)
+        else
+          !/" | \\[^'\\] | \#[@{$]/x.match?(src)
+        end
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking and correcting surrounding whitespace.
+    module SurroundingSpace
+      include RangeHelp
+
+      NO_SPACE_COMMAND = 'Do not use'
+      SPACE_COMMAND = 'Use'
+
+      SINGLE_SPACE_REGEXP = /[ \t]/.freeze
+
+      private
+
+      def side_space_range(range:, side:)
+        buffer = processed_source.buffer
+        src = buffer.source
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        if side == :left
+          end_pos = begin_pos
+          begin_pos = reposition(src, begin_pos, -1)
+        end
+        if side == :right
+          begin_pos = end_pos
+          end_pos = reposition(src, end_pos, 1)
+        end
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def on_new_investigation
+        @token_table = nil
+        super
+      end
+
+      def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                            left_token,
+                            right_token,
+                            message,
+                            start_ok: false,
+                            end_ok: false)
+        if extra_space?(left_token, :left) && !start_ok
+          space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
+        end
+        return if !extra_space?(right_token, :right) || end_ok
+
+        space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
+      end
+
+      def space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                         left_token,
+                         right_token,
+                         message,
+                         start_ok: false,
+                         end_ok: false)
+        unless extra_space?(left_token, :left) || start_ok
+          space_offense(node, left_token, :none, message, SPACE_COMMAND)
+        end
+        return if extra_space?(right_token, :right) || end_ok
+
+        space_offense(node, right_token, :none, message, SPACE_COMMAND)
+      end
+
+      def extra_space?(token, side)
+        return false unless token
+
+        if side == :left
+          SINGLE_SPACE_REGEXP.match?(String(token.space_after?))
+        else
+          SINGLE_SPACE_REGEXP.match?(String(token.space_before?))
+        end
+      end
+
+      def reposition(src, pos, step)
+        offset = step == -1 ? -1 : 0
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset])
+        pos.negative? ? 0 : pos
+      end
+
+      def space_offense(node, token, side, message, command)
+        range = side_space_range(range: token.pos, side: side)
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node) unless ignored_node?(node)
+
+          ignore_node(node)
+        end
+      end
+
+      def empty_offenses(node, left, right, message)
+        range = range_between(left.begin_pos, right.end_pos)
+        if offending_empty_space?(empty_config, left, right)
+          empty_offense(node, range, message, 'Use one')
+        end
+        return unless offending_empty_no_space?(empty_config, left, right)
+
+        empty_offense(node, range, message, 'Do not use')
+      end
+
+      def empty_offense(node, range, message, command)
+        add_offense(range, message: format(message, command: command)) do |corrector|
+          autocorrect(corrector, node)
+        end
+      end
+
+      def empty_brackets?(left_bracket_token, right_bracket_token)
+        left_index = processed_source.tokens.index(left_bracket_token)
+        right_index = processed_source.tokens.index(right_bracket_token)
+        right_index && left_index == right_index - 1
+      end
+
+      def offending_empty_space?(config, left_token, right_token)
+        config == 'space' && !space_between?(left_token, right_token)
+      end
+
+      def offending_empty_no_space?(config, left_token, right_token)
+        config == 'no_space' && !no_space_between?(left_token, right_token)
+      end
+
+      def space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
+      end
+
+      def no_space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos == right_bracket_token.begin_pos
+      end
+    end
+  end
+end