rubocop 1.18.2 → 1.19.1

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

@@ -289,12 +289,16 @@ module RuboCop
           (node.first_line - 1).downto(1) do |annotation_line|
             break unless (comment = processed_source.comment_at_line(annotation_line))
 
-            first_comment = comment
+            first_comment = comment if whole_line_comment_at_line?(annotation_line)
           end
 
           start_line_position(first_comment || node)
         end
 
+        def whole_line_comment_at_line?(line)
+          /\A\s*#/.match?(processed_source.lines[line - 1])
+        end
+
         def start_line_position(node)
           buffer.line_range(node.loc.line).begin_pos - 1
         end

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

@@ -38,12 +38,14 @@ module RuboCop
       class EmptyLineAfterGuardClause < Base
         include RangeHelp
         extend AutoCorrector
+        extend Util
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
 
         def on_if(node)
           return if correct_style?(node)
+          return if multiple_statements_on_line?(node)
 
           if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
             return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
@@ -166,6 +168,13 @@ module RuboCop
             node
           end
         end
+
+        def multiple_statements_on_line?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.begin_type? && parent.single_line?
+        end
       end
     end
   end

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

@@ -165,9 +165,11 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument?
+          return node.parent if node.case_type? && node.argument? &&
+                                node.loc.line == node.parent.loc.line
+
+          assignment = assignment_or_operator_method(node)
 
-          assignment = node.ancestors.find(&:assignment_or_similar?)
           if assignment && !line_break_before_keyword?(assignment.source_range, node)
             assignment
           else
@@ -177,6 +179,12 @@ module RuboCop
             node
           end
         end
+
+        def assignment_or_operator_method(node)
+          node.ancestors.find do |ancestor|
+            ancestor.assignment_or_similar? || ancestor.send_type? && ancestor.operator_method?
+          end
+        end
       end
     end
   end

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

@@ -154,7 +154,7 @@ module RuboCop
 
         def on_send(node)
           return if style != :consistent && enforce_first_argument_with_fixed_indentation?
-          return if !node.arguments? || bare_operator?(node)
+          return if !node.arguments? || bare_operator?(node) || node.setter_method?
 
           indent = base_indentation(node) + configured_indentation_width
 

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

@@ -213,18 +213,22 @@ module RuboCop
           check_pairs(node)
         end
 
-        attr_accessor :offences_by, :column_deltas
+        attr_accessor :offenses_by, :column_deltas
 
         private
 
         def autocorrect_incompatible_with_other_cops?(node)
-          enforce_first_argument_with_fixed_indentation? &&
-            node.pairs.any? &&
-            node.parent&.call_type? && node.parent.loc.selector.line == node.pairs.first.loc.line
+          return false unless enforce_first_argument_with_fixed_indentation? &&
+                              node.pairs.any? &&
+                              node.parent&.call_type?
+
+          parent_loc = node.parent.loc
+          selector = parent_loc.selector || parent_loc.expression
+          selector.line == node.pairs.first.loc.line
         end
 
         def reset!
-          self.offences_by = {}
+          self.offenses_by = {}
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
         end
 
@@ -248,33 +252,33 @@ module RuboCop
             end
           end
 
-          add_offences
+          add_offenses
         end
 
-        def add_offences
-          kwsplat_offences = offences_by.delete(KeywordSplatAlignment)
-          register_offences_with_format(kwsplat_offences, KeywordSplatAlignment)
+        def add_offenses
+          kwsplat_offenses = offenses_by.delete(KeywordSplatAlignment)
+          register_offenses_with_format(kwsplat_offenses, KeywordSplatAlignment)
 
-          format, offences = offences_by.min_by { |_, v| v.length }
-          register_offences_with_format(offences, format)
+          format, offenses = offenses_by.min_by { |_, v| v.length }
+          register_offenses_with_format(offenses, format)
         end
 
