rubocop 0.70.0 → 1.6.1

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

@@ -27,7 +27,10 @@ module RuboCop
       #   class << self
       #     attr_reader :baz
       #   end
-      class TrivialAccessors < Cop
+      class TrivialAccessors < Base
+        include AllowedMethods
+        extend AutoCorrector
+
         MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
 
         def on_def(node)
@@ -39,17 +42,6 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          parent = node.parent
-          return if parent&.send_type?
-
-          if node.def_type?
-            autocorrect_instance(node)
-          elsif node.defs_type? && node.children.first.self_type?
-            autocorrect_class(node)
-          end
-        end
-
         private
 
         def in_module_or_instance_eval?(node)
@@ -60,7 +52,7 @@ module RuboCop
             when :module
               return true
             else
-              return true if pnode.method_name == :instance_eval
+              return true if pnode.method?(:instance_eval)
             end
           end
           false
@@ -74,9 +66,20 @@ module RuboCop
                  end
           return unless kind
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, kind: kind))
+          add_offense(node.loc.keyword, message: format(MSG, kind: kind)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          parent = node.parent
+          return if parent&.send_type?
+
+          if node.def_type?
+            autocorrect_instance(corrector, node)
+          elsif node.defs_type? && node.children.first.self_type?
+            autocorrect_class(corrector, node)
+          end
         end
 
         def exact_name_match?
@@ -95,9 +98,8 @@ module RuboCop
           cop_config['IgnoreClassMethods']
         end
 
-        def whitelist
-          whitelist = cop_config['Whitelist']
-          Array(whitelist).map(&:to_sym) + [:initialize]
+        def allowed_method_names
+          allowed_methods.map(&:to_sym) + [:initialize]
         end
 
         def dsl_writer?(method_name)
@@ -106,7 +108,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,16 +117,16 @@ 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
+        def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
           {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
            (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
         PATTERN
 
-        def allowed_method?(node)
-          whitelist.include?(node.method_name) ||
+        def allowed_method_name?(node)
+          allowed_method_names.include?(node.method_name) ||
             exact_name_match? && !names_match?(node)
         end
 
@@ -155,31 +157,26 @@ module RuboCop
           "attr_#{kind} :#{method_name.to_s.chomp('=')}"
         end
 
-        def autocorrect_instance(node)
+        def autocorrect_instance(corrector, node)
           kind = trivial_accessor_kind(node)
 
           return unless names_match?(node) && !node.predicate_method? && kind
 
-          lambda do |corrector|
-            corrector.replace(node.source_range,
-                              accessor(kind, node.method_name))
-          end
+          corrector.replace(node, accessor(kind, node.method_name))
         end
 
-        def autocorrect_class(node)
+        def autocorrect_class(corrector, node)
           kind = trivial_accessor_kind(node)
 
           return unless names_match?(node) && kind
 
-          lambda do |corrector|
-            indent = ' ' * node.loc.column
-            corrector.replace(
-              node.source_range,
-              ['class << self',
-               "#{indent}  #{accessor(kind, node.method_name)}",
-               "#{indent}end"].join("\n")
-            )
-          end
+          indent = ' ' * node.loc.column
+          corrector.replace(
+            node.source_range,
+            ['class << self',
+             "#{indent}  #{accessor(kind, node.method_name)}",
+             "#{indent}end"].join("\n")
+          )
         end
 
         def top_level_node?(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for *unless* expressions with *else* clauses.
+      # This cop looks for `unless` expressions with `else` clauses.
       #
       # @example
       #   # bad
@@ -19,8 +19,9 @@ module RuboCop
       #   else
       #     # do a different thing...
       #   end
-      class UnlessElse < Cop
+      class UnlessElse < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
               'positive case first.'
@@ -28,14 +29,10 @@ module RuboCop
         def on_if(node)
           return unless node.unless? && node.else?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          body_range = range_between_condition_and_else(node, node.condition)
-          else_range = range_between_else_and_end(node)
+          add_offense(node) do |corrector|
+            body_range = range_between_condition_and_else(node, node.condition)
+            else_range = range_between_else_and_end(node)
 
-          lambda do |corrector|
             corrector.replace(node.loc.keyword, 'if')
             corrector.replace(body_range, else_range.source)
             corrector.replace(else_range, body_range.source)

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

@@ -17,15 +17,14 @@ module RuboCop
       #   # good
       #   'foo'.unpack1('h*')
       #
-      class UnpackFirst < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
+      class UnpackFirst < Base
+        extend AutoCorrector
 
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
-        def_node_matcher :unpack_and_first_element?, <<-PATTERN
+        def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
             (send $(send (...) :unpack $(...)) :first)
             (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
@@ -39,13 +38,7 @@ module RuboCop
                              receiver: unpack_call.receiver.source,
                              format: unpack_arg.source,
                              method: range.source)
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
-            lambda do |corrector|
+            add_offense(node, message: message) do |corrector|
               corrector.remove(first_element_range(node, unpack_call))
               corrector.replace(unpack_call.loc.selector, 'unpack1')
             end

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

@@ -15,38 +15,25 @@ module RuboCop
       #   "His name is #{$name}"
       #   /check #{$pattern}/
       #   "Let's go to the #{@store}"
-      class VariableInterpolation < Cop
+      class VariableInterpolation < Base
+        include Interpolation
+        extend AutoCorrector
+
         MSG = 'Replace interpolated variable `%<variable>s` ' \
               'with expression `#{%<variable>s}`.'
 
-        def on_dstr(node)
-          check_for_interpolation(node)
-        end
-
-        def on_regexp(node)
-          check_for_interpolation(node)
-        end
-
-        def on_xstr(node)
-          check_for_interpolation(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
+        def on_node_with_interpolations(node)
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node) do |corrector|
+              corrector.replace(var_node, "{#{var_node.source}}")
+            end
           end
         end
 
         private
 
-        def check_for_interpolation(node)
-          var_nodes(node.children).each do |var_node|
-            add_offense(var_node)
-          end
-        end
-
-        def message(node)
-          format(MSG, variable: node.source)
+        def message(range)
+          format(MSG, variable: range.source)
         end
 
         def var_nodes(nodes)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for *when;* uses in *case* expressions.
+      # This cop checks for `when;` uses in `case` expressions.
       #
       # @example
       #   # bad
@@ -17,17 +17,15 @@ module RuboCop
       #   when 1 then 'baz'
       #   when 2 then 'bar'
       #   end
-      class WhenThen < Cop
+      class WhenThen < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `when x;`. Use `when x then` instead.'
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node, location: :begin)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.begin) do |corrector|
             corrector.replace(node.loc.begin, ' then')
           end
         end

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

@@ -28,31 +28,21 @@ module RuboCop
       #   until x.empty?
       #     do_something(x.pop)
       #   end
-      class WhileUntilDo < Cop
+      class WhileUntilDo < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `do` with multi-line `%<keyword>s`.'
 
         def on_while(node)
-          handle(node)
-        end
-
-        def on_until(node)
-          handle(node)
-        end
-
-        def handle(node)
           return unless node.multiline? && node.do?
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          do_range = node.condition.source_range.end.join(node.loc.begin)
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            do_range = node.condition.source_range.end.join(node.loc.begin)
 
-          lambda do |corrector|
             corrector.remove(do_range)
           end
         end
+        alias on_until on_while
       end
     end
   end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Checks for while and until statements that would fit on one line
       # if written as a modifier while/until. The maximum line length is
-      # configured in the `Metrics/LineLength` cop.
+      # configured in the `Layout/LineLength` cop.
       #
       # @example
       #   # bad
@@ -24,37 +24,32 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
-      class WhileUntilModifier < Cop
+      #
+      # @example
+      #   # bad
+      #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+      #
+      #   # good
+      #   while x < 500 # a long comment that makes code too long if it were a single line
+      #     x += 100
+      #   end
+      class WhileUntilModifier < Base
         include StatementModifier
+        extend AutoCorrector
 
         MSG = 'Favor modifier `%<keyword>s` usage when ' \
               'having a single-line body.'
 
         def on_while(node)
-          check(node)
-        end
-
-        def on_until(node)
-          check(node)
-        end
+          return unless node.multiline? && single_line_as_modifier?(node)
 
-        def autocorrect(node)
-          oneline = "#{node.body.source} #{node.keyword} " \
-                    "#{node.condition.source}"
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
+            oneline = "#{node.body.source} #{node.keyword} #{node.condition.source}"
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, oneline)
+            corrector.replace(node, oneline)
           end
         end
-
-        private
-
-        def check(node)
-          return unless node.multiline? && single_line_as_modifier?(node)
-
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
-        end
+        alias on_until on_while
       end
     end
   end

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

@@ -27,11 +27,12 @@ module RuboCop
       #
       #   # bad
       #   %w[foo bar baz]
-      class WordArray < Cop
+      class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
+        extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
         ARRAY_MSG = 'Use `[]` for an array of words.'
@@ -44,36 +45,19 @@ module RuboCop
           if bracketed_array_of?(:str, node)
             return if complex_content?(node.values)
 
-            check_bracketed_array(node)
+            check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
             check_percent_array(node)
           end
         end
 
-        def autocorrect(node)
-          if style == :percent
-            PercentLiteralCorrector
-              .new(@config, @preferred_delimiters)
-              .correct(node, 'w')
-          else
-            correct_bracketed(node)
-          end
-        end
-
         private
 
-        def check_bracketed_array(node)
-          return if allowed_bracket_array?(node)
-
-          array_style_detected(:brackets, node.values.size)
-          add_offense(node) if style == :percent
-        end
-
         def complex_content?(strings)
           strings.any? do |s|
-            string = s.str_content
-            !string.dup.force_encoding(::Encoding::UTF_8).valid_encoding? ||
-              string !~ word_regex || string =~ / /
+            string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
+            !string.valid_encoding? ||
+              !word_regex.match?(string) || / /.match?(string)
           end
         end
 
@@ -81,7 +65,7 @@ module RuboCop
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(node)
+        def correct_bracketed(corrector, node)
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
@@ -92,9 +76,7 @@ module RuboCop
             end
           end
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, "[#{words.join(', ')}]")
-          end
+          corrector.replace(node, "[#{words.join(', ')}]")
         end
       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
