rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -18,8 +18,7 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autofixer will default to `start_of_line`.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: either (default)
       #   # bad
       #
       #   foo.bar
@@ -27,19 +26,19 @@ module RuboCop
       #        baz
       #          end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: either (default)
-      #
       #   # good
       #
       #   variable = lambda do |i|
       #     i
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_block
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_block
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
       #
       #   # good
       #
@@ -48,9 +47,13 @@ module RuboCop
       #        baz
       #      end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_line
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
       #
       #   # good
       #
@@ -80,6 +83,19 @@ module RuboCop
           'EnforcedStyleAlignWith'
         end
 
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta > 0
+            add_space_before(loc_end, delta)
+          elsif delta < 0
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
+        end
+
         private
 
         def start_for_block_node(block_node)
@@ -211,19 +227,6 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta > 0
-            add_space_before(loc_end, delta)
-          elsif delta < 0
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
         def add_space_before(loc, delta)
           ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
         end

data/lib/rubocop/cop/lint/boolean_symbol.rb

@@ -30,7 +30,7 @@ module RuboCop
         def on_sym(node)
           return unless boolean_symbol?(node)
 
-          add_offense(node, message: format(MSG, node.to_a.first))
+          add_offense(node, message: format(MSG, node.value))
         end
       end
     end

data/lib/rubocop/cop/lint/def_end_alignment.rb

@@ -12,25 +12,22 @@ module RuboCop
       # keyword is. If it's set to `def`, the `end` shall be aligned with the
       # `def` keyword.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
       #   # bad
       #
       #   private def foo
       #               end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: start_of_line (default)
-      #
       #   # good
       #
       #   private def foo
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: def
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: def
+      #   private def foo
+      #               end
       #
       #   # good
       #
@@ -63,8 +60,6 @@ module RuboCop
           ignore_node(method_def) # Don't check the same `end` again.
         end
 
-        private
-
         def autocorrect(node)
           if style == :start_of_line && node.parent && node.parent.send_type?
             align(node, node.parent)

data/lib/rubocop/cop/lint/else_layout.rb

@@ -12,7 +12,7 @@ module RuboCop
       #   # bad
       #
       #   if something
-      #     ...
+      #     # ...
       #   else do_this
       #     do_that
       #   end
@@ -22,7 +22,7 @@ module RuboCop
       #   # good
       #
       #   if something
-      #     ...
+      #     # ...
       #   else
       #     do_this
       #     do_that

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

@@ -17,34 +17,33 @@ module RuboCop
       # If it's set to `start_of_line`, the `end` shall be aligned with the
       # start of the line where the matching keyword appears.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad
       #
       #   variable = if true
       #       end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: keyword (default)
-      #
       #   # good
       #
       #   variable = if true
       #              end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: variable
+      #   variable = if true
+      #       end
       #
       #   # good
       #
       #   variable = if true
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_line
+      #   variable = if true
+      #       end
       #
       #   # good
       #
@@ -82,6 +81,10 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          align(node, alignment_node(node))
+        end
+
         private
 
         def check_assignment(node, rhs)
@@ -125,10 +128,6 @@ module RuboCop
           check_end_kw_alignment(node, align_with)
         end
 
-        def autocorrect(node)
-          align(node, alignment_node(node))
-        end
-
         def alignment_node(node)
           if style == :keyword
             node

data/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -96,7 +96,7 @@ module RuboCop
         end
 
         def check_scope(node, cur_vis = :public)
-          node.children.reduce(cur_vis) do |visibility, child|
+          node.each_child_node.reduce(cur_vis) do |visibility, child|
             check_child_scope(child, visibility)
           end
         end
@@ -133,14 +133,13 @@ module RuboCop
         end
 
         def mark_method_as_useless(node, cur_vis)
-          _, method_name, = *node
-          @useless[method_name] = [node, cur_vis, @last_access_modifier]
+          @useless[node.method_name] = [node, cur_vis, @last_access_modifier]
         end
 
         def revert_method_uselessness(methods)
           methods.each do |sym|
             next unless sym.sym_type?
-            @useless.delete(sym.children[0])
+            @useless.delete(sym.value)
           end
         end
       end

data/lib/rubocop/cop/lint/inherit_exception.rb

@@ -8,23 +8,19 @@ module RuboCop
       # `StandardError`. It is configurable to suggest using either
       # `RuntimeError` (default) or `StandardError` instead.
       #
-      # @example
-      #
+      # @example EnforcedStyle: runtime_error (default)
       #   # bad
       #
       #   class C < Exception; end
       #
-      # @example
-      #
-      #   # EnforcedStyle: runtime_error (default)
-      #
       #   # good
       #
       #   class C < RuntimeError; end
       #
