fablicop 1.10.1 → 1.10.3

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether class/module/method definitions are
+      # separated by one or more empty lines.
+      #
+      # `NumberOfEmptyLines` can be an integer (default is 1) or
+      # an array (e.g. [1, 2]) to specify a minimum and maximum
+      # number of empty lines permitted.
+      #
+      # `AllowAdjacentOneLineDefs` configures whether adjacent
+      # one-line definitions are considered an offense.
+      #
+      # @example EmptyLineBetweenMethodDefs: true (default)
+      #   # checks for empty lines between method definitions.
+      #
+      #   # bad
+      #   def a
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def a
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenClassDefs: true (default)
+      #   # checks for empty lines between class definitions.
+      #
+      #   # bad
+      #   class A
+      #   end
+      #   class B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   class A
+      #   end
+      #
+      #   class B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenModuleDefs: true (default)
+      #   # checks for empty lines between module definitions.
+      #
+      #   # bad
+      #   module A
+      #   end
+      #   module B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   module A
+      #   end
+      #
+      #   module B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example AllowAdjacentOneLineDefs: true (default)
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
+      # @example AllowAdjacentOneLineDefs: false
+      #
+      #   # bad
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
+      class EmptyLineBetweenDefs < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Expected %<expected>s between %<type>s definitions; found %<actual>d.'
+
+        def self.autocorrect_incompatible_with
+          [Layout::EmptyLines]
+        end
+
+        # We operate on `begin` nodes, instead of using `OnMethodDef`,
+        # so that we can walk over pairs of consecutive nodes and
+        # efficiently access a node's predecessor; #prev_node ends up
+        # doing a linear scan over siblings, so we don't want to call
+        # it on each def.
+        def on_begin(node)
+          node.children.each_cons(2) do |prev, n|
+            nodes = [prev, n]
+            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
+          end
+        end
+
+        def check_defs(nodes)
+          count = blank_lines_count_between(*nodes)
+
+          return if line_count_allowed?(count)
+          return if multiple_blank_lines_groups?(*nodes)
+          return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
+
+          correction_node = nodes.last
+
+          location = def_location(correction_node)
+          add_offense(location, message: message(correction_node, count: count)) do |corrector|
+            autocorrect(corrector, *nodes, count)
+          end
+        end
+
+        def autocorrect(corrector, prev_def, node, count)
+          # finds position of first newline
+          end_pos = end_loc(prev_def).end_pos
+          source_buffer = end_loc(prev_def).source_buffer
+          newline_pos = source_buffer.source.index("\n", end_pos)
+
+          # Handle the case when multiple one-liners are on the same line.
+          newline_pos = end_pos + 1 if newline_pos > node.source_range.begin_pos
+
+          if count > maximum_empty_lines
+            autocorrect_remove_lines(corrector, newline_pos, count)
+          else
+            autocorrect_insert_lines(corrector, newline_pos, count)
+          end
+        end
+
+        private
+
+        def def_location(correction_node)
+          if correction_node.block_type?
+            correction_node.source_range.join(correction_node.children.first.source_range)
+          else
+            correction_node.loc.keyword.join(correction_node.loc.name)
+          end
+        end
+
+        def candidate?(node)
+          return false unless node
+
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node) ||
+            macro_candidate?(node)
+        end
+
+        def empty_line_between_macros
+          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+        end
+
+        def macro_candidate?(node)
+          node.block_type? && node.children.first.macro? &&
+            empty_line_between_macros.include?(node.children.first.method_name)
+        end
+
+        def method_candidate?(node)
+          cop_config['EmptyLineBetweenMethodDefs'] && (node.def_type? || node.defs_type?)
+        end
+
+        def class_candidate?(node)
+          cop_config['EmptyLineBetweenClassDefs'] && node.class_type?
+        end
+
+        def module_candidate?(node)
+          cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
+        end
+
+        def message(node, count: nil)
+          type = node_type(node)
+
+          format(MSG, type: type, expected: expected_lines, actual: count)
+        end
+
+        def expected_lines
+          if allowance_range?
+            "#{minimum_empty_lines..maximum_empty_lines} empty lines"
+          else
+            lines = maximum_empty_lines == 1 ? 'line' : 'lines'
+            "#{maximum_empty_lines} empty #{lines}"
+          end
+        end
+
+        def multiple_blank_lines_groups?(first_def_node, second_def_node)
+          lines = lines_between_defs(first_def_node, second_def_node)
+          blank_start = lines.each_index.select { |i| lines[i].blank? }.max
+          non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
+          return false if blank_start.nil? || non_blank_end.nil?
+
+          blank_start > non_blank_end
+        end
+
+        def line_count_allowed?(count)
+          (minimum_empty_lines..maximum_empty_lines).cover?(count)
+        end
+
+        def blank_lines_count_between(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).count(&:blank?)
+        end
+
+        def minimum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).first
+        end
+
+        def maximum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).last
+        end
+
+        def lines_between_defs(first_def_node, second_def_node)
+          begin_line_num = def_end(first_def_node)
+          end_line_num = def_start(second_def_node) - 2
+          return [] if end_line_num.negative?
+
+          processed_source.lines[begin_line_num..end_line_num]
+        end
+
+        def def_start(node)
+          if node.block_type? && node.children.first.send_type?
+            node.source_range.line
+          else
+            node.loc.keyword.line
+          end
+        end
+
+        def def_end(node)
+          end_loc(node).line
+        end
+
+        def end_loc(node)
+          if (node.def_type? || node.defs_type?) && node.endless?
+            node.source_range.end
+          else
+            node.loc.end
+          end
+        end
+
+        def autocorrect_remove_lines(corrector, newline_pos, count)
+          difference = count - maximum_empty_lines
+          range_to_remove = range_between(newline_pos, newline_pos + difference)
+
+          corrector.remove(range_to_remove)
+        end
+
+        def autocorrect_insert_lines(corrector, newline_pos, count)
+          difference = minimum_empty_lines - count
+          where_to_insert = range_between(newline_pos, newline_pos + 1)
+
+          corrector.insert_after(where_to_insert, "\n" * difference)
+        end
+
+        def node_type(node)
+          case node.type
+          when :def, :defs
+            :method
+          else
+            node.type
+          end
+        end
+
+        def allowance_range?
+          minimum_empty_lines != maximum_empty_lines
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/layout/empty_lines.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for two or more consecutive blank lines.
+      #
+      # @example
+      #
+      #   # bad - It has two empty lines.
+      #   some_method
+      #   # one empty line
+      #   # two empty lines
+      #   some_method
+      #
+      #   # good
+      #   some_method
+      #   # one empty line
+      #   some_method
+      #
+      class EmptyLines < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Extra blank line detected.'
+        LINE_OFFSET = 2
+
+        def on_new_investigation
+          return if processed_source.tokens.empty?
+          # Quick check if we possibly have consecutive blank lines.
+          return unless processed_source.raw_source.include?("\n\n\n")
+
+          lines = Set.new
+          processed_source.tokens.each { |token| lines << token.line }
+
+          each_extra_empty_line(lines.sort) do |range|
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+
+        private
+
+        def each_extra_empty_line(lines)
+          prev_line = 1
+
+          lines.each do |cur_line|
+            if exceeds_line_offset?(cur_line - prev_line)
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                next unless previous_and_current_lines_empty?(line)
+
+                yield source_range(processed_source.buffer, line, 0)
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+
+        def exceeds_line_offset?(line_diff)
+          line_diff > LINE_OFFSET
+        end
+
+        def previous_and_current_lines_empty?(line)
+          processed_source[line - 2].empty? && processed_source[line - 1].empty?
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Access modifiers should be surrounded by blank lines.
+      #
+      # @example EnforcedStyle: around (default)
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #
+      #     def baz; end
+      #   end
+      #
+      # @example EnforcedStyle: only_before
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #     def baz; end
+      #   end
+      #
+      class EmptyLinesAroundAccessModifier < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%<modifier>s`.'
+
+        MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
+        MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
+
+        RESTRICT_ON_SEND = %i[public protected private module_function].freeze
+
+        def initialize(config = nil, options = nil)
+          super
+
+          @block_line = nil
+        end
+
+        def on_class(node)
+          @class_or_module_def_first_line = if node.parent_class
+                                              node.parent_class.first_line
+                                            else
+                                              node.source_range.first_line
+                                            end
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
+
+        def on_module(node)
+          @class_or_module_def_first_line = node.source_range.first_line
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
+
+        def on_sclass(node)
+          @class_or_module_def_first_line = node.identifier.source_range.first_line
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
+
+        def on_block(node)
+          @block_line = node.source_range.first_line
+        end
+
+        alias on_numblock on_block
+
+        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity
+          return unless node.bare_access_modifier? &&
+                        !(node.parent&.block_type? || node.parent&.numblock_type?)
+          return if expected_empty_lines?(node)
+
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
+            line = range_by_whole_lines(node.source_range)
+
+            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
+
+            correct_next_line_if_denied_style(corrector, node, line)
+          end
+        end
+
+        private
+
+        def expected_empty_lines?(node)
+          case style
+          when :around
+            return true if empty_lines_around?(node)
+          when :only_before
+            return true if allowed_only_before_style?(node)
+          end
+
+          false
+        end
+
+        def allowed_only_before_style?(node)
+          if node.special_modifier?
+            return true if processed_source[node.last_line] == 'end'
+            return false if next_line_empty?(node.last_line)
+          end
+
+          previous_line_empty?(node.first_line)
+        end
+
+        def correct_next_line_if_denied_style(corrector, node, line)
+          case style
+          when :around
+            corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
+          when :only_before
+            if next_line_empty?(node.last_line)
+              range = next_empty_line_range(node)
+
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def previous_line_ignoring_comments(processed_source, send_line)
+          processed_source[0..send_line - 2].reverse.find { |line| !comment_line?(line) }
+        end
+
+        def previous_line_empty?(send_line)
+          previous_line = previous_line_ignoring_comments(processed_source, send_line)
+          return true unless previous_line
+
+          block_start?(send_line) || class_def?(send_line) || previous_line.blank?
+        end
+
+        def next_line_empty?(last_send_line)
+          next_line = processed_source[last_send_line]
+
+          body_end?(last_send_line) || next_line.blank?
+        end
+
+        def empty_lines_around?(node)
+          previous_line_empty?(node.first_line) && next_line_empty?(node.last_line)
+        end
+
+        def class_def?(line)
+          return false unless @class_or_module_def_first_line
+
+          line == @class_or_module_def_first_line + 1
+        end
+
+        def block_start?(line)
+          return false unless @block_line
+
+          line == @block_line + 1
+        end
+
+        def body_end?(line)
+          return false unless @class_or_module_def_last_line
+
+          line == @class_or_module_def_last_line - 1
+        end
+
+        def next_empty_line_range(node)
+          source_range(processed_source.buffer, node.last_line + 1, 0)
+        end
+
+        def message(node)
+          case style
+          when :around
+            message_for_around_style(node)
+          when :only_before
+            message_for_only_before_style(node)
+          end
+        end
+
+        def message_for_around_style(node)
+          send_line = node.first_line
+
+          if block_start?(send_line) || class_def?(send_line)
+            format(MSG_AFTER, modifier: node.loc.selector.source)
+          else
+            format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)
+          end
+        end
+
+        def message_for_only_before_style(node)
+          modifier = node.loc.selector.source
+
+          if next_line_empty?(node.last_line)
+            format(MSG_AFTER_FOR_ONLY_BEFORE, modifier: modifier)
+          else
+            format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.54.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if empty lines exist around the arguments
+      # of a method invocation.
+      #
+      # @example
+      #   # bad
+      #   do_something(
+      #     foo
+      #
+      #   )
+      #
+      #   process(bar,
+      #
+      #           baz: qux,
+      #           thud: fred)
+      #
+      #   some_method(
+      #
+      #     [1,2,3],
+      #     x: y
+      #   )
+      #
+      #   # good
+      #   do_something(
+      #     foo
+      #   )
+      #
+      #   process(bar,
+      #           baz: qux,
+      #           thud: fred)
+      #
+      #   some_method(
+      #     [1,2,3],
+      #     x: y
+      #   )
+      #
+      class EmptyLinesAroundArguments < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Empty line detected around arguments.'
+
+        def on_send(node)
+          return if node.single_line? || node.arguments.empty? ||
+                    receiver_and_method_call_on_different_lines?(node)
+
+          extra_lines(node) do |range|
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def receiver_and_method_call_on_different_lines?(node)
+          node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
+        end
+
+        def empty_lines(node)
+          lines = processed_lines(node)
+          lines.select! { |code, _| code.empty? }
+          lines.map { |_, line| line }
+        end
+
+        def extra_lines(node)
+          empty_lines(node).each do |line|
+            range = source_range(processed_source.buffer, line, 0)
+            yield(range)
+          end
+        end
+
+        def processed_lines(node)
+          line_numbers(node).each_with_object([]) do |num, array|
+            array << [processed_source.lines[num - 1], num]
+          end
+        end
+
+        def line_numbers(node)
+          inner_lines = []
+          line_nums = node.arguments.each_with_object([]) do |arg_node, lines|
+            lines << outer_lines(arg_node)
+            inner_lines << inner_lines(arg_node) if arg_node.multiline?
+          end
+          line_nums.flatten.uniq - inner_lines.flatten - outer_lines(node)
+        end
+
+        def inner_lines(node)
+          [node.first_line + 1, node.last_line - 1]
+        end
+
+        def outer_lines(node)
+          [node.first_line - 1, node.last_line + 1]
+        end
+      end
+    end
+  end
+end