fablicop 1.10.1 → 1.10.2

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the right hand side operand in binary operations that
+      # span more than one line.
+      #
+      # The `aligned` style checks that operators are aligned if they are part of an `if` or `while`
+      # condition, an explicit `return` statement, etc. In other contexts, the second operand should
+      # be indented regardless of enforced style.
+      #
+      # @example EnforcedStyle: aligned (default)
+      #   # bad
+      #   if a +
+      #       b
+      #     something &&
+      #     something_else
+      #   end
+      #
+      #   # good
+      #   if a +
+      #      b
+      #     something &&
+      #       something_else
+      #   end
+      #
+      # @example EnforcedStyle: indented
+      #   # bad
+      #   if a +
+      #      b
+      #     something &&
+      #     something_else
+      #   end
+      #
+      #   # good
+      #   if a +
+      #       b
+      #     something &&
+      #       something_else
+      #   end
+      #
+      class MultilineOperationIndentation < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        include MultilineExpressionIndentation
+        extend AutoCorrector
+
+        def on_and(node)
+          check_and_or(node)
+        end
+
+        def on_or(node)
+          check_and_or(node)
+        end
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation` ' \
+                                 'cop only accepts an `IndentationWidth` ' \
+                                 'configuration parameter when ' \
+                                 '`EnforcedStyle` is `indented`.'
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        def relevant_node?(node)
+          return false if node.send_type? && node.unary_operation?
+
+          !node.loc.dot # Don't check method calls with dot operator.
+        end
+
+        def check_and_or(node)
+          lhs, rhs = *node
+          range = offending_range(node, lhs, rhs.source_range, style)
+          check(range, node, lhs, rhs.source_range)
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if not_for_this_cop?(node)
+
+          correct_column = if should_align?(node, rhs, given_style)
+                             node.loc.column
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def should_align?(node, rhs, given_style)
+          assignment_node = part_of_assignment_rhs(node, rhs)
+          if assignment_node
+            assignment_rhs = CheckAssignment.extract_rhs(assignment_node)
+            return true if begins_its_line?(assignment_rhs.source_range)
+          end
+
+          given_style == :aligned &&
+            (kw_node_with_special_indentation(node) ||
+             assignment_node ||
+             argument_in_method_call(node, :with_or_without_parentheses))
+        end
+
+        def message(node, lhs, rhs)
+          what = operation_description(node, rhs)
+          if should_align?(node, rhs, style)
+            "Align the operands of #{what} spanning multiple lines."
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+              "spaces for indenting #{what} spanning multiple lines."
+          end
+        end
+
+        def right_hand_side(send_node)
+          send_node.first_argument.source_range
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/layout/parameter_alignment.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the parameters on a multi-line method call or
+      # definition are aligned.
+      #
+      # To set the alignment of the first argument, use the cop
+      # FirstParameterIndentation.
+      #
+      # @example EnforcedStyle: with_first_parameter (default)
+      #   # good
+      #
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #        baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   def foo(bar,
+      #     baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
+      class ParameterAlignment < Base
+        include Alignment
+        extend AutoCorrector
+
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
+                           'they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
+                           'following the first line of a multi-line method definition.'
+
+        def on_def(node)
+          return if node.arguments.size < 2
+
+          check_alignment(node.arguments, base_column(node, node.arguments))
+        end
+        alias on_defs on_def
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          node.loc.keyword.line
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether certain expressions, e.g. method calls, that could fit
+      # completely on a single line, are broken up into multiple lines unnecessarily.
+      #
+      # @example any configuration
+      #   # bad
+      #   foo(
+      #     a,
+      #     b
+      #   )
+      #
+      #   puts 'string that fits on ' \
+      #        'a single line'
+      #
+      #   things
+      #     .select { |thing| thing.cond? }
+      #     .join('-')
+      #
+      #   # good
+      #   foo(a, b)
+      #
+      #   puts 'string that fits on a single line'
+      #
+      #   things.select { |thing| thing.cond? }.join('-')
+      #
+      # @example InspectBlocks: false (default)
+      #   # good
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      # @example InspectBlocks: true
+      #   # bad
+      #   foo(a) do |x|
+      #     puts x
+      #   end
+      #
+      #   # good
+      #   foo(a) { |x| puts x }
+      #
+      class RedundantLineBreak < Base
+        include CheckAssignment
+        extend AutoCorrector
+
+        MSG = 'Redundant line break detected.'
+
+        def on_send(node)
+          # Include "the whole expression".
+          node = node.parent while node.parent&.send_type? ||
+                                   convertible_block?(node) ||
+                                   node.parent.is_a?(RuboCop::AST::BinaryOperatorNode)
+
+          return unless offense?(node) && !part_of_ignored_node?(node)
+
+          register_offense(node)
+        end
+
+        private
+
+        def check_assignment(node, _rhs)
+          return unless offense?(node)
+
+          register_offense(node)
+        end
+
+        def register_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node, to_single_line(node.source).strip)
+          end
+          ignore_node(node)
+        end
+
+        def offense?(node)
+          node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
+            !configured_to_not_be_inspected?(node)
+        end
+
+        def configured_to_not_be_inspected?(node)
+          return true if other_cop_takes_precedence?(node)
+
+          !cop_config['InspectBlocks'] && (node.block_type? ||
+                                           any_descendant?(node, :block, &:multiline?))
+        end
+
+        def other_cop_takes_precedence?(node)
+          single_line_block_chain_enabled? && any_descendant?(node, :block) do |block_node|
+            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+          end
+        end
+
+        def single_line_block_chain_enabled?
+          @config.for_cop('Layout/SingleLineBlockChain')['Enabled']
+        end
+
+        def suitable_as_single_line?(node)
+          !comment_within?(node) &&
+            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
+            node.each_descendant(:dstr, :str).none?(&:heredoc?) &&
+            node.each_descendant(:begin).none? { |b| !b.single_line? }
+        end
+
+        def convertible_block?(node)
+          parent = node.parent
+          parent&.block_type? && node == parent.send_node &&
+            (node.parenthesized? || !node.arguments?)
+        end
+
+        def comment_within?(node)
+          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+            comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          end
+        end
+
+        def too_long?(node)
+          lines = processed_source.lines[(node.first_line - 1)...node.last_line]
+          to_single_line(lines.join("\n")).length > max_line_length
+        end
+
+        def to_single_line(source)
+          source
+            .gsub(/" *\\\n\s*'/, %q(" + ')) # Double quote, backslash, and then single quote
+            .gsub(/' *\\\n\s*"/, %q(' + ")) # Single quote, backslash, and then double quote
+            .gsub(/(["']) *\\\n\s*\1/, '')  # Double or single quote, backslash, then same quote
+            .gsub(/\n\s*(?=\.\w)/, '')      # Extra space within method chaining
+            .gsub(/\s*\\?\n\s*/, ' ')       # Any other line break, with or without backslash
+        end
+
+        def max_line_length
+          config.for_cop('Layout/LineLength')['Max']
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether the rescue and ensure keywords are aligned
+      # properly.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #     rescue
+      #     puts 'error'
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue
+      #     puts 'error'
+      #   end
+      class RescueEnsureAlignment < Base
+        include RangeHelp
+        include EndKeywordAlignment
+        extend AutoCorrector
+
+        MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
+              'aligned with `%<beginning>s` at ' \
+              '%<begin_loc_line>d, %<begin_loc_column>d.'
+        ANCESTOR_TYPES = %i[kwbegin def defs class module block].freeze
+        ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = %i[def defs].freeze
+        ALTERNATIVE_ACCESS_MODIFIERS = %i[public_class_method private_class_method].freeze
+
+        def on_resbody(node)
+          check(node) unless modifier?(node)
+        end
+
+        def on_ensure(node)
+          check(node)
+        end
+
+        def on_new_investigation
+          @modifier_locations =
+            processed_source.tokens.each_with_object([]) do |token, locations|
+              next unless token.rescue_modifier?
+
+              locations << token.pos
+            end
+        end
+
+        private
+
+        # Check alignment of node with rescue or ensure modifiers.
+
+        def check(node)
+          alignment_node = alignment_node(node)
+          return if alignment_node.nil?
+
+          alignment_loc = alignment_location(alignment_node)
+          kw_loc        = node.loc.keyword
+
+          return if alignment_loc.column == kw_loc.column || same_line?(alignment_loc, kw_loc)
+
+          add_offense(
+            kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)
+          ) do |corrector|
+            autocorrect(corrector, node, alignment_loc)
+          end
+        end
+
+        def autocorrect(corrector, node, alignment_location)
+          whitespace = whitespace_range(node)
+          # Some inline node is sitting before current node.
+          return nil unless whitespace.source.strip.empty?
+
+          new_column = alignment_location.column
+
+          corrector.replace(whitespace, ' ' * new_column)
+        end
+
+        def format_message(alignment_node, alignment_loc, kw_loc)
+          format(
+            MSG,
+            kw_loc: kw_loc.source,
+            kw_loc_line: kw_loc.line,
+            kw_loc_column: kw_loc.column,
+            beginning: alignment_source(alignment_node, alignment_loc),
+            begin_loc_line: alignment_loc.line,
+            begin_loc_column: alignment_loc.column
+          )
+        end
+
+        def alignment_source(node, starting_loc)
+          ending_loc =
+            case node.type
+            when :block, :kwbegin
+              node.loc.begin
+            when :def, :defs, :class, :module,
+                 :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+              node.loc.name
+            when :masgn
+              mlhs_node, = *node
+              mlhs_node.source_range
+            else
+              # It is a wrapper with access modifier.
+              node.child_nodes.first.loc.name
+            end
+
+          range_between(starting_loc.begin_pos, ending_loc.end_pos).source
+        end
+
+        # We will use ancestor or wrapper with access modifier.
+
+        def alignment_node(node)
+          ancestor_node = ancestor_node(node)
+
+          return ancestor_node if ancestor_node.nil? || ancestor_node.kwbegin_type?
+          return if ancestor_node.respond_to?(:send_node) &&
+                    aligned_with_line_break_method?(ancestor_node, node)
+
+          assignment_node = assignment_node(ancestor_node)
+          return assignment_node if same_line?(ancestor_node, assignment_node)
+
+          access_modifier_node = access_modifier_node(ancestor_node)
+          return access_modifier_node unless access_modifier_node.nil?
+
+          ancestor_node
+        end
+
+        def ancestor_node(node)
+          node.each_ancestor(*ANCESTOR_TYPES).first
+        end
+
+        def aligned_with_line_break_method?(ancestor_node, node)
+          send_node_loc = ancestor_node.send_node.loc
+          do_keyword_line = ancestor_node.loc.begin.line
+          rescue_keyword_column = node.loc.keyword.column
+          selector = send_node_loc.respond_to?(:selector) ? send_node_loc.selector : send_node_loc
+
+          if aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)
+            return true
+          end
+
+          do_keyword_line == selector&.line && rescue_keyword_column == selector.column
+        end
+
+        def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column)
+          return false unless send_node_loc.respond_to?(:dot) && (dot = send_node_loc.dot)
+
+          do_keyword_line == dot.line && rescue_keyword_column == dot.column
+        end
+
+        def assignment_node(node)
+          assignment_node = node.ancestors.first
+          return nil unless
+            assignment_node&.assignment?
+
+          assignment_node
+        end
+
+        def access_modifier_node(node)
+          return nil unless
+            ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS.include?(node.type)
+
+          access_modifier_node = node.ancestors.first
+          return nil unless access_modifier?(access_modifier_node)
+
+          access_modifier_node
+        end
+
+        def modifier?(node)
+          return false unless @modifier_locations.respond_to?(:include?)
+
+          @modifier_locations.include?(node.loc.keyword)
+        end
+
+        def whitespace_range(node)
+          begin_pos      = node.loc.keyword.begin_pos
+          current_column = node.loc.keyword.column
+
+          range_between(begin_pos - current_column, begin_pos)
+        end
+
+        def access_modifier?(node)
+          return true if node.respond_to?(:access_modifier?) && node.access_modifier?
+
+          return true if node.respond_to?(:method_name) &&
+                         ALTERNATIVE_ACCESS_MODIFIERS.include?(node.method_name)
+
+          false
+        end
+
+        def alignment_location(alignment_node)
+          if begin_end_alignment_style == 'start_of_line'
+            start_line_range(alignment_node)
+          else
+            alignment_node.source_range
+          end
+        end
+
+        def begin_end_alignment_style
+          begin_end_alignment_conf = config.for_cop('Layout/BeginEndAlignment')
+
+          begin_end_alignment_conf['Enabled'] && begin_end_alignment_conf['EnforcedStyleAlignWith']
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/layout/single_line_block_chain.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if method calls are chained onto single line blocks. It considers that a
+      # line break before the dot improves the readability of the code.
+      #
+      # @example
+      #   # bad
+      #   example.select { |item| item.cond? }.join('-')
+      #
+      #   # good
+      #   example.select { |item| item.cond? }
+      #          .join('-')
+      #
+      #   # good (not a concern for this cop)
+      #   example.select do |item|
+      #     item.cond?
+      #   end.join('-')
+      #
+      class SingleLineBlockChain < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Put method call on a separate line if chained to a single line block.'
+
+        def on_send(node)
+          range = offending_range(node)
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+        end
+
+        private
+
+        def offending_range(node)
+          receiver = node.receiver
+          return unless receiver&.block_type?
+
+          receiver_location = receiver.loc
+          closing_block_delimiter_line_num = receiver_location.end.line
+          return if receiver_location.begin.line < closing_block_delimiter_line_num
+
+          node_location = node.loc
+          dot_range = node_location.dot
+          return unless dot_range
+          return unless call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
+
+          range_between(dot_range.begin_pos, selector_range(node).end_pos)
+        end
+
+        def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num)
+          return false if dot_range.line > closing_block_delimiter_line_num
+
+          dot_range.column < selector_range(node).column
+        end
+
+        def selector_range(node)
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.52.1/lib/rubocop/cop/layout/space_after_colon.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for colon (:) not followed by some kind of space.
+      # N.B. this cop does not handle spaces after a ternary operator, which are
+      # instead handled by Layout/SpaceAroundOperators.
+      #
+      # @example
+      #   # bad
+      #   def f(a:, b:2); {a:3}; end
+      #
+      #   # good
+      #   def f(a:, b: 2); {a: 3}; end
+      class SpaceAfterColon < Base
+        extend AutoCorrector
+
+        MSG = 'Space missing after colon.'
+
+        def on_pair(node)
+          return if !node.colon? || node.value_omission?
+
+          colon = node.loc.operator
+
+          register_offense(colon) unless followed_by_space?(colon)
+        end
+
+        def on_kwoptarg(node)
+          # We have no direct reference to the colon source range following an
+          # optional keyword argument's name, so must construct one.
+          colon = node.loc.name.end.resize(1)
+
+          register_offense(colon) unless followed_by_space?(colon)
+        end
+
+        private
+
+        def register_offense(colon)
+          add_offense(colon) { |corrector| corrector.insert_after(colon, ' ') }
+        end
+
+        def followed_by_space?(colon)
+          /\s/.match?(colon.source_buffer.source[colon.end_pos])
+        end
+      end
+    end
+  end
+end