rubocop 0.49.1 → 0.52.0

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

@@ -3,7 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses if the keyword *not* instead of !.
+      # This cop checks for uses of the keyword `not` instead of `!`.
+      #
+      # @example
+      #
+      #   # bad - parentheses are required because of op precedence
+      #   x = (not something)
+      #
+      #   # good
+      #   x = !something
+      #
       class Not < Cop
         MSG = 'Use `!` instead of `not`.'.freeze
 
@@ -19,13 +28,12 @@ module RuboCop
         def on_send(node)
           return unless node.keyword_not?
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
-          range = range_with_surrounding_space(node.loc.selector, :right)
+          range = range_with_surrounding_space(range: node.loc.selector,
+                                               side: :right)
 
           if opposite_method?(node.receiver)
             correct_opposite_method(range, node.receiver)
@@ -36,6 +44,8 @@ module RuboCop
           end
         end
 
+        private
+
         def opposite_method?(child)
           child.send_type? && OPPOSITE_METHODS.key?(child.method_name)
         end

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

@@ -27,14 +27,12 @@ module RuboCop
 
         def on_int(node)
           type = literal_type(node)
+
           return unless type
 
-          msg = self.class.const_get("#{type.upcase}_MSG")
-          add_offense(node, :expression, msg)
+          add_offense(node)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             type = literal_type(node)
@@ -43,6 +41,12 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          self.class.const_get("#{literal_type(node).upcase}_MSG")
+        end
+
         def literal_type(node)
           literal = integer_part(node)
 

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

@@ -41,6 +41,12 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, format_number(node))
+          end
+        end
+
         private
 
         def max_parameter_name
@@ -56,9 +62,9 @@ module RuboCop
 
           case int
           when /^\d+$/
-            add_offense(node, :expression) { self.max = int.size + 1 }
+            add_offense(node) { self.max = int.size + 1 }
           when /\d{4}/, short_group_regex
-            add_offense(node, :expression) do
+            add_offense(node) do
               self.config_to_allow_offenses = { 'Enabled' => false }
             end
           end
@@ -68,12 +74,6 @@ module RuboCop
           cop_config['Strict'] ? /_\d{1,2}(_|$)/ : /_\d{1,2}_/
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, format_number(node))
-          end
-        end
-
         def format_number(node)
           int_part, float_part = node.source.split('.')
           int_part = int_part.to_i
@@ -86,7 +86,7 @@ module RuboCop
           formatted_int.insert(0, '-') if int_part < 0
 
           if float_part
-            format('%s.%s', formatted_int, float_part)
+            format('%<int>s.%<float>s', int: formatted_int, float: float_part)
           else
             formatted_int
           end

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

@@ -8,14 +8,15 @@ module RuboCop
       # These can be replaced by their respective predicate methods.
       # The cop can also be configured to do the reverse.
       #
-      # The cop disregards `nonzero?` as it its value is truthy or falsey,
+      # The cop disregards `#nonzero?` as it its value is truthy or falsey,
       # but not `true` and `false`, and thus not always interchangeable with
       # `!= 0`.
       #
-      # @example
-      #
-      #   # EnforcedStyle: predicate (default)
+      # The cop ignores comparisons to global variables, since they are often
+      # populated with objects which can be compared with integers, but are
+      # not themselves `Interger` polymorphic.
       #
+      # @example EnforcedStyle: predicate (default)
       #   # bad
       #
       #   foo == 0
@@ -28,10 +29,7 @@ module RuboCop
       #   foo.negative?
       #   bar.baz.positive?
       #
-      # @example
-      #
-      #   # EnforcedStyle: comparison
-      #
+      # @example EnforcedStyle: comparison
       #   # bad
       #
       #   foo.zero?