-        def register_offences_with_format(offences, format)
-          (offences || []).each do |offence|
-            add_offense(offence, message: MESSAGES[format]) do |corrector|
-              delta = column_deltas[alignment_for(offence).first.class][offence]
+        def register_offenses_with_format(offenses, format)
+          (offenses || []).each do |offense|
+            add_offense(offense, message: MESSAGES[format]) do |corrector|
+              delta = column_deltas[alignment_for(offense).first.class][offense]
 
-              correct_node(corrector, offence, delta) unless delta.nil?
+              correct_node(corrector, offense, delta) unless delta.nil?
             end
           end
         end
 
         def check_delta(delta, node:, alignment:)
-          offences_by[alignment.class] ||= []
+          offenses_by[alignment.class] ||= []
           return if good_alignment? delta
 
           column_deltas[alignment.class][node] = delta
-          offences_by[alignment.class].push(node)
+          offenses_by[alignment.class].push(node)
         end
 
         def ignore_hash_argument?(node)

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

@@ -143,13 +143,6 @@ module RuboCop
           indent_level(base_line)
         end
 
-        def indent_level(str)
-          indentations = str.lines
-                            .map { |line| line[/^\s*/] }
-                            .reject { |line| line.end_with?("\n") }
-          indentations.empty? ? 0 : indentations.min_by(&:size).size
-        end
-
         # Returns '~', '-' or nil
         def heredoc_indent_type(node)
           node.source[/^<<([~-])/, 1]

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

@@ -43,7 +43,7 @@ module RuboCop
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            next unless (range = find_offence(line, lineno))
+            next unless (range = find_offense(line, lineno))
             next if in_string_literal?(str_ranges, range)
 
             add_offense(range) { |corrector| autocorrect(corrector, range) }
@@ -60,7 +60,7 @@ module RuboCop
           end
         end
 
-        def find_offence(line, lineno)
+        def find_offense(line, lineno)
           match = if style == :spaces
                     line.match(/\A\s*\t+/)
                   else

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

@@ -57,7 +57,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
+            next unless /\A#+[^#\s=+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)

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

@@ -11,8 +11,7 @@ module RuboCop
       # concatenated string parts shall be indented regardless of `EnforcedStyle` configuration.
       #
       # If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step
-      # more than the first line. Lines 3 and forward shall be aligned with line 2. Here too there
-      # are exceptions. Values in a hash literal are always aligned.
+      # more than the first line. Lines 3 and forward shall be aligned with line 2.
       #
       # @example
       #   # bad
@@ -34,29 +33,44 @@ module RuboCop
       #       'z'
       #   end
       #
-      #   my_hash = {
-      #     first: 'a message' \
-      #            'in two parts'
-      #   }
-      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   puts 'x' \
       #     'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
       #   # good
       #   puts 'x' \
       #        'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
       # @example EnforcedStyle: indented
       #   # bad
       #   result = 'x' \
       #            'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #            'in two parts'
+      #   }
+      #
       #   # good
       #   result = 'x' \
       #     'y'
       #
+      #   my_hash = {
+      #     first: 'a message' \
+      #       'in two parts'
+      #   }
+      #
       class LineEndStringConcatenationIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
@@ -70,7 +84,7 @@ module RuboCop
           return unless strings_concatenated_with_backslash?(node)
 
           children = node.children
-          if style == :aligned && !always_indented?(node) || always_aligned?(node)
+          if style == :aligned && !always_indented?(node)
             check_aligned(children, 1)
           else
             check_indented(children)
@@ -85,24 +99,15 @@ module RuboCop
         private
 
         def strings_concatenated_with_backslash?(dstr_node)
-          !dstr_node.heredoc? &&
-            !single_string_literal?(dstr_node) &&
-            dstr_node.children.length > 1 &&
-            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? }
-        end
-
-        def single_string_literal?(dstr_node)
-          dstr_node.loc.respond_to?(:begin) && dstr_node.loc.begin
+          dstr_node.multiline? &&
+            dstr_node.children.all? { |c| c.str_type? || c.dstr_type? } &&
+            dstr_node.children.none?(&:multiline?)
         end
 
         def always_indented?(dstr_node)
           PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
         end
 
