rubocop 0.90.0 → 0.91.0

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

@@ -26,6 +26,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove unnecessary `require` statement.'
+        RESTRICT_ON_SEND = %i[require].freeze
 
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require

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

@@ -40,10 +40,12 @@ module RuboCop
 
         MSG = 'Use `%<method>s %<module_name>s` instead of `%<bad_method>s`.'
         MIXIN_METHODS = %i[include prepend extend].freeze
+        SEND_METHODS = %i[send public_send __send__].freeze
+        RESTRICT_ON_SEND = SEND_METHODS
 
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
-            (const _ _) {:send :public_send :__send__}
+            (const _ _) {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
               $(const _ _))
         PATTERN

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

@@ -24,6 +24,7 @@ module RuboCop
       class StructNewOverride < Base
         MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
               ' and it may be unexpected.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         STRUCT_METHOD_NAMES = Struct.instance_methods
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze

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

@@ -9,12 +9,23 @@ module RuboCop
       # for an optional argument, your method should too.
       #
       # @example
-      #   # bad
-      #   def to_json
-      #   end
+      #   class Point
+      #     attr_reader :x, :y
+      #
+      #     # bad, incorrect arity
+      #     def to_json
+      #       JSON.generate([x, y])
+      #     end
+      #
+      #     # good, preserving args
+      #     def to_json(*args)
+      #       JSON.generate([x, y], *args)
+      #     end
       #
-      #   # good
-      #   def to_json(*_args)
+      #     # good, discarding args
+      #     def to_json(*_args)
+      #       JSON.generate([x, y])
+      #     end
       #   end
       #
       class ToJSON < Base

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

@@ -130,7 +130,8 @@ module RuboCop
           case node.type
           when :begin, :kwbegin
             statements = *node
-            statements.any? { |statement| break_statement?(statement) }
+            break_statement = statements.find { |statement| break_statement?(statement) }
+            break_statement && !preceded_by_continue_statement?(break_statement)
           when :if
             check_if(node)
           when :case

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

@@ -44,10 +44,12 @@ module RuboCop
         MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
               'Instead, use %<replacements>s depending on your specific use ' \
               'case.'
+        METHOD_NAMES = %i[escape encode unescape decode].freeze
+        RESTRICT_ON_SEND = METHOD_NAMES
 
         def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
-            (const ${nil? cbase} :URI) ${:escape :encode :unescape :decode}
+            (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}
             ...)
         PATTERN
 

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

@@ -18,9 +18,10 @@ module RuboCop
 
         MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
         URI_CONSTANTS = ['URI', '::URI'].freeze
+        RESTRICT_ON_SEND = %i[regexp].freeze
 
         def on_send(node)
-          return unless node.method?(:regexp) && node.receiver
+          return unless node.receiver
           return unless URI_CONSTANTS.include?(node.receiver.source)
 
           argument = node.first_argument ? "(#{node.first_argument.source})" : ''

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

@@ -12,32 +12,26 @@ module RuboCop
       # @example
       #   # bad
       #   def initialize
+      #     super
       #   end
       #
       #   def method
       #     super
       #   end
       #
-      #   # good
-      #   def initialize
-      #     initialize_internals
-      #   end
-      #
-      #   def method
+      #   # good - with default arguments
+      #   def initialize(x = Object.new)
       #     super
-      #     do_something_else
       #   end
       #
-      # @example AllowComments: true (default)
       #   # good
       #   def initialize
-      #     # Comment.
+      #     super
+      #     initialize_internals
       #   end
       #
-      # @example AllowComments: false
-      #   # bad
-      #   def initialize
-      #     # Comment.
+      #   def method(*args)
+      #     super(:extra_arg, *args)
       #   end
       #
       class UselessMethodDefinition < Base
@@ -46,8 +40,8 @@ module RuboCop
         MSG = 'Useless method definition detected.'
 
         def on_def(node)
