rubocop 1.6.1 → 1.9.1

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -106,23 +106,13 @@ module RuboCop
           error && error.ancestors[1] == SystemCallError
         end
 
-        def silence_warnings
-          # Replaces Kernel::silence_warnings since it hides any warnings,
-          # including the RuboCop ones
-          old_verbose = $VERBOSE
-          $VERBOSE = nil
-          yield
-        ensure
-          $VERBOSE = old_verbose
-        end
-
         def evaluate_exceptions(group)
           rescued_exceptions = group.exceptions
 
           if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
-                silence_warnings do
+                RuboCop::Util.silence_warnings do
                   # Avoid printing deprecation warnings about constants
                   converted << Kernel.const_get(exception.source)
                 end

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for uses of literal strings converted to
+      # a symbol where a literal symbol could be used instead.
+      #
+      # @example
+      #   # bad
+      #   'string'.to_sym
+      #   :symbol.to_sym
+      #   'underscored_string'.to_sym
+      #   :'underscored_symbol'
+      #   'hyphenated-string'.to_sym
+      #
+      #   # good
+      #   :string
+      #   :symbol
+      #   :underscored_string
+      #   :underscored_symbol
+      #   :'hyphenated-string'
+      #
+      class SymbolConversion < Base
+        extend AutoCorrector
+
+        MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        RESTRICT_ON_SEND = %i[to_sym intern].freeze
+
+        def on_send(node)
+          return unless node.receiver
+          return unless node.receiver.str_type? || node.receiver.sym_type?
+
+          register_offense(node, correction: node.receiver.value.to_sym.inspect)
+        end
+
+        def on_sym(node)
+          return if properly_quoted?(node.source, node.value.inspect)
+
+          # `alias` arguments are symbols but since a symbol that requires
+          # being quoted is not a valid method identifier, it can be ignored
+          return if in_alias?(node)
+
+          # The `%I[]` and `%i[]` macros are parsed as normal arrays of symbols
+          # so they need to be ignored.
+          return if in_percent_literal_array?(node)
+
+          # Symbol hash keys have a different format and need to be handled separately
+          return correct_hash_key(node) if hash_key?(node)
+
+          register_offense(node, correction: node.value.inspect)
+        end
+
+        private
+
+        def register_offense(node, correction:, message: format(MSG, correction: correction))
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, correction)
+          end
+        end
+
+        def properly_quoted?(source, value)
+          return true if !source.match?(/['"]/) || value.end_with?('=')
+
+          source == value ||
+            # `Symbol#inspect` uses double quotes, but allow single-quoted
+            # symbols to work as well.
+            source.tr("'", '"') == value
+        end
+
+        def in_alias?(node)
+          node.parent&.alias_type?
+        end
+
+        def in_percent_literal_array?(node)
+          node.parent&.array_type? && node.parent&.percent_literal?
+        end
+
+        def hash_key?(node)
+          node.parent&.pair_type? && node == node.parent.child_nodes.first
+        end
+
+        def correct_hash_key(node)
+          # Although some operators can be converted to symbols normally
+          # (ie. `:==`), these are not accepted as hash keys and will
+          # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
+          # symbol does not start with an alpha-numeric or underscore, it
+          # will be ignored.
+          return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
+
+          correction = node.value.inspect.gsub(/\A:/, '')
+          return if properly_quoted?(node.source, correction)
+
+          register_offense(
+            node,
+            correction: correction,
+            message: format(MSG, correction: "#{correction}:")
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/triple_quotes.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # of quotes greater than 1).
+      #
+      # Ruby allows multiple strings to be implicitly concatenated by just
+      # being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes
+      # gives the impression that there is something special about triple quotes, but
+      # in fact it is just extra unnecessary quotes and produces the same string. Each
+      # pair of quotes produces an additional concatenated empty string, so the result
+      # is still only the "actual" string within the delimiters.
+      #
+      # NOTE: Although this cop is called triple quotes, the same behavior is present
+      # for strings delimited by 5, 7, etc. quotation marks.
+      #
+      # @example
+      #   # bad
+      #   """
+      #     A string
+      #   """
+      #
+      #   # bad
+      #   '''
+      #     A string
+      #   '''
+      #
+      #   # good
+      #   "
+      #     A string
+      #   "
+      #
+      #   # good
+      #   <<STRING
+      #     A string
+      #   STRING
+      #
+      #   # good (but not the same spacing as the bad case)
+      #   'A string'
+      class TripleQuotes < Base
+        extend AutoCorrector
+
+        MSG = 'Delimiting a string with multiple quotes has no effect, use a single quote instead.'
+
+        def on_dstr(node)
+          return if (empty_str_nodes = empty_str_nodes(node)).none?
+
+          opening_quotes = node.source.scan(/(?<=\A)['"]*/)[0]
+          return if opening_quotes.size < 3
+
+          # If the node is composed of only empty `str` nodes, keep one
+          empty_str_nodes.shift if empty_str_nodes.size == node.child_nodes.size
+
+          add_offense(node) do |corrector|
+            empty_str_nodes.each do |str|
+              corrector.remove(str)
+            end
+          end
+        end
+
+        private
+
+        def empty_str_nodes(node)
+          node.each_child_node(:str).select { |str| str.value == '' }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/unreachable_loop.rb

@@ -9,6 +9,12 @@ module RuboCop
       # In rare cases where only one iteration (or at most one iteration) is intended behavior,
       # the code should be refactored to use `if` conditionals.
       #
+      # NOTE: Block methods that are used with `Enumerable`s are considered to be loops.
+      #
+      # `IgnoredPatterns` can be used to match against the block receiver in order to allow
+      # code that would otherwise be registered as an offense (eg. `times` used not in an
+      # `Enumerable` context).
+      #
       # @example
       #   # bad
       #   while node
@@ -70,7 +76,16 @@ module RuboCop
       #     raise NotFoundError
       #   end
       #
+      #   # bad
+      #   2.times { raise ArgumentError }
+      #
+      # @example IgnoredPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default)
+      #
+      #   # good
+      #   exactly(2).times { raise StandardError }
       class UnreachableLoop < Base
+        include IgnoredPattern
+
         MSG = 'This loop will have at most one iteration.'
 
         def on_while(node)
@@ -91,6 +106,8 @@ module RuboCop
           return false unless node.block_type?
 
           send_node = node.send_node
+          return false if matches_ignored_pattern?(send_node.source)
+
           send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
         end
 

data/lib/rubocop/cop/message_annotator.rb

@@ -85,8 +85,11 @@ module RuboCop
         end
       end
 
+      # Returns the base style guide URL from AllCops or the specific department
+      #
+      # @return [String] style guide URL
       def style_guide_base_url
-        department_name = cop_name.split('/').first
+        department_name = cop_name.split('/')[0..-2].join('/')
 
         config.for_department(department_name)['StyleGuideBaseURL'] ||
           config.for_all_cops['StyleGuideBaseURL']

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -12,13 +12,13 @@ module RuboCop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
-        include ConfigurableMax
-
         NESTING_BLOCKS = %i[
           case if while while_post
           until until_post for resbody
         ].freeze
 
+        exclude_limit 'Max'
+
         def on_new_investigation
           return if processed_source.blank?
 

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -51,7 +51,8 @@ module RuboCop
       #   end
       #
       class ParameterLists < Base
-        include ConfigurableMax
+        exclude_limit 'Max'
+        exclude_limit 'MaxOptionalParameters'
 
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
               '[%<count>d/%<max>d]'
@@ -70,7 +71,9 @@ module RuboCop
             count: optargs.count
           )
 
-          add_offense(node, message: message)
+          add_offense(node, message: message) do
+            self.max_optional_parameters = optargs.count
+          end
         end
         alias on_defs on_def
 

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

@@ -124,7 +124,7 @@ module RuboCop
           end
 
           def classlike_node?(node)
-            CLASSLIKE_TYPES.include?(node.type)
+            CLASSLIKE_TYPES.include?(node&.type)
           end
 
           def foldable_node?(node)

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain identifiers in a cop.
+    module AllowedIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def allowed_identifier?(name)
+        allowed_identifiers.include?(name.to_s.delete(SIGILS))
+      end
+
+      def allowed_identifiers
+        cop_config.fetch('AllowedIdentifiers', [])
+      end
+    end
+  end
+end

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

@@ -69,6 +69,11 @@ module RuboCop
       # @api private
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
+
+        # If the first argument is a hash pair but the method is not parenthesized,
+        # the argument cannot be moved to another line because it cause a syntax error.
+        elements.shift if node.send_type? && !node.parenthesized? && elements.first.pair_type?
+
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
         return elements.first if i.zero?

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

@@ -4,10 +4,12 @@ module RuboCop
   module Cop
     # Common functionality for checking length of code segments.
     module CodeLength
-      include ConfigurableMax
+      extend ExcludeLimit
 
       MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'
 
+      exclude_limit 'Max'
+
       private
 
       def message(length, max_length)

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

@@ -9,7 +9,6 @@ module RuboCop
       def source_range_with_comment(node)
         begin_pos = begin_pos_with_comment(node)
         end_pos = end_position_for(node)
-        end_pos += 1 if node.def_type?
 
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
@@ -22,16 +21,7 @@ module RuboCop
       end
 
       def begin_pos_with_comment(node)
-        annotation_line = node.first_line - 1
-        first_comment = nil
-
-        processed_source.comments_before_line(annotation_line)
-                        .reverse_each do |comment|
-          if comment.location.line == annotation_line
-            first_comment = comment
-            annotation_line -= 1
-          end
-        end
+        first_comment = processed_source.ast_with_comments[node].first
 
         start_line_position(first_comment || node)
       end

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Handles `Max` configuration parameters, especially setting them to an
     # appropriate value with --auto-gen-config.
+    # @deprecated Use `exclude_limit ParameterName` instead.
     module ConfigurableMax
       private
 

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

@@ -21,7 +21,7 @@ module RuboCop
       end
 
       def check_children_line_break(node, children, start = node)
-        return if children.size < 2
+        return if children.empty?
 
         line = start.first_line
 

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

@@ -6,10 +6,12 @@ module RuboCop
     #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include ConfigurableMax
       include IgnoredMethods
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
+      extend ExcludeLimit
+
+      exclude_limit 'Max'
 
       # Ensure cops that include `MethodComplexity` have the config
       # `attr_accessor`s that `ignored_method?` needs.

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

@@ -24,7 +24,11 @@ module RuboCop
           name = full_name.gsub(/\A(_+)/, '')
           next if allowed_names.include?(name)
 
-          range = arg_range(arg, name.size)
+          length = full_name.size
+          length += 1 if arg.restarg_type?
+          length += 2 if arg.kwrestarg_type?
+
+          range = arg_range(arg, length)
           issue_offenses(node, range, name)
         end
       end

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

@@ -4,7 +4,9 @@ module RuboCop
   module Cop
     module Naming
       # This cop checks for memoized methods whose instance variable name
-      # does not match the method name.
+      # does not match the method name. Applies to both regular methods
+      # (defined with `def`) and dynamic methods (defined with
+      # `define_method` or `define_singleton_method`).
       #
       # This cop can be configured with the EnforcedStyleForLeadingUnderscores
       # directive. It can be configured to allow for memoized instance variables
@@ -48,6 +50,17 @@ module RuboCop
       #     @foo ||= calculate_expensive_thing(helper_variable)
       #   end
       #
+      #   # good
+      #   define_method(:foo) do
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     return @foo if defined?(@foo)
+      #     @foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores: required
       #   # bad
       #   def foo
@@ -79,6 +92,17 @@ module RuboCop
       #     @_foo = calculate_expensive_thing
       #   end
       #
+      #   # good
+      #   define_method(:foo) do
+      #     @_foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     return @_foo if defined?(@_foo)
+      #     @_foo = calculate_expensive_thing
+      #   end
+      #
       # @example EnforcedStyleForLeadingUnderscores :optional
       #   # bad
       #   def foo
@@ -105,6 +129,16 @@ module RuboCop
       #     return @_foo if defined?(@_foo)
       #     @_foo = calculate_expensive_thing
       #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     @foo ||= calculate_expensive_thing
+      #   end
+      #
+      #   # good
+      #   define_method(:foo) do
+      #     @_foo ||= calculate_expensive_thing
+      #   end
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 
@@ -112,17 +146,27 @@ module RuboCop
           'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
           'with `_`. Use `@%<suggested_var>s` instead.'
+        DYNAMIC_DEFINE_METHODS = %i[define_method define_singleton_method].to_set.freeze
+
+        def_node_matcher :method_definition?, <<~PATTERN
+          ${
+            (block (send _ %DYNAMIC_DEFINE_METHODS ({sym str} $_)) ...)
+            (def $_ ...)
+            (defs _ $_ ...)
+          }
+        PATTERN
 
         # rubocop:disable Metrics/AbcSize
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
-          return unless (method_node = node.each_ancestor(:def, :defs).first)
+
+          method_node, method_name = find_definition(node)
+          return unless method_node
 
           body = method_node.body
           return unless body == node || body.children.last == node
 
-          method_name = method_node.method_name
           return if matches?(method_name, lhs)
 
           msg = format(
@@ -147,11 +191,10 @@ module RuboCop
           arg = node.arguments.first
           return unless arg.ivar_type?
 
-          method_node = node.each_ancestor(:def, :defs).first
+          method_node, method_name = find_definition(node)
           return unless method_node
 
           var_name = arg.children.first
-          method_name = method_node.method_name
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
             return if matches?(method_name, ivar_assign)
 
@@ -174,6 +217,17 @@ module RuboCop
           'EnforcedStyleForLeadingUnderscores'
         end
 
+        def find_definition(node)
+          # Methods can be defined in a `def` or `defs`,
+          # or dynamically via a `block` node.
+          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+            method_node, method_name = method_definition?(ancestor)
+            return [method_node, method_name] if method_node
+          end
+
+          nil
+        end
+
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || method_name == :initialize