rubocop 1.9.1 → 1.13.0

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

@@ -26,6 +26,24 @@ module RuboCop
       #     public_constant :BAZ
       #   end
       #
+      # @example IgnoreModules: false (default)
+      #   # bad
+      #   class Foo
+      #     MyClass = Struct.new()
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     MyClass = Struct.new()
+      #     public_constant :MyClass
+      #   end
+      #
+      # @example IgnoreModules: true
+      #   # good
+      #   class Foo
+      #     MyClass = Struct.new()
+      #   end
+      #
       class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
@@ -33,6 +51,7 @@ module RuboCop
         def on_casgn(node)
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
+          return if ignore_modules? && module?(node)
 
           message = message(node)
           add_offense(node, message: message)
@@ -40,6 +59,14 @@ module RuboCop
 
         private
 
+        def ignore_modules?
+          cop_config.fetch('IgnoreModules', false)
+        end
+
+        def module?(node)
+          node.children.last.class_constructor?
+        end
+
         def message(node)
           _namespace, constant_name, _value = *node
 
@@ -65,6 +92,7 @@ module RuboCop
           end
         end
 
+        # @!method visibility_declaration_for?(node, const_name)
         def_node_matcher :visibility_declaration_for?, <<~PATTERN
           (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
         PATTERN

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

@@ -19,10 +19,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
-              'any code.'
-        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
-                                    'your RuboCop config'
+        MSG = 'Include a copyright notice matching /%<notice>s/ before any code.'
+        AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in your RuboCop config'
 
         def on_new_investigation
           return if notice.empty? || notice_found?(processed_source)
@@ -57,8 +55,7 @@ module RuboCop
           regex = Regexp.new(notice)
           return if autocorrect_notice&.match?(regex)
 
-          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                         "match Notice /#{notice}/"
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must match Notice /#{notice}/"
         end
 
         def insert_notice_before(processed_source)

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

@@ -47,28 +47,28 @@ module RuboCop
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
+        # @!method date_time?(node)
         def_node_matcher :date_time?, <<~PATTERN
           (send (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
+        # @!method historic_date?(node)
         def_node_matcher :historic_date?, <<~PATTERN
           (send _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
+        # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
           (send _ :to_datetime)
         PATTERN
 
         def on_send(node)
-          return unless date_time?(node) ||
-                        (to_datetime?(node) && disallow_coercion?)
+          return unless date_time?(node) || (to_datetime?(node) && disallow_coercion?)
           return if historic_date?(node)
 
           message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         private

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

@@ -36,8 +36,7 @@ module RuboCop
       class DefWithParentheses < Base
         extend AutoCorrector
 
-        MSG = "Omit the parentheses in defs when the method doesn't accept " \
-              'any arguments.'
+        MSG = "Omit the parentheses in defs when the method doesn't accept any arguments."
 
         def on_def(node)
           return if node.single_line?

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

@@ -22,6 +22,7 @@ module RuboCop
         MSG = "Use `__dir__` to get an absolute path to the current file's directory."
         RESTRICT_ON_SEND = %i[expand_path dirname].freeze
 
+        # @!method dir_replacement?(node)
         def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
            (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}

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

@@ -70,8 +70,8 @@ module RuboCop
         end
 
         def directive_cops(comment)
-          match = CommentConfig::COMMENT_DIRECTIVE_REGEXP.match(comment.text)
-          match && match[2] ? match[2].split(',').map(&:strip) : []
+          match_captures = DirectiveComment.new(comment).match_captures
+          match_captures && match_captures[1] ? match_captures[1].split(',').map(&:strip) : []
         end
 
         def allowed_cops

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

@@ -60,13 +60,27 @@ module RuboCop
       #       extend Foo
       #     end
       #
+      # @example AllowedConstants: ['ClassMethods']
+      #
+      #    # good
+      #    module A
+      #      module ClassMethods
+      #        # ...
+      #      end
+      #     end
+      #
       class Documentation < Base
         include DocumentationComment
 
         MSG = 'Missing top-level %<type>s documentation comment.'
 
+        # @!method constant_definition?(node)
         def_node_matcher :constant_definition?, '{class module casgn}'
+
+        # @!method outer_module(node)
         def_node_search :outer_module, '(const (const nil? _) _)'
+
+        # @!method constant_visibility_declaration?(node)
         def_node_matcher :constant_visibility_declaration?, <<~PATTERN
           (send nil? {:public_constant :private_constant} ({sym str} _))
         PATTERN
@@ -85,14 +99,19 @@ module RuboCop
 
         def check(node, body, type)
           return if namespace?(body)
-          return if documentation_comment?(node) || nodoc_comment?(node)
-          return if compact_namespace?(node) &&
-                    nodoc_comment?(outer_module(node).first)
+          return if documentation_comment?(node)
+          return if constant_allowed?(node)
+          return if nodoc_self_or_outer_module?(node)
           return if macro_only?(body)
 
           add_offense(node.loc.keyword, message: format(MSG, type: type))
         end
 
+        def nodoc_self_or_outer_module?(node)
+          nodoc_comment?(node) ||
+            compact_namespace?(node) && nodoc_comment?(outer_module(node).first)
+        end
+
         def macro_only?(body)
           body.respond_to?(:macro?) && body.macro? ||
             body.respond_to?(:children) && body.children&.all? { |child| macro_only?(child) }
@@ -112,6 +131,10 @@ module RuboCop
           constant_definition?(node) || constant_visibility_declaration?(node)
         end
 
+        def constant_allowed?(node)
+          allowed_constants.include?(node.identifier.short_name)
+        end
+
         def compact_namespace?(node)
           /::/.match?(node.loc.name.source)
         end
@@ -138,6 +161,10 @@ module RuboCop
         def nodoc(node)
           processed_source.ast_with_comments[node.children.first].first
         end
+
+        def allowed_constants
+          @allowed_constants ||= cop_config.fetch('AllowedConstants', []).map(&:intern)
+        end
       end
     end
   end

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

@@ -97,6 +97,7 @@ module RuboCop
 
         MSG = 'Missing method documentation comment.'
 
+        # @!method module_function_node?(node)
         def_node_matcher :module_function_node?, <<~PATTERN
           (send nil? :module_function ...)
         PATTERN

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # This cop checks for uses of double negation (`!!`) to convert something to a boolean value.
       #
-      # When using `EnforcedStyle: allowed_in_returns`, allow double nagation in contexts
-      # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double nagation
+      # When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts
+      # that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation
       # should be forbidden always.
       #
       # @example
@@ -39,6 +39,7 @@ module RuboCop
         MSG = 'Avoid the use of double negation (`!!`).'
         RESTRICT_ON_SEND = %i[!].freeze
 
+        # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_send(node)

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

@@ -25,8 +25,7 @@ module RuboCop
       class EachForSimpleLoop < Base
         extend AutoCorrector
 
-        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
-              'number of times.'
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
         def on_block(node)
           return unless offending_each_range(node)
@@ -46,6 +45,7 @@ module RuboCop
 
         private
 
+        # @!method offending_each_range(node)
         def_node_matcher :offending_each_range, <<~PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN

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

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
+        # @!method each_with_object_candidate?(node)
         def_node_matcher :each_with_object_candidate?, <<~PATTERN
           (block $(send _ {:inject :reduce} _) $_ $_)
         PATTERN

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

@@ -44,19 +44,14 @@ module RuboCop
         def on_case(case_node)
           return if case_node.condition
 
-          branch_bodies = [
-            *case_node.when_branches.map(&:body),
-            case_node.else_branch
-          ].compact
+          branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
           return if branch_bodies.any? do |body|
             body.return_type? ||
             body.each_descendant.any?(&:return_type?)
           end
 
-          add_offense(case_node.loc.keyword) do |corrector|
-            autocorrect(corrector, case_node)
-          end
+          add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
 
         private

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

@@ -123,17 +123,13 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node.loc.else) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
         def nil_check(node)
           return unless node.else_branch&.nil_type?
 
-          add_offense(node.loc.else) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node.loc.else) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -154,9 +150,7 @@ module RuboCop
           return node if node.case_type?
           return node unless node.elsif?
 
-          node.each_ancestor(:if, :case, :when).find(-> { node }) do |parent|
-            parent.loc.end
-          end
+          node.each_ancestor(:if, :case, :when).find(-> { node }) { |parent| parent.loc.end }
         end
 
         def autocorrect_forbidden?(type)

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

@@ -27,11 +27,19 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method array_node(node)
         def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+
+        # @!method hash_node(node)
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+
+        # @!method str_node(node)
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
-        def_node_matcher :array_with_block,
-                         '(block (send (const {nil? cbase} :Array) :new) args _)'
+
+        # @!method array_with_block(node)
+        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+
+        # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
           {
             (block (send (const {nil? cbase} :Hash) :new) args _)
@@ -75,20 +83,17 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) &&
-            !parentheses?(node.parent)
+          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)
-          if hash_node(node) &&
-             first_argument_unparenthesized?(node)
+          if hash_node(node) && first_argument_unparenthesized?(node)
             # `some_method {}` is not same as `some_method Hash.new`
             # because the braces are interpreted as a block. We will have
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].source_range.begin_pos - 1,
-                          args[-1].source_range.end_pos)
+            range_between(args[0].source_range.begin_pos - 1, args[-1].source_range.end_pos)
           else
             node.source_range
           end

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