-      # @example
+      # @example EnforcedStyle: standard_error
+      #   # bad
       #
-      #   # EnforcedStyle: standard_error
+      #   class C < Exception; end
       #
       #   # good
       #
@@ -59,18 +55,18 @@ module RuboCop
           add_offense(base_class)
         end
 
-        private
-
-        def message(node)
-          format(MSG, preferred_base_class, node.const_name)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.loc.expression, preferred_base_class)
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, preferred_base_class, node.const_name)
+        end
+
         def illegal_class_name?(class_node)
           ILLEGAL_CLASSES.include?(class_node.const_name)
         end

data/lib/rubocop/cop/lint/missing_cop_enable_directive.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnneededDisable
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks that there is an `# rubocop:enable ...` statement
+      # after a `# rubocop:disable ...` statement. This will prevent leaving
+      # cop disables on wide ranges of code, that latter contributors to
+      # a file wouldn't be aware of.
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: .inf
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #   # y = 1
+      #   # EOF
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # EOF
+      #
+      # @example
+      #   # Lint/MissingCopEnableDirective:
+      #   #   MaximumRangeSize: 2
+      #
+      #   # good
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   # With the previous, there are 2 lines on which cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   # rubocop:disable Layout/SpaceAroundOperators
+      #   x= 0
+      #   x += 1
+      #   # Including this, that's 3 lines on which the cop is disabled.
+      #   # rubocop:enable Layout/SpaceAroundOperators
+      #
+      class MissingCopEnableDirective < Cop
+        MSG = 'Re-enable %{cop} cop with `# rubocop:enable` after disabling it.'
+              .freeze
+        MSG_BOUND = 'Re-enable %{cop} cop within %{max_range} lines after ' \
+                    'disabling it.'.freeze
+
+        def investigate(processed_source)
+          max_range = cop_config['MaximumRangeSize']
+          processed_source.disabled_line_ranges.each do |cop, line_ranges|
+            line_ranges.each do |line_range|
+              # This has to remain a strict inequality to handle
+              # the case when max_range is Float::INFINITY
+              next if line_range.max - line_range.min < max_range + 2
+              range = source_range(processed_source.buffer,
+                                   line_range.min,
+                                   (0..0))
+              add_offense(range,
+                          location: range,
+                          message: message(max_range: max_range, cop: cop))
+            end
+          end
+        end
+
+        private
+
+        def message(max_range:, cop:)
+          if max_range == Float::INFINITY
+            format(MSG, cop: cop)
+          else
+            format(MSG_BOUND, cop: cop, max_range: max_range)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededDisable, Layout/SpaceAroundOperators

data/lib/rubocop/cop/lint/nested_percent_literal.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for nested percent literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The percent literal for nested_attributes is parsed as four tokens,
+      #   # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"].
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: %i[name content %i[incorrectly nested]]
+      #   }
+      class NestedPercentLiteral < Cop
+        include PercentLiteral
+
+        MSG = 'Within percent literals, nested percent literals do not ' \
+          'function and may be unwanted in the result.'.freeze
+
+        # The array of regular expressions representing percent literals that,
+        # if found within a percent literal expression, will cause a
+        # NestedPercentLiteral violation to be emitted.
+        REGEXES = PercentLiteral::PERCENT_LITERAL_TYPES.map do |percent_literal|
+          /#{percent_literal}\W/
+        end.freeze
+
+        def on_array(node)
+          process(node, *PercentLiteral::PERCENT_LITERAL_TYPES)
+        end
+
+        def on_percent_literal(node)
+          add_offense(node) if contains_percent_literals?(node)
+        end
+
+        private
+
+        def str_content(node)
+          if node.str_type?
+            node.children[0]
+          else
+            node.children.map { |c| str_content(c) }.join
+          end
+        end
+
+        def contains_percent_literals?(node)
+          node.each_child_node.any? do |child|
+            literal = child.children.first.to_s.scrub
+            REGEXES.any? { |regex| literal.match(regex) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -18,13 +18,13 @@ module RuboCop
       #
       #   class ItemApi
       #     rescue_from ValidationError do |e| # non-iteration block with arg
-      #       return message: 'validation error' unless e.errors # allowed
+      #       return { message: 'validation error' } unless e.errors # allowed
       #       error_array = e.errors.map do |error| # block with method chain
       #         return if error.suppress? # warned
       #         return "#{error.param}: invalid" unless error.message # allowed
       #         "#{error.param}: #{error.message}"
       #       end
-      #       message: 'validation error', errors: error_array
+      #       { message: 'validation error', errors: error_array }
       #     end
       #
       #     def update_items