rubocop 0.89.1 → 0.90.0

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using `def self.method_name` or `class << self` to define class methods.
+      #
+      # @example EnforcedStyle: def_self (default)
+      #   # bad
+      #   class SomeClass
+      #     class << self
+      #       attr_accessor :class_accessor
+      #
+      #       def class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #
+      #     class << self
+      #       attr_accessor :class_accessor
+      #     end
+      #   end
+      #
+      #   # good - contains private method
+      #   class SomeClass
+      #     class << self
+      #       attr_accessor :class_accessor
+      #
+      #       private
+      #
+      #       def private_class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: self_class
+      #   # bad
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     class << self
+      #       def class_method
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
+      class ClassMethodsDefinitions < Base
+        include ConfigurableEnforcedStyle
+        include CommentsHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s` to define class method.'
+
+        def on_sclass(node)
+          return unless def_self_style?
+          return unless node.identifier.source == 'self'
+          return if contains_non_public_methods?(node)
+
+          def_nodes(node).each do |def_node|
+            next unless node_visibility(def_node) == :public
+
+            message = format(MSG, preferred: "def self.#{def_node.method_name}")
+            add_offense(def_node, message: message) do |corrector|
+              extract_def_from_sclass(def_node, node, corrector)
+            end
+          end
+        end
+
+        def on_defs(node)
+          return if def_self_style?
+
+          message = format(MSG, preferred: 'class << self')
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def def_self_style?
+          style == :def_self
+        end
+
+        def contains_non_public_methods?(sclass_node)
+          def_nodes(sclass_node).any? { |def_node| node_visibility(def_node) != :public }
+        end
+
+        def def_nodes(sclass_node)
+          sclass_def = sclass_node.body
+          return [] unless sclass_def
+
+          if sclass_def.def_type?
+            [sclass_def]
+          elsif sclass_def.begin_type?
+            sclass_def.each_child_node(:def).to_a
+          else
+            []
+          end
+        end
+
+        def extract_def_from_sclass(def_node, sclass_node, corrector)
+          range = source_range_with_comment(def_node)
+          source = range.source.sub!(
+            "def #{def_node.method_name}",
+            "def self.#{def_node.method_name}"
+          )
+
+          corrector.insert_before(sclass_node, "#{source}\n#{indent(sclass_node)}")
+          corrector.remove(range)
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# 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
+      #
+      class CombinableLoops < Base
+        MSG = 'Combine this loop with the previous loop.'
+
+        def on_block(node)
+          return unless collection_looping_method?(node)
+
+          sibling = left_sibling_of(node)
+          add_offense(node) if same_collection_looping?(node, sibling)
+        end
+
+        def on_for(node)
+          sibling = left_sibling_of(node)
+          add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        private
+
+        def collection_looping_method?(node)
+          method_name = node.send_node.method_name
+          method_name.match?(/^each/) || method_name.match?(/_each$/)
+        end
+
+        def left_sibling_of(node)
+          return unless node.parent&.begin_type?
+
+          index = node.sibling_index - 1
+          node.parent.children[index] if index >= 0
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -21,9 +21,10 @@ module RuboCop
       #
       #   # good
       #   a { do_something }
-      class EmptyBlockParameter < Cop
+      class EmptyBlockParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit pipes for the empty block parameters.'
 
@@ -32,15 +33,13 @@ module RuboCop
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            block = node.parent
-            range = range_between(
-              block.loc.begin.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          block = node.parent
+          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -16,9 +16,10 @@ module RuboCop
       #
       #   # good
       #   -> (arg) { do_something(arg) }
-      class EmptyLambdaParameter < Cop
+      class EmptyLambdaParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
@@ -29,15 +30,13 @@ module RuboCop
           check(node) if node.send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            send_node = node.parent.send_node
-            range = range_between(
-              send_node.loc.expression.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          send_node = node.parent.send_node
+          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -17,6 +17,7 @@ module RuboCop
       #   # good
       #   def test
       #     return unless something
+      #
       #     work
       #   end
       #

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

@@ -140,11 +140,12 @@ module RuboCop
         def acceptable_19_syntax_symbol?(sym_name)
           sym_name.sub!(/\A:/, '')
 
-          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols']
-            # Prefer { :production? => false } over { production?: false } and
-            # similarly for other non-alnum final characters (except quotes,
-            # to prefer { "x y": 1 } over { :"x y" => 1 }).
-            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
+          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
+             # Prefer { :production? => false } over { production?: false } and
+             # similarly for other non-alnum final characters (except quotes,
+             # to prefer { "x y": 1 } over { :"x y" => 1 }).
+             !/[\p{Alnum}"']\z/.match?(sym_name)
+            return false
           end
 
           # Most hash keys can be matched against a simple regex.

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

@@ -18,7 +18,9 @@ module RuboCop
       # @example
       #   # bad
       #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v }
-      #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }
+      #   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
+      #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
+      #   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
       #
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
@@ -68,6 +70,17 @@ module RuboCop
             :to_h)
         PATTERN
 
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :to_h)
+            (args
+              (arg $_)
+              (arg _val))
+            (array $_ $(lvar _val)))
+        PATTERN
+
         private
 
         def extract_captures(match)

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

@@ -18,7 +18,9 @@ module RuboCop
       # @example
       #   # bad
       #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
-      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }
+      #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
+      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
+      #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
@@ -65,6 +67,17 @@ module RuboCop
             :to_h)
         PATTERN
 
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :to_h)
+            (args
+              (arg _key)
+              (arg $_))
+            (array $(lvar _key) $_))
+        PATTERN
+
         private
 
         def extract_captures(match)

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

@@ -43,8 +43,8 @@ module RuboCop
           'Modifier form of `%<keyword>s` makes the line too long.'
 
         def on_if(node)
-          msg = if single_line_as_modifier?(node)
-                  MSG_USE_MODIFIER unless named_capture_in_condition?(node)
+          msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+                  MSG_USE_MODIFIER
                 elsif too_long_due_to_modifier?(node)
                   MSG_USE_NORMAL
                 end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces that optional keyword parameters are placed at the
+      # end of the parameters list.
+      #
+      # This improves readability, because when looking through the source,
+      # it is expected to find required parameters at the beginning of parameters list
+      # and optional parameters at the end.
+      #
+      # @example
+      #   # bad
+      #   def some_method(first: false, second:, third: 10)
+      #     # body omitted
+      #   end
+      #
+      #   # good
+      #   def some_method(second:, first: false, third: 10)
+      #     # body omitted
+      #   end
+      #
+      class KeywordParametersOrder < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Place optional keyword parameters at the end of the parameters list.'
+
+        def on_kwoptarg(node)
+          kwarg_nodes = right_siblings_of(node).select(&:kwarg_type?)
+          return if kwarg_nodes.empty?
+
+          add_offense(node) do |corrector|
+            if node.parent.find(&:kwoptarg_type?) == node
+              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+              remove_kwargs(kwarg_nodes, corrector)
+            end
+          end
+        end
+
+        private
+
+        # TODO: Use API from `rubocop-ast` when released.
+        def right_siblings_of(node)
+          node.parent.children[node.sibling_index + 1..-1]
+        end
+
+        def remove_kwargs(kwarg_nodes, corrector)
+          kwarg_nodes.each do |kwarg|
+            with_space = range_with_surrounding_space(range: kwarg.source_range)
+            corrector.remove(range_with_surrounding_comma(with_space, :left))
+          end
+        end
+      end
+    end
+  end
+end