rubocop 0.91.1 → 1.1.0

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

@@ -33,10 +33,31 @@ module RuboCop
       #
       #   # bad
       #   format('%<greeting>s', greeting: 'Hello')
-      #   format('%{greeting}', 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
       #
       #   # good
       #   format('%s', 'Hello')
+      #
+      # It is allowed to contain unannotated token
+      # if the number of them is less than or equals to
+      # `MaxUnannotatedPlaceholdersAllowed`.
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 0
+      #
+      #   # bad
+      #   format('%06d', 10)
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%<number>06d', number: 10)
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+      #
+      #   # bad
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%06d', 10)
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
@@ -44,8 +65,12 @@ module RuboCop
           return unless node.value.include?('%')
           return if node.each_ancestor(:xstr, :regexp).any?
 
-          tokens(node) do |detected_style, token_range|
-            if detected_style == style || unannotated_format?(node, detected_style)
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_style, token_range|
+            if detected_style == style
               correct_style_detected
             else
               style_detected(detected_style)
@@ -112,6 +137,26 @@ module RuboCop
             yield(detected_style, token)
           end
         end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_style, token_range|
+            unless unannotated_format?(node, detected_style)
+              detections << [detected_style, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false if detections.size > max_unannotated_placeholders_allowed
+
+          detections.all? { |detected_style,| detected_style == :unannotated }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
       end
     end
   end

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/multiple_comparison.rb

@@ -4,7 +4,10 @@ module RuboCop
   module Cop
     module Style
       # This cop checks against comparing a variable with multiple items, where
-      # `Array#include?` could be used instead to avoid code repetition.
+      # `Array#include?`, `Set#include?` or a `case` could be used instead
+      # to avoid code repetition.
+      # It accepts comparisons of multiple method calls to avoid unnecessary method calls
+      # by default. It can be configured by `AllowMethodComparison` option.
       #
       # @example
       #   # bad
@@ -14,25 +17,61 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
+      #
+      #   VALUES = Set['a', 'b', 'c'].freeze
+      #   # elsewhere...
+      #   foo if VALUES.include?(a)
+      #
+      #   case foo
+      #   when 'a', 'b', 'c' then foo
+      #   # ...
+      #   end
+      #
+      #   # accepted (but consider `case` as above)
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      # @example AllowMethodComparison: true (default)
+      #   # good
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      # @example AllowMethodComparison: false
+      #   # bad
+      #   foo if a == b.lightweight || a == b.heavyweight
+      #
+      #   # good
+      #   foo if [b.lightweight, b.heavyweight].include?(a)
       class MultipleComparison < Base
+        extend AutoCorrector
+
         MSG = 'Avoid comparing a variable with multiple items ' \
           'in a conditional, use `Array#include?` instead.'
 
+        def on_new_investigation
+          @compared_elements = []
+        end
+
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
 
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            elements = @compared_elements.join(', ')
+            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+
+            corrector.replace(node, prefer_method)
+          end
         end
 
         private
 
         def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-        def_node_matcher :simple_comparison?, <<~PATTERN
-          {(send $lvar :== _)
-           (send _ :== $lvar)}
+        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
+          (send $lvar :== $_)
+        PATTERN
+        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
+          (send $_ :== $lvar)
         PATTERN
 
         def nested_variable_comparison?(node)
@@ -55,9 +94,13 @@ module RuboCop
           simple_double_comparison?(node) do |var1, var2|
             return [variable_name(var1), variable_name(var2)]
           end
-          simple_comparison?(node) do |var|
+          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
+            return [] if allow_method_comparison? && obj.send_type?
+
+            @compared_elements << obj.source
             return [variable_name(var)]
           end
+
           []
         end
 
@@ -74,7 +117,7 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison?(node) || nested_comparison?(node)
+          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
         end
 
         def root_of_or_node(or_node)
@@ -86,6 +129,10 @@ module RuboCop
             or_node
           end
         end
+
+        def allow_method_comparison?
+          cop_config.fetch('AllowMethodComparison', true)
+        end
       end
     end
   end

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/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,13 +24,20 @@ 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
-        METHODS_EXCLUDED = %i[respond_to_missing?].freeze
 
         def on_def(node)
-          return if METHODS_EXCLUDED.include?(node.method_name)
+          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/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