rubocop 0.85.1 → 0.89.1

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

@@ -55,6 +55,8 @@ module RuboCop
         MSG = 'Use `%<suggestion>s` instead of '\
               '`%<sorter>s...%<accessor_source>s`.'
 
+        SORT_METHODS = %i[sort sort_by].freeze
+
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
             (send $(send _ $:sort ...) ${:last :first})
@@ -72,18 +74,21 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          redundant_sort?(node) do |sort_node, sorter, accessor|
-            range = range_between(
-              sort_node.loc.selector.begin_pos,
-              node.loc.expression.end_pos
-            )
+          return unless sort_method?(node)
 
-            add_offense(node,
-                        location: range,
-                        message: message(node,
-                                         sorter,
-                                         accessor))
+          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
+            ancestor = node.parent
+          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
+            ancestor = node.parent.parent
+          else
+            return
           end
+
+          add_offense(ancestor,
+                      location: offense_range(sort_node, ancestor),
+                      message: message(ancestor,
+                                       sorter,
+                                       accessor))
         end
 
         def autocorrect(node)
@@ -108,6 +113,14 @@ module RuboCop
 
         private
 
+        def sort_method?(node)
+          SORT_METHODS.include?(node.method_name)
+        end
+
+        def offense_range(sort_node, ancestor)
+          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        end
+
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,
@@ -135,9 +148,10 @@ module RuboCop
         end
 
         def suffix(sorter)
-          if sorter == :sort
+          case sorter
+          when :sort
             ''
-          elsif sorter == :sort_by
+          when :sort_by
             '_by'
           end
         end

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

@@ -85,7 +85,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :rescue_standard_error?, <<~PATTERN
-          (resbody $(array (const nil? :StandardError)) _ _)
+          (resbody $(array (const {nil? cbase} :StandardError)) _ _)
         PATTERN
 
         def on_resbody(node)

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

@@ -136,10 +136,10 @@ module RuboCop
         end
 
         def comments(node)
-          processed_source.comments.select do |comment|
-            comment.loc.first_line > node.loc.first_line &&
-              comment.loc.last_line < node.loc.last_line
-          end
+          processed_source.each_comment_in_lines(
+            node.loc.first_line...
+            node.loc.last_line
+          ).to_a
         end
 
         def allowed_if_condition?(node)

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

@@ -92,7 +92,7 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node)
+        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
           vals = range_node.to_a
           return :unknown unless vals.all?(&:int_type?)
 

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

@@ -39,7 +39,7 @@ module RuboCop
           check_for_line_terminator_or_opener
         end
 
-        def on_begin(node)
+        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if cop_config['AllowAsExpressionSeparator']
 
           exprs = node.children

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

@@ -111,7 +111,7 @@ module RuboCop
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'
 
-        def_node_matcher :kernel_call?, '(send (const nil? :Kernel) %1 ...)'
+        def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
         def_node_search :custom_fail_methods,
                         '{(def :fail ...) (defs _ :fail ...)}'
 
