rubocop 0.80.1 → 0.81.0

data/lib/rubocop/cop/migration/department_name.rb

@@ -14,19 +14,24 @@ module RuboCop
           /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
 
         # The token that makes up a disable comment.
-        # The token used after `# rubocop: disable` are `A-z`, `/`, and `,`.
-        # Also `A-z` includes `all`.
-        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z/,]+}.freeze
+        # The allowed specification for comments after `# rubocop: disable` is
+        # `DepartmentName/CopName` or` all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
 
         def investigate(processed_source)
           processed_source.each_comment do |comment|
             next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
-            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
-              break unless valid_content_token?(name.strip)
 
-              check_cop_name(name, comment, offset)
+            Regexp.last_match(4).scan(/[^,]+|[\W]+/) do |name|
+              trimmed_name = name.strip
+
+              break if contain_plain_comment?(trimmed_name)
+
+              unless valid_content_token?(trimmed_name)
+                check_cop_name(trimmed_name, comment, offset)
+              end
 
               offset += name.length
             end
@@ -47,16 +52,24 @@ module RuboCop
 
         private
 
-        def check_cop_name(name, comment, offset)
-          return if name !~ /^[A-Z]/ || name =~ %r{/}
+        def disable_comment_offset
+          Regexp.last_match(1).length
+        end
 
+        def check_cop_name(name, comment, offset)
           start = comment.location.expression.begin_pos + offset
           range = range_between(start, start + name.length)
+
           add_offense(range, location: range)
         end
 
         def valid_content_token?(content_token)
-          !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+          !/\W+/.match(content_token).nil? ||
+            !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+        end
+
+        def contain_plain_comment?(name)
+          name == '#'
         end
 
         def qualified_legacy_cop_name(cop_name)

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

@@ -20,7 +20,7 @@ module RuboCop
         return if ignored_node?(node)
 
         end_loc = node.loc.end
-        return unless end_loc # Discard modifier forms of if/while/until.
+        return if accept_end_kw_alignment?(end_loc)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -49,6 +49,11 @@ module RuboCop
         add_offense(node, location: end_loc, message: msg)
       end
 
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+      end
+
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end

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

@@ -5,15 +5,20 @@ module RuboCop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
+      include IgnoredMethods
       extend NodePattern::Macros
 
       def on_def(node)
+        return if ignored_method?(node.method_name)
+
         check_complexity(node, node.method_name)
       end
       alias on_defs on_def
 
       def on_block(node)
         define_method?(node) do |name|
+          return if ignored_method?(name)
+
           check_complexity(node, name)
         end
       end

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

@@ -31,9 +31,28 @@ module RuboCop
       class MethodName < Cop
         include ConfigurableNaming
         include IgnoredPattern
+        include RangeHelp
 
         MSG = 'Use %<style>s for method names.'
 
+        def_node_matcher :attr?, <<~PATTERN
+          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+        PATTERN
+
+        def_node_matcher :sym_name, '(sym $_name)'
+        def_node_matcher :str_name, '(str $_name)'
+
+        def on_send(node)
+          return unless (attrs = attr?(node))
+
+          attrs.last.each do |name_item|
+            name = attr_name(name_item)
+            next if !name || matches_ignored_pattern?(name)
+
+            check_name(node, name, range_position(node))
+          end
+        end
+
         def on_def(node)
           return if node.operator_method? ||
                     matches_ignored_pattern?(node.method_name)
@@ -44,6 +63,17 @@ module RuboCop
 
         private
 
+        def attr_name(name_item)
+          sym_name(name_item) || str_name(name_item)
+        end
+
+        def range_position(node)
+          selector_end_pos = node.loc.selector.end_pos + 1
+          expr_end_pos = node.loc.expression.end_pos
+
+          range_between(selector_end_pos, expr_end_pos)
+        end
+
         def message(style)
           format(MSG, style: style)
         end

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

@@ -5,11 +5,12 @@ module RuboCop
     module Style
       # Access modifiers should be declared to apply to a group of methods
       # or inline before each method, depending on configuration.
+      # EnforcedStyle config covers only method definitions.
+      # Applications of visibility methods to symbols can be controlled
+      # using AllowModifiersOnSymbols config.
       #
       # @example EnforcedStyle: group (default)
-      #
       #   # bad
-      #
       #   class Foo
       #
       #     private def bar; end
@@ -18,7 +19,6 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private
@@ -27,10 +27,9 @@ module RuboCop
       #     def baz; end
       #
       #   end
-      # @example EnforcedStyle: inline
       #
+      # @example EnforcedStyle: inline
       #   # bad
-      #
       #   class Foo
       #
       #     private
@@ -41,13 +40,28 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private def bar; end
       #     private def baz; end
       #
       #   end
+      #
+      # @example AllowModifiersOnSymbols: true
+      #   # good
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: false
+      #   # bad
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
       class AccessModifierDeclarations < Cop
         include ConfigurableEnforcedStyle
 
@@ -61,9 +75,15 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
+          (send nil? {:private :protected :public} (sym _))
+        PATTERN
+
         def on_send(node)
           return unless node.access_modifier?
           return if node.parent.pair_type?
+          return if cop_config['AllowModifiersOnSymbols'] &&
+                    access_modifier_with_symbol?(node)
 
           if offense?(node)
             add_offense(node, location: :selector) do

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

@@ -27,6 +27,7 @@ module RuboCop
       #   items.inject
       #   items.detect
       #   items.find_all
+      #   items.member?
       #
       #   # good
       #   items.map
@@ -34,6 +35,7 @@ module RuboCop
       #   items.reduce
       #   items.find
       #   items.select
+      #   items.include?
       #
       class CollectionMethods < Cop
         include MethodPreference

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

