rubocop 0.57.2 → 0.58.0

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

@@ -36,7 +36,7 @@ module RuboCop
         def_node_matcher :redundant_with_object?, <<-PATTERN
           (block
             $(send _ {:each_with_object :with_object}
-              (_))
+              _)
             (args
               (arg _))
             ...)

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

@@ -77,9 +77,7 @@ module RuboCop
             next if references.any? do |reference|
               next true if !reference.explicit? && ignore_implicit_references?
 
-              reference_pos = reference.node.source_range.begin_pos
-
-              reference_pos <= assignment_without_usage_pos
+              reference_pos(reference.node) <= assignment_without_usage_pos
             end
 
             yield location_known ? node : argument.declaration_node
@@ -115,6 +113,12 @@ module RuboCop
           end
         end
 
+        def reference_pos(node)
+          node = node.parent.masgn_type? ? node.parent : node
+
+          node.source_range.begin_pos
+        end
+
         # Check whether the given node is nested into block or conditional.
         #
         def node_within_block_or_conditional?(node, stop_search_node)

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

@@ -44,7 +44,7 @@ module RuboCop
       #   end
       #
       #   case foo
-      #   when *[1, 2, 3]
+      #   when 1, 2, 3
       #     bar
       #   else
       #     baz

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

@@ -134,11 +134,16 @@ module RuboCop
 
           if node.begin_type?
             check_scope(node)
-          elsif node.send_type? && node.bare_access_modifier?
+          elsif node.send_type? && access_modifier?(node)
             add_offense(node, message: format(MSG, current: node.method_name))
           end
         end
 
+        def access_modifier?(node)
+          node.bare_access_modifier? ||
+            node.method_name == :private_class_method
+        end
+
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
 
@@ -147,9 +152,8 @@ module RuboCop
 
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
-            if child.send_type? && child.bare_access_modifier?
-              cur_vis, unused =
-                check_new_visibility(child, unused, child.method_name, cur_vis)
+            if child.send_type? && access_modifier?(child)
+              cur_vis, unused = check_send_node(child, cur_vis, unused)
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -162,6 +166,15 @@ module RuboCop
           [cur_vis, unused]
         end
 
+        def check_send_node(node, cur_vis, unused)
+          if node.bare_access_modifier?
+            check_new_visibility(node, unused, node.method_name, cur_vis)
+          elsif node.method_name == :private_class_method && !node.arguments?
+            add_offense(node, message: format(MSG, current: node.method_name))
+            [cur_vis, unused]
+          end
+        end
+
         def check_new_visibility(node, unused, new_vis, cur_vis)
           # does this modifier just repeat the existing visibility?
           if new_vis == cur_vis

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

@@ -7,6 +7,8 @@ module RuboCop
     module Metrics
       # This cop checks the length of lines in the source code.
       # The maximum length is configurable.
+      # The tab size is configured in the `IndentationWidth`
+      # of the `Layout/Tab` cop.
       class LineLength < Cop
         include ConfigurableMax
         include IgnoredPattern
@@ -23,8 +25,24 @@ module RuboCop
 
         private
 
+        def tab_indentation_width
+          config.for_cop('Layout/Tab')['IndentationWidth']
+        end
+
+        def line_length(line)
+          if tab_indentation_width
+            line = line.gsub("\t", ' ' * tab_indentation_width)
+          end
+          line.length
+        end
+
+        def highligh_start(line)
+          return max unless tab_indentation_width
+          max - (tab_indentation_width - 1) * line.count("\t")
+        end
+
         def check_line(line, index, heredocs)
-          return if line.length <= max
+          return if line_length(line) <= max
           return if ignored_line?(line, index, heredocs)
 
           if ignore_cop_directives? && directive_on_source_line?(index)
@@ -33,7 +51,10 @@ module RuboCop
           return check_uri_line(line, index) if allow_uri?
 
           register_offense(
-            source_range(processed_source.buffer, index + 1, 0...line.length),
+            source_range(
+              processed_source.buffer, index,
+              highligh_start(line)...line_length(line)
+            ),
             line
           )
         end
@@ -44,10 +65,10 @@ module RuboCop
         end
 
         def register_offense(loc, line)
-          message = format(MSG, length: line.length, max: max)
+          message = format(MSG, length: line_length(line), max: max)
 
           add_offense(nil, location: loc, message: message) do
-            self.max = line.length
+            self.max = line_length(line)
           end
         end
 
@@ -59,7 +80,7 @@ module RuboCop
                                end
 
           source_range(processed_source.buffer, index + 1,
-                       excessive_position...(line.length))
+                       excessive_position...(line_length(line)))
         end
 
         def max
@@ -100,7 +121,8 @@ module RuboCop
 
         def allowed_uri_position?(line, uri_range)
           uri_range.begin < max &&
-            (uri_range.end == line.length || uri_range.end == line.length - 1)
+            (uri_range.end == line_length(line) ||
+             uri_range.end == line_length(line) - 1)
         end
 
         def find_excessive_uri_range(line)

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

