rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,59 +7,34 @@ module RuboCop
       # current Ruby version supports keyword arguments.
       #
       # @example
-      #   Instead of:
       #
+      #   # bad
       #   def fry(options = {})
       #     temperature = options.fetch(:temperature, 300)
-      #     ...
+      #     # ...
       #   end
       #
-      #   Prefer:
       #
+      #   # good
       #   def fry(temperature: 300)
-      #     ...
+      #     # ...
       #   end
       class OptionHash < Cop
         MSG = 'Prefer keyword arguments to options hashes.'.freeze
 
-        def on_args(node)
-          *_but_last, last_arg = *node
-
-          # asserting that there was an argument at all
-          return unless last_arg
-
-          # asserting last argument is an optional argument
-          return unless last_arg.optarg_type?
-
-          arg, default_value = *last_arg
-
-          # asserting default value is a hash
-          return unless default_value.hash_type?
+        def_node_matcher :option_hash, <<-PATTERN
+          (args ... $(optarg [#suspicious_name? _] (hash)))
+        PATTERN
 
-          # asserting default value is empty hash
-          *key_value_pairs = *default_value
-          return unless key_value_pairs.empty?
-
-          # Check for suspicious argument names
-          return unless name_in_suspicious_param_names?(arg)
-
-          add_offense(last_arg, :expression, MSG)
-        end
-
-        def validate_config
-          if target_ruby_version < 2.0
-            raise ValidationError, 'The `Style/OptionHash` cop is only ' \
-                                  'compatible with Ruby 2.0 and up, but the ' \
-                                  'target Ruby version for your project is ' \
-                                  "1.9.\nPlease disable this cop or adjust " \
-                                  'the `TargetRubyVersion` parameter in your ' \
-                                  'configuration.'
+        def on_args(node)
+          option_hash(node) do |options|
+            add_offense(options)
           end
         end
 
         private
 
-        def name_in_suspicious_param_names?(arg_name)
+        def suspicious_name?(arg_name)
           cop_config.key?('SuspiciousParamNames') &&
             cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
         end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -25,25 +24,37 @@ module RuboCop
         def on_def(node)
           _method, arguments, = *node
           arguments = *arguments
-          optarg_positions = []
-          arg_positions = []
 
-          arguments.each_with_index do |argument, index|
-            optarg_positions << index if argument.optarg_type?
-            arg_positions << index if argument.arg_type?
+          each_misplaced_optional_arg(arguments) do |argument|
+            add_offense(argument)
           end
+        end
+
+        private
 
+        def each_misplaced_optional_arg(arguments)
+          optarg_positions, arg_positions = argument_positions(arguments)
           return if optarg_positions.empty? || arg_positions.empty?
 
           optarg_positions.each do |optarg_position|
             # there can only be one group of optional arguments
             break if optarg_position > arg_positions.max
-            argument = arguments[optarg_position]
-            arg, = *argument
 
-            add_offense(argument, :expression, format(MSG, arg))
+            yield arguments[optarg_position]
           end
         end
+
+        def argument_positions(arguments)
+          optarg_positions = []
+          arg_positions = []
+
+          arguments.each_with_index do |argument, index|
+            optarg_positions << index if argument.optarg_type?
+            arg_positions << index if argument.arg_type?
+          end
+
+          [optarg_positions, arg_positions]
+        end
       end
     end
   end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for potential usage of the `||=` operator.
+      #
+      # @example
+      #   # bad
+      #   name = name ? name : 'Bozhidar'
+      #
+      #   # bad
+      #   name = if name
+      #            name
+      #          else
+      #            'Bozhidar'
+      #          end
+      #
+      #   # bad
+      #   unless name
+      #     name = 'Bozhidar'
+      #   end
+      #
+      #   # bad
+      #   name = 'Bozhidar' unless name
+      #
+      #   # good - set name to 'Bozhidar', only if it's nil or false
+      #   name ||= 'Bozhidar'
+      class OrAssignment < Cop
+        MSG = 'Use the double pipe equals operator `||=` instead.'.freeze
+
+        def_node_matcher :ternary_assignment?, <<-PATTERN
+          ({lvasgn ivasgn cvasgn gvasgn} _var
+            (if
+              ({lvar ivar cvar gvar} _var)
+              ({lvar ivar cvar gvar} _var)
+              _))
+        PATTERN
+
+        def_node_matcher :unless_assignment?, <<-PATTERN
+          (if
+            ({lvar ivar cvar gvar} _var) nil?
+            ({lvasgn ivasgn cvasgn gvasgn} _var
+              _))
+        PATTERN
+
+        def on_if(node)
+          return unless unless_assignment?(node)
+          add_offense(node)
+        end
+
+        def on_lvasgn(node)
+          return unless ternary_assignment?(node)
+          add_offense(node)
+        end
+
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def autocorrect(node)
+          if ternary_assignment?(node)
+            variable, default = take_variable_and_default_from_ternary(node)
+          else
+            variable, default = take_variable_and_default_from_unless(node)
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range,
+                              "#{variable} ||= #{default.source}")
+          end
+        end
+
+        private
+
+        def take_variable_and_default_from_ternary(node)
+          variable, if_statement = *node
+          [variable, if_statement.else_branch]
+        end
+
+        def take_variable_and_default_from_unless(node)
+          variable, default = *node.if_branch
+          [variable, default]
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'tsort'
@@ -24,35 +23,19 @@ module RuboCop
       #   b = 2
       #   c = 3
       class ParallelAssignment < Cop
-        include IfNode
+        include RescueNode
 
         MSG = 'Do not use parallel assignment.'.freeze
 
         def on_masgn(node)
-          left, right = *node
-          left_elements = *left
-          right_elements = [*right].compact # edge case for one constant
+          lhs, rhs = *node
+          lhs_elements = *lhs
+          rhs_elements = [*rhs].compact # edge case for one constant
 
-          # only complain when the number of variables matches
-          return if left_elements.size != right_elements.size
+          return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
+                    allowed_masign?(lhs_elements, rhs_elements)
 
-          # account for edge cases using one variable with a comma
-          return if left_elements.size == 1
-
-          # account for edge case of Constant::CONSTANT
-          return unless right.array_type?
-
-          # allow mass assignment as the return of a method call
-          return if right.block_type? || right.send_type?
-
-          # allow mass assignment when using splat
-          return if (left_elements + right_elements).any?(&:splat_type?)
-
-          order = find_valid_order(left_elements, right_elements)
-          # For `a, b = b, a` or similar, there is no valid order
-          return if order.nil?
-
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -61,23 +44,54 @@ module RuboCop
             left_elements = *left
             right_elements = [*right].compact
             order = find_valid_order(left_elements, right_elements)
+            correction = assignment_corrector(node, order)
 
-            assignment_corrector =
-              if modifier_statement?(node.parent)
-                ModifierCorrector.new(node, config, order)
-              elsif rescue_modifier?(node.parent)
-                RescueCorrector.new(node, config, order)
-              else
-                GenericCorrector.new(node, config, order)
-              end
-
-            corrector.replace(assignment_corrector.correction_range,
-                              assignment_corrector.correction)
+            corrector.replace(correction.correction_range,
+                              correction.correction)
           end
         end
 
         private
 
+        def allowed_masign?(lhs_elements, rhs_elements)
+          lhs_elements.size != rhs_elements.size ||
+            !find_valid_order(lhs_elements,
+                              add_self_to_getters(rhs_elements))
+        end
+
+        def allowed_lhs?(node)
+          elements = *node
+
+          # Account for edge cases using one variable with a comma
+          # E.g.: `foo, = *bar`
+          elements.one? || elements.any?(&:splat_type?)
+        end
+
+        def allowed_rhs?(node)
+          # Edge case for one constant
+          elements = [*node].compact
+
+          # Account for edge case of `Constant::CONSTANT`
+          !node.array_type? ||
+            return_of_method_call?(node) ||
+            elements.any?(&:splat_type?)
+        end
+
+        def return_of_method_call?(node)
+          node.block_type? || node.send_type?
+        end
+
+        def assignment_corrector(node, order)
+          _assignment, modifier = *node.parent
+          if modifier_statement?(node.parent)
+            ModifierCorrector.new(node, config, order)
+          elsif rescue_modifier?(modifier)
+            RescueCorrector.new(node, config, order)
+          else
+            GenericCorrector.new(node, config, order)
+          end
+        end
+
         def find_valid_order(left_elements, right_elements)
           # arrange left_elements in an order such that no corresponding right
           # element refers to a left element earlier in the sequence
@@ -92,6 +106,17 @@ module RuboCop
           end
         end
 
+        # Converts (send nil :something) nodes to (send (:self) :something).
+        # This makes the sorting algorithm work for expressions such as
+        # `self.a, self.b = b, a`.
+        def add_self_to_getters(right_elements)
+          right_elements.map do |e|
+            implicit_self_getter?(e) { |var| s(:send, s(:self), var) } || e
+          end
+        end
+
+        def_node_matcher :implicit_self_getter?, '(send nil? $_)'
+
         # Helper class necessitated by silly design of TSort prior to Ruby 2.1
         # Newer versions have a better API, but that doesn't help us
         class AssignmentSorter
@@ -117,19 +142,24 @@ module RuboCop
 
             @assignments.each do |other|
               _other_lhs, other_rhs = *other
-              if ((var = var_name(my_lhs)) && uses_var?(other_rhs, var)) ||
-                 (my_lhs.asgn_method_call? && accesses?(other_rhs, my_lhs))
-                yield other
-              end
+
+              next unless dependency?(my_lhs, other_rhs)
+
+              yield other
             end
           end
 
+          def dependency?(lhs, rhs)
+            uses_var?(rhs, var_name(lhs)) ||
+              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+          end
+
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
           # Does `rhs` access the same value which is assigned by `lhs`?
           def accesses?(rhs, lhs)
-            if lhs.method_name == :[]=
+            if lhs.method?(:[]=)
               matching_calls(rhs, lhs.receiver, :[]).any? do |args|
-                args == lhs.method_args
+                args == lhs.arguments
               end
             else
               access_method = lhs.method_name.to_s.chop.to_sym
@@ -139,28 +169,14 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node &&
-            ((node.if_type? && modifier_if?(node)) ||
-            ((node.while_type? || node.until_type?) && modifier_while?(node)))
-        end
-
-        def modifier_while?(node)
-          node.loc.respond_to?(:keyword) &&
-            %w(while until).include?(node.loc.keyword.source) &&
-            node.modifier_form?
-        end
-
-        def rescue_modifier?(node)
-          node && node.rescue_type? &&
-            (node.parent.nil? || !(node.parent.kwbegin_type? ||
-            node.parent.ensure_type?))
+          node && %i[if while until].include?(node.type) && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment
         class GenericCorrector
-          include AutocorrectAlignment
+          include Alignment
 
-          attr_reader :config, :node, :correction, :correction_range
+          attr_reader :config, :node
 
           def initialize(node, config, new_elements)
             @node = node
@@ -247,12 +263,7 @@ module RuboCop
           def correction
             parent = node.parent
 
-            modifier_range =
-              Parser::Source::Range.new(parent.source_range.source_buffer,
-                                        parent.loc.keyword.begin_pos,
-                                        parent.source_range.end_pos)
-
-            "#{modifier_range.source}\n" \
+            "#{modifier_range(parent).source}\n" \
               "#{indentation(node)}" \
               "#{assignment.join("\n#{indentation(node)}")}" \
               "\n#{offset(node)}end"
@@ -261,6 +272,14 @@ module RuboCop
           def correction_range
             node.parent.source_range
           end
+
+          private
+
+          def modifier_range(node)
+            Parser::Source::Range.new(node.source_range.source_buffer,
+                                      node.loc.keyword.begin_pos,
+                                      node.source_range.end_pos)
+          end
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,50 +5,69 @@ module RuboCop
     module Style
       # This cop checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
+      #
+      # @example
+      #   # bad
+      #   x += 1 while (x < 10)
+      #   foo unless (bar || baz)
+      #
+      #   if (x > 10)
+      #   elsif (x < 3)
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #   foo unless bar || baz
+      #
+      #   if x > 10
+      #   elsif x < 3
+      #   end
       class ParenthesesAroundCondition < Cop
-        include IfNode
         include SafeAssignment
         include Parentheses
 
         def on_if(node)
-          return if ternary?(node)
+          return if node.ternary?
+
           process_control_op(node)
         end
 
         def on_while(node)
           process_control_op(node)
         end
+        alias on_until on_while
 
-        def on_until(node)
-          process_control_op(node)
+        def autocorrect(node)
+          ParenthesesCorrector.correct(node)
         end
 
         private
 
+        def_node_matcher :control_op_condition, <<-PATTERN
+          (begin $_ ...)
+        PATTERN
+
         def process_control_op(node)
-          cond, _body = *node
+          cond = node.condition
 
-          return unless cond.type == :begin
-          # handle `if (something rescue something_else) ...`
-          return if modifier_op?(cond.children.first)
-          # check if there's any whitespace between the keyword and the cond
-          return if parens_required?(node.children.first)
-          # allow safe assignment
-          return if safe_assignment?(cond) && safe_assignment_allowed?
+          control_op_condition(cond) do |first_child|
+            return if modifier_op?(first_child)
+            return if parens_required?(node.condition)
+            return if safe_assignment?(cond) && safe_assignment_allowed?
 
-          add_offense(cond, :expression, message(node))
+            add_offense(cond)
+          end
         end
 
         def modifier_op?(node)
-          return false if ternary?(node)
-          return true if node.type == :rescue
+          return false if node.if_type? && node.ternary?
+          return true if node.rescue_type?
 
-          [:if, :while, :until].include?(node.type) &&
-            node.loc.end.nil?
+          MODIFIER_NODES.include?(node.type) && node.modifier_form?
         end
 
         def message(node)
-          kw = node.loc.keyword.source
+          kw = node.parent.keyword
           article = kw == 'while' ? 'a' : 'an'
           "Don't use parentheses around the condition of #{article} `#{kw}`."
         end

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

@@ -1,15 +1,33 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop enforces the consistent usage of `%`-literal delimiters.
+      #
+      # Specify the 'default' key to set all preferred delimiters at once. You
+      # can continue to specify individual preferred delimiters to override the
+      # default.
+      #
+      # @example
+      #   # Style/PercentLiteralDelimiters:
+      #   #   PreferredDelimiters:
+      #   #     default: '[]'
+      #   #     '%i':    '()'
+      #
+      #   # good
+      #   %w[alpha beta] + %i(gamma delta)
+      #
+      #   # bad
+      #   %W(alpha #{beta})
+      #
+      #   # bad
+      #   %I(alpha beta)
       class PercentLiteralDelimiters < Cop
         include PercentLiteral
 
         def on_array(node)
-          process(node, '%w', '%W', '%i')
+          process(node, '%w', '%W', '%i', '%I')
         end
 
         def on_regexp(node)
@@ -31,18 +49,16 @@ module RuboCop
 
         def message(node)
           type = type(node)
-          delimiters = preferred_delimiters(type)
+          delimiters = preferred_delimiters_for(type)
 
           "`#{type}`-literals should be delimited by " \
           "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
-        private
-
         def autocorrect(node)
           type = type(node)
 
-          opening_delimiter, closing_delimiter = preferred_delimiters(type)
+          opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
 
           lambda do |corrector|
             corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
@@ -50,36 +66,55 @@ module RuboCop
           end
         end
 
+        private
+
         def on_percent_literal(node)
           type = type(node)
           return if uses_preferred_delimiter?(node, type) ||
-                    contains_preferred_delimiter?(node, type)
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
 
-          add_offense(node, :expression)
-        end
-
-        def preferred_delimiters(type)
-          cop_config['PreferredDelimiters'][type].split(//)
+          add_offense(node)
         end
 
         def uses_preferred_delimiter?(node, type)
-          preferred_delimiters(type)[0] == begin_source(node)[-1]
+          preferred_delimiters_for(type)[0] == begin_source(node)[-1]
         end
 
         def contains_preferred_delimiter?(node, type)
-          preferred_delimiters = preferred_delimiters(type)
+          preferred_delimiters = preferred_delimiters_for(type)
           node
             .children.map { |n| string_source(n) }.compact
             .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
         end
 
+        def include_same_character_as_used_for_delimiter?(node, type)
+          return false unless %w[%w %i].include?(type)
+
+          used_delimiters = matchpairs(begin_source(node)[-1])
+          escaped_delimiters = used_delimiters.map { |d| "\\#{d}" }.join('|')
+
+          node
+            .children.map { |n| string_source(n) }.compact
+            .any? { |s| Regexp.new(escaped_delimiters) =~ s }
+        end
+
         def string_source(node)
           if node.is_a?(String)
             node
-          elsif node.respond_to?(:type) && node.type == :str
+          elsif node.respond_to?(:type) && node.str_type?
             node.source
           end
         end
+
+        def matchpairs(begin_delimiter)
+          {
+            '(' => %w[( )],
+            '[' => %w[[ ]],
+            '{' => %w[{ }],
+            '<' => %w[< >]
+          }.fetch(begin_delimiter, [begin_delimiter])
+        end
       end
     end
   end