rubocop 0.93.0 → 1.3.0

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

@@ -255,7 +255,7 @@ module RuboCop
               PATTERN
             end
 
-            send(matcher_name, child)
+            public_send(matcher_name, child)
           end
         end
 
@@ -279,7 +279,7 @@ module RuboCop
               PATTERN
             end
 
-            send(matcher_name, child)
+            public_send(matcher_name, child)
           end
         end
       end

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

@@ -54,11 +54,9 @@ module RuboCop
         end
 
         def delegating?(node, def_node)
-          if node.nil?
-            false
-          elsif node.zsuper_type?
+          if node&.zsuper_type?
             true
-          elsif node.super_type?
+          elsif node&.super_type?
             node.arguments.map(&:source) == def_node.arguments.map(&:source)
           else
             false

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

@@ -5,6 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
+      # Its auto-correction is marked as unsafe because return value will be changed.
       #
       # NOTE: There are edge cases in which the local variable references a
       # value that is also accessible outside the local scope. This is not
@@ -29,6 +30,8 @@ module RuboCop
       #     x
       #   end
       class UselessSetterCall < Base
+        extend AutoCorrector
+
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -45,7 +48,9 @@ module RuboCop
 
           loc_name = receiver.loc.name
 
-          add_offense(loc_name, message: format(MSG, variable: loc_name.source))
+          add_offense(loc_name, message: format(MSG, variable: loc_name.source)) do |corrector|
+            corrector.insert_after(last_expr, "\n#{indent(last_expr)}#{loc_name.source}")
+          end
         end
         alias on_defs on_def
 

data/lib/rubocop/cop/metrics/class_length.rb

@@ -39,13 +39,19 @@ module RuboCop
         end
 
         def on_casgn(node)
-          if node.parent&.assignment?
-            block_node = node.parent.children[1]
+          parent = node.parent
+
+          if parent&.assignment?
+            block_node = parent.children[1]
+          elsif parent&.parent&.masgn_type?
+            block_node = parent.parent.children[1]
           else
             _scope, _name, block_node = *node
           end
 
-          check_code_length(block_node) if block_node.class_definition?
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
         end
 
         private

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -12,6 +12,9 @@ module RuboCop
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
               '[%<count>d/%<max>d]'
 
+        NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
+        private_constant :NAMED_KEYWORD_TYPES
+
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
@@ -33,7 +36,7 @@ module RuboCop
           if count_keyword_args?
             node.children.size
           else
-            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
           end
         end
 

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -103,7 +103,7 @@ module RuboCop
         # hashes wrapped in a set of curly braces like {foo: 1}.
         # That is, not a kwargs hash. For method calls, this ensures
         # the method call is made with parens.
-        starts_with_bracket = node.loc.begin
+        starts_with_bracket = !node.hash_type? || node.loc.begin
 
         # If the call has a second argument, we can insert a line
         # break before the second argument and the rest of the

data/lib/rubocop/cop/mixin/configurable_numbering.rb

@@ -8,9 +8,9 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
-        non_integer: /[[[:upper:]][[:lower:]]_]$/
+        snake_case:  /(?:\D|_\d+)$/,
+        normalcase:  /(?:\D|[^_\d]\d+)$/,
+        non_integer: /\D$/
       }.freeze
     end
   end

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -57,7 +57,7 @@ module RuboCop
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
-        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+        (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
       end
 
       def tab_indentation_width

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -19,7 +19,8 @@ module RuboCop
       def non_eligible_node?(node)
         node.modifier_form? ||
           node.nonempty_line_count > 3 ||
-          processed_source.line_with_comment?(node.loc.last_line)
+          processed_source.line_with_comment?(node.loc.last_line) ||
+          (first_line_comment(node) && code_after(node))
       end
 
       def non_eligible_body?(body)
@@ -41,11 +42,9 @@ module RuboCop
 
       def length_in_modifier_form(node)
         keyword_element = node.loc.keyword
-        end_element = node.loc.end
         code_before = keyword_element.source_line[0...keyword_element.column]
-        code_after = end_element.source_line[end_element.last_column..-1]
         expression = to_modifier_form(node)
-        line_length("#{code_before}#{expression}#{code_after}")
+        line_length("#{code_before}#{expression}#{code_after(node)}")
       end
 
       def to_modifier_form(node)
@@ -64,6 +63,12 @@ module RuboCop
         comment_source unless comment_disables_cop?(comment_source)
       end
 
+      def code_after(node)
+        end_element = node.loc.end
+        code = end_element.source_line[end_element.last_column..-1]
+        code unless code.empty?
+      end
+
       def parenthesize?(node)
         # Parenthesize corrected expression if changing to modifier-if form
         # would change the meaning of the parent expression

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -14,11 +14,13 @@ module RuboCop
       #   # good
       #   def +(other); end
       class BinaryOperatorParameterName < Base
+        extend AutoCorrector
+
         MSG = 'When defining the `%<opr>s` operator, ' \
               'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
@@ -26,7 +28,15 @@ module RuboCop
 
         def on_def(node)
           op_method_candidate?(node) do |name, arg|
-            add_offense(arg, message: format(MSG, opr: name))
+            add_offense(arg, message: format(MSG, opr: name)) do |corrector|
+              corrector.replace(arg, 'other')
+              node.each_descendant(:lvar, :lvasgn) do |lvar|
+                lvar_location = lvar.loc.name
+                next unless lvar_location.source == arg.source
+
+                corrector.replace(lvar_location, 'other')
+              end
+            end
           end
         end
 

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -30,13 +30,19 @@ module RuboCop
       class HeredocDelimiterCase < Base
         include Heredoc
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          add_offense(node.loc.heredoc_end) do |corrector|
+            expr = node.loc.expression
+
+            corrector.replace(expr, correct_delimiters(expr.source))
+            corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))
+          end
         end
 
         private
