rubocop 1.8.0 → 1.11.0

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -11,12 +11,12 @@ module RuboCop
       #   name      = "RuboCop"
       #   # Some comment and an empty line
       #
-      #   website  += "/rubocop-hq/rubocop" unless cond
+      #   website  += "/rubocop/rubocop" unless cond
       #   puts        "rubocop"          if     debug
       #
       #   # bad for any configuration
       #   set_app("RuboCop")
-      #   website  = "https://github.com/rubocop-hq/rubocop"
+      #   website  = "https://github.com/rubocop/rubocop"
       #
       #   # good only if AllowBeforeTrailingComments is true
       #   object.method(arg)  # this is a comment

data/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -4,11 +4,14 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks the indentation of the first argument in a method call.
-      # Arguments after the first one are checked by Layout/ArgumentAlignment,
+      # Arguments after the first one are checked by `Layout/ArgumentAlignment`,
       # not by this cop.
       #
       # For indenting the first parameter of method _definitions_, check out
-      # Layout/FirstParameterIndentation.
+      # `Layout/FirstParameterIndentation`.
+      #
+      # This cop will respect `Layout/ArgumentAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
       #
       # @example
       #
@@ -149,7 +152,8 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
-          return if !node.arguments? || node.operator_method?
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+          return if !node.arguments? || bare_operator?(node)
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -163,6 +167,10 @@ module RuboCop
 
         private
 
+        def bare_operator?(node)
+          node.operator_method? && !node.dot?
+        end
+
         def message(arg_node)
           return 'Bad indentation of the first argument.' unless arg_node
 
@@ -202,6 +210,7 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
+        # @!method eligible_method_call?(node)
         def_node_matcher :eligible_method_call?, <<~PATTERN
           (send _ !:[]= ...)
         PATTERN
@@ -250,6 +259,16 @@ module RuboCop
         def on_new_investigation
           @comment_lines = nil
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless argument_alignment_config['Enabled']
+
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def argument_alignment_config
+          config.for_cop('Layout/ArgumentAlignment')
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -52,6 +52,7 @@ module RuboCop
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
               'spaces for%<name>s indentation.'
 
+        # @!method access_modifier?(node)
         def_node_matcher :access_modifier?, <<~PATTERN
           [(send ...) access_modifier?]
         PATTERN

data/lib/rubocop/cop/layout/line_length.rb

@@ -60,12 +60,13 @@ module RuboCop
       #   }
       class LineLength < Base
         include CheckLineBreakable
-        include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
         include LineLengthHelp
         extend AutoCorrector
 
+        exclude_limit 'Max'
+
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
         def on_block(node)

data/lib/rubocop/cop/layout/multiline_assignment_layout.rb

@@ -31,6 +31,32 @@ module RuboCop
       #   foo = if expression
       #     'bar'
       #   end
+      #
+      # @example SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module'] (default)
+      #   # good
+      #   foo =
+      #     if expression
+      #       'bar'
+      #     end
+      #
+      #   # good
+      #   foo =
+      #     [1].map do |i|
+      #       i + 1
+      #     end
+      #
+      # @example SupportedTypes: ['block']
+      #   # good
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good
+      #   foo =
+      #     [1].map do |i|
+      #       'bar' * i
+      #     end
+      #
       class MultilineAssignmentLayout < Base
         include CheckAssignment
         include ConfigurableEnforcedStyle

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -61,7 +61,7 @@ module RuboCop
           # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
           # That means preventing auto-correction to incorrect auto-corrected
           # code.
-          # See: https://github.com/rubocop-hq/rubocop/issues/7534
+          # See: https://github.com/rubocop/rubocop/issues/7534
           return if conflict_with_block_delimiters?(node)
 
           left_brace = node.loc.begin

data/lib/rubocop/cop/layout/space_before_brackets.rb

@@ -39,12 +39,17 @@ module RuboCop
 
             range_between(receiver_end_pos, selector_begin_pos)
           elsif node.method?(:[]=)
-            end_pos = node.receiver.source_range.end_pos
+            offense_range_for_assignment(node, begin_pos)
+          end
+        end
 
-            return if begin_pos - end_pos == 1
+        def offense_range_for_assignment(node, begin_pos)
+          end_pos = node.receiver.source_range.end_pos
 