@@ -45,16 +45,13 @@ module RuboCop
         extend AutoCorrector
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'
-        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
-                       'next line.'
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, corrected(node))
-          end
+          add_offense(node) { |corrector| corrector.replace(node, corrected(node)) }
         end
         alias on_defs on_def
 
@@ -65,8 +62,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          compact_style? && compact?(node) ||
-            expanded_style? && expanded?(node)
+          compact_style? && compact?(node) || expanded_style? && expanded?(node)
         end
 
         def corrected(node)

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

@@ -15,8 +15,7 @@ module RuboCop
       class EndBlock < Base
         extend AutoCorrector
 
-        MSG = 'Avoid the use of `END` blocks. ' \
-              'Use `Kernel#at_exit` instead.'
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
           add_offense(node.loc.keyword) do |corrector|

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

@@ -11,6 +11,7 @@ module RuboCop
       # Other method definition types are not considered by this cop.
       #
       # The supported styles are:
+      #
       # * allow_single_line (default) - only single line endless method definitions are allowed.
       # * allow_always - all endless method definitions are allowed.
       # * disallow - all endless method definitions are disallowed.
@@ -78,9 +79,7 @@ module RuboCop
         def handle_disallow_style(node)
           return unless node.endless?
 
-          add_offense(node) do |corrector|
-            correct_to_multiline(corrector, node)
-          end
+          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
         end
 
         def correct_to_multiline(corrector, node)

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