@@ -46,14 +52,14 @@ module RuboCop
         end
 
         def correct_case_delimiters?(node)
-          delimiter_string(node) == correct_delimiters(node)
+          delimiter_string(node) == correct_delimiters(delimiter_string(node))
         end
 
-        def correct_delimiters(node)
+        def correct_delimiters(source)
           if style == :uppercase
-            delimiter_string(node).upcase
+            source.upcase
           else
-            delimiter_string(node).downcase
+            source.downcase
           end
         end
       end

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -20,6 +20,11 @@ module RuboCop
       #     @something ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @something if defined?(@something)
+      #     @something = calculate_expensive_thing
+      #   end
+      #
       #   # good
       #   def _foo
       #     @foo ||= calculate_expensive_thing
@@ -54,6 +59,11 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @foo if defined?(@foo)
+      #     @foo = calculate_expensive_thing
+      #   end
+      #
       #   # good
       #   def foo
       #     @_foo ||= calculate_expensive_thing
@@ -64,6 +74,11 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       #
+      #   def foo
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores :optional
       #   # bad
       #   def foo
@@ -84,6 +99,12 @@ module RuboCop
       #   def _foo
       #     @_foo ||= calculate_expensive_thing
       #   end
+      #
+      #   # good
+      #   def foo
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 
@@ -92,32 +113,60 @@ module RuboCop
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
           'with `_`. Use `@%<suggested_var>s` instead.'
 
-        def self.node_pattern
-          memo_assign = '(or_asgn $(ivasgn _) _)'
-          memoized_at_end_of_method = "(begin ... #{memo_assign})"
-          instance_method =
-            "(def $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
-          class_method =
-            "(defs self $_ _ {#{memo_assign} #{memoized_at_end_of_method}})"
-          "{#{instance_method} #{class_method}}"
-        end
+        # rubocop:disable Metrics/AbcSize
+        def on_or_asgn(node)
+          lhs, _value = *node
+          return unless lhs.ivasgn_type?
+          return unless (method_node = node.each_ancestor(:def, :defs).first)
 
-        private_class_method :node_pattern
-        def_node_matcher :memoized?, node_pattern
+          body = method_node.body
+          return unless body == node || body.children.last == node
 
-        def on_def(node)
-          (method_name, ivar_assign) = memoized?(node)
-          return if matches?(method_name, ivar_assign)
+          method_name = method_node.method_name
+          return if matches?(method_name, lhs)
 
           msg = format(
-            message(ivar_assign.children.first.to_s),
-            var: ivar_assign.children.first.to_s,
+            message(lhs.children.first.to_s),
+            var: lhs.children.first.to_s,
             suggested_var: suggested_var(method_name),
             method: method_name
           )
-          add_offense(ivar_assign.source_range, message: msg)
+          add_offense(lhs, message: msg)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def_node_matcher :defined_memoized?, <<~PATTERN
+          (begin
+            (if (defined $(ivar %1)) (return $(ivar %1)) nil?)
+            ...
+            $(ivasgn %1 _))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def on_defined?(node)
+          arg = node.arguments.first
+          return unless arg.ivar_type?
+
+          method_node = node.each_ancestor(:def, :defs).first
+          return unless method_node
+
+          var_name = arg.children.first
+          method_name = method_node.method_name
+          defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
+            return if matches?(method_name, ivar_assign)
+
+            msg = format(
+              message(var_name.to_s),
+              var: var_name.to_s,
+              suggested_var: suggested_var(method_name),
+              method: method_name
+            )
+            add_offense(defined_ivar, message: msg)
+            add_offense(return_ivar, message: msg)
+            add_offense(ivar_assign.loc.name, message: msg)
+          end
         end