@@ -191,6 +191,8 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
+          return unless node.method?(name)
+
           node.command?(name) || kernel_call?(node, name)
         end
 

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sometimes using dig method ends up with just a single
+      # argument. In such cases, dig should be replaced with [].
+      #
+      # @example
+      #   # bad
+      #   { key: 'value' }.dig(:key)
+      #   [1, 2, 3].dig(0)
+      #
+      #   # good
+      #   { key: 'value' }[:key]
+      #   [1, 2, 3][0]
+      #
+      #   # good
+      #   { key1: { key2: 'value' } }.dig(:key1, :key2)
+      #   [1, [2, [3]]].dig(1, 1)
+      #
+      #   # good
+      #   keys = %i[key1 key2]
+      #   { key1: { key2: 'value' } }.dig(*keys)
+      #
+      class SingleArgumentDig < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<receiver>s[%<argument>s]` instead of `%<original>s`.'
+
+        def_node_matcher :single_argument_dig?, <<~PATTERN
+          (send _ :dig $!splat)
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+
+          expression = single_argument_dig?(node)
+          return unless expression
+
+          receiver = node.receiver.source
+          argument = expression.source
+
+          message = format(MSG, receiver: receiver, argument: argument,
+                                original: node.source)
+          add_offense(node, message: message) do |corrector|
+            correct_access = "#{receiver}[#{argument}]"
+            corrector.replace(node, correct_access)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -73,7 +73,7 @@ module RuboCop
 
         def move_comment(node, corrector)
           LineBreakCorrector.move_comment(
-            eol_comment: end_of_line_comment(node.source_range.line),
+            eol_comment: processed_source.comment_at_line(node.source_range.line),
             node: node, corrector: corrector
           )
         end

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

@@ -34,9 +34,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if style == :require_parentheses
+          case style
+          when :require_parentheses
             missing_parentheses_corrector(node)
-          elsif style == :require_no_parentheses
+          when :require_no_parentheses
             unwanted_parentheses_corrector(node)
           end
         end

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

@@ -22,7 +22,7 @@ module RuboCop
 
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send
-            {(gvar #stderr_gvar?) (const nil? :STDERR)}
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
             :puts $_
             ...)
         PATTERN

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where string concatenation
+      # can be replaced with string interpolation.
+      #
+      # @example
+      #   # bad
+      #   email_with_name = user.name + ' <' + user.email + '>'
+      #
+      #   # good
+      #   email_with_name = "#{user.name} <#{user.email}>"
+      #   email_with_name = format('%s <%s>', user.name, user.email)
+      #
+      class StringConcatenation < Base
+        include Util
+        extend AutoCorrector
+
+        MSG = 'Prefer string interpolation to string concatenation.'
+
+        def_node_matcher :string_concatenation?, <<~PATTERN
+          {
+            (send str_type? :+ _)
+            (send _ :+ str_type?)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless node.method?(:+)
+          return unless string_concatenation?(node)
+
+          topmost_plus_node = find_topmost_plus_node(node)
+
+          parts = []
+          collect_parts(topmost_plus_node, parts)
+
+          add_offense(topmost_plus_node) do |corrector|
+            corrector.replace(topmost_plus_node, replacement(parts))
+          end
+        end
+
+        private
+
+        def find_topmost_plus_node(node)
+          current = node
+          while (parent = current.parent) && plus_node?(parent)
+            current = parent
+          end
+          current
+        end
+
+        def collect_parts(node, parts)
+          return unless node
+
+          if plus_node?(node)
+            collect_parts(node.receiver, parts)
+            collect_parts(node.first_argument, parts)
+          else
+            parts << node
+          end
+        end
+
+        def plus_node?(node)
+          node.send_type? && node.method?(:+)
+        end
+
+        def replacement(parts)
+          interpolated_parts =
+            parts.map do |part|
+              if part.str_type?
+                if single_quoted?(part)
+                  part.value.gsub('\\') { '\\\\' }
+                else
+                  escape_string(part.value)
+                end
+              else
+                "\#{#{part.source}}"
+              end
+            end
+
+          "\"#{interpolated_parts.join}\""
+        end
+
+        def single_quoted?(str_node)
+          str_node.source.start_with?("'")
+        end
+      end
+    end
+  end
+end

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

@@ -20,6 +20,8 @@ module RuboCop
       #     end
       #   end
       class StructInheritance < Cop
+        include RangeHelp
+
         MSG = "Don't extend an instance initialized by `Struct.new`. " \
               'Use a block to customize the struct.'
 
@@ -29,10 +31,29 @@ module RuboCop
           add_offense(node, location: node.parent_class.source_range)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.keyword, newlines: false))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
         def_node_matcher :struct_constructor?, <<~PATTERN
-          {(send (const nil? :Struct) :new ...)
-           (block (send (const nil? :Struct) :new ...) ...)}
+          {(send (const {nil? cbase} :Struct) :new ...)
+           (block (send (const {nil? cbase} :Struct) :new ...) ...)}
         PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+          else
+            corrector.insert_after(parent.loc.expression, ' do')
+          end
+        end
       end
     end
   end

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

@@ -65,7 +65,7 @@ module RuboCop
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
-            content =~ / /
+            / /.match?(content)
           end
         end
 
@@ -74,7 +74,7 @@ module RuboCop
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
 
-              ':' + trim_string_interporation_escape_character(string_literal)
+              ":#{trim_string_interporation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             end
@@ -104,12 +104,12 @@ module RuboCop
           )
 
           # method name
-          string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
+          /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
             # instance / class variable
-            string =~ /\A@@?[a-zA-Z_]\w*\z/ ||
+            /\A@@?[a-zA-Z_]\w*\z/.match?(string) ||
             # global variable
-            string =~ /\A\$[1-9]\d*\z/ ||
-            string =~ /\A\$[a-zA-Z_]\w*\z/ ||
+            /\A\$[1-9]\d*\z/.match?(string) ||
+            /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
             special_gvars.include?(string) ||
             redefinable_operators.include?(string)
         end

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

@@ -19,7 +19,7 @@ module RuboCop
               'instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
-        def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
+        def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
         def_node_matcher :symbol_proc?, <<~PATTERN
           (block
             ${(send ...) (super ...) zsuper}
@@ -84,7 +84,7 @@ module RuboCop
           arg_range = args.last.source_range
           arg_range = range_with_surrounding_comma(arg_range, :right)
           replacement = " &:#{method_name}"
-          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement)
           corrector.remove(block_range_with_space(node))
         end

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

@@ -174,7 +174,7 @@ module RuboCop
         end
 
         def unparenthesized_method_call?(child)
-          method_name(child) =~ /^[a-z]/i && !child.parenthesized?
+          /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end
 
         def below_ternary_precedence?(child)

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

@@ -33,8 +33,8 @@ module RuboCop
       #     end
       #   end
       #
-      class TrailingMethodEndStatement < Cop
-        include Alignment
+      class TrailingMethodEndStatement < Base
+        extend AutoCorrector
 
         MSG = 'Place the end statement of a multi-line method on ' \
               'its own line.'
@@ -42,13 +42,11 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node, location: end_token(node).pos)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            break_line_before_end(node, corrector)
-            remove_semicolon(node, corrector)
+          add_offense(node.loc.end) do |corrector|
+            corrector.insert_before(
+              node.loc.end,
+              "\n#{' ' * node.loc.keyword.column}"
+            )
           end
         end
 
@@ -60,30 +58,9 @@ module RuboCop
             body_and_end_on_same_line?(node)
         end
 
-        def end_token(node)
-          tokens(node).reverse.find(&:end?)
-        end
-
         def body_and_end_on_same_line?(node)
-          end_token(node).line == token_before_end(node).line
-        end
-
-        def token_before_end(node)
-          i = tokens(node).index(end_token(node))
-          tokens(node)[i - 1]
-        end
-
-        def break_line_before_end(node, corrector)
-          corrector.insert_before(
-            end_token(node).pos,
-            "\n" + ' ' * configured_indentation_width
-          )
-        end
-
-        def remove_semicolon(node, corrector)
-          return unless token_before_end(node).semicolon?
-
-          corrector.remove(token_before_end(node).pos)
+          last_child = node.children.last
+          last_child.loc.last_line == node.loc.end.last_line
         end
       end
     end

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

@@ -28,6 +28,8 @@ module RuboCop
       #     attr_reader :baz
       #   end
       class TrivialAccessors < Cop
+        include AllowedMethods
+
         MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
 
         def on_def(node)
@@ -95,9 +97,8 @@ module RuboCop
           cop_config['IgnoreClassMethods']
         end
 
-        def allowed_methods
-          allowed_methods = cop_config['AllowedMethods']
-          Array(allowed_methods).map(&:to_sym) + [:initialize]
+        def allowed_method_names
+          allowed_methods.map(&:to_sym) + [:initialize]
         end
 
         def dsl_writer?(method_name)
@@ -106,7 +107,7 @@ module RuboCop
 
         def trivial_reader?(node)
           looks_like_trivial_reader?(node) &&
-            !allowed_method?(node) && !allowed_reader?(node)
+            !allowed_method_name?(node) && !allowed_reader?(node)
         end
 
         def looks_like_trivial_reader?(node)
@@ -115,7 +116,7 @@ module RuboCop
 
         def trivial_writer?(node)
           looks_like_trivial_writer?(node) &&
-            !allowed_method?(node) && !allowed_writer?(node.method_name)
+            !allowed_method_name?(node) && !allowed_writer?(node.method_name)
         end
 
         def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
@@ -123,8 +124,8 @@ module RuboCop
            (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
         PATTERN
 
-        def allowed_method?(node)
-          allowed_methods.include?(node.method_name) ||
+        def allowed_method_name?(node)
+          allowed_method_names.include?(node.method_name) ||
             exact_name_match? && !names_match?(node)
         end
 

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

@@ -73,7 +73,7 @@ module RuboCop
           strings.any? do |s|
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
             !string.valid_encoding? ||
-              string !~ word_regex || string =~ / /
+              !word_regex.match?(string) || / /.match?(string)
           end
         end
 

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

@@ -19,6 +19,8 @@ module RuboCop
       #   foo == "bar"
       #   foo <= 42
       #   bar > 10
+      #   "#{interpolation}" == foo
+      #   /#{interpolation}/ == foo
       #
       # @example EnforcedStyle: forbid_for_equality_operators_only
       #   # bad
@@ -109,7 +111,8 @@ module RuboCop
           rhs = node.first_argument
 
           return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal?
+                         !lhs.literal? && !rhs.literal? ||
+                         interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?
         end
@@ -150,6 +153,20 @@ module RuboCop
         def program_name?(name)
           PROGRAM_NAMES.include?(name)
         end
+
+        def interpolation?(node)
+          return true if node.dstr_type?
+
+          # TODO: Use `RegexpNode#interpolation?` when the following is released.
+          # https://github.com/rubocop-hq/rubocop-ast/pull/18
+          if node.regexp_type?
+            return true if node.children.any? do |child|
+              child.respond_to?(:begin_type?) && child.begin_type?
+            end
+          end
+
+          false
+        end
       end
     end
   end

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

