rubocop 0.48.1 → 1.16.0

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

@@ -9,41 +9,76 @@ module RuboCop
       # Unfortunately we cannot actually know if a method is from
       # Enumerable or not (static analysis limitation), so this cop
       # can yield some false positives.
-      class CollectionMethods < Cop
+      #
+      # You can customize the mapping from undesired method to desired method.
+      #
+      # e.g. to use `detect` over `find`:
+      #
+      #   Style/CollectionMethods:
+      #     PreferredMethods:
+      #       find: detect
+      #
+      # The default mapping for `PreferredMethods` behaves as follows.
+      #
+      # @example
+      #   # bad
+      #   items.collect
+      #   items.collect!
+      #   items.inject
+      #   items.detect
+      #   items.find_all
+      #   items.member?
+      #
+      #   # good
+      #   items.map
+      #   items.map!
+      #   items.reduce
+      #   items.find
+      #   items.select
+      #   items.include?
+      #
+      class CollectionMethods < Base
         include MethodPreference
+        extend AutoCorrector
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_block(node)
-          method, _args, _body = *node
-
-          check_method_node(method)
+          check_method_node(node.send_node)
         end
 
         def on_send(node)
-          return unless node.arguments.one? &&
-                        node.first_argument.block_pass_type?
+          return unless implicit_block?(node)
 
           check_method_node(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
+        private
+
+        def check_method_node(node)
+          return unless preferred_methods[node.method_name]
+
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
           end
         end
 
-        private
+        def implicit_block?(node)
+          return false unless node.arguments.any?
 
-        def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
+          node.last_argument.block_pass_type? ||
+            node.last_argument.sym_type? && methods_accepting_symbol.include?(node.method_name.to_s)
         end
 
-        def check_method_node(node)
-          return unless preferred_methods[node.method_name]
+        def message(node)
+          format(MSG, prefer: preferred_method(node.method_name), current: node.method_name)
+        end
 
-          add_offense(node, :selector)
+        # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead
+        # of a block.
+        def methods_accepting_symbol
+          Array(cop_config['MethodsAcceptingSymbol'])
         end
       end
     end

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

@@ -5,27 +5,40 @@ module RuboCop
     module Style
       # This cop checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
-      class ColonMethodCall < Cop
-        MSG = 'Do not use `::` for method calls.'.freeze
+      #
+      # @example
+      #   # bad
+      #   Timeout::timeout(500) { do_something }
+      #   FileUtils::rmdir(dir)
+      #   Marshal::dump(obj)
+      #
+      #   # good
+      #   Timeout.timeout(500) { do_something }
+      #   FileUtils.rmdir(dir)
+      #   Marshal.dump(obj)
+      #
+      class ColonMethodCall < Base
+        extend AutoCorrector
 
-        def_node_matcher :java_type_node?, <<-PATTERN
+        MSG = 'Do not use `::` for method calls.'
+
+        # @!method java_type_node?(node)
+        def_node_matcher :java_type_node?, <<~PATTERN
           (send
-            (const nil :Java)
-            {:boolean :byte :char :double :float :int :long :short})
+            (const nil? :Java) _)
         PATTERN
 
-        def on_send(node)
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
+        def self.autocorrect_incompatible_with
+          [RedundantSelf]
+        end
 
+        def on_send(node)
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
 
-          add_offense(node, :dot)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+          add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Do not use `::` for defining class methods.'
+
+        def on_defs(node)
+          return unless node.loc.operator.source == '::'
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where multiple consecutive loops over the same data
+      # can be combined into a single loop. It is very likely that combining them
+      # will make the code more efficient and more concise.
+      #
+      # It is marked as unsafe, because the first loop might modify
+      # a state that the second loop depends on; these two aren't combinable.
+      #
+      # @example
+      #   # bad
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #     end
+      #
+      #     items.each do |item|
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #     end
+      #
+      #     for item in items do
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     each_slice(2) { |slice| do_something(slice) }
+      #     each_slice(3) { |slice| do_something(slice) }
+      #   end
+      #
+      class CombinableLoops < Base
+        MSG = 'Combine this loop with the previous loop.'
+
+        def on_block(node)
+          return unless node.parent&.begin_type?
+          return unless collection_looping_method?(node)
+
+          add_offense(node) if same_collection_looping?(node, node.left_sibling)
+        end
+
+        def on_for(node)
+          return unless node.parent&.begin_type?
+
+          sibling = node.left_sibling
+          add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        private
+
+        def collection_looping_method?(node)
+          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+          method_name = node.send_node.method_name.to_s
+          method_name.start_with?('each') || method_name.end_with?('_each')
+        end
+
+        def same_collection_looping?(node, sibling)
+          sibling&.block_type? &&
+            sibling.send_node.method?(node.method_name) &&
+            sibling.send_node.receiver == node.send_node.receiver &&
+            sibling.send_node.arguments == node.send_node.arguments
+        end
+      end
+    end
+  end
+end

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

@@ -5,68 +5,138 @@ module RuboCop
     module Style
       # This cop enforces using `` or %x around command literals.
       #
-      # @example
-      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
       #   folders = `find . -type d`.split
       #
-      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
       #   folders = %x(find . -type d).split
       #
-      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   # bad
       #   `
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   `
       #
-      #   # Good if EnforcedStyle is percent_x or mixed, bad if backticks.
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
       #   %x(
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   )
       #
-      #   # Bad unless AllowInnerBackticks is true.
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
       #   `echo \`ls\``
-      class CommandLiteral < Cop
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
+      #   `echo \`ls\``
+      class CommandLiteral < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG_USE_BACKTICKS = 'Use backticks around command string.'.freeze
-        MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
 
         def on_xstr(node)
-          return if heredoc_literal?(node)
+          return if node.heredoc?
 
           if backtick_literal?(node)
-            check_backtick_literal(node)
+            check_backtick_literal(node, MSG_USE_PERCENT_X)
           else
-            check_percent_x_literal(node)
+            check_percent_x_literal(node, MSG_USE_BACKTICKS)
           end
         end
 
         private
 
-        def check_backtick_literal(node)
+        def check_backtick_literal(node, message)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_PERCENT_X)
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
-        def check_percent_x_literal(node)
+        def check_percent_x_literal(node, message)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node, :expression, MSG_USE_BACKTICKS)
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
         end
 
         def allowed_backtick_literal?(node)
-          style == :backticks && !contains_disallowed_backtick?(node) ||
-            style == :mixed && node.single_line? &&
-              !contains_disallowed_backtick?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
         end
 
         def allowed_percent_x_literal?(node)
-          style == :backticks && contains_disallowed_backtick?(node) ||
-            style == :percent_x ||
-            style == :mixed && node.multiline? ||
-            style == :mixed && contains_disallowed_backtick?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
         end
 
         def contains_disallowed_backtick?(node)
@@ -78,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          node_body(node) =~ /`/
+          /`/.match?(node_body(node))
         end
 
         def node_body(node)
@@ -86,32 +156,24 @@ module RuboCop
           loc.expression.source[loc.begin.length...-loc.end.length]
         end
 
-        def heredoc_literal?(node)
-          node.loc.respond_to?(:heredoc_body)
-        end
-
         def backtick_literal?(node)
           node.loc.begin.source == '`'
         end
 
-        def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%x'].split(//)
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).chars
         end
 
-        def autocorrect(node)
-          return if contains_backtick?(node)
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
 
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w[` `]
-                        end
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
 
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
+        def preferred_delimiters_config
+          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
         end
       end
     end