-        alias on_defs on_def
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -67,7 +67,8 @@ module RuboCop
         private
 
         def allowed_method_name?(method_name, prefix)
-          !method_name.match?(/^#{prefix}[^0-9]/) ||
+          !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
+              method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
             allowed_method?(method_name)

data/lib/rubocop/cop/naming/variable_number.rb

@@ -7,42 +7,102 @@ module RuboCop
       # configured style, snake_case, normalcase, or non_integer,
       # for their numbering.
       #
+      # Additionally, `CheckMethodNames` and `CheckSymbols` configuration options
+      # can be used to specify whether method names and symbols should be checked.
+      # Both are enabled by default.
+      #
       # @example EnforcedStyle: snake_case
       #   # bad
-      #
+      #   :some_sym1
       #   variable1 = 1
       #
-      #   # good
+      #   def some_method1; end
       #
+      #   def some_method_1(arg1); end
+      #
+      #   # good
+      #   :some_sym_1
       #   variable_1 = 1
       #
+      #   def some_method_1; end
+      #
+      #   def some_method_1(arg_1); end
+      #
       # @example EnforcedStyle: normalcase (default)
       #   # bad
-      #
+      #   :some_sym_1
       #   variable_1 = 1
       #
-      #   # good
+      #   def some_method_1; end
       #
+      #   def some_method1(arg_1); end
+      #
+      #   # good
+      #   :some_sym1
       #   variable1 = 1
       #
+      #   def some_method1; end
+      #
+      #   def some_method1(arg1); end
+      #
       # @example EnforcedStyle: non_integer
       #   # bad
+      #   :some_sym1
+      #   :some_sym_1
       #
       #   variable1 = 1
-      #
       #   variable_1 = 1
       #
+      #   def some_method1; end
+      #
+      #   def some_method_1; end
+      #
+      #   def some_methodone(arg1); end
+      #   def some_methodone(arg_1); end
+      #
       #   # good
+      #   :some_symone
+      #   :some_sym_one
       #
       #   variableone = 1
-      #
       #   variable_one = 1
+      #
+      #   def some_methodone; end
+      #
+      #   def some_method_one; end
+      #
+      #   def some_methodone(argone); end
+      #   def some_methodone(arg_one); end
+      #
+      #   # In the following examples, we assume `EnforcedStyle: normalcase` (default).
+      #
+      # @example CheckMethodNames: true (default)
+      #   # bad
+      #   def some_method_1; end
+      #
+      # @example CheckMethodNames: false
+      #   # good
+      #   def some_method_1; end
+      #
+      # @example CheckSymbols: true (default)
+      #   # bad
+      #   :some_sym_1
+      #
+      # @example CheckSymbols: false
+      #   # good
+      #   :some_sym_1
+      #
+      # @example AllowedIdentifier: [capture3]
+      #   # good
+      #   expect(Open3).to receive(:capture3)
+      #
       class VariableNumber < Base
         include ConfigurableNumbering
 
-        MSG = 'Use %<style>s for variable numbers.'
+        MSG = 'Use %<style>s for %<identifier_type>s numbers.'
 
         def on_arg(node)
+          @node = node
           name, = *node
           check_name(node, name, node.loc.name)
         end
@@ -50,10 +110,40 @@ module RuboCop
         alias on_ivasgn on_arg
         alias on_cvasgn on_arg
 
+        def on_def(node)
+          @node = node
+          return if allowed_identifier?(node.method_name)
+
+          check_name(node, node.method_name, node.loc.name) if cop_config['CheckMethodNames']
+        end
+        alias on_defs on_def
+
+        def on_sym(node)
+          @node = node
+          return if allowed_identifier?(node.value)
+
+          check_name(node, node.value, node) if cop_config['CheckSymbols']
+        end
+
         private
 
         def message(style)
-          format(MSG, style: style)
+          identifier_type =
+            case @node.type
+            when :def, :defs then 'method name'
+            when :sym        then 'symbol'
+            else                  'variable'
+            end
+
+          format(MSG, style: style, identifier_type: identifier_type)
+        end
+
+        def allowed_identifier?(name)
+          allowed_identifiers.include?(name.to_s)
+        end
+
+        def allowed_identifiers
+          cop_config.fetch('AllowedIdentifiers', [])
         end
       end
     end