@@ -3,10 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for missing top-level documentation of
-      # classes and modules. Classes with no body are exempt from the
-      # check and so are namespace modules - modules that have nothing in
-      # their bodies except classes, other modules, or constant definitions.
+      # This cop checks for missing top-level documentation of classes and
+      # modules. Classes with no body are exempt from the check and so are
+      # namespace modules - modules that have nothing in their bodies except
+      # classes, other modules, constant definitions or constant visibility
+      # declarations.
       #
       # The documentation requirement is annulled if the class or module has
       # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
@@ -18,12 +19,42 @@ module RuboCop
       #     # ...
       #   end
       #
+      #   module Math
+      #   end
+      #
       #   # good
       #   # Description/Explanation of Person class
       #   class Person
       #     # ...
       #   end
       #
+      #   # allowed
+      #     # Class without body
+      #     class Person
+      #     end
+      #
+      #     # Namespace - A namespace can be a class or a module
+      #     # Containing a class
+      #     module Namespace
+      #       # Description/Explanation of Person class
+      #       class Person
+      #         # ...
+      #       end
+      #     end
+      #
+      #     # Containing constant visibility declaration
+      #     module Namespace
+      #       class Private
+      #       end
+      #
+      #       private_constant :Private
+      #     end
+      #
+      #     # Containing constant definition
+      #     module Namespace
+      #       Public = Class.new
+      #     end
+      #
       class Documentation < Cop
         include DocumentationComment
 
@@ -31,6 +62,9 @@ module RuboCop
 
         def_node_matcher :constant_definition?, '{class module casgn}'
         def_node_search :outer_module, '(const (const nil? _) _)'
+        def_node_matcher :constant_visibility_declaration?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} _))
+        PATTERN
 
         def on_class(node)
           return unless node.body
@@ -59,12 +93,16 @@ module RuboCop
           return false unless node
 
           if node.begin_type?
-            node.children.all? { |child| constant_definition?(child) }
+            node.children.all?(&method(:constant_declaration?))
           else
             constant_definition?(node)
           end
         end
 
+        def constant_declaration?(node)
+          constant_definition?(node) || constant_visibility_declaration?(node)
+        end
+
         def compact_namespace?(node)
           node.loc.name.source =~ /::/
         end

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

@@ -19,6 +19,12 @@ module RuboCop
         def on_postexe(node)
           add_offense(node, location: :keyword)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, 'at_exit')
+          end
+        end
       end
     end
   end

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

@@ -40,6 +40,8 @@ module RuboCop
 
         def register_kv_offense(node)
           kv_each(node) do |target, method|
+            return unless target.receiver.receiver
+
             msg = format(message, prefer: "each_#{method[0..-2]}",
                                   current: "#{method}.each")
 

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

@@ -31,7 +31,9 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !(send _ :each_with_index) :each_with_object (hash))
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
@@ -55,7 +57,9 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
-              ({send csend} !(send _ :each_with_index) {:map :collect})
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                {:map :collect})
               (args
                 (arg $_)
                 (arg _val))

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

@@ -31,7 +31,9 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !(send _ :each_with_index) :each_with_object (hash))
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
@@ -55,7 +57,9 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
-              ({send csend} !(send _ :each_with_index) {:map :collect})
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                 {:map :collect})
               (args
                 (arg _key)
                 (arg $_))

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

@@ -44,7 +44,7 @@ module RuboCop
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::Not]
+          [Style::Not, Style::SymbolProc]
         end
 
         def_node_matcher :inverse_candidate?, <<~PATTERN

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

@@ -73,6 +73,7 @@ module RuboCop
                       location: node.send_node.source_range,
                       message: message(node, selector))
         end
+        alias on_numblock on_block
 
         def autocorrect(node)
           if node.send_node.source == 'lambda'

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self.
+      # Supported styles are: module_function, extend_self, forbidden.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -46,6 +46,29 @@ module RuboCop
       #     # ...
       #   end
       #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
+      #
       # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
       class ModuleFunction < Cop
@@ -55,6 +78,8 @@ module RuboCop
           'Use `module_function` instead of `extend self`.'
         EXTEND_SELF_MSG =
           'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG =
+          'Do not use `module_function` or `extend self`.'
 
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
@@ -69,6 +94,8 @@ module RuboCop
         end
 
         def autocorrect(node)
+          return if style == :forbidden
+
           lambda do |corrector|
             if extend_self_node?(node)
               corrector.replace(node.source_range, 'module_function')
@@ -80,22 +107,41 @@ module RuboCop
 
         private
 
-        def each_wrong_style(nodes)
+        def each_wrong_style(nodes, &block)
           case style
           when :module_function
-            private_directive = nodes.any? { |node| private_directive?(node) }
-
-            nodes.each do |node|
-              yield node if extend_self_node?(node) && !private_directive
-            end
+            check_module_function(nodes, &block)
           when :extend_self
-            nodes.each do |node|
-              yield node if module_function_node?(node)
-            end
+            check_extend_self(nodes, &block)
+          when :forbidden
+            check_forbidden(nodes, &block)
+          end
+        end
+
+        def check_module_function(nodes)
+          private_directive = nodes.any? { |node| private_directive?(node) }
+
+          nodes.each do |node|
+            yield node if extend_self_node?(node) && !private_directive
+          end
+        end
+
+        def check_extend_self(nodes)
+          nodes.each do |node|
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def check_forbidden(nodes)
+          nodes.each do |node|
+            yield node if extend_self_node?(node)
+            yield node if module_function_node?(node)
           end
         end
 
         def message(_node)
+          return FORBIDDEN_MSG if style == :forbidden
+
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
         end
       end