rubocop 0.58.2 → 0.59.0

data/lib/rubocop/cop/force.rb

@@ -29,6 +29,7 @@ module RuboCop
       def run_hook(method_name, *args)
         cops.each do |cop|
           next unless cop.respond_to?(method_name)
+
           cop.send(method_name, *args)
         end
       end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -61,6 +61,7 @@ module RuboCop
 
         def investigate(processed_source)
           return if processed_source.blank?
+
           dependency_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)

data/lib/rubocop/cop/generator.rb

@@ -203,6 +203,7 @@ module RuboCop
 
       def snake_case(camel_case_string)
         return 'rspec' if camel_case_string == 'RSpec'
+
         camel_case_string
           .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
           .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')

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

@@ -66,6 +66,7 @@ module RuboCop
 
         def check_body(body, node)
           return if body.nil? # Empty class etc.
+          return unless body.begin_type?
 
           modifiers = body.each_child_node(:send).select(&:access_modifier?)
           class_column = node.source_range.column

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

@@ -162,6 +162,7 @@ module RuboCop
         # @return String otherwise trying to {humanize_node} of the current node
         def classify(node)
           return node.to_s unless node.respond_to?(:type)
+
           case node.type
           when :block
             classify(node.send_node)
@@ -185,6 +186,7 @@ module RuboCop
           class_elements(class_node).each do |node|
             classification = classify(node)
             next if ignore?(classification)
+
             yield node, classification
           end
         end
@@ -192,6 +194,7 @@ module RuboCop
         def class_elements(class_node)
           *, class_def = class_node.children
           return [] unless class_def
+
           if class_def.def_type? || class_def.send_type?
             [class_def]
           else
@@ -241,6 +244,7 @@ module RuboCop
           method_name, = *node
           if node.def_type?
             return :initializer if method_name == :initialize
+
             return "#{node_visibility(node)}_methods"
           end
           HUMANIZED_NODE_TYPE[node.type] || node.type

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

@@ -79,10 +79,11 @@ module RuboCop
         end
 
         def argument_indentation_correct?(node)
-          node.argument? &&
-            opening_indentation(
-              find_node_used_heredoc_argument(node.parent)
-            ) == closing_indentation(node)
+          return unless node.argument? || node.chained?
+
+          opening_indentation(
+            find_node_used_heredoc_argument(node.parent)
+          ) == closing_indentation(node)
         end
 
         def contents_indentation(node)

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

@@ -95,6 +95,14 @@ module RuboCop
         private
 
         def check(node, elements)
+          if elements.empty?
+            check_for_no_elements(node)
+          else
+            check_for_elements(node, elements)
+          end
+        end
+
+        def check_for_elements(node, elements)
           left_paren  = node.loc.begin
           right_paren = node.loc.end
 
@@ -113,6 +121,25 @@ module RuboCop
                                         right_paren))
         end
 
+        def check_for_no_elements(node)
+          left_paren = node.loc.begin
+          right_paren = node.loc.end
+          return unless right_paren && begins_its_line?(right_paren)
+
+          candidates = correct_column_candidates(node, left_paren)
+
+          return if candidates.include?(right_paren.column)
+
+          # Although there are multiple choices for a correct column,
+          # select the first one of candidates to determine a specification.
+          correct_column = candidates.first
+          add_offense(right_paren,
+                      location: right_paren,
+                      message:  message(correct_column,
+                                        left_paren,
+                                        right_paren))
+        end
+
         def expected_column(left_paren, elements)
           if !line_break_after_left_paren?(left_paren, elements) &&
              all_elements_aligned?(elements)
@@ -140,6 +167,14 @@ module RuboCop
             .first_line
         end
 
+        def correct_column_candidates(node, left_paren)
+          [
+            processed_source.line_indentation(left_paren.line),
+            left_paren.column,
+            node.loc.column
+          ]
+        end
+
         def message(correct_column, left_paren, right_paren)
           if correct_column == left_paren.column
             MSG_ALIGN

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

@@ -120,6 +120,7 @@ module RuboCop
 
           @column_delta = effective_column(base_range) - else_range.column
           return if @column_delta.zero?
