rubocop 1.3.1 → 1.5.1

data/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb

@@ -6,7 +6,12 @@ module RuboCop
       module Utils
         # @api private
         #
-        # Helps to calculate code length for the provided node.
+        # Identifies repetitions `&.` on the same variable:
+        #
+        #  my_var&.foo
+        #  my_var&.bar # => repeated
+        #  my_var = baz # => reset
+        #  my_var&.qux # => not repeated
         module RepeatedCsendDiscount
           def reset_repeated_csend
             @repeated_csend = {}

data/lib/rubocop/cop/mixin/configurable_numbering.rb

@@ -7,10 +7,11 @@ module RuboCop
     module ConfigurableNumbering
       include ConfigurableFormatting
 
+      implicit_param = /\A_\d+\z/
       FORMATS = {
         snake_case:  /(?:\D|_\d+|\A\d+)\z/,
-        normalcase:  /(?:\D|[^_\d]\d+|\A\d+)\z/,
-        non_integer: /(\D|\A\d+)\z/
+        normalcase:  /(?:\D|[^_\d]\d+|\A\d+)\z|#{implicit_param}/,
+        non_integer: /(\D|\A\d+)\z|#{implicit_param}/
       }.freeze
     end
   end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -2,7 +2,15 @@
 
 module RuboCop
   module Cop
-    # Common functionality for enforcing a specific superclass
+    # Common functionality for enforcing a specific superclass.
+    #
+    # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
+    # Rails department has been extracted to RuboCop Rails gem.
+    # This module is deprecated and will be removed by RuboCop 2.0.
+    # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
+    # with existing RuboCop Rails 2.8 or lower.
+    #
+    # @api private
     module EnforceSuperclass
       def self.included(base)
         base.def_node_matcher :class_definition, <<~PATTERN

data/lib/rubocop/cop/mixin/ignored_methods.rb

@@ -4,15 +4,48 @@ module RuboCop
   module Cop
     # This module encapsulates the ability to ignore certain methods when
     # parsing.
+    # Cops that use `IgnoredMethods` can accept either strings or regexes to match
+    # against.
     module IgnoredMethods
-      private
+      # Configuration for IgnoredMethods. It is added to classes that include
+      # the module so that configuration can be set using the `ignored_methods`
+      # class macro.
+      module Config
+        attr_accessor :deprecated_key
+
+        def ignored_methods(**config)
+          self.deprecated_key = config[:deprecated_key]
+        end
+      end
+
+      def self.included(base)
+        base.extend(Config)
+      end
 
       def ignored_method?(name)
-        ignored_methods.include?(name.to_s)
+        ignored_methods.any? do |value|
+          case value
+          when Regexp
+            value.match? String(name)
+          else
+            value == String(name)
+          end
+        end
       end
 
       def ignored_methods
-        cop_config.fetch('IgnoredMethods', [])
+        keys = %w[IgnoredMethods]
+        keys << deprecated_key if deprecated_key
+
+        cop_config.slice(*keys).values.reduce(&:concat)
+      end
+
+      private
+
+      def deprecated_key
+        return unless self.class.respond_to?(:deprecated_key)
+
+        self.class.deprecated_key&.to_s
       end
     end
   end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -11,6 +11,12 @@ module RuboCop
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
 
+      # Ensure cops that include `MethodComplexity` have the config
+      # `attr_accessor`s that `ignored_method?` needs.
+      def self.included(base)
+        base.extend(IgnoredMethods::Config)
+      end
+
       def on_def(node)
         return if ignored_method?(node.method_name)
 

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -31,7 +31,7 @@ module RuboCop
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent&.send_type?
+        lhs = lhs.parent while lhs.parent&.send_type? && lhs.parent.loc.dot
         lhs
       end
 

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -16,9 +16,7 @@ module RuboCop
       end
 
       def find_visibility_start(node)
-        node.left_siblings
-            .reverse
-            .find(&method(:visibility_block?))
+        node.left_siblings.reverse.find { |sibling| visibility_block?(sibling) }
       end
 
       # Navigate to find the last protected method

data/lib/rubocop/cop/naming/variable_number.rb

@@ -104,6 +104,8 @@ module RuboCop
         def on_arg(node)
           @node = node
           name, = *node
+          return if allowed_identifier?(name)
+
           check_name(node, name, node.loc.name)
         end
         alias on_lvasgn on_arg
@@ -139,7 +141,7 @@ module RuboCop
         end
 
         def allowed_identifier?(name)
-          allowed_identifiers.include?(name.to_s)
+          allowed_identifiers.include?(name.to_s.delete('@'))
         end
 
         def allowed_identifiers

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

@@ -72,6 +72,8 @@ module RuboCop
             end
 
             corrector.replace(node.loc.operator, node.alternate_operator)
+
+            keep_operator_precedence(corrector, node)
           end
         end
 
@@ -123,6 +125,14 @@ module RuboCop
           corrector.wrap(node, '(', ')')
         end
 
+        def keep_operator_precedence(corrector, node)
+          if node.or_type? && node.parent&.and_type?
+            corrector.wrap(node, '(', ')')
+          elsif node.and_type? && node.rhs.or_type?
+            corrector.wrap(node.rhs, '(', ')')
+          end
+        end
+
         def correctable_send?(node)
           !node.parenthesized? && node.arguments? && !node.method?(:[])
         end

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

@@ -55,13 +55,18 @@ module RuboCop
           padding = ((' ' * indent_width) + leading_spaces(node)).to_s
           padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
 