@@ -46,7 +44,7 @@ module RuboCop
       class NumericPredicate < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         REPLACEMENTS = {
           'zero?' => '==',
@@ -59,8 +57,18 @@ module RuboCop
 
           return unless numeric
 
-          add_offense(node, node.loc.expression,
-                      format(MSG, replacement, node.source))
+          add_offense(node,
+                      message: format(MSG,
+                                      prefer: replacement,
+                                      current: node.source))
+        end
+
+        def autocorrect(node)
+          _, replacement = check(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement)
+          end
         end
 
         private
@@ -78,14 +86,6 @@ module RuboCop
           [numeric, replacement(numeric, operator)]
         end
 
-        def autocorrect(node)
-          _, replacement = check(node)
-
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
-
         def replacement(numeric, operation)
           if style == :predicate
             [parenthesized_source(numeric),
@@ -128,11 +128,11 @@ module RuboCop
         PATTERN
 
         def_node_matcher :comparison, <<-PATTERN
-          (send $(...) ${:== :> :<} (int 0))
+          (send [$(...) !gvar_type?] ${:== :> :<} (int 0))
         PATTERN
 
         def_node_matcher :inverted_comparison, <<-PATTERN
-          (send (int 0) ${:== :> :<} $(...))
+          (send (int 0) ${:== :> :<} [$(...) !gvar_type?])
         PATTERN
       end
     end

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

@@ -9,12 +9,12 @@ module RuboCop
         include OnNormalIfUnless
 
         MSG = 'Favor the ternary operator (`?:`) ' \
-              'over `%s/then/else/end` constructs.'.freeze
+              'over `%<keyword>s/then/else/end` constructs.'.freeze
 
         def on_normal_if_unless(node)
           return unless node.single_line? && node.else_branch
 
-          add_offense(node, :expression, format(MSG, node.keyword))
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -23,6 +23,12 @@ module RuboCop
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, keyword: node.keyword)
+        end
+
         def replacement(node)
           return to_ternary(node) unless node.parent
 
@@ -56,8 +62,7 @@ module RuboCop
         end
 
         def method_call_with_changed_precedence?(node)
-          return false unless node.send_type?
-          return false if node.method_args.empty?
+          return false unless node.send_type? && node.arguments?
           return false if parenthesized_call?(node)
 
           !operator?(node.method_name)

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

@@ -7,43 +7,29 @@ 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
-
-          return unless last_arg && last_arg.optarg_type?
-
-          arg, default_value = *last_arg
-
-          return unless default_value.hash_type? && default_value.pairs.empty?
-          return unless suspicious_name?(arg)
+        def_node_matcher :option_hash, <<-PATTERN
+          (args ... $(optarg [#suspicious_name? _] (hash)))
+        PATTERN
 
-          add_offense(last_arg, :expression, MSG)
-        end
-
-        def validate_config
-          return unless 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

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

@@ -26,8 +26,7 @@ module RuboCop
           arguments = *arguments
 
           each_misplaced_optional_arg(arguments) do |argument|
-            arg, = *argument
-            add_offense(argument, :expression, format(MSG, arg))
+            add_offense(argument)
           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

@@ -35,7 +35,20 @@ module RuboCop
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
 
-          add_offense(node, :expression)
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            left, right = *node
+            left_elements = *left
+            right_elements = [*right].compact
+            order = find_valid_order(left_elements, right_elements)
+            correction = assignment_corrector(node, order)
+
+            corrector.replace(correction.correction_range,
+                              correction.correction)
+          end
         end
 
         private
@@ -68,19 +81,6 @@ module RuboCop
           node.block_type? || node.send_type?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = *node
-            left_elements = *left
-            right_elements = [*right].compact
-            order = find_valid_order(left_elements, right_elements)
-            correction = assignment_corrector(node, order)
-
-            corrector.replace(correction.correction_range,
-                              correction.correction)
-          end
-        end
-
         def assignment_corrector(node, order)
           _assignment, modifier = *node.parent
           if modifier_statement?(node.parent)
@@ -115,7 +115,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :implicit_self_getter?, '(send nil $_)'
+        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
@@ -159,7 +159,7 @@ module RuboCop
           def accesses?(rhs, lhs)
             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