@@ -11,8 +11,6 @@ module RuboCop
       end
 
       def on_send(node)
-        return unless node.setter_method?
-
         rhs = extract_rhs(node)
 
         return unless rhs

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

@@ -39,7 +39,7 @@ module RuboCop
       end
 
       def length_in_modifier_form(node, cond, body_length)
-        indentation = node.loc.keyword.column
+        indentation = node.loc.keyword.column * indentation_multiplier
         kw_length = node.loc.keyword.size
         cond_length = cond.source_range.size
         space = 1
@@ -49,6 +49,11 @@ module RuboCop
       def max_line_length
         config.for_cop('Metrics/LineLength')['Max']
       end
+
+      def indentation_multiplier
+        return 1 if config.for_cop('Layout/Tab')['Enabled']
+        config.for_cop('Layout/Tab')['IndentationWidth']
+      end
     end
   end
 end

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

@@ -6,7 +6,13 @@ module RuboCop
       # This cop checks for memoized methods whose instance variable name
       # does not match the method name.
       #
-      # @example
+      # This cop can be configured with the EnforcedStyleForLeadingUnderscores
+      # directive. It can be configured to allow for memoized instance variables
+      # prefixed with an underscore. Prefixing ivars with an undersscore is a
+      # convention that is used to implicitly indicate that an ivar should not
+      # be set or referencd outside of the memoization method.
+      #
+      # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
       #   # Method foo is memoized using an instance variable that is
       #   # not `@foo`. This can cause confusion and bugs.
@@ -32,9 +38,44 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing(helper_variable)
       #   end
       #
+      # @example EnforcedStyleForLeadingUnderscores :required
+      #   # bad
+      #   def foo
+      #     @something ||= calculate_expensive_thing
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      # @example EnforcedStyleForLeadingUnderscores :optional
+      #   # bad
+      #   def foo
+      #     @something ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     @_foo ||= calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Cop
+        include ConfigurableEnforcedStyle
+
         MSG = 'Memoized variable `%<var>s` does not match ' \
           'method name `%<method>s`. Use `@%<suggested_var>s` instead.'.freeze
+        UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
+          'with `_`. Use `@%<suggested_var>s` instead.'.freeze
 
         def self.node_pattern
           memo_assign = '(or_asgn $(ivasgn _) _)'
@@ -52,10 +93,11 @@ module RuboCop
         def on_def(node)
           (method_name, ivar_assign) = memoized?(node)
           return if matches?(method_name, ivar_assign)
+
           msg = format(
-            MSG,
+            message(ivar_assign.children.first.to_s),
             var: ivar_assign.children.first.to_s,
-            suggested_var: method_name.to_s.delete('!?'),
+            suggested_var: suggested_var(method_name),
             method: method_name
           )
           add_offense(node, location: ivar_assign.source_range, message: msg)
@@ -64,12 +106,45 @@ module RuboCop
 
         private
 
+        def style_parameter_name
+          'EnforcedStyleForLeadingUnderscores'
+        end
+
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || method_name == :initialize
           method_name = method_name.to_s.delete('!?')
           variable = ivar_assign.children.first
           variable_name = variable.to_s.sub('@', '')
-          variable_name == method_name
+
+          return false unless valid_leading_underscore?(variable_name)
+
+          variable_name.sub(/\A_/, '') == method_name
+        end
+
+        def message(variable)
+          variable_name = variable.to_s.sub('@', '')
+
+          return UNDERSCORE_REQUIRED if style == :required &&
+                                        !variable_name.start_with?('_')
+
+          MSG
+        end
+
+        def suggested_var(method_name)
+          suggestion = method_name.to_s.delete('!?')
+
+          style == :required ? "_#{suggestion}" : suggestion
+        end
+
+        def valid_leading_underscore?(variable_name)
+          case style
+          when :required
+            variable_name.start_with?('_')
+          when :disallowed
+            !variable_name.start_with?('_')
+          else
+            true
+          end
         end
       end
     end

data/lib/rubocop/cop/performance/inefficient_hash_search.rb

@@ -38,11 +38,15 @@ module RuboCop
       #
       class InefficientHashSearch < Cop
         def_node_matcher :inefficient_include?, <<-PATTERN
-          (send $(send _ ${:keys :values}) :include? $_)
+          (send (send $_ {:keys :values}) :include? _)
         PATTERN
 
         def on_send(node)
-          add_offense(node, message: msg(node)) if inefficient_include?(node)
+          inefficient_include?(node) do |receiver|
+            return if receiver.nil?
+
+            add_offense(node)
+          end
         end
 
         def autocorrect(node)
@@ -59,7 +63,7 @@ module RuboCop
 
         private
 
-        def msg(node)
+        def message(node)
           "Use `##{autocorrect_method(node)}` instead of "\
             "`##{current_method(node)}.include?`."
         end
