rubocop 1.9.0 → 1.12.1

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

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks for uses of literal strings converted to
       # a symbol where a literal symbol could be used instead.
       #
+      # There are two possible styles for this cop.
+      # `strict` (default) will register an offense for any incorrect usage.
+      # `consistent` additionally requires hashes to use the same style for
+      # every symbol key (ie. if any symbol key needs to be quoted it requires
+      # all keys to be quoted).
+      #
       # @example
       #   # bad
       #   'string'.to_sym
@@ -21,20 +27,60 @@ module RuboCop
       #   :underscored_symbol
       #   :'hyphenated-string'
       #
+      # @example EnforcedStyle: strict (default)
+      #
+      #   # bad
+      #   {
+      #     'a': 1,
+      #     "b": 2,
+      #     'c-d': 3
+      #   }
+      #
+      #   # good (don't quote keys that don't require quoting)
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     'c-d': 3
+      #   }
+      #
+      # @example EnforcedStyle: consistent
+      #
+      #   # bad
+      #   {
+      #     a: 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (quote all keys if any need quoting)
+      #   {
+      #     'a': 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (no quoting required)
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
+      #
       class SymbolConversion < Base
         extend AutoCorrector
+        include ConfigurableEnforcedStyle
 
         MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        MSG_CONSISTENCY = 'Symbol hash key should be quoted for consistency; ' \
+          '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)
+          return if ignored_node?(node) || 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
@@ -50,6 +96,21 @@ module RuboCop
           register_offense(node, correction: node.value.inspect)
         end
 
+        def on_hash(node)
+          # For `EnforcedStyle: strict`, hash keys are evaluated in `on_sym`
+          return unless style == :consistent
+
+          keys = node.keys.select(&:sym_type?)
+
+          if keys.any? { |key| requires_quotes?(key) }
+            correct_inconsistent_hash_keys(keys)
+          else
+            # If there are no symbol keys requiring quoting,
+            # treat the hash like `EnforcedStyle: strict`.
+            keys.each { |key| correct_hash_key(key) }
+          end
+        end
+
         private
 
         def register_offense(node, correction:, message: format(MSG, correction: correction))
@@ -59,7 +120,7 @@ module RuboCop
         end
 
         def properly_quoted?(source, value)