-            range_between(end_pos, begin_pos - 1)
-          end
+          return if begin_pos - end_pos == 1 ||
+                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
+
+          range
         end
 
         def register_offense(range)

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -89,7 +89,7 @@ module RuboCop
           # preventing auto-correction to single-line empty braces. It will
           # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
           # if auto-corrected to a single-line empty braces.
-          # See: https://github.com/rubocop-hq/rubocop/issues/7363
+          # See: https://github.com/rubocop/rubocop/issues/7363
           return if node.body.nil? && node.multiline?
 
           left_brace = node.loc.begin

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

@@ -21,6 +21,7 @@ module RuboCop
               'Use `%<double_colon>sBigDecimal()` instead.'
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method big_decimal_new(node)
         def_node_matcher :big_decimal_new, <<~PATTERN
           (send
             (const ${nil? cbase} :BigDecimal) :new ...)

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

@@ -27,6 +27,7 @@ module RuboCop
         MSG = 'Symbol with a boolean name - ' \
               'you probably meant to use `%<boolean>s`.'
 
+        # @!method boolean_symbol?(node)
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'
 
         def on_sym(node)

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

@@ -66,10 +66,12 @@ module RuboCop
 
         MSG = 'Do not define constants this way within a block.'
 
+        # @!method constant_assigned_in_block?(node)
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
           ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
         PATTERN
 
+        # @!method module_defined_in_block?(node)
         def_node_matcher :module_defined_in_block?, <<~PATTERN
           ({^block_type? [^begin_type? ^^block_type?]} ...)
         PATTERN

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

@@ -58,6 +58,7 @@ module RuboCop
       class ConstantResolution < Base
         MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
 