@@ -12,6 +12,11 @@ module RuboCop
       # The cop also checks that the line number given relative to `__LINE__` is
       # correct.
       #
+      # This cop will autocorrect incorrect or missing filename and line number
+      # values. However, if `eval` is called without a binding argument, the cop
+      # will not attempt to automatically add a binding, or add filename and
+      # line values.
+      #
       # @example
       #   # bad
       #   eval <<-RUBY
@@ -36,7 +41,21 @@ module RuboCop
       #     def do_something
       #     end
       #   RUBY
+      #
+      # This cop works only when a string literal is given as a code string.
+      # No offence is reported if a string variable is given as below:
+      #
+      # @example
+      #   # not checked
+      #   code = <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #   eval code
+      #
       class EvalWithLocation < Base
+        extend AutoCorrector
+
         MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
         MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
         MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
@@ -46,10 +65,12 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
+        # @!method valid_eval_receiver?(node)
         def_node_matcher :valid_eval_receiver?, <<~PATTERN
           { nil? (const {nil? cbase} :Kernel) }
         PATTERN
 
+        # @!method line_with_offset?(node, sign, num)
         def_node_matcher :line_with_offset?, <<~PATTERN
           {
             (send #special_line_keyword? %1 (int %2))
@@ -66,31 +87,36 @@ module RuboCop
           code = node.arguments.first
           return unless code && (code.str_type? || code.dstr_type?)
 
+          check_location(node, code)
+        end
+
+        private
+
+        def check_location(node, code)
           file, line = file_and_line(node)
 
           if line
             check_file(node, file)
             check_line(node, code)
+          elsif file
+            check_file(node, file)
+            add_offense_for_missing_line(node, code)
           else
-            register_offense(node)
+            add_offense_for_missing_location(node, code)
           end
         end
 
-        private
-
-        def register_offense(node)
+        def register_offense(node, &block)
           msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
-          add_offense(node, message: msg)
+          add_offense(node, message: msg, &block)
         end
 
         def special_file_keyword?(node)
-          node.str_type? &&
-            node.source == '__FILE__'
+          node.str_type? && node.source == '__FILE__'
         end
 
         def special_line_keyword?(node)
-          node.int_type? &&
-            node.source == '__LINE__'
+          node.int_type? && node.source == '__LINE__'
         end
 
         def file_and_line(node)
@@ -98,6 +124,10 @@ module RuboCop
           [node.arguments[base], node.arguments[base + 1]]
         end
 
+        def with_binding?(node)
+          node.method?(:eval) ? node.arguments.size >= 2 : true
+        end
+
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
@@ -109,18 +139,16 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(method_name, actual, sign, line_diff)
-          expected =
-            if line_diff.zero?
-              '__LINE__'
-            else
-              "__LINE__ #{sign} #{line_diff}"
-            end
+        def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
+          expected = expected_line(sign, line_diff)
+          message = format(MSG_INCORRECT_LINE,
+                           method_name: method_name,
+                           actual: line_node.source,
+                           expected: expected)
 
-          format(MSG_INCORRECT_LINE,
-                 method_name: method_name,
-                 actual: actual.source,
-                 expected: expected)
+          add_offense(line_node.loc.expression, message: message) do |corrector|
+            corrector.replace(line_node, expected)
+          end
         end
 
         def check_file(node, file_node)
@@ -131,13 +159,14 @@ module RuboCop
                            expected: '__FILE__',
                            actual: file_node.source)
 
-          add_offense(file_node, message: message)
+          add_offense(file_node, message: message) do |corrector|
+            corrector.replace(file_node, '__FILE__')
+          end
         end
 
         def check_line(node, code)
           line_node = node.arguments.last
-          lineno_range = line_node.loc.expression
-          line_diff = string_first_line(code) - lineno_range.first_line
+          line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)
           else
