rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that operators have space around them, except for ** which
+      # should or shouldn't have surrounding space depending on configuration.
+      # It allows vertical alignment consisting of one or more whitespace
+      # around operators.
+      #
+      # This cop has `AllowForAlignment` option. When `true`, allows most
+      # uses of extra spacing if the intent is to align with an operator on
+      # the previous or next line, not counting empty lines or comment lines.
+      #
+      # @example
+      #   # bad
+      #   total = 3*4
+      #   "apple"+"juice"
+      #   my_number = 38/4
+      #
+      #   # good
+      #   total = 3 * 4
+      #   "apple" + "juice"
+      #   my_number = 38 / 4
+      #
+      # @example AllowForAlignment: true (default)
+      #   # good
+      #   {
+      #     1 =>  2,
+      #     11 => 3
+      #   }
+      #
+      # @example AllowForAlignment: false
+      #   # bad
+      #   {
+      #     1 =>  2,
+      #     11 => 3
+      #   }
+      #
+      # @example EnforcedStyleForExponentOperator: no_space (default)
+      #   # bad
+      #   a ** b
+      #
+      #   # good
+      #   a**b
+      #
+      # @example EnforcedStyleForExponentOperator: space
+      #   # bad
+      #   a**b
+      #
+      #   # good
+      #   a ** b
+      #
+      # @example EnforcedStyleForRationalLiterals: no_space (default)
+      #   # bad
+      #   1 / 48r
+      #
+      #   # good
+      #   1/48r
+      #
+      # @example EnforcedStyleForRationalLiterals: space
+      #   # bad
+      #   1/48r
+      #
+      #   # good
+      #   1 / 48r
+      class SpaceAroundOperators < Base
+        include PrecedingFollowingAlignment
+        include RangeHelp
+        include RationalLiteral
+        extend AutoCorrector
+
+        IRREGULAR_METHODS = %i[[] ! []=].freeze
+        EXCESSIVE_SPACE = '  '
+
+        def self.autocorrect_incompatible_with
+          [Style::SelfAssignment]
+        end
+
+        def on_sclass(node)
+          check_operator(:sclass, node.loc.operator, node)
+        end
+
+        def on_pair(node)
+          return unless node.hash_rocket?
+
+          return if hash_table_style? && !node.parent.pairs_on_same_line?
+
+          check_operator(:pair, node.loc.operator, node)
+        end
+
+        def on_if(node)
+          return unless node.ternary?
+
+          check_operator(:if, node.loc.question, node.if_branch)
+          check_operator(:if, node.loc.colon, node.else_branch)
+        end
+
+        def on_resbody(node)
+          return unless node.loc.assoc
+
+          check_operator(:resbody, node.loc.assoc, node.exception_variable)
+        end
+
+        def on_send(node)
+          return if rational_literal?(node)
+
+          if node.setter_method?
+            on_setter_method(node)
+          elsif regular_operator?(node)
+            check_operator(:send, node.loc.selector, node.first_argument)
+          end
+        end
+
+        def on_assignment(node)
+          rhs = node.rhs
+
+          return unless rhs
+
+          type = node.op_asgn_type? ? :special_asgn : :assignment
+          check_operator(type, node.loc.operator, rhs)
+        end
+
+        def on_class(node)
+          rhs = node.parent_class
+
+          return unless rhs
+
+          check_operator(:class, node.loc.operator, rhs)
+        end
+
+        def on_binary(node)
+          rhs = node.rhs
+
+          return unless rhs
+
+          check_operator(:binary, node.loc.operator, rhs)
+        end
+
+        def on_setter_method(node)
+          rhs = node.first_argument
+
+          return unless rhs
+
+          check_operator(:special_asgn, node.loc.operator, node.first_argument)
+        end
+
+        def on_match_pattern(node)
+          return if target_ruby_version < 3.0
+
+          check_operator(:match_pattern, node.loc.operator, node)
+        end
+
+        alias on_or       on_binary
+        alias on_and      on_binary
+        alias on_lvasgn   on_assignment
+        alias on_casgn    on_assignment
+        alias on_masgn    on_assignment
+        alias on_ivasgn   on_assignment
+        alias on_cvasgn   on_assignment
+        alias on_gvasgn   on_assignment
+        alias on_or_asgn  on_assignment
+        alias on_and_asgn on_assignment
+        alias on_op_asgn  on_assignment
+
+        private
+
+        def regular_operator?(send_node)
+          return false if send_node.unary_operation? || send_node.dot? || send_node.double_colon?
+
+          operator_with_regular_syntax?(send_node)
+        end
+
+        def operator_with_regular_syntax?(send_node)
+          send_node.operator_method? && !IRREGULAR_METHODS.include?(send_node.method_name)
+        end
+
+        def check_operator(type, operator, right_operand)
+          with_space = range_with_surrounding_space(operator)
+          return if with_space.source.start_with?("\n")
+
+          comment = processed_source.comment_at_line(operator.line)
+          return if comment && with_space.last_column == comment.loc.column
+
+          offense(type, operator, with_space, right_operand) do |msg|
+            add_offense(operator, message: msg) do |corrector|
+              autocorrect(corrector, with_space, right_operand)
+            end
+          end
+        end
+
+        def offense(type, operator, with_space, right_operand)
+          msg = offense_message(type, operator, with_space, right_operand)
+          yield msg if msg
+        end
+
+        def autocorrect(corrector, range, right_operand)
+          range_source = range.source
+
+          if range_source.include?('**') && !space_around_exponent_operator?
+            corrector.replace(range, '**')
+          elsif range_source.include?('/') && !space_around_slash_operator?(right_operand)
+            corrector.replace(range, '/')
+          elsif range_source.end_with?("\n")
+            corrector.replace(range, " #{range_source.strip}\n")
+          else
+            enclose_operator_with_space(corrector, range)
+          end
+        end
+
+        def enclose_operator_with_space(corrector, range)
+          operator = range.source
+
+          # If `ForceEqualSignAlignment` is true, `Layout/ExtraSpacing` cop
+          # inserts spaces before operator. If `Layout/SpaceAroundOperators` cop
+          # inserts a space, it collides and raises the infinite loop error.
+          if force_equal_sign_alignment? && !operator.end_with?(' ')
+            corrector.insert_after(range, ' ')
+          else
+            corrector.replace(range, " #{operator.strip} ")
+          end
+        end
+
+        def offense_message(type, operator, with_space, right_operand)
+          if should_not_have_surrounding_space?(operator, right_operand)
+            return if with_space.is?(operator.source)
+
+            "Space around operator `#{operator.source}` detected."
+          elsif !/^\s.*\s$/.match?(with_space.source)
+            "Surrounding space missing for operator `#{operator.source}`."
+          elsif excess_leading_space?(type, operator, with_space) ||
+                excess_trailing_space?(right_operand.source_range, with_space)
+            "Operator `#{operator.source}` should be surrounded " \
+              'by a single space.'
+          end
+        end
+
+        def excess_leading_space?(type, operator, with_space)
+          return false unless allow_for_alignment?
+          return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
+
+          return !aligned_with_operator?(operator) unless type == :assignment
+
+          token            = Token.new(operator, nil, operator.source)
+          align_preceding  = aligned_with_preceding_equals_operator(token)
+
+          return false if align_preceding == :yes ||
+                          aligned_with_subsequent_equals_operator(token) == :none
+
+          aligned_with_subsequent_equals_operator(token) != :yes
+        end
+
+        def excess_trailing_space?(right_operand, with_space)
+          with_space.source.end_with?(EXCESSIVE_SPACE) &&
+            (!allow_for_alignment? || !aligned_with_something?(right_operand))
+        end
+
+        def align_hash_cop_config
+          config.for_cop('Layout/HashAlignment')
+        end
+
+        def hash_table_style?
+          return false unless align_hash_cop_config
+
+          enforced_styles = Array(align_hash_cop_config['EnforcedHashRocketStyle'])
+          enforced_styles.include?('table')
+        end
+
+        def space_around_exponent_operator?
+          cop_config['EnforcedStyleForExponentOperator'] == 'space'
+        end
+
+        def space_around_slash_operator?(right_operand)
+          return true unless right_operand.rational_type?
+
+          cop_config['EnforcedStyleForRationalLiterals'] == 'space'
+        end
+
+        def force_equal_sign_alignment?
+          config.for_cop('Layout/ExtraSpacing')['ForceEqualSignAlignment']
+        end
+
+        def should_not_have_surrounding_space?(operator, right_operand)
+          if operator.is?('**')
+            !space_around_exponent_operator?
+          elsif operator.is?('/')
+            !space_around_slash_operator?(right_operand)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that block braces have or don't have a space before the opening
+      # brace depending on configuration.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # bad
+      #   foo.map{ |a|
+      #     a.bar.to_s
+      #   }
+      #
+      #   # good
+      #   foo.map { |a|
+      #     a.bar.to_s
+      #   }
+      #
+      # @example EnforcedStyle: no_space
+      #   # bad
+      #   foo.map { |a|
+      #     a.bar.to_s
+      #   }
+      #
+      #   # good
+      #   foo.map{ |a|
+      #     a.bar.to_s
+      #   }
+      #
+      # @example EnforcedStyleForEmptyBraces: space (default)
+      #   # bad
+      #   7.times{}
+      #
+      #   # good
+      #   7.times {}
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space
+      #   # bad
+      #   7.times {}
+      #
+      #   # good
+      #   7.times{}
+      class SpaceBeforeBlockBraces < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MISSING_MSG = 'Space missing to the left of {.'
+        DETECTED_MSG = 'Space detected to the left of {.'
+
+        def self.autocorrect_incompatible_with
+          [Style::SymbolProc]
+        end
+
+        def on_block(node)
+          return if node.keywords?
+
+          # Do not register an offense for multi-line braces when specifying
+          # `EnforcedStyle: no_space`. It will conflict with autocorrection
+          # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
+          # That means preventing autocorrection to incorrect autocorrected
+          # code.
+          # See: https://github.com/rubocop/rubocop/issues/7534
+          return if conflict_with_block_delimiters?(node)
+
+          left_brace = node.loc.begin
+          space_plus_brace = range_with_surrounding_space(left_brace)
+          used_style =
+            space_plus_brace.source.start_with?('{') ? :no_space : :space
+
+          if empty_braces?(node.loc)
+            check_empty(left_brace, space_plus_brace, used_style)
+          else
+            check_non_empty(left_brace, space_plus_brace, used_style)
+          end
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def check_empty(left_brace, space_plus_brace, used_style)
+          if style_for_empty_braces == used_style
+            handle_different_styles_for_empty_braces(used_style)
+            return
+          elsif !config_to_allow_offenses.key?('Enabled')
+            config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          end
+
+          if style_for_empty_braces == :space
+            range = left_brace
+            msg = MISSING_MSG
+          else
+            range = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+            msg = DETECTED_MSG
+          end
+          add_offense(range, message: msg) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def handle_different_styles_for_empty_braces(used_style)
+          if config_to_allow_offenses['EnforcedStyleForEmptyBraces'] &&
+             config_to_allow_offenses['EnforcedStyleForEmptyBraces'].to_sym != used_style
+            config_to_allow_offenses.clear
+            config_to_allow_offenses['Enabled'] = false
+          end
+        end
+
+        def check_non_empty(left_brace, space_plus_brace, used_style)
+          case used_style
+          when style  then correct_style_detected
+          when :space then space_detected(left_brace, space_plus_brace)
+          else             space_missing(left_brace)
+          end
+        end
+
+        def space_missing(left_brace)
+          add_offense(left_brace, message: MISSING_MSG) do |corrector|
+            autocorrect(corrector, left_brace)
+            opposite_style_detected
+          end
+        end
+
+        def space_detected(left_brace, space_plus_brace)
+          space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+
+          add_offense(space, message: DETECTED_MSG) do |corrector|
+            autocorrect(corrector, space)
+            opposite_style_detected
+          end
+        end
+
+        def autocorrect(corrector, range)
+          case range.source
+          when /\s/ then corrector.remove(range)
+          else           corrector.insert_before(range, ' ')
+          end
+        end
+
+        def style_for_empty_braces
+          case cop_config['EnforcedStyleForEmptyBraces']
+          when 'space'    then :space
+          when 'no_space' then :no_space
+          when nil then style
+          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
+          end
+        end
+
+        def conflict_with_block_delimiters?(node)
+          block_delimiters_style == 'line_count_based' && style == :no_space && node.multiline?
+        end
+
+        def block_delimiters_style
+          config.for_cop('Style/BlockDelimiters')['EnforcedStyle']
+        end
+
+        def empty_braces?(loc)
+          loc.begin.end_pos == loc.end.begin_pos
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_before_brackets.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for space between the name of a receiver and a left
+      # brackets.
+      #
+      # @example
+      #
+      #   # bad
+      #   collection [index_or_key]
+      #
+      #   # good
+      #   collection[index_or_key]
+      #
+      class SpaceBeforeBrackets < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the space before the opening brackets.'
+        RESTRICT_ON_SEND = %i[[] []=].freeze
+
+        def on_send(node)
+          return unless (first_argument = node.first_argument)
+
+          begin_pos = first_argument.source_range.begin_pos
+          return unless (range = offense_range(node, begin_pos))
+
+          register_offense(range)
+        end
+
+        private
+
+        def offense_range(node, begin_pos)
+          receiver_end_pos = node.receiver.source_range.end_pos
+          selector_begin_pos = node.loc.selector.begin_pos
+          return if receiver_end_pos >= selector_begin_pos
+          return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
+
+          if reference_variable_with_brackets?(node)
+            range_between(receiver_end_pos, selector_begin_pos)
+          elsif node.method?(:[]=)
+            offense_range_for_assignment(node, begin_pos)
+          end
+        end
+
+        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
+          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
+
+          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
+        end
+
+        def offense_range_for_assignment(node, begin_pos)
+          end_pos = node.receiver.source_range.end_pos
+
+          return if begin_pos - end_pos == 1 ||
+                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
+
+          range
+        end
+
+        def register_offense(range)
+          add_offense(range) { |corrector| corrector.remove(range) }
+        end
+
+        def reference_variable_with_brackets?(node)
+          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_before_comma.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for comma (`,`) preceded by space.
+      #
+      # @example
+      #   # bad
+      #   [1 , 2 , 3]
+      #   a(1 , 2)
+      #   each { |a , b| }
+      #
+      #   # good
+      #   [1, 2, 3]
+      #   a(1, 2)
+      #   each { |a, b| }
+      #
+      class SpaceBeforeComma < Base
+        include SpaceBeforePunctuation
+        extend AutoCorrector
+
+        def kind(token)
+          'comma' if token.comma?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/space_before_comment.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for missing space between a token and a comment on the
+      # same line.
+      #
+      # @example
+      #   # bad
+      #   1 + 1# this operation does ...
+      #
+      #   # good
+      #   1 + 1 # this operation does ...
+      class SpaceBeforeComment < Base
+        extend AutoCorrector
+
+        MSG = 'Put a space before an end-of-line comment.'
+
+        def on_new_investigation
+          processed_source.sorted_tokens.each_cons(2) do |token1, token2|
+            next unless token2.comment?
+            next unless same_line?(token1, token2)
+            next unless token1.pos.end == token2.pos.begin
+
+            range = token2.pos
+
+            add_offense(range) { |corrector| corrector.insert_before(range, ' ') }
+          end
+        end
+      end
+    end
+  end
+end

data/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/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