-          return unless (constructor?(node) && empty_constructor?(node)) ||
-                        delegating?(node.body, node)
+          return if optional_args?(node)
+          return unless delegating?(node.body, node)
 
           add_offense(node) { |corrector| corrector.remove(node) }
         end
@@ -55,21 +49,20 @@ module RuboCop
 
         private
 
-        def empty_constructor?(node)
-          return false if node.body
-          return false if cop_config['AllowComments'] && comment_lines?(node)
-
-          true
-        end
-
-        def constructor?(node)
-          node.def_type? && node.method?(:initialize)
+        def optional_args?(node)
+          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
         end
 
         def delegating?(node, def_node)
-          return false unless node&.super_type? || node&.zsuper_type?
-
-          !node.arguments? || node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          if node.nil?
+            false
+          elsif node.zsuper_type?
+            true
+          elsif node.super_type?
+            node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          else
+            false
+          end
         end
       end
     end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of `Integer#times` that will never yield
+      # (when the integer <= 0) or that will only ever yield once
+      # (`1.times`).
+      #
+      # This cop is marked as unsafe as `times` returns its receiver, which
+      # is *usually* OK, but might change behavior.
+      #
+      # @example
+      #   # bad
+      #   -5.times { do_something }
+      #   0.times { do_something }
+      #   1.times { do_something  }
+      #   1.times { |i| do_something(i) }
+      #
+      #   # good
+      #   do_something
+      #   do_something(1)
+      class UselessTimes < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Useless call to `%<count>i.times` detected.'
+        RESTRICT_ON_SEND = %i[times].freeze
+
+        def_node_matcher :times_call?, <<~PATTERN
+          (send (int $_) :times (block-pass (sym $_))?)
+        PATTERN
+
+        def_node_matcher :block_arg, <<~PATTERN
+          (block _ (args (arg $_)) ...)
+        PATTERN
+
+        def_node_search :block_reassigns_arg?, <<~PATTERN
+          (lvasgn %)
+        PATTERN
+
+        def on_send(node)
+          return unless (count, proc_name = times_call?(node))
+          return if count > 1
+
+          # Get the block node if applicable
+          node = node.block_node if node.block_literal?
+
+          add_offense(node, message: format(MSG, count: count)) do |corrector|
+            next unless own_line?(node)
+
+            if count < 1
+              remove_node(corrector, node)
+            elsif !proc_name.empty?
+              autocorrect_block_pass(corrector, node, proc_name)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def remove_node(corrector, node)
+          corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
+        end
+
+        def autocorrect_block_pass(corrector, node, proc_name)
+          corrector.replace(node, proc_name)
+        end
+
+        def autocorrect_block(corrector, node)
+          block_arg = block_arg(node)
+          return if block_reassigns_arg?(node, block_arg)
+
+          source = node.body.source
+          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+
+          corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
+        end
+
+        def fix_indentation(source, range)
+          # Cleanup indentation in a multiline block
+          source_lines = source.split("\n")
+          source_lines[1..-1].each { |line| line[range] = '' }
+          source_lines.join("\n")
+        end
+
+        def own_line?(node)
+          # If there is anything else on the line other than whitespace,
+          # don't try to autocorrect
+          processed_source.buffer.source_line(node.loc.line)[0...node.loc.column] !~ /\S/
+        end
+      end
+    end
+  end
+end

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

@@ -7,15 +7,9 @@ module RuboCop
       include VisibilityHelp
 
       def source_range_with_comment(node)
-        begin_pos, end_pos =
-          if node.def_type?
-            start_node = find_visibility_start(node) || node
-            end_node = find_visibility_end(node) || node
-            [begin_pos_with_comment(start_node),
-             end_position_for(end_node) + 1]
-          else
-            [begin_pos_with_comment(node), end_position_for(node)]
-          end
+        begin_pos = begin_pos_with_comment(node)
+        end_pos = end_position_for(node)
+        end_pos += 1 if node.def_type?
 
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end

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