-          replace_keyword_with_module(corrector, node)
+          replace_namespace_keyword(corrector, node)
           split_on_double_colon(corrector, node, padding)
           add_trailing_end(corrector, node, padding_for_trailing_end)
         end
 
-        def replace_keyword_with_module(corrector, node)
-          corrector.replace(node.loc.keyword, 'module')
+        def replace_namespace_keyword(corrector, node)
+          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+            class_node.identifier == node.identifier.namespace
+          end
+          namespace_keyword = class_definition ? 'class' : 'module'
+
+          corrector.replace(node.loc.keyword, namespace_keyword)
         end
 
         def split_on_double_colon(corrector, node, padding)

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

@@ -55,6 +55,11 @@ module RuboCop
       #       Public = Class.new
       #     end
       #
+      #     # Macro calls
+      #     module Namespace
+      #       extend Foo
+      #     end
+      #
       class Documentation < Base
         include DocumentationComment
 
@@ -83,15 +88,21 @@ module RuboCop
           return if documentation_comment?(node) || nodoc_comment?(node)
           return if compact_namespace?(node) &&
                     nodoc_comment?(outer_module(node).first)
+          return if macro_only?(body)
 
           add_offense(node.loc.keyword, message: format(MSG, type: type))
         end
 
+        def macro_only?(body)
+          body.respond_to?(:macro?) && body.macro? ||
+            body.respond_to?(:children) && body.children&.all? { |child| macro_only?(child) }
+        end
+
         def namespace?(node)
           return false unless node
 
           if node.begin_type?
-            node.children.all?(&method(:constant_declaration?))
+            node.children.all? { |child| constant_declaration?(child) }
           else
             constant_definition?(node)
           end

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

@@ -111,15 +111,20 @@ module RuboCop
           format = format_arg.source
 
           args = if param_args.one?
-                   arg = param_args.last
-
-                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                   format_single_parameter(param_args.last)
                  else
                    "[#{param_args.map(&:source).join(', ')}]"
                  end
 
           corrector.replace(node, "#{format} % #{args}")
         end
+
+        def format_single_parameter(arg)
+          source = arg.source
+          return "{ #{source} }" if arg.hash_type?
+
+          arg.send_type? && arg.operator_method? && !arg.parenthesized? ? "(#{source})" : source
+        end
       end
     end
   end

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/method_call_with_args_parentheses/omit_parentheses.rb

@@ -74,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)
@@ -110,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_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/numeric_literals.rb

@@ -27,12 +27,13 @@ module RuboCop
       #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
-      class NumericLiterals < Cop
+      class NumericLiterals < Base
         # The parameter is called MinDigits (meaning the minimum number of
         # digits for which an offense can be registered), but essentially it's
         # a Max parameter (the maximum number of something that's allowed).
         include ConfigurableMax
         include IntegerNode
+        extend AutoCorrector
 
         MSG = 'Use underscores(_) as thousands separator and ' \
               'separate every 3 digits with them.'
@@ -46,12 +47,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, format_number(node))
-          end
-        end
-
         private
 
         def max_parameter_name
@@ -67,11 +62,19 @@ module RuboCop
 
           case int
           when /^\d+$/
-            add_offense(node) { self.max = int.size + 1 }
+            return unless (self.max = int.size + 1)
+
+            register_offense(node)
           when /\d{4}/, short_group_regex
-            add_offense(node) do
-              self.config_to_allow_offenses = { 'Enabled' => false }
-            end
+            return unless (self.config_to_allow_offenses = { 'Enabled' => false })
+
+            register_offense(node)
+          end
+        end
+
+        def register_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(node, format_number(node))
           end
         end
 

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a redundant argument passed to certain methods.
+      #
+      # Limitations:
+      #
+      # 1. This cop matches for method names only and hence cannot tell apart
+      #    methods with same name in different classes.
+      # 2. This cop is limited to methods with single parameter.
+      # 3. This cop is unsafe if certain special global variables (e.g. `$;`) are set.
+      #    That depends on the nature of the target methods, of course.
+      #
+      # Method names and their redundant arguments can be configured like this:
+      #
+      # Methods:
+      #   join: ''
+      #   split: ' '
+      #   foo: 2
+      #
+      # @example
+      #   # bad
+      #   array.join('')
+      #   [1, 2, 3].join("")
+      #   string.split(" ")
+      #   "first\nsecond".split(" ")
+      #   A.foo(2)
+      #
+      #   # good
+      #   array.join
+      #   [1, 2, 3].join
+      #   string.split
+      #   "first second".split
+      #   A.foo
+      class RedundantArgument < Base
+        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+
+        def on_send(node)
+          return if node.receiver.nil?
+          return if node.arguments.count != 1
+          return unless redundant_argument?(node)
+
+          add_offense(node, message: format(MSG, arg: node.arguments.first.source))
+        end
+
+        private
+
+        def redundant_argument?(node)
+          redundant_argument = redundant_arg_for_method(node.method_name.to_s)
+          return false if redundant_argument.nil?
+
+          node.arguments.first == redundant_argument
+        end
+
+        def redundant_arg_for_method(method_name)
+          return nil unless cop_config['Methods'].key?(method_name)
+
+          @mem ||= {}
+          @mem[method_name] ||=
+            begin
+              arg = cop_config['Methods'].fetch(method_name)
+              buffer = Parser::Source::Buffer.new('(string)', 1)
+              buffer.source = arg.inspect
+              builder = RuboCop::AST::Builder.new
+              Parser::CurrentRuby.new(builder).parse(buffer)
+            end
+        end
+      end
+    end
+  end
+end