rubocop 1.8.0 → 1.11.0

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

@@ -77,6 +77,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[private protected public module_function].freeze
 
+        # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public} (sym _))
         PATTERN

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

@@ -145,6 +145,7 @@ module RuboCop
           corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
         end
 
+        # @!method identifier(node)
         def_node_matcher :identifier, <<~PATTERN
           (sym $_)
         PATTERN

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

@@ -47,14 +47,17 @@ module RuboCop
 
         MSG = 'Use arguments forwarding.'
 
+        # @!method use_rest_arguments?(node)
         def_node_matcher :use_rest_arguments?, <<~PATTERN
           (args (restarg $_) $...)
         PATTERN
 
+        # @!method only_rest_arguments?(node, name)
         def_node_matcher :only_rest_arguments?, <<~PATTERN
           (send _ _ (splat (lvar %1)))
         PATTERN
 
+        # @!method forwarding_method_arguments?(node, rest_name, block_name, kwargs_name)
         def_node_matcher :forwarding_method_arguments?, <<~PATTERN
           {
             (send _ _

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

@@ -26,10 +26,12 @@ module RuboCop
         SPLAT_MSG = 'Use `Array(%<arg>s)` instead of `[*%<arg>s]`.'
         CHECK_MSG = 'Use `Array(%<arg>s)` instead of explicit `Array` check.'
 
+        # @!method array_splat?(node)
         def_node_matcher :array_splat?, <<~PATTERN
           (array (splat $_))
         PATTERN
 
+        # @!method unless_array?(node)
         def_node_matcher :unless_array?, <<~PATTERN
           (if
             (send

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

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Favor `Array#join` over `Array#*`.'
         RESTRICT_ON_SEND = %i[*].freeze
 
+        # @!method join_candidate?(node)
         def_node_matcher :join_candidate?, '(send $array :* $str)'
 
         def on_send(node)

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

@@ -7,7 +7,7 @@ module RuboCop
     module Style
       # This cop checks for non-ascii (non-English) characters
       # in comments. You could set an array of allowed non-ascii chars in
-      # AllowedChars attribute (empty by default).
+      # `AllowedChars` attribute (copyright notice "©" by default).
       #
       # @example
       #   # bad

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

@@ -62,6 +62,7 @@ module RuboCop
           end
         end
 
+        # @!method class_eval?(node)
         def_node_matcher :class_eval?, <<~PATTERN
           (block (send _ {:class_eval :module_eval}) ...)
         PATTERN

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

@@ -35,6 +35,7 @@ module RuboCop
         MSG = 'Avoid the use of the case equality operator `===`.'
         RESTRICT_ON_SEND = %i[===].freeze
 
+        # @!method case_equality?(node)
         def_node_matcher :case_equality?, '(send $#const? :=== $_)'
 
         def on_send(node)
@@ -64,7 +65,7 @@ module RuboCop
             # The automatic correction from `a === b` to `a.match?(b)` needs to
             # consider `Regexp.last_match?`, `$~`, `$1`, and etc.
             # This correction is expected to be supported by `Performance/Regexp` cop.
-            # See: https://github.com/rubocop-hq/rubocop-performance/issues/152
+            # See: https://github.com/rubocop/rubocop-performance/issues/152
             #
             # So here is noop.
           when :begin

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

@@ -25,6 +25,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[== equal? eql?].freeze
 
+        # @!method class_comparison_candidate?(node)
         def_node_matcher :class_comparison_candidate?, <<~PATTERN
           (send
             {$(send _ :class) (send $(send _ :class) :name)}

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

@@ -35,6 +35,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
 
+        # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
@@ -44,6 +45,7 @@ module RuboCop
               $(lvar _) :nil?))
         PATTERN
 
+        # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send

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

@@ -22,6 +22,7 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
+        # @!method java_type_node?(node)
         def_node_matcher :java_type_node?, <<~PATTERN
           (send
             (const nil? :Java) _)

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

@@ -165,7 +165,7 @@ module RuboCop
         end
 
         def preferred_delimiter
-          (command_delimiter || default_delimiter).split(//)
+          (command_delimiter || default_delimiter).split('')
         end
 
         def command_delimiter

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

@@ -231,6 +231,7 @@ module RuboCop
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
+        # @!method assignment_type?(node)
         def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
@@ -300,6 +301,7 @@ module RuboCop
           style == :assign_inside_condition && assignment_rhs_exist?(node)
         end
 
+        # @!method candidate_condition?(node)
         def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
 
         def allowed_ternary?(assignment)

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/date_time.rb

@@ -47,14 +47,17 @@ 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

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

@@ -9,37 +9,77 @@ module RuboCop
       # This is useful if want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
+      # Specific cops can be allowed with the `AllowedCops` configuration. Note that
+      # if this configuration is set, `rubocop:disable all` is still disallowed.
+      #
       # @example
       #   # bad
       #   # rubocop:disable Metrics/AbcSize
-      #   def f
+      #   def foo
       #   end
       #   # rubocop:enable Metrics/AbcSize
       #
       #   # good
-      #   def fixed_method_name_and_no_rubocop_comments
+      #   def foo
+      #   end
+      #
+      # @example AllowedCops: [Metrics/AbcSize]
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   def foo
       #   end
+      #   # rubocop:enable Metrics/AbcSize
       #
       class DisableCopsWithinSourceCodeDirective < Base
         extend AutoCorrector
 
         # rubocop:enable Lint/RedundantCopDisableDirective
-        MSG = 'Comment to disable/enable RuboCop.'
+        MSG = 'Rubocop disable/enable directives are not permitted.'
+        MSG_FOR_COPS = 'Rubocop disable/enable directives for %<cops>s are not permitted.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless rubocop_directive_comment?(comment)
+            directive_cops = directive_cops(comment)
+            disallowed_cops = directive_cops - allowed_cops
 
-            add_offense(comment) do |corrector|
-              corrector.replace(comment, '')
-            end
+            next unless disallowed_cops.any?
+
+            register_offense(comment, directive_cops, disallowed_cops)
           end
         end
 
         private
 
-        def rubocop_directive_comment?(comment)
-          CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
+        def register_offense(comment, directive_cops, disallowed_cops)
+          message = if any_cops_allowed?
+                      format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
+                    else
+                      MSG
+                    end
+
+          add_offense(comment, message: message) do |corrector|
+            replacement = ''
+
+            if directive_cops.length != disallowed_cops.length
+              replacement = comment.text.sub(/#{Regexp.union(disallowed_cops)},?\s*/, '')
+                                   .sub(/,\s*$/, '')
+            end
+
+            corrector.replace(comment, replacement)
+          end
+        end
+
+        def directive_cops(comment)
+          match = CommentConfig::COMMENT_DIRECTIVE_REGEXP.match(comment.text)
+          match && match[2] ? match[2].split(',').map(&:strip) : []
+        end
+
+        def allowed_cops
+          Array(cop_config['AllowedCops'])
+        end
+
+        def any_cops_allowed?
+          allowed_cops.any?
         end
       end
     end

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

@@ -65,8 +65,13 @@ module RuboCop
 
         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

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

@@ -46,6 +46,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_literal.rb

@@ -27,11 +27,20 @@ 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)'
+
+        # @!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 _)

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.

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

@@ -3,9 +3,19 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks `eval` method usage. `eval` can receive source location
-      # metadata, that are filename and line number. The metadata is used by
-      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      # This cop ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # and `module_eval`) are given filename and line number values (`__FILE__`
+      # and `__LINE__`). This data is used to ensure that any errors raised
+      # within the evaluated code will be given the correct identification
+      # in a backtrace.
+      #
+      # 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
@@ -31,30 +41,36 @@ 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
-        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
-              'as they are used by backtraces.'
-        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
-                             'as they are used by backtraces.'
+        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`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
 
         RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
-        def_node_matcher :eval_without_location?, <<~PATTERN
-          {
-            (send nil? :eval ${str dstr})
-            (send nil? :eval ${str dstr} _)
-            (send nil? :eval ${str dstr} _ #special_file_keyword?)
-            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
-
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr})
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword?)
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword? _)
-          }
+        # @!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))
@@ -63,17 +79,38 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          eval_without_location?(node) do |code|
-            if with_lineno?(node)
-              on_with_lineno(node, code)
-            else
-              add_offense(node)
-            end
-          end
+          # Classes should not redefine eval, but in case one does, it shouldn't
+          # register an offense. Only `eval` without a receiver and `Kernel.eval`
+          # are considered.
+          return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
+
+          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
+            add_offense_for_missing_location(node, code)
+          end
+        end
+
+        def register_offense(node, &block)
+          msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
+          add_offense(node, message: msg, &block)
+        end
+
         def special_file_keyword?(node)
           node.str_type? &&
             node.source == '__FILE__'
@@ -84,6 +121,15 @@ module RuboCop
             node.source == '__LINE__'
         end
 
+        def file_and_line(node)
+          base = node.method?(:eval) ? 2 : 1
+          [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)
@@ -95,20 +141,34 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(actual, sign, line_diff)
-          expected =
-            if line_diff.zero?
-              '__LINE__'
-            else
-              "__LINE__ #{sign} #{line_diff}"
-            end
-          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+        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)
+
+          add_offense(line_node.loc.expression, message: message) do |corrector|
+            corrector.replace(line_node, expected)
+          end
+        end
+
+        def check_file(node, file_node)
+          return true if special_file_keyword?(file_node)
+
+          message = format(MSG_INCORRECT_FILE,
+                           method_name: node.method_name,
+                           expected: '__FILE__',
+                           actual: file_node.source)
+
+          add_offense(file_node, message: message) do |corrector|
+            corrector.replace(file_node, '__FILE__')
+          end
         end
 
-        def on_with_lineno(node, code)
+        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
@@ -116,6 +176,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
@@ -124,23 +188,50 @@ module RuboCop
           end
         end
 
-        def add_offense_for_same_line(_node, line_node)
+        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(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)
+        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(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.loc.expression.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