+
           message = format(
             MSG,
             else_range: else_range.source,

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

@@ -80,6 +80,7 @@ module RuboCop
 
         def def_node?(node)
           return unless node
+
           node.def_type? || node.defs_type?
         end
 
@@ -88,6 +89,7 @@ module RuboCop
           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
 

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

@@ -45,6 +45,7 @@ module RuboCop
 
         def on_send(node)
           return if node.single_line? || node.arguments.empty?
+
           extra_lines(node) { |range| add_offense(node, location: range) }
         end
 

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

@@ -70,8 +70,11 @@ module RuboCop
         KIND = 'class'.freeze
 
         def on_class(node)
-          _name, _superclass, body = *node
-          check(node, body)
+          _name, superclass, body = *node
+
+          adjusted_first_line = superclass.first_line if superclass
+
+          check(node, body, adjusted_first_line: adjusted_first_line)
         end
 
         def on_sclass(node)

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

@@ -104,6 +104,7 @@ module RuboCop
 
         def keyword_locations(node)
           return [] unless node
+
           case node.type
           when :rescue
             keyword_locations_in_rescue(node)

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

@@ -51,6 +51,7 @@ module RuboCop
 
           processed_source.raw_source.each_line.with_index do |line, index|
             break if index >= last_line
+
             msg = offense_message(line)
             next unless msg
             next if unimportant_missing_cr?(index, last_line, line)

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

@@ -89,6 +89,7 @@ module RuboCop
             message = format(MSG_UNALIGNED_ASGN, location: 'following')
           end
           return if aligned_assignment?(token.pos, assignment_line)
+
           add_offense(token.pos, location: token.pos, message: message)
         end
 

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

@@ -114,6 +114,7 @@ module RuboCop
           first_elem = array_node.values.first
           if first_elem
             return if first_elem.source_range.line == left_bracket.line
+
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end
 

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

@@ -100,6 +100,7 @@ module RuboCop
           end
 
           return if too_long_line?(node)
+
           add_offense(node, location: :heredoc_body)
         end
 
@@ -174,6 +175,7 @@ module RuboCop
 
         def too_long_line?(node)
           return false if config.for_cop('Metrics/LineLength')['AllowHeredoc']
+
           body = heredoc_body(node)
 
           expected_indent = base_indent_level(node) + indentation_width
@@ -191,6 +193,7 @@ module RuboCop
 
         def correct_by_squiggly(node)
           return if target_ruby_version < 2.3
+
           lambda do |corrector|
             if heredoc_indent_type(node) == '~'
               adjust_squiggly(corrector, node)

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

@@ -70,6 +70,7 @@ module RuboCop
           # Check indentation against end keyword but only if it's first on its
           # line.
           return unless begins_its_line?(node.loc.end)
+
           check_indentation(node.loc.end, node.children.first)
         end
 
@@ -165,6 +166,7 @@ module RuboCop
           else
             members.first.children.each do |member|
               next if member.send_type? && member.access_modifier?
+
               check_indentation(base, member)
             end
           end

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

@@ -196,6 +196,7 @@ module RuboCop
           node = node.parent until node.loc.dot
 
           return if node.loc.dot.line != node.first_line
+
           node
         end
 

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

@@ -61,6 +61,8 @@ module RuboCop
         private
 
         def relevant_node?(node)
+          return false if node.unary_operation?
+
           !node.loc.dot # Don't check method calls with dot operator.
         end
 
@@ -72,7 +74,6 @@ module RuboCop
 
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
-          return false if lhs.first_line == rhs.line # Needed for unary op.
           return false if not_for_this_cop?(node)
 
           correct_column = if should_align?(node, rhs, given_style)

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

@@ -25,8 +25,10 @@ module RuboCop
         include RangeHelp
 
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
-              'aligned with `end` at %<end_loc_line>d, %<end_loc_column>d.'
-              .freeze
+              'aligned with `%<beginning>s` at ' \
+              '%<begin_loc_line>d, %<begin_loc_column>d.'.freeze
+        ANCESTOR_TYPES = %i[kwbegin def defs class module].freeze
+        RUBY_2_5_ANCESTOR_TYPES = (ANCESTOR_TYPES + [:block]).freeze
 
         def on_resbody(node)
           check(node) unless modifier?(node)
@@ -40,6 +42,7 @@ module RuboCop
           @modifier_locations =
             processed_source.tokens.each_with_object([]) do |token, locations|
               next unless token.rescue_modifier?
+
               locations << token.pos
             end
         end
@@ -55,28 +58,44 @@ module RuboCop
         private
 
         def check(node)
-          end_loc = ancestor_node(node).loc.end
+          ancestor_node = ancestor_node(node)
+          alignment_loc = ancestor_node.loc.expression
           kw_loc = node.loc.keyword
 
-          return if end_loc.column == kw_loc.column
-          return if end_loc.line == kw_loc.line
+          return if alignment_loc.column == kw_loc.column
+          return if alignment_loc.line == kw_loc.line
 
           add_offense(node,
                       location: kw_loc,
-                      message: format_message(kw_loc, end_loc))
+                      message: format_message(kw_loc,
+                                              alignment_loc,
+                                              ancestor_node))
         end
 