@@ -50,9 +52,10 @@ module RuboCop
       #   # good
       #   99 == foo
       #   "bar" != foo
-      class YodaCondition < Cop
+      class YodaCondition < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
 
@@ -67,15 +70,18 @@ module RuboCop
 
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
 
+        PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+
+        def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
+          (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
+        PATTERN
+
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node)
-
-          valid_yoda?(node) || add_offense(node)
-        end
+          return if equality_only? && non_equality_operator?(node) ||
+                    file_constant_equal_program_name?(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          valid_yoda?(node) || add_offense(node) do |corrector|
             corrector.replace(actual_code_range(node), corrected_code(node))
           end
         end
@@ -102,7 +108,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
@@ -135,6 +142,20 @@ module RuboCop
         def noncommutative_operator?(node)
           NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
         end
+
+        def source_file_path_constant?(node)
+          node.source == '__FILE__'
+        end
+
+        def program_name?(name)
+          PROGRAM_NAMES.include?(name)
+        end
+
+        def interpolation?(node)
+          return true if node.dstr_type?
+
+          node.regexp_type? && node.interpolation?
+        end
       end
     end
   end

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

@@ -7,7 +7,7 @@ module RuboCop
       # by a predicate method, such as receiver.length == 0,
       # receiver.length > 0, receiver.length != 0,
       # receiver.length < 1 and receiver.size == 0 that can be
-      # replaced by receiver.empty? and !receiver.empty.
+      # replaced by receiver.empty? and !receiver.empty?.
       #
       # @example
       #   # bad
@@ -25,62 +25,60 @@ module RuboCop
       #   !{a: 1, b: 2}.empty?
       #   !string.empty?
       #   !hash.empty?
-      class ZeroLengthPredicate < Cop
+      class ZeroLengthPredicate < Base
+        extend AutoCorrector
+
         ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
         NONZERO_MSG = 'Use `!empty?` instead of ' \
                       '`%<lhs>s %<opr>s %<rhs>s`.'
 
+        RESTRICT_ON_SEND = %i[size length].freeze
+
         def on_send(node)
           check_zero_length_predicate(node)
           check_nonzero_length_predicate(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement(node))
-          end
-        end
-
         private
 
         def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node)