@@ -8,8 +8,8 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}(?:_|_?[a-z][\da-zA-Z]*)[!?=]?$/
+        snake_case: /^@{0,2}[\d[[:lower:]]_]+[!?=]?$/,
+        camelCase:  /^@{0,2}(?:_|_?[[[:lower:]]][\d[[:lower:]][[:upper:]]]*)[!?=]?$/
       }.freeze
     end
   end

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

@@ -39,6 +39,15 @@ module RuboCop
         end
       end
 
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
+
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
+      end
+
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
         msg = format(MSG, end_line: end_loc.line,

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

@@ -4,7 +4,15 @@ module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
     # Style/HashTransformValues
-    module HashTransformMethod
+    module HashTransformMethod # rubocop:disable Metrics/ModuleLength
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[[] to_h].freeze
+
+      def_node_matcher :array_receiver?, <<~PATTERN
+        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      PATTERN
+
       def on_block(node)
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')

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

@@ -35,7 +35,7 @@ module RuboCop
         def op_method?(name)
           return false if EXCLUDED.include?(name)
 
-          !/\A\w/.match?(name) || OP_LIKE_METHODS.include?(name)
+          !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
       end
     end

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

@@ -33,7 +33,7 @@ module RuboCop
                             'called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
-        SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
+        SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
         def on_new_investigation
           file_path = processed_source.file_path

data/lib/rubocop/cop/security/eval.rb

@@ -13,6 +13,7 @@ module RuboCop
       #   binding.eval(something)
       class Eval < Base
         MSG = 'The use of `eval` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[eval].freeze
 
         def_node_matcher :eval?, <<~PATTERN
           (send {nil? (send nil? :binding)} :eval $!str ...)

data/lib/rubocop/cop/security/json_load.rb

@@ -26,6 +26,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
 
         def_node_matcher :json_load, <<~PATTERN
           (send (const {nil? cbase} :JSON) ${:load :restore} ...)

data/lib/rubocop/cop/security/marshal_load.rb

@@ -20,6 +20,7 @@ module RuboCop
       #
       class MarshalLoad < Base
         MSG = 'Avoid using `Marshal.%<method>s`.'
+        RESTRICT_ON_SEND = %i[load restore].freeze
 
         def_node_matcher :marshal_load, <<~PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}

data/lib/rubocop/cop/security/open.rb

@@ -21,6 +21,7 @@ module RuboCop
       #   URI.parse(something).open
       class Open < Base
         MSG = 'The use of `Kernel#open` is a serious security risk.'
+        RESTRICT_ON_SEND = %i[open].freeze
 
         def_node_matcher :open?, <<~PATTERN
           (send nil? :open $!str ...)

data/lib/rubocop/cop/security/yaml_load.rb

@@ -19,6 +19,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
+        RESTRICT_ON_SEND = %i[load].freeze
 
         def_node_matcher :yaml_load, <<~PATTERN
           (send (const {nil? cbase} :YAML) :load ...)

data/lib/rubocop/cop/style/access_modifier_declarations.rb

@@ -65,8 +65,6 @@ module RuboCop
       class AccessModifierDeclarations < Base
         include ConfigurableEnforcedStyle
 
-        ACCESS_MODIFIERS = %i[private protected public module_function].to_set.freeze
-
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
           'inlined in method definitions.'
@@ -77,12 +75,14 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        RESTRICT_ON_SEND = %i[private protected public module_function].freeze
+
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public} (sym _))
         PATTERN
 
         def on_send(node)
-          return unless access_modifier?(node)
+          return unless node.access_modifier?
           return if node.parent.pair_type?
           return if cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
 
@@ -95,14 +95,6 @@ module RuboCop
 
         private
 
-        def access_modifier?(node)
-          maybe_access_modifier?(node) && node.access_modifier?
-        end
-
-        def maybe_access_modifier?(node)
-          !node.receiver && ACCESS_MODIFIERS.include?(node.method_name)
-        end
-
         def offense?(node)
           (group_style? && access_modifier_is_inlined?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))