-          return true unless source.match?(/['"]/)
+          return true if style == :strict && (!source.match?(/['"]/) || value.end_with?('='))
 
           source == value ||
             # `Symbol#inspect` uses double quotes, but allow single-quoted
@@ -67,6 +128,10 @@ module RuboCop
             source.tr("'", '"') == value
         end
 
+        def requires_quotes?(sym_node)
+          sym_node.value.inspect.match?(/^:".*?"|=$/)
+        end
+
         def in_alias?(node)
           node.parent&.alias_type?
         end
@@ -87,7 +152,7 @@ module RuboCop
           # will be ignored.
           return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
 
-          correction = node.value.inspect.delete(':')
+          correction = node.value.inspect.gsub(/\A:/, '')
           return if properly_quoted?(node.source, correction)
 
           register_offense(
@@ -96,6 +161,29 @@ module RuboCop
             message: format(MSG, correction: "#{correction}:")
           )
         end
+
+        def correct_inconsistent_hash_keys(keys)
+          keys.each do |key|
+            ignore_node(key)
+
+            next if requires_quotes?(key)
+            next if properly_quoted?(key.source, %("#{key.value}"))
+
+            correction = "#{quote_type}#{key.value}#{quote_type}"
+            register_offense(
+              key,
+              correction: correction,
+              message: format(MSG_CONSISTENCY, correction: "#{correction}:")
+            )
+          end
+        end
+
+        def quote_type
+          # Use the `Style/StringLiterals` configuration for quoting symbols
+          return '"' unless config.for_cop('Style/StringLiterals')['Enabled']
+
+          config.for_cop('Style/StringLiterals')['EnforcedStyle'] == 'single_quotes' ? "'" : '"'
+        end
       end
     end
   end

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

@@ -23,14 +23,17 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[to_enum enum_for].freeze
 
+        # @!method enum_conversion_call?(node)
         def_node_matcher :enum_conversion_call?, <<~PATTERN
           (send {nil? self} {:to_enum :enum_for} $_ $...)
         PATTERN
 
+        # @!method method_name?(node, name)
         def_node_matcher :method_name?, <<~PATTERN
           {(send nil? {:__method__ :__callee__}) (sym %1)}
         PATTERN
 
+        # @!method passing_keyword_arg?(node, name)
         def_node_matcher :passing_keyword_arg?, <<~PATTERN
           (pair (sym %1) (lvar %1))
         PATTERN

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

@@ -22,6 +22,7 @@ module RuboCop
 
         MSG = 'Use `Integer` instead of `%<klass>s`.'
 
+        # @!method fixnum_or_bignum_const(node)
         def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
           (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN

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

@@ -66,6 +66,7 @@ module RuboCop
         MSG = 'Ensure the accumulator `%<accum>s` will be modified by `%<method>s`.'
         MSG_INDEX = 'Do not return an element of the accumulator in `%<method>s`.'
 
+        # @!method reduce_with_block?(node)
         def_node_matcher :reduce_with_block?, <<~PATTERN
           {
             (block (send _recv {:reduce :inject} ...) args ...)
@@ -73,10 +74,12 @@ module RuboCop
           }
         PATTERN
 
+        # @!method accumulator_index?(node, accumulator_name)
         def_node_matcher :accumulator_index?, <<~PATTERN
           (send (lvar %1) {:[] :[]=} ...)
         PATTERN
 
+        # @!method element_modified?(node, element_name)
         def_node_search :element_modified?, <<~PATTERN
           {
             (send _receiver !{:[] :[]=} <`(lvar %1) `_ ...>)               # method(el, ...)
@@ -86,6 +89,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method lvar_used?(node, name)
         def_node_matcher :lvar_used?, <<~PATTERN
           {
             (lvar %1)
@@ -96,6 +100,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method expression_values(node)
         def_node_search :expression_values, <<~PATTERN
           {
             (%RuboCop::AST::Node::VARIABLES $_)

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

@@ -51,6 +51,7 @@ module RuboCop
 
         private
 
+        # @!method flow_command?(node)
         def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo

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

@@ -131,6 +131,7 @@ module RuboCop
           end
         end
 
+        # @!method break_command?(node)
         def_node_matcher :break_command?, <<~PATTERN
           {
             return break

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

@@ -62,6 +62,7 @@ module RuboCop
         include UnusedArgument
         extend AutoCorrector
 
+        # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
           {(send nil? :raise (const {nil? cbase} :NotImplementedError))
            (send nil? :fail ...)}

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

@@ -47,6 +47,7 @@ module RuboCop
         METHOD_NAMES = %i[escape encode unescape decode].freeze
         RESTRICT_ON_SEND = METHOD_NAMES
 
+        # @!method uri_escape_unescape?(node)
         def_node_matcher :uri_escape_unescape?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}

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

@@ -150,18 +150,22 @@ module RuboCop
           corrector.remove(range)
         end
 
+        # @!method static_method_definition?(node)
         def_node_matcher :static_method_definition?, <<~PATTERN
           {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
         PATTERN
 
+        # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
           {(send nil? :define_method ...) (block (send nil? :define_method ...) ...)}
         PATTERN
 
+        # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
           (block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
+        # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN

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

@@ -56,6 +56,7 @@ module RuboCop
 
         private
 
+        # @!method setter_call_to_local_variable?(node)
         def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
           [(send (lvar _) ...) setter_method?]
         PATTERN

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

@@ -27,14 +27,17 @@ module RuboCop
         MSG = 'Useless call to `%<count>i.times` detected.'
         RESTRICT_ON_SEND = %i[times].freeze
 
+        # @!method times_call?(node)
         def_node_matcher :times_call?, <<~PATTERN
           (send (int $_) :times (block-pass (sym $_))?)
         PATTERN
 
+        # @!method block_arg(node)
         def_node_matcher :block_arg, <<~PATTERN
           (block _ (args (arg $_)) ...)
         PATTERN
 
+        # @!method block_reassigns_arg?(node)
         def_node_search :block_reassigns_arg?, <<~PATTERN
           (lvasgn %)
         PATTERN

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

@@ -44,6 +44,7 @@ module RuboCop
 
         private
 
+        # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
           (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN

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
 
@@ -87,6 +90,7 @@ module RuboCop
 
         private
 
+        # @!method argument_to_lambda_or_proc?(node)
         def_node_matcher :argument_to_lambda_or_proc?, <<~PATTERN
           ^lambda_or_proc?
         PATTERN

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

@@ -26,10 +26,12 @@ module RuboCop
             return length if @foldable_types.empty?
 
             each_top_level_descendant(@node, @foldable_types) do |descendant|
-              if foldable_node?(descendant)
-                descendant_length = code_length(descendant)
-                length = length - descendant_length + 1
-              end
+              next unless foldable_node?(descendant)
+
+              descendant_length = code_length(descendant)
+              length = length - descendant_length + 1
+              # Subtract 2 length of opening and closing brace if method argument omits hash braces.
+              length -= 2 if descendant.hash_type? && !descendant.braces?
             end
 
             length

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

@@ -60,6 +60,7 @@ module RuboCop
 
           private
 
+          # @!method attribute_call?(node)
           def_node_matcher :attribute_call?, <<~PATTERN
             ( {csend send} _receiver _method # and no parameters
             )
@@ -90,6 +91,7 @@ module RuboCop
             end
           end
 
+          # @!method root_node?(node)
           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`

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

@@ -29,15 +29,15 @@ module RuboCop
 
         each_bad_alignment(items, base_column) do |current|
           expr = current.source_range
-          if offenses.any? { |o| within?(expr, o.location) }
+          if @current_offenses.any? { |o| within?(expr, o.location) }
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same
             # cop cannot be handled. The next iteration will find the
             # offense again and correct it.
-            add_offense(nil, location: expr)
+            register_offense(expr, nil)
           else
-            add_offense(current)
+            register_offense(current, current)
           end
         end
       end
@@ -71,6 +71,13 @@ module RuboCop
       def end_of_line_comment(line)
         processed_source.line_with_comment?(line)
       end
+
+      # @api private
+      def register_offense(offense_node, message_node)
+        add_offense(offense_node, message: message(message_node)) do |corrector|
+          autocorrect(corrector, message_node)
+        end
+      end
     end
   end
 end

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

@@ -83,7 +83,7 @@ module RuboCop
 
       # @api private
       def within_column_limit?(element, max, line)
-        element && element.loc.column < max && element.loc.line == line
+        element && element.loc.column <= max && element.loc.line == line
       end
 
       # @api private