rubocop 1.3.0 → 1.5.0

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

@@ -13,6 +13,7 @@ module RuboCop
         class AbcSizeCalculator
           include IteratingBlock
           include RepeatedCsendDiscount
+          prepend RepeatedAttributeDiscount
 
           # > Branch -- an explicit forward program branch out of scope -- a
           # > function call, class method call ..
@@ -24,8 +25,8 @@ module RuboCop
           # > http://c2.com/cgi/wiki?AbcMetric
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
-          def self.calculate(node)
-            new(node).calculate
+          def self.calculate(node, discount_repeated_attributes: false)
+            new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
           end
 
           # TODO: move to rubocop-ast
@@ -42,14 +43,8 @@ module RuboCop
           end
 
           def calculate
-            @node.each_node do |child|
-              @assignment += 1 if assignment?(child)
-
-              if branch?(child)
-                evaluate_branch_nodes(child)
-              elsif condition?(child)
-                evaluate_condition_node(child)
-              end
+            visit_depth_last(@node) do |child|
+              calculate_node(child)
             end
 
             [
@@ -80,6 +75,21 @@ module RuboCop
 
           private
 
+          def visit_depth_last(node, &block)
+            node.each_child_node { |child| visit_depth_last(child, &block) }
+            yield node
+          end
+
+          def calculate_node(node)
+            @assignment += 1 if assignment?(node)
+
+            if branch?(node)
+              evaluate_branch_nodes(node)
+            elsif condition?(node)
+              evaluate_condition_node(node)
+            end
+          end
+
           def assignment?(node)
             return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
 

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # Identifies repetitions `{c}send` calls with no arguments:
+        #
+        #   foo.bar
+        #   foo.bar # => repeated
+        #   foo.bar.baz.qux # => inner send repeated
+        #   foo.bar.baz.other # => both inner send repeated
+        #   foo.bar(2) # => not repeated
+        #
+        # It also invalidates sequences if a receiver is reassigned:
+        #
+        #   xx.foo.bar
+        #   xx.foo.baz      # => inner send repeated
+        #   self.xx = any   # => invalidates everything so far
+        #   xx.foo.baz      # => no repetition
+        #   self.xx.foo.baz # => all repeated
+        #
+        module RepeatedAttributeDiscount
+          extend NodePattern::Macros
+          include RuboCop::AST::Sexp
+
+          # Plug into the calculator
+          def initialize(node, discount_repeated_attributes: false)
+            super(node)
+            return unless discount_repeated_attributes
+
+            self_attributes = {} # Share hash for `(send nil? :foo)` and `(send (self) :foo)`
+            @known_attributes = {
+              s(:self) => self_attributes,
+              nil => self_attributes
+            }
+            # example after running `obj = foo.bar; obj.baz.qux`
+            # { nil => {foo: {bar: {}}},
+            #   s(self) => same hash ^,
+            #   s(:lvar, :obj) => {baz: {qux: {}}}
+            # }
+          end
+
+          def discount_repeated_attributes?
+            defined?(@known_attributes)
+          end
+
+          def evaluate_branch_nodes(node)
+            return if discount_repeated_attributes? && discount_repeated_attribute?(node)
+
+            super
+          end
+
+          def calculate_node(node)
+            update_repeated_attribute(node) if discount_repeated_attributes?
+            super
+          end
+
+          private
+
+          def_node_matcher :attribute_call?, <<~PATTERN
+            ( {csend send} _receiver _method # and no parameters
+            )
+          PATTERN
+
+          def discount_repeated_attribute?(send_node)
+            return false unless attribute_call?(send_node)
+
+            repeated = true
+            find_attributes(send_node) do |hash, lookup|
+              return false if hash.nil?
+
+              repeated = false
+              hash[lookup] = {}
+            end
+
+            repeated
+          end
+
+          def update_repeated_attribute(node)
+            return unless (receiver, method = setter_to_getter(node))
+
+            calls = find_attributes(receiver) { return }
+            if method # e.g. `self.foo = 42`
+              calls.delete(method)
+            else      # e.g. `var = 42`
+              calls.clear
+            end
+          end
+
+          def_node_matcher :root_node?, <<~PATTERN
+            { nil? | self               # e.g. receiver of `my_method` or `self.my_attr`
+            | lvar | ivar | cvar | gvar # e.g. receiver of `var.my_method`
+            | const }                   # e.g. receiver of `MyConst.foo.bar`
+          PATTERN
+
+          # Returns the "known_attributes" for the `node` by walking the receiver tree
+          # If at any step the subdirectory does not exist, it is yielded with the
+          # associated key (method_name)
+          # If the node is not a series of `(c)send` calls with no arguments,
+          # then `nil` is yielded
+          def find_attributes(node, &block)
+            if attribute_call?(node)
+              calls = find_attributes(node.receiver, &block)
+              value = node.method_name
+            elsif root_node?(node)
+              calls = @known_attributes
+              value = node
+            else
+              return yield nil
+            end
+
+            calls.fetch(value) do
+              yield [calls, value]
+            end
+          end
+
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
+          # @returns `[receiver, method | nil]` for the given setter `node`
+          # or `nil` if it is not a setter.
+          def setter_to_getter(node)
+            if (type = VAR_SETTER_TO_GETTER[node.type])
+              # (lvasgn :my_var (int 42)) => [(lvar my_var), nil]
+              [s(type, node.children.first), nil]
+            elsif node.shorthand_asgn? # (or-asgn (send _receiver :foo) _value)
+              # (or-asgn (send _receiver :foo) _value) => [_receiver, :foo]
+              node.children.first.children
+            elsif node.respond_to?(:setter_method?) && node.setter_method?
+              # (send _receiver :foo= (int 42) ) => [_receiver, :foo]
+              method_name = node.method_name[0...-1].to_sym
+              [node.receiver, method_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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+)$/,
-        normalcase:  /(?:\D|[^_\d]\d+)$/,
-        non_integer: /\D$/
+        snake_case:  /(?:\D|_\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/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/document_dynamic_eval_definition.rb

@@ -68,6 +68,12 @@ module RuboCop
       #       end
       #     EOT
       #   )
+      #
+      #   # bad - interpolated string without comment
+      #   class_eval("def #{unsafe_method}!(*params); end")
+      #
+      #   # good - with inline comment or replace it with block comment using heredoc
+      #   class_eval("def #{unsafe_method}!(*params); end # def capitalize!(*params); end")
       class DocumentDynamicEvalDefinition < Base
         BLOCK_COMMENT_REGEXP = /^\s*#(?!{)/.freeze
         COMMENT_REGEXP = /\s*#(?!{).*/.freeze
@@ -79,7 +85,8 @@ module RuboCop
           arg_node = node.first_argument
 
           return unless arg_node&.dstr_type? && interpolated?(arg_node)
-          return if inline_comment_docs?(arg_node) || comment_block_docs?(arg_node)
+          return if inline_comment_docs?(arg_node) ||
+                    arg_node.heredoc? && comment_block_docs?(arg_node)
 
           add_offense(node.loc.selector)
         end

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