rubocop 0.91.0 → 1.0.0

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

@@ -28,7 +28,7 @@ module RuboCop
         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?)
+          kwarg_nodes = node.right_siblings.select(&:kwarg_type?)
           return if kwarg_nodes.empty?
 
           add_offense(node) do |corrector|
@@ -41,11 +41,6 @@ module RuboCop
 
         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)

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

@@ -144,25 +144,22 @@ module RuboCop
       #   # good
       #   Array 1
       class MethodCallWithArgsParentheses < Base
+        require_relative 'method_call_with_args_parentheses/omit_parentheses'
+        require_relative 'method_call_with_args_parentheses/require_parentheses'
+
         include ConfigurableEnforcedStyle
         include IgnoredMethods
         include IgnoredPattern
+        include RequireParentheses
+        include OmitParentheses
         extend AutoCorrector
 
-        def initialize(*)
-          super
-          return unless style_configured?
-
-          case style
-          when :require_parentheses
-            extend RequireParentheses
-          when :omit_parentheses
-            extend OmitParentheses
-          end
+        def on_send(node)
+          send(style, node) # call require_parentheses or omit_parentheses
         end
-
-        # @abstract Overridden in style modules
-        def autocorrect(_node); end
+        alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         private
 

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -7,15 +7,19 @@ module RuboCop
         # Style omit_parentheses
         module OmitParentheses
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+          OMIT_MSG = 'Omit parentheses for method calls with arguments.'
+          private_constant :OMIT_MSG
 
-          def on_send(node)
+          private
+
+          def omit_parentheses(node)
             return unless node.parenthesized?
             return if node.implicit_call?
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
-            add_offense(offense_range(node)) do |corrector|
+            add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
               if parentheses_at_the_end_of_multiline_call?(node)
                 corrector.replace(args_begin(node), ' \\')
               else
@@ -24,20 +28,11 @@ module RuboCop
               corrector.remove(node.loc.end)
             end
           end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          private
 
           def offense_range(node)
             node.loc.begin.join(node.loc.end)
           end
 
-          def message(_range = nil)
-            'Omit parentheses for method calls with arguments.'
-          end
-
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -6,27 +6,23 @@ module RuboCop
       class MethodCallWithArgsParentheses
         # Style require_parentheses
         module RequireParentheses
-          def on_send(node)
+          REQUIRE_MSG = 'Use parentheses for method calls with arguments.'
+          private_constant :REQUIRE_MSG
+
+          private
+
+          def require_parentheses(node)
             return if ignored_method?(node.method_name)
             return if matches_ignored_pattern?(node.method_name)
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
 
-            add_offense(node) do |corrector|
+            add_offense(node, message: REQUIRE_MSG) do |corrector|
               corrector.replace(args_begin(node), '(')
 
               corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
             end
           end
-          alias on_csend on_send
-          alias on_super on_send
-          alias on_yield on_send
-
-          def message(_node = nil)
-            'Use parentheses for method calls with arguments.'
-          end
-
-          private
 
           def eligible_for_parentheses_omission?(node)
             node.operator_method? || node.setter_method? || ignored_macro?(node)

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

@@ -140,16 +140,12 @@ module RuboCop
         def missing_parentheses(node)
           location = node.arguments.source_range
 
-          return unless unexpected_style_detected(:require_no_parentheses)
-
           add_offense(location, message: MSG_MISSING) do |corrector|
             correct_definition(node, corrector)
           end
         end
 
         def unwanted_parentheses(args)
-          return unless unexpected_style_detected(:require_parentheses)
-
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted
             correct_arguments(args, corrector)

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

@@ -50,41 +50,21 @@ module RuboCop
             const)
         PATTERN
 
