fablicop 1.10.1 → 1.10.3

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that exactly one space is used between a method name and the
+      # first argument for method calls without parentheses.
+      #
+      # Alternatively, extra spaces can be added to align the argument with
+      # something on a preceding or following line, if the AllowForAlignment
+      # config parameter is true.
+      #
+      # @example
+      #   # bad
+      #   something  x
+      #   something   y, z
+      #   something'hello'
+      #
+      #   # good
+      #   something x
+      #   something y, z
+      #   something 'hello'
+      #
+      class SpaceBeforeFirstArg < Base
+        include PrecedingFollowingAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Put one space between the method name and the first argument.'
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
+        def on_send(node)
+          return unless regular_method_call_with_arguments?(node)
+          return if node.parenthesized?
+
+          first_arg = node.first_argument.source_range
+          first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
+          space = range_between(first_arg_with_space.begin_pos, first_arg.begin_pos)
+          return if space.length == 1
+          return unless expect_params_after_method_name?(node)
+
+          add_offense(space) { |corrector| corrector.replace(space, ' ') }
+        end
+        alias on_csend on_send
+
+        private
+
+        def regular_method_call_with_arguments?(node)
+          node.arguments? && !node.operator_method? && !node.setter_method?
+        end
+
+        def expect_params_after_method_name?(node)
+          return true if no_space_between_method_name_and_first_argument?(node)
+
+          first_arg = node.first_argument
+
+          same_line?(first_arg, node) &&
+            !(allow_for_alignment? && aligned_with_something?(first_arg.source_range))
+        end
+
+        def no_space_between_method_name_and_first_argument?(node)
+          end_pos_of_method_name = node.loc.selector.end_pos
+          begin_pos_of_argument = node.first_argument.source_range.begin_pos
+
+          end_pos_of_method_name == begin_pos_of_argument
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for semicolon (;) preceded by space.
+      #
+      # @example
+      #   # bad
+      #   x = 1 ; y = 2
+      #
+      #   # good
+      #   x = 1; y = 2
+      class SpaceBeforeSemicolon < Base
+        include SpaceBeforePunctuation
+        extend AutoCorrector
+
+        def kind(token)
+          'semicolon' if token.semicolon?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for spaces between `->` and opening parameter
+      # parenthesis (`(`) in lambda literals.
+      #
+      # @example EnforcedStyle: require_no_space (default)
+      #     # bad
+      #     a = -> (x, y) { x + y }
+      #
+      #     # good
+      #     a = ->(x, y) { x + y }
+      #
+      # @example EnforcedStyle: require_space
+      #     # bad
+      #     a = ->(x, y) { x + y }
+      #
+      #     # good
+      #     a = -> (x, y) { x + y }
+      class SpaceInLambdaLiteral < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
+
+        def on_send(node)
+          return unless arrow_lambda_with_args?(node)
+
+          if style == :require_space && !space_after_arrow?(node)
+            lambda_node = range_of_offense(node)
+
+            add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
+              corrector.insert_before(lambda_arguments(node), ' ')
+            end
+          elsif style == :require_no_space && space_after_arrow?(node)
+            space = space_after_arrow(node)
+
+            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
+              corrector.remove(space)
+            end
+          end
+        end
+
+        private
+
+        def arrow_lambda_with_args?(node)
+          node.lambda_literal? && node.parent.arguments?
+        end
+
+        def space_after_arrow?(lambda_node)
+          !space_after_arrow(lambda_node).empty?
+        end
+
+        def space_after_arrow(lambda_node)
+          arrow = lambda_node.parent.children[0].source_range
+          parentheses = lambda_node.parent.children[1].source_range
+
+          arrow.end.join(parentheses.begin)
+        end
+
+        def range_of_offense(node)
+          range_between(
+            node.parent.source_range.begin_pos,
+            node.parent.arguments.source_range.end_pos
+          )
+        end
+
+        def lambda_arguments(node)
+          node.parent.children[1]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that brackets used for array literals have or don't have
+      # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that array literals have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   array = [ a, b, c, d ]
+      #
+      #   # good
+      #   array = [a, b, c, d]
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that array literals have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   array = [a, b, c, d]
+      #
+      #   # good
+      #   array = [ a, b, c, d ]
+      #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style normally requires a space inside
+      #   # array brackets, with the exception that successive left
+      #   # or right brackets are collapsed together in nested arrays.
+      #
+      #   # bad
+      #   array = [ a, [ b, c ] ]
+      #   array = [
+      #     [ a ],
+      #     [ b, c ]
+      #   ]
+      #
+      #   # good
+      #   array = [ a, [ b, c ]]
+      #   array = [[ a ],
+      #     [ b, c ]]
+      #
+      # @example EnforcedStyleForEmptyBrackets: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty array brackets do not contain spaces.
+      #
+      #   # bad
+      #   foo = [ ]
+      #   bar = [     ]
+      #
+      #   # good
+      #   foo = []
+      #   bar = []
+      #
+      # @example EnforcedStyleForEmptyBrackets: space
+      #   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty array brackets contain exactly one space.
+      #
+      #   # bad
+      #   foo = []
+      #   bar = [    ]
+      #
+      #   # good
+      #   foo = [ ]
+      #   bar = [ ]
+      #
+      class SpaceInsideArrayLiteralBrackets < Base
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = '%<command>s space inside array brackets.'
+        EMPTY_MSG = '%<command>s space inside empty array brackets.'
+
+        def on_array(node)
+          return unless node.square_brackets?
+
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            return empty_offenses(node, left, right, EMPTY_MSG)
+          end
+
+          start_ok = next_to_newline?(node, left)
+          end_ok = node.single_line? ? false : end_has_own_line?(right)
+
+          issue_offenses(node, left, right, start_ok, end_ok)
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          tokens, left, right = array_brackets(node)
+
+          if empty_brackets?(left, right, tokens: tokens)
+            SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
+          elsif style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, left, right)
+          elsif style == :space
+            SpaceCorrector.add_space(processed_source, corrector, left, right)
+          else
+            compact_corrections(corrector, node, left, right)
+          end
+        end
+
+        def array_brackets(node)
+          tokens = processed_source.tokens_within(node)
+
+          left = tokens.find(&:left_array_bracket?)
+          right = tokens.reverse_each.find(&:right_bracket?)
+
+          [tokens, left, right]
+        end
+
+        def empty_config
+          cop_config['EnforcedStyleForEmptyBrackets']
+        end
+
+        def next_to_newline?(node, token)
+          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
+        end
+
+        def end_has_own_line?(token)
+          line, col = line_and_column_for(token)
+          return true if col == -1
+
+          !/\S/.match?(processed_source.lines[line][0..col])
+        end
+
+        def index_for(node, token)
+          processed_source.tokens_within(node).index(token)
+        end
+
+        def line_and_column_for(token)
+          [token.line - 1, token.column - 1]
+        end
+
+        def issue_offenses(node, left, right, start_ok, end_ok)
+          case style
+          when :no_space
+            start_ok = next_to_comment?(node, left)
+            no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
+          when :space
+            space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
+          else
+            compact_offenses(node, left, right, start_ok, end_ok)
+          end
+        end
+
+        def next_to_comment?(node, token)
+          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
+        end
+
+        def compact_offenses(node, left, right, start_ok, end_ok)
+          if qualifies_for_compact?(node, left, side: :left)
+            compact_offense(node, left, side: :left)
+          elsif !multi_dimensional_array?(node, left, side: :left)
+            space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
+          end
+          if qualifies_for_compact?(node, right)
+            compact_offense(node, right)
+          elsif !multi_dimensional_array?(node, right)
+            space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
+          end
+        end
+
+        def qualifies_for_compact?(node, token, side: :right)
+          if side == :right
+            multi_dimensional_array?(node, token) && token.space_before?
+          else
+            multi_dimensional_array?(node, token, side: :left) && token.space_after?
+          end
+        end
+
+        def multi_dimensional_array?(node, token, side: :right)
+          offset = side == :right ? -1 : +1
+          i = index_for(node, token) + offset
+          i += offset while processed_source.tokens_within(node)[i].new_line?
+          if side == :right
+            processed_source.tokens_within(node)[i].right_bracket?
+          else
+            processed_source.tokens_within(node)[i].left_array_bracket?
+          end
+        end
+
+        def next_to_bracket?(token, side: :right)
+          line_index, col = line_and_column_for(token)
+          line = processed_source.lines[line_index]
+          side == :right ? line[col] == ']' : line[col + 2] == '['
+        end
+
+        def compact_offense(node, token, side: :right)
+          if side == :right
+            space_offense(node, token, :left, MSG, NO_SPACE_COMMAND)
+          else
+            space_offense(node, token, :right, MSG, NO_SPACE_COMMAND)
+          end
+        end
+
+        def compact_corrections(corrector, node, left, right)
+          if multi_dimensional_array?(node, left, side: :left)
+            compact(corrector, left, :right)
+          elsif !left.space_after?
+            corrector.insert_after(left.pos, ' ')
+          end
+
+          if multi_dimensional_array?(node, right)
+            compact(corrector, right, :left)
+          elsif !right.space_before?
+            corrector.insert_before(right.pos, ' ')
+          end
+        end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side, include_newlines: true)
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for unnecessary additional spaces inside array percent literals
+      # (i.e. %i/%w).
+      #
+      # Note that blank percent literals (e.g. `%i( )`) are checked by
+      # `Layout/SpaceInsidePercentLiteralDelimiters`.
+      #
+      # @example
+      #
+      #   # bad
+      #   %w(foo  bar  baz)
+      #   # good
+      #   %i(foo bar baz)
+      class SpaceInsideArrayPercentLiteral < Base
+        include MatchRange
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Use only a single space inside array percent literal.'
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
+
+        def on_array(node)
+          process(node, '%i', '%I', '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          each_unnecessary_space_match(node) do |range|
+            add_offense(range) do |corrector|
+              corrector.replace(range, ' ')
+            end
+          end
+        end
+
+        private
+
+        def each_unnecessary_space_match(node, &blk)
+          each_match_range(contents_range(node), MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that block braces have or don't have surrounding space inside
+      # them on configuration. For blocks taking parameters, it checks that the
+      # left brace has or doesn't have trailing space depending on
+      # configuration.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # The `space` style enforces that block braces have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   some_array.each {puts e}
+      #
+      #   # good
+      #   some_array.each { puts e }
+      #
+      # @example EnforcedStyle: no_space
+      #   # The `no_space` style enforces that block braces don't
+      #   # have surrounding space.
+      #
+      #   # bad
+      #   some_array.each { puts e }
+      #
+      #   # good
+      #   some_array.each {puts e}
+      #
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+      #   # block braces don't have a space in between when empty.
+      #
+      #   # bad
+      #   some_array.each {   }
+      #   some_array.each {  }
+      #   some_array.each { }
+      #
+      #   # good
+      #   some_array.each {}
+      #
+      # @example EnforcedStyleForEmptyBraces: space
+      #   # The `space` EnforcedStyleForEmptyBraces style enforces that
+      #   # block braces have at least a space in between when empty.
+      #
+      #   # bad
+      #   some_array.each {}
+      #
+      #   # good
+      #   some_array.each { }
+      #   some_array.each {  }
+      #   some_array.each {   }
+      #
+      #
+      # @example SpaceBeforeBlockParameters: true (default)
+      #   # The SpaceBeforeBlockParameters style set to `true` enforces that
+      #   # there is a space between `{` and `|`. Overrides `EnforcedStyle`
+      #   # if there is a conflict.
+      #
+      #   # bad
+      #   [1, 2, 3].each {|n| n * 2 }
+      #
+      #   # good
+      #   [1, 2, 3].each { |n| n * 2 }
+      #
+      # @example SpaceBeforeBlockParameters: false
+      #   # The SpaceBeforeBlockParameters style set to `false` enforces that
+      #   # there is no space between `{` and `|`. Overrides `EnforcedStyle`
+      #   # if there is a conflict.
+      #
+      #   # bad
+      #   [1, 2, 3].each { |n| n * 2 }
+      #
+      #   # good
+      #   [1, 2, 3].each {|n| n * 2 }
+      #
+      class SpaceInsideBlockBraces < Base
+        include ConfigurableEnforcedStyle
+        include SurroundingSpace
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_block(node)
+          return if node.keywords?
+
+          # Do not register an offense for multi-line empty braces. That means
+          # preventing autocorrection to single-line empty braces. It will
+          # conflict with autocorrection by `Layout/SpaceInsideBlockBraces` cop
+          # if autocorrected to a single-line empty braces.
+          # See: https://github.com/rubocop/rubocop/issues/7363
+          return if node.body.nil? && node.multiline?
+
+          left_brace = node.loc.begin
+          right_brace = node.loc.end
+
+          check_inside(node, left_brace, right_brace)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def check_inside(node, left_brace, right_brace)
+          if left_brace.end_pos == right_brace.begin_pos
+            adjacent_braces(left_brace, right_brace)
+          else
+            range = range_between(left_brace.end_pos, right_brace.begin_pos)
+            inner = range.source
+
+            if /\S/.match?(inner)
+              braces_with_contents_inside(node, inner)
+            elsif style_for_empty_braces == :no_space
+              offense(range.begin_pos, range.end_pos,
+                      'Space inside empty braces detected.',
+                      'EnforcedStyleForEmptyBraces')
+            end
+          end
+        end
+
+        def adjacent_braces(left_brace, right_brace)
+          return if style_for_empty_braces != :space
+
+          offense(left_brace.begin_pos, right_brace.end_pos,
+                  'Space missing inside empty braces.',
+                  'EnforcedStyleForEmptyBraces')
+        end
+
+        def braces_with_contents_inside(node, inner)
+          args_delimiter = node.arguments.loc.begin if node.block_type? # Can be ( | or nil.
+
+          check_left_brace(inner, node.loc.begin, args_delimiter)
+          check_right_brace(node, inner, node.loc.begin, node.loc.end, node.single_line?)
+        end
+
+        def check_left_brace(inner, left_brace, args_delimiter)
+          if /\A\S/.match?(inner)
+            no_space_inside_left_brace(left_brace, args_delimiter)
+          else
+            space_inside_left_brace(left_brace, args_delimiter)
+          end
+        end
+
+        def check_right_brace(node, inner, left_brace, right_brace, single_line)
+          if single_line && /\S$/.match?(inner)
+            no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
+          else
+            column = node.source_range.column
+            return if multiline_block?(left_brace, right_brace) &&
+                      aligned_braces?(inner, right_brace, column)
+
+            space_inside_right_brace(inner, right_brace, column)
+          end
+        end
+
+        def multiline_block?(left_brace, right_brace)
+          left_brace.first_line != right_brace.first_line
+        end
+
+        def aligned_braces?(inner, right_brace, column)
+          column == right_brace.column || column == inner_last_space_count(inner)
+        end
+
+        def inner_last_space_count(inner)
+          inner.split("\n").last.count(' ')
+        end
+
+        def no_space_inside_left_brace(left_brace, args_delimiter)
+          if pipe?(args_delimiter)
+            if left_brace.end_pos == args_delimiter.begin_pos &&
+               cop_config['SpaceBeforeBlockParameters']
+              offense(left_brace.begin_pos, args_delimiter.end_pos,
+                      'Space between { and | missing.')
+            else
+              correct_style_detected
+            end
+          else
+            # We indicate the position after the left brace. Otherwise it's
+            # difficult to distinguish between space missing to the left and to
+            # the right of the brace in autocorrect.
+            no_space(left_brace.end_pos, left_brace.end_pos + 1, 'Space missing inside {.')
+          end
+        end
+
+        def space_inside_left_brace(left_brace, args_delimiter)
+          if pipe?(args_delimiter)
+            if cop_config['SpaceBeforeBlockParameters']
+              correct_style_detected
+            else
+              offense(left_brace.end_pos, args_delimiter.begin_pos,
+                      'Space between { and | detected.')
+            end
+          else
+            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
+            space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
+                  'Space inside { detected.')
+          end
+        end
+
+        def pipe?(args_delimiter)
+          args_delimiter&.is?('|')
+        end
+
+        def space_inside_right_brace(inner, right_brace, column)
+          brace_with_space = range_with_surrounding_space(right_brace, side: :left)
+          begin_pos = brace_with_space.begin_pos
+          end_pos = brace_with_space.end_pos - 1
+
+          if brace_with_space.source.match?(/\R/)
+            begin_pos = end_pos - (right_brace.column - column)
+          end
+
+          if inner.end_with?(']')
+            end_pos -= 1
+            begin_pos = end_pos - (inner_last_space_count(inner) - column)
+          end
+
+          space(begin_pos, end_pos, 'Space inside } detected.')
+        end
+
+        def no_space(begin_pos, end_pos, msg)
+          if style == :space
+            offense(begin_pos, end_pos, msg)
+          else
+            correct_style_detected
+          end
+        end
+
+        def space(begin_pos, end_pos, msg)
+          if style == :no_space
+            offense(begin_pos, end_pos, msg)
+          else
+            correct_style_detected
+          end
+        end
+
+        def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
+          return if begin_pos > end_pos
+
+          range = range_between(begin_pos, end_pos)
+          add_offense(range, message: msg) do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            when '{}' then corrector.replace(range, '{ }')
+            when '{|' then corrector.replace(range, '{ |')
+            else           corrector.insert_before(range, ' ')
+            end
+            opposite_style_detected if style_param == 'EnforcedStyle'
+          end
+        end
+
+        def style_for_empty_braces
+          case cop_config['EnforcedStyleForEmptyBraces']
+          when 'space'    then :space
+          when 'no_space' then :no_space
+          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
+          end
+        end
+      end
+    end
+  end
+end