rubocop 0.93.1 → 1.6.1

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

@@ -97,10 +97,10 @@ module RuboCop
         end
 
         def no_mixed_keys_check(pairs)
-          if !sym_indices?(pairs)
-            check(pairs, ':', MSG_NO_MIXED_KEYS)
-          else
+          if sym_indices?(pairs)
             check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
+          else
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
           end
         end
 

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

@@ -3,8 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical lines at the beginning or end of
-      # each branch of a conditional statement.
+      # This cop checks for identical expressions at the beginning or end of
+      # each branch of a conditional expression. Such expressions should normally
+      # be placed outside the conditional expression - before or after it.
+      #
+      # NOTE: The cop is poorly named and some people might think that it actually
+      # checks for duplicated conditional branches. The name will probably be changed
+      # in a future major RuboCop release.
       #
       # @example
       #   # bad

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

@@ -59,6 +59,9 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
         def on_if(node)
@@ -69,11 +72,44 @@ module RuboCop
           return unless else_branch&.if_type? && else_branch&.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
-          add_offense(else_branch.loc.keyword)
+          add_offense(else_branch.loc.keyword) do |corrector|
+            autocorrect(corrector, else_branch)
+          end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          if node.modifier_form?
+            correct_to_elsif_from_modifier_form(corrector, node)
+            end_range = node.parent.loc.end
+          else
+            correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
+            end_range = node.loc.end
+          end
+          corrector.remove(range_by_whole_lines(end_range, include_final_newline: true))
+          corrector.remove(
+            range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
+          )
+        end
+
+        def correct_to_elsif_from_modifier_form(corrector, node)
+          corrector.replace(node.parent.loc.else, <<~RUBY.chop)
+            elsif #{node.condition.source}
+            #{indent(node.if_branch)}#{node.if_branch.source}
+            end
+          RUBY
+        end
+
+        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
+          corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+          if_condition_range = range_between(
+            node.loc.keyword.begin_pos, condition.source_range.end_pos
+          )
+          corrector.replace(if_condition_range, node.if_branch.source)
+          corrector.remove(condition)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -21,14 +21,18 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
-      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
       #
       #   # good
       #   do_stuff(bar) if condition
       #   Foo.do_something unless qux.empty?
       #
-      #   if long_condition
-      #     do_something_in_a_method_with_a_long_name(arg)
+      #   if long_condition_that_prevents_code_fit_on_single_line
+      #     do_something_with_a_long_name(arg)
+      #   end
+      #
+      #   if short_condition # a long comment that makes it too long if it were just a single line
+      #     do_something
       #   end
       class IfUnlessModifier < Base
         include StatementModifier
@@ -42,6 +46,10 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
         def on_if(node)
           msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
                   MSG_USE_MODIFIER

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

@@ -17,26 +17,61 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG = 'Do not use if x; Use the ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
+        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return unless node.else_branch
+          return if node.parent&.if_type?
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, correct_to_ternary(node))
+          message = node.else_branch.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+
+          add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
+            corrector.replace(node, autocorrect(node))
           end
         end
 
         private
 
-        def correct_to_ternary(node)
+        def autocorrect(node)
+          return correct_elsif(node) if node.else_branch.if_type?
+
           else_code = node.else_branch ? node.else_branch.source : 'nil'
 
           "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
         end
+
+        def correct_elsif(node)
+          <<~RUBY.chop
+            if #{node.condition.source}
+              #{node.if_branch.source}
+            #{build_else_branch(node.else_branch).chop}
+            end
+          RUBY
+        end
+
+        def build_else_branch(second_condition)
+          result = <<~RUBY
+            elsif #{second_condition.condition.source}
+              #{second_condition.if_branch.source}
+          RUBY
+
+          if second_condition.else_branch
+            result += if second_condition.else_branch.if_type?
+                        build_else_branch(second_condition.else_branch)
+                      else
+                        <<~RUBY
+                          else
+                            #{second_condition.else_branch.source}
+                        RUBY
+                      end
+          end
+
+          result
+        end
       end
     end
   end

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

@@ -5,6 +5,10 @@ module RuboCop
     module Style
       # Use `Kernel#loop` for infinite loops.
       #
+      # This cop is marked as unsafe as the rule does not necessarily
+      # apply if the body might raise a `StopIteration` exception; contrary to
+      # other infinite loops, `Kernel#loop` silently rescues that and returns `nil`.
+      #
       # @example
       #   # bad
       #   while true

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

@@ -18,7 +18,7 @@ module RuboCop
       #
       #   # good
       #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
-      class IpAddresses < Cop
+      class IpAddresses < Base
         include StringHelp
 
         IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest

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

@@ -34,6 +34,10 @@ module RuboCop
           add_offense(node) do |corrector|
             if node.parent.find(&:kwoptarg_type?) == node
               corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+              arguments = node.each_ancestor(:def, :defs).first.arguments
+              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
               remove_kwargs(kwarg_nodes, corrector)
             end
           end
@@ -41,6 +45,14 @@ module RuboCop
 
         private
 
+        def append_newline_to_last_kwoptarg(arguments, corrector)
+          last_argument = arguments.last
+          return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
+
+          last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
+          corrector.insert_after(last_kwoptarg, "\n")
+        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
@@ -79,7 +74,7 @@ module RuboCop
             parent &&
               (logical_operator?(parent) ||
               parent.send_type? &&
-              parent.arguments.any?(&method(:logical_operator?)))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
@@ -115,7 +110,7 @@ module RuboCop
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any?(&method(:hash_literal?))
+                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
             end
           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_call_without_args_parentheses.rb

@@ -21,21 +21,30 @@ module RuboCop
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
+          return if default_argument?(node)
           return if ignored_method?(node.method_name)
           return if same_name_assignment?(node)
 
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
           add_offense(offense_range(node)) do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end
         end
 
-        private
-
         def ineligible_node?(node)
           node.camel_case_method? || node.implicit_call? || node.prefix_not?
         end
 
+        def default_argument?(node)
+          node.parent&.optarg_type?
+        end
+
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
             next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?

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

@@ -135,10 +135,6 @@ module RuboCop
 
           "#{node.method_name} #{mixin_names.join(', ')}"
         end
-
-        def indent(node)
-          ' ' * node.loc.column
-        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,63 @@ 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 = []
+          @allowed_method_comparison = false
+        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)
+          return if @allowed_method_comparison
 
-          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 +96,12 @@ 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))
+            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
+            @compared_elements << obj.source
             return [variable_name(var)]
           end
+
           []
         end
 
@@ -74,7 +118,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 +130,10 @@ module RuboCop
             or_node
           end
         end
+
+        def allow_method_comparison?
+          cop_config.fetch('AllowMethodComparison', true)
+        end
       end
     end
   end