-        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
-          {({sclass class module block} ... ({begin if} ...))}
+        def_node_matcher :in_top_level_scope?, <<~PATTERN
+          {
+            root?                        # either at the top level
+            ^[  {kwbegin begin if def}   # or wrapped within one of these
+                #in_top_level_scope? ]   # that is in top level scope
+          }
         PATTERN
 
         def on_send(node)
           include_statement(node) do |statement|
-            return if node.argument? ||
-                      accepted_include?(node) ||
-                      belongs_to_class_or_module?(node)
+            return unless in_top_level_scope?(node)
 
             add_offense(node, message: format(MSG, statement: statement))
           end
         end
-
-        private
-
-        def accepted_include?(node)
-          node.parent && (node.macro? || ascend_macro_scope?(node.parent))
-        end
-
-        def ascend_macro_scope?(ancestor)
-          return true if wrapped_macro_scope?(ancestor)
-
-          ancestor.parent && ascend_macro_scope?(ancestor.parent)
-        end
-
-        def belongs_to_class_or_module?(node)
-          if !node.parent
-            false
-          else
-            return true if node.parent.class_type? || node.parent.module_type?
-
-            belongs_to_class_or_module?(node.parent)
-          end
-        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module RuboCop
       #   alive_threads.map do |t|
       #     t.object_id
       #   end
-      class MultilineBlockChain < Cop
+      class MultilineBlockChain < Base
         include RangeHelp
 
         MSG = 'Avoid multi-line chains of blocks.'
@@ -36,7 +36,7 @@ module RuboCop
             range = range_between(receiver.loc.end.begin_pos,
                                   node.send_node.source_range.end_pos)
 
-            add_offense(nil, location: range)
+            add_offense(range)
 
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -58,6 +58,7 @@ module RuboCop
         private
 
         def require_then?(when_node)
+          return true if when_node.conditions.count >= 2
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line

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

@@ -49,6 +49,8 @@ module RuboCop
         end
 
         def remove_parentheses(source)
+          return source unless source.start_with?('(')
+
           source.gsub(/\A\(/, '').gsub(/\)\z/, '')
         end
       end

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

@@ -89,7 +89,9 @@ module RuboCop
         end
 
         def else_branch_to_multiline(else_branch, indentation)
-          if else_branch.if_type? && else_branch.elsif?
+          if else_branch.nil?
+            'end'
+          elsif else_branch.if_type? && else_branch.elsif?
             multiline_replacement(else_branch, indentation)
           else
             <<~RUBY.chomp

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for places where keyword arguments can be used instead of
-      # boolean arguments when defining methods.
+      # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -23,11 +24,21 @@ module RuboCop
       #     puts bar
       #   end
       #
+      # @example AllowedMethods: ['some_method']
+      #   # good
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
       class OptionalBooleanParameter < Base
+        include AllowedMethods
+
         MSG = 'Use keyword arguments when defining method with boolean argument.'
         BOOLEAN_TYPES = %i[true false].freeze
 
         def on_def(node)
+          return if allowed_method?(node.method_name)
+
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 

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

@@ -84,8 +84,6 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
-            return unless opposite_style_detected
-
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
               replacement = correction_exploded_to_compact(node)
 
@@ -103,7 +101,6 @@ module RuboCop
 
           return unless first_arg.send_type? && first_arg.method?(:new)
           return if acceptable_exploded_args?(first_arg.arguments)
-          return unless opposite_style_detected
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
             replacement = correction_compact_to_exploded(node)

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

@@ -36,7 +36,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange}))
+              {int (irange int int) (erange int int)}))
         PATTERN
 
         def_node_matcher :rand_op_integer?, <<~PATTERN
@@ -44,7 +44,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:+ :-}
             int)
         PATTERN
@@ -54,7 +54,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:succ :pred :next})
         PATTERN
 

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

@@ -94,21 +94,13 @@ module RuboCop
             add_offense(assignment) do |corrector|
               expression = assignment.children[1]
               corrector.replace(assignment, expression.source)
-              corrector.remove(right_sibling_of(assignment))
+              corrector.remove(assignment.right_sibling)
             end
           else
             last_expr = node.children.last
             check_branch(last_expr)
           end
         end
-
-        def right_sibling_of(node)
-          siblings_of(node)[node.sibling_index + 1]
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
       end
     end
   end

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

@@ -28,6 +28,14 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
       #   # When using Ruby 2.5 or later.
       #   do_something do
       #     begin
@@ -60,7 +68,9 @@ module RuboCop
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
-          check(node)
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
         end
         alias on_defs on_def
 
@@ -69,20 +79,38 @@ module RuboCop
 
           return if node.send_node.lambda_literal?
           return if node.braces?
+          return unless node.body&.kwbegin_type?
 
-          check(node)
+          register_offense(node.body)
         end
 
-        private
+        def on_kwbegin(node)
+          return if contain_rescue_or_ensure?(node) || valid_context_using_only_begin?(node)
 
-        def check(node)
-          return unless node.body&.kwbegin_type?
+          register_offense(node)
+        end
+
+        private
 
-          add_offense(node.body.loc.begin) do |corrector|
-            corrector.remove(node.body.loc.begin)
-            corrector.remove(node.body.loc.end)
+        def register_offense(node)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
           end
         end
+
+        def contain_rescue_or_ensure?(node)
+          first_child = node.children.first
+
+          first_child.rescue_type? || first_child.ensure_type?
+        end
+
+        def valid_context_using_only_begin?(node)
+          parent = node.parent
+
+          node.each_ancestor.any?(&:assignment?) || parent&.post_condition_loop? ||
+            parent&.send_type? || parent&.operator_keyword?
+        end
       end
     end
   end

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

@@ -75,7 +75,7 @@ module RuboCop
         def offense?(node)
           condition, if_branch, else_branch = *node
 
-          return false if use_if_branch?(else_branch)
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           condition == if_branch && !node.elsif? && (
             node.ternary? ||
@@ -88,6 +88,10 @@ module RuboCop
           else_branch&.if_type?
         end
 
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch&.method?(:[]=)
+        end
+
         def else_source(else_branch)
           if require_parentheses?(else_branch)
             "(#{else_branch.source})"

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

@@ -24,8 +24,9 @@ module RuboCop
       #
       #   # good
       #   x != y
-      class RedundantConditional < Cop
+      class RedundantConditional < Base
         include Alignment
+        extend AutoCorrector
 
         operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
         COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
@@ -36,11 +37,9 @@ module RuboCop
         def on_if(node)
           return unless offense?(node)
 
-          add_offense(node)
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement_condition(node))
           end
         end