+        # @!method unqualified_const?(node)
         def_node_matcher :unqualified_const?, <<~PATTERN
           (const nil? #const_name?)
         PATTERN

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

@@ -3,8 +3,21 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for calls to debugger or pry.
-      # The cop can be configured to define which methods and receivers must be fixed.
+      # This cop checks for debug calls (such as `debugger` or `binding.pry`) that should
+      # not be kept for production code.
+      #
+      # The cop can be configured using `DebuggerMethods`. By default, a number of gems
+      # debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `Pry`, `Rails`,
+      # and `WebConsole`). Additional methods can be added.
+      #
+      # Specific default groups can be disabled if necessary:
+      #
+      # [source,yaml]
+      # ----
+      # Lint/Debugger:
+      #   WebConsole: ~
+      # ----
+      #
       #
       # @example
       #
@@ -33,14 +46,34 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
+      #
+      # @example DebuggerMethods: [my_debugger]
+      #
+      #   # bad (ok during development)
+      #
+      #   def some_method
+      #     my_debugger
+      #   end
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         RESTRICT_ON_SEND = [].freeze
 
+        # @!method kernel?(node)
+        def_node_matcher :kernel?, <<~PATTERN
+          (const {nil? cbase} :Kernel)
+        PATTERN
+
+        # @!method valid_receiver?(node, arg1)
+        def_node_matcher :valid_receiver?, <<~PATTERN
+          {
+            (const {nil? cbase} %1)
+            (send {nil? #kernel?} %1)
+          }
+        PATTERN
+
         def on_send(node)
-          return unless debugger_method?(node.method_name)
-          return if !node.receiver.nil? && !debugger_receiver?(node)
+          return unless debugger_method?(node)
 
           add_offense(node)
         end
@@ -51,19 +84,32 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def debugger_method?(name)
-          cop_config.fetch('DebuggerMethods', []).include?(name.to_s)
+        def debugger_methods
+          @debugger_methods ||= begin
+            config = cop_config.fetch('DebuggerMethods', [])
+            values = config.is_a?(Array) ? config : config.values.flatten
+            values.map do |v|
+              next unless v
+
+              *receiver, method_name = v.split('.')
+              {
+                receiver: receiver.empty? ? nil : receiver.join.to_sym,
+                method_name: method_name.to_sym
+              }
+            end.compact
+          end
         end
 
-        def debugger_receiver?(node)
-          receiver = case node.receiver
-                     when RuboCop::AST::SendNode
-                       node.receiver.method_name
-                     when RuboCop::AST::ConstNode
-                       node.receiver.const_name
-                     end
+        def debugger_method?(send_node)
+          debugger_methods.any? do |method|
+            next unless method[:method_name] == send_node.method_name
 
-          cop_config.fetch('DebuggerReceivers', []).include?(receiver.to_s)
+            if method[:receiver].nil?
+              send_node.receiver.nil?
+            else
+              valid_receiver?(send_node.receiver, method[:receiver])
+            end
+          end
         end
       end
     end

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

@@ -37,6 +37,11 @@ module RuboCop
         DO_NOT_USE_MSG = 'Do not use `%<bad>s`%<deprecated_message>s.'
 
         def on_const(node)
+          # FIXME: Workaround for "`undefined method `expression' for nil:NilClass`" when processing
+          #        `__ENCODING__`. It is better to be able to work without this condition.
+          #        Maybe further investigation of RuboCop AST will lead to an essential solution.
+          return unless node.loc
+
           constant = node.absolute? ? consntant_name(node, node.short_name.to_s) : node.source
           return unless (deprecated_constant = deprecated_constants[constant])
 

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

@@ -44,6 +44,9 @@ module RuboCop
         MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
           ' instead of `%<original>s`.'
 
+        NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
+
+        # @!method algorithm_const(node)
         def_node_matcher :algorithm_const, <<~PATTERN
           (send
             $(const
@@ -104,7 +107,7 @@ module RuboCop
         def algorithm_name(node)
           name = node.loc.name.source
 
-          if openssl_class(node) == 'OpenSSL::Cipher'
+          if openssl_class(node) == 'OpenSSL::Cipher' && !NO_ARG_ALGORITHM.include?(name)
             name.scan(/.{3}/).join('-')
           else
             name
@@ -124,16 +127,23 @@ module RuboCop
           algorithm_name = algorithm_name(algorithm_constant)
 
           if openssl_class(algorithm_constant) == 'OpenSSL::Cipher'
-            build_cipher_arguments(node, algorithm_name)
+            build_cipher_arguments(node, algorithm_name, node.arguments.empty?)
           else
             (["'#{algorithm_name}'"] + node.arguments.map(&:source)).join(', ')
           end
         end
 
-        def build_cipher_arguments(node, algorithm_name)
+        def build_cipher_arguments(node, algorithm_name, no_arguments)
           algorithm_parts = algorithm_name.downcase.split('-')
           size_and_mode = sanitize_arguments(node.arguments).map(&:downcase)
-          "'#{(algorithm_parts + size_and_mode + ['cbc']).take(3).join('-')}'"
+
+          if NO_ARG_ALGORITHM.include?(algorithm_parts.first.upcase) && no_arguments
+            "'#{algorithm_parts.first}'"
+          else
+            mode = 'cbc' unless size_and_mode == ['cbc']
+
+            "'#{(algorithm_parts + size_and_mode + [mode]).compact.take(3).join('-')}'"
+          end
         end
       end
     end

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

@@ -74,7 +74,7 @@ module RuboCop
       #   else 250
       #   end
       #
-      # @example IgnoreLiteralBranches: true
+      # @example IgnoreConstantBranches: true
       #   # good
       #   case size
       #   when "small" then SMALL_SIZE

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

@@ -82,6 +82,7 @@ module RuboCop
           end
         end
 
+        # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
@@ -94,10 +95,12 @@ module RuboCop
           found_instance_method(node, name)
         end
 
+        # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
+        # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
         def on_send(node)
           if (name = alias_method?(node))

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

@@ -21,11 +21,12 @@ module RuboCop
       #
       class DuplicateRequire < Base
         MSG = 'Duplicate `%<method>s` detected.'
-        REQUIRE_METHODS = %i[require require_relative].freeze
+        REQUIRE_METHODS = Set.new(%i[require require_relative]).freeze
         RESTRICT_ON_SEND = REQUIRE_METHODS
 
+        # @!method require_call?(node)
         def_node_matcher :require_call?, <<~PATTERN
-          (send {nil? (const _ :Kernel)} {:#{REQUIRE_METHODS.join(' :')}} _)
+          (send {nil? (const _ :Kernel)} %REQUIRE_METHODS _)
         PATTERN
 
         def on_new_investigation

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

@@ -25,6 +25,7 @@ module RuboCop
         MSG = 'The argument to each_with_object cannot be immutable.'
         RESTRICT_ON_SEND = %i[each_with_object].freeze
 
+        # @!method each_with_object?(node)
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)
         PATTERN

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

@@ -47,7 +47,7 @@ module RuboCop
         MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)
-          return if node.ternary? || node.elsif?
+          return if node.ternary?
 
           check(node)
         end