@@ -145,6 +174,10 @@ module RuboCop
           end
         end
 
+        def line_difference(line_node, code)
+          string_first_line(code) - line_node.loc.expression.first_line
+        end
+
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
@@ -156,20 +189,47 @@ module RuboCop
         def add_offense_for_same_line(node, line_node)
           return if special_line_keyword?(line_node)
 
-          add_offense(
-            line_node.loc.expression,
-            message: message_incorrect_line(node.method_name, line_node, nil, 0)
-          )
+          add_offense_for_incorrect_line(node.method_name, line_node, nil, 0)
         end
 
         def add_offense_for_different_line(node, line_node, line_diff)
           sign = line_diff.positive? ? :+ : :-
           return if line_with_offset?(line_node, sign, line_diff.abs)
 
-          add_offense(
-            line_node.loc.expression,
-            message: message_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
-          )
+          add_offense_for_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
+        end
+
+        def expected_line(sign, line_diff)
+          if line_diff.zero?
+            '__LINE__'
+          else
+            "__LINE__ #{sign} #{line_diff.abs}"
+          end
+        end
+
+        def add_offense_for_missing_line(node, code)
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.loc.expression.end, ", #{line_str}")
+          end
+        end
+
+        def add_offense_for_missing_location(node, code)
+          if node.method?(:eval) && !with_binding?(node)
+            register_offense(node)
+            return
+          end
+
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.last_argument.source_range.end, ", __FILE__, #{line_str}")
+          end
+        end
+
+        def missing_line(node, code)
+          line_diff = line_difference(node.arguments.last, code)
+          sign = line_diff.positive? ? :+ : :-
+          expected_line(sign, line_diff)
         end
       end
     end