@@ -30,6 +30,8 @@ module RuboCop
         NONZERO_MSG = 'Use `!empty?` instead of ' \
                       '`%<lhs>s %<opr>s %<rhs>s`.'
 
+        LENGTH_METHODS = %i[size length].freeze
+
         def on_send(node)
           check_zero_length_predicate(node)
           check_nonzero_length_predicate(node)
@@ -44,31 +46,33 @@ module RuboCop
         private
 
         def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node)
+          return unless LENGTH_METHODS.include?(node.method_name)
 
+          zero_length_predicate = zero_length_predicate(node.parent)
           return unless zero_length_predicate
 
           lhs, opr, rhs = zero_length_predicate
 
-          return if non_polymorphic_collection?(node)
+          return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node,
+            node.parent,
             message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
           )
         end
 
         def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node)
+          return unless LENGTH_METHODS.include?(node.method_name)
 
+          nonzero_length_predicate = nonzero_length_predicate(node.parent)
           return unless nonzero_length_predicate
 
           lhs, opr, rhs = nonzero_length_predicate
 
-          return if non_polymorphic_collection?(node)
+          return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node,
+            node.parent,
             message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
           )
         end
@@ -108,8 +112,8 @@ module RuboCop
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
-          {(send (send (send (const nil? :File) :stat _) ...) ...)
-           (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+          {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
+           (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN
       end
     end