@@ -72,7 +76,7 @@ module RuboCop
         end
 
         def current_method(node)
-          node.children[0].method_name
+          node.receiver.method_name
         end
 
         def use_long_method
@@ -87,7 +91,7 @@ module RuboCop
         end
 
         def autocorrect_hash_expression(node)
-          node.children[0].children[0].loc.expression.source
+          node.receiver.receiver.source
         end
       end
     end

data/lib/rubocop/cop/performance/range_include.rb

@@ -9,11 +9,17 @@ module RuboCop
       # end points of the `Range`. In a great majority of cases, this is what
       # is wanted.
       #
-      # Here is an example of a case where `Range#cover?` may not provide the
-      # desired result:
+      # @example
+      #   # bad
+      #   ('a'..'z').include?('b') # => true
       #
-      #     ('a'..'z').cover?('yellow') # => true
+      #   # good
+      #   ('a'..'z').cover?('b') # => true
       #
+      #   # Example of a case where `Range#cover?` may not provide
+      #   # the desired result:
+      #
+      #   ('a'..'z').cover?('yellow') # => true
       class RangeInclude < Cop
         MSG = 'Use `Range#cover?` instead of `Range#include?`.'.freeze
 

data/lib/rubocop/cop/performance/sample.rb

@@ -11,6 +11,8 @@ module RuboCop
       #   [1, 2, 3].shuffle.first
       #   [1, 2, 3].shuffle.first(2)
       #   [1, 2, 3].shuffle.last
+      #   [2, 1, 3].shuffle.at(0)
+      #   [2, 1, 3].shuffle.slice(0)
       #   [1, 2, 3].shuffle[2]
       #   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
       #   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
@@ -28,7 +30,7 @@ module RuboCop
         MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'.freeze
 
         def_node_matcher :sample_candidate?, <<-PATTERN
-          (send $(send _ :shuffle $...) ${:first :last :[]} $...)
+          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
         PATTERN
 
         def on_send(node)
@@ -57,7 +59,7 @@ module RuboCop
           case method
           when :first, :last
             true
-          when :[]
+          when :[], :at, :slice
             sample_size(method_args) != :unknown
           else
             false
@@ -78,7 +80,7 @@ module RuboCop
           when :erange, :irange
             range_size(arg)
           when :int
-            arg.to_a.first.zero? ? nil : :unknown
+            [0, -1].include?(arg.to_a.first) ? nil : :unknown
           else
             :unknown
           end
@@ -126,7 +128,7 @@ module RuboCop
           case method
           when :first, :last
             extract_source(method_args)
-          when :[]
+          when :[], :slice
             sample_size(method_args)
           end
         end

data/lib/rubocop/cop/rails/bulk_change_table.rb

@@ -76,7 +76,7 @@ module RuboCop
         MYSQL = 'mysql'.freeze
         POSTGRESQL = 'postgresql'.freeze
 
-        MIGRATIION_METHODS = %i[change up down].freeze
+        MIGRATION_METHODS = %i[change up down].freeze
 
         COMBINABLE_TRANSFORMATIONS = %i[
           primary_key
@@ -134,7 +134,7 @@ module RuboCop
 
         def on_def(node)
           return unless support_bulk_alter?
-          return unless MIGRATIION_METHODS.include?(node.method_name)
+          return unless MIGRATION_METHODS.include?(node.method_name)
           return unless node.body
 
           recorder = AlterMethodsRecorder.new
@@ -168,7 +168,7 @@ module RuboCop
 
         # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
         def include_bulk_options?(node)
-          # arguments: [(sym :table) (hash (pair (sym :bulk) _))]
+          # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]
           options = node.arguments[1]
           return false unless options
           options.hash_type? &&
@@ -196,6 +196,8 @@ module RuboCop
           config = yaml['development']
           return nil unless config.is_a?(Hash)
           config
+        rescue Psych::SyntaxError
+          nil
         end
 
         def support_bulk_alter?
@@ -231,7 +233,7 @@ module RuboCop
 
         # @param node [RuboCop::AST::SendNode]
         def add_offense_for_alter_methods(node)
-          # arguments: [(sym :table) ...]
+          # arguments: [{(sym :table)(str "table")} ...]
           table_name = node.arguments[0].value
           message = format(MSG_FOR_ALTER_METHODS, table: table_name)
           add_offense(node, message: message)
@@ -251,9 +253,11 @@ module RuboCop
 
           # @param new_node [RuboCop::AST::SendNode]
           def process(new_node)
-            # arguments: [(sym :table) ...]
-            table_name = new_node.arguments[0]
-            flush unless @nodes.all? { |node| node.arguments[0] == table_name }
+            # arguments: [{(sym :table)(str "table")} ...]
+            table_name = new_node.arguments[0].value.to_s
+            flush unless @nodes.all? do |node|
+              node.arguments[0].value.to_s == table_name
+            end
             @nodes << new_node
           end