-        def format_message(kw_loc, end_loc)
+        def format_message(kw_loc, alignment_loc, ancestor_node)
           format(MSG,
                  kw_loc: kw_loc.source,
                  kw_loc_line: kw_loc.line,
                  kw_loc_column: kw_loc.column,
-                 end_loc_line: end_loc.line,
-                 end_loc_column: end_loc.column)
+                 beginning: alignment_source(ancestor_node),
+                 begin_loc_line: alignment_loc.line,
+                 begin_loc_column: alignment_loc.column)
+        end
+
+        def alignment_source(node)
+          ending = case node.type
+                   when :def, :defs, :class, :module
+                     node.loc.name
+                   when :block, :kwbegin
+                     node.loc.begin
+                   end
+
+          range_between(node.loc.expression.begin_pos, ending.end_pos).source
         end
 
         def modifier?(node)
           return false unless @modifier_locations.respond_to?(:include?)
+
           @modifier_locations.include?(node.loc.keyword)
         end
 
@@ -88,8 +107,12 @@ module RuboCop
         end
 
         def ancestor_node(node)
-          types = %i[kwbegin def defs class module]
-          types << :block if target_ruby_version >= 2.5
+          types = if target_ruby_version >= 2.5
+                    RUBY_2_5_ANCESTOR_TYPES
+                  else
+                    ANCESTOR_TYPES
+                  end
+
           node.each_ancestor(*types).first
         end
       end

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

@@ -23,6 +23,7 @@ module RuboCop
         def on_def(node)
           args = node.arguments
           return unless args.loc.begin && args.loc.begin.is?('(')
+
           expr = args.source_range
           pos_before_left_paren = range_between(expr.begin_pos - 1,
                                                 expr.begin_pos)

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

@@ -17,7 +17,7 @@ module RuboCop
         MSG = 'Do not leave space between `!` and its argument.'.freeze
 
         def on_send(node)
-          return unless node.keyword_bang? && whitespace_after_operator?(node)
+          return unless node.prefix_bang? && whitespace_after_operator?(node)
 
           add_offense(node)
         end

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

@@ -96,7 +96,7 @@ module RuboCop
         end
 
         def on_send(node)
-          check(node, [:selector].freeze) if node.keyword_not?
+          check(node, [:selector].freeze) if node.prefix_not?
         end
 
         def on_super(node)
@@ -140,6 +140,7 @@ module RuboCop
         def check(node, locations, begin_keyword = DO)
           locations.each do |loc|
             next unless node.loc.respond_to?(loc)
+
             range = node.loc.public_send(loc)
             next unless range
 
@@ -182,6 +183,7 @@ module RuboCop
         def space_before_missing?(range)
           pos = range.begin_pos - 1
           return false if pos < 0
+
           range.source_buffer.source[pos] !~ /[\s\(\|\{\[;,\*\=]/
         end
 

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

@@ -71,6 +71,7 @@ module RuboCop
           _, _, right, = *node
 
           return unless right
+
           check_operator(node.loc.operator, right.source_range)
         end
 

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

@@ -19,6 +19,7 @@ module RuboCop
           processed_source.tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
             next unless token1.line == token2.line
+
             if token1.pos.end == token2.pos.begin
               add_offense(token2.pos, location: token2.pos)
             end

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for spaces between -> and opening parameter
-      # brace in lambda literals.
+      # This cop checks for spaces between `->` and opening parameter
+      # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
       #     # bad
@@ -24,20 +24,21 @@ module RuboCop
         include RangeHelp
 
         ARROW = '->'.freeze
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and opening brace ' \
-                            'in lambda literals'.freeze
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and opening ' \
-                               'brace in lambda literals'.freeze
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
+                            '`(` in lambda literals.'.freeze
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
+                               '`(` in lambda literals.'.freeze
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
+
           if style == :require_space && !space_after_arrow?(node)
             add_offense(node,
-                        location: node.parent.loc.expression,
+                        location: range_of_offense(node),
                         message: MSG_REQUIRE_SPACE)
           elsif style == :require_no_space && space_after_arrow?(node)
             add_offense(node,
-                        location: node.parent.loc.expression,
+                        location: range_of_offense(node),
                         message: MSG_REQUIRE_NO_SPACE)
           end
         end
@@ -80,6 +81,13 @@ module RuboCop
           parentheses = lambda_node.parent.children[1]
           parentheses.source_range.begin_pos - arrow.source_range.end_pos > 0
         end
+
+        def range_of_offense(node)
+          range_between(
+            node.parent.loc.expression.begin_pos,
+            node.parent.arguments.loc.expression.end_pos
+          )
+        end
       end
     end
   end