-        def always_aligned?(dstr_node)
-          dstr_node.parent&.pair_type?
-        end
-
         def check_aligned(children, start_index)
           base_column = children[start_index - 1].loc.column
           children[start_index..-1].each do |child|
@@ -113,11 +118,20 @@ module RuboCop
         end
 
         def check_indented(children)
-          base_column = children[0].source_range.source_line =~ /\S/
-          @column_delta = base_column + configured_indentation_width - children[1].loc.column
+          @column_delta = base_column(children[0]) + configured_indentation_width -
+                          children[1].loc.column
           add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
         end
 
+        def base_column(child)
+          grandparent = child.parent.parent
+          if grandparent&.type == :pair
+            grandparent.loc.column
+          else
+            child.source_range.source_line =~ /\S/
+          end
+        end
+
         def add_offense_and_correction(node, message)
           add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end

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

@@ -29,8 +29,7 @@ module RuboCop
         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].freeze
-        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + %i[block]).freeze
+        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
 
@@ -118,6 +117,8 @@ module RuboCop
           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)
@@ -129,14 +130,26 @@ module RuboCop
         end
 
         def ancestor_node(node)
-          ancestor_types =
-            if target_ruby_version >= 2.5
-              RUBY_2_5_ANCESTOR_TYPES
-            else
-              ANCESTOR_TYPES
-            end
+          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)
 
-          node.each_ancestor(*ancestor_types).first
+          do_keyword_line == dot.line && rescue_keyword_column == dot.column
         end
 
         def assignment_node(node)

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

@@ -63,6 +63,10 @@ module RuboCop
           [Style::SelfAssignment]
         end
 
+        def on_sclass(node)
+          check_operator(:sclass, node.loc.operator, node.source_range)
+        end
+
         def on_pair(node)
           return unless node.hash_rocket?
 
@@ -104,6 +108,14 @@ module RuboCop
           check_operator(:assignment, node.loc.operator, rhs.source_range)
         end
 
+        def on_casgn(node)
+          _, _, right, = *node
+
+          return unless right
+
+          check_operator(:assignment, node.loc.operator, right.source_range)
+        end
+
         def on_binary(node)
           _, rhs, = *node
 
@@ -130,7 +142,6 @@ module RuboCop
         alias on_and      on_binary
         alias on_lvasgn   on_assignment
         alias on_masgn    on_assignment
-        alias on_casgn    on_special_asgn
         alias on_ivasgn   on_assignment
         alias on_cvasgn   on_assignment
         alias on_gvasgn   on_assignment

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

@@ -18,7 +18,7 @@ module RuboCop
         MSG = 'Put a space before an end-of-line comment.'
 
         def on_new_investigation
-          processed_source.tokens.each_cons(2) do |token1, token2|
+          processed_source.sorted_tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
             next unless token1.line == token2.line
             next unless token1.pos.end == token2.pos.begin

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

@@ -43,12 +43,12 @@ module RuboCop
         MSG_SPACE = 'No space inside parentheses detected.'
 
         def on_new_investigation
-          @processed_source = processed_source
+          tokens = processed_source.sorted_tokens
 
           if style == :space
-            process_with_space_style(processed_source)
+            process_with_space_style(tokens)
           else
-            each_extraneous_space(processed_source.tokens) do |range|
+            each_extraneous_space(tokens) do |range|
               add_offense(range) do |corrector|
                 corrector.remove(range)
               end
@@ -58,8 +58,8 @@ module RuboCop
 
         private
 
-        def process_with_space_style(processed_source)
-          processed_source.tokens.each_cons(2) do |token1, token2|
+        def process_with_space_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
             each_extraneous_space_in_empty_parens(token1, token2) do |range|
               add_offense(range) do |corrector|
                 corrector.remove(range)