-
+          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,
-            message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          )
+            node.parent, message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          ) do |corrector|
+            corrector.replace(node.parent, replacement(node.parent))
+          end
         end
 
         def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node)
-
+          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,
-            message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          )
+            node.parent, message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          ) do |corrector|
+            corrector.replace(node.parent, replacement(node.parent))
+          end
         end
 
-        def_node_matcher :zero_length_predicate, <<-PATTERN
+        def_node_matcher :zero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
            (send (send (...) ${:length :size}) $:<  (int $1))
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
-        def_node_matcher :nonzero_length_predicate, <<-PATTERN
+        def_node_matcher :nonzero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
         PATTERN
@@ -92,14 +90,14 @@ module RuboCop
           "!#{other_receiver(node).source}.empty?"
         end
 
-        def_node_matcher :zero_length_receiver, <<-PATTERN
+        def_node_matcher :zero_length_receiver, <<~PATTERN
           {(send (send $_ _) :== (int 0))
            (send (int 0) :== (send $_ _))
            (send (send $_ _) :<  (int 1))
            (send (int 1) :> (send $_ _))}
         PATTERN
 
-        def_node_matcher :other_receiver, <<-PATTERN
+        def_node_matcher :other_receiver, <<~PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
         PATTERN
@@ -107,9 +105,9 @@ module RuboCop
         # Some collection like objects in the Ruby standard library
         # 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} ...) ...) ...)}
+        def_node_matcher :non_polymorphic_collection?, <<~PATTERN
+          {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
+           (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN
       end
     end