rubocop 0.51.0 → 0.87.0

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

@@ -5,10 +5,35 @@ module RuboCop
     module Style
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     @foo
+      #   end
+      #
+      #   def bar=(val)
+      #     @bar = val
+      #   end
+      #
+      #   def self.baz
+      #     @baz
+      #   end
+      #
+      #   # good
+      #   attr_reader :foo
+      #   attr_writer :bar
+      #
+      #   class << self
+      #     attr_reader :baz
+      #   end
       class TrivialAccessors < Cop
-        MSG = 'Use `attr_%s` to define trivial %s methods.'.freeze
+        include AllowedMethods
+
+        MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
 
         def on_def(node)
+          return if top_level_node?(node)
           return if in_module_or_instance_eval?(node)
           return if ignore_class_methods? && node.defs_type?
 
@@ -16,6 +41,17 @@ 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)
@@ -26,7 +62,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
@@ -42,7 +78,7 @@ module RuboCop
 
           add_offense(node,
                       location: :keyword,
-                      message: format(MSG, kind, kind))
+                      message: format(MSG, kind: kind))
         end
 
         def exact_name_match?
@@ -61,9 +97,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)
@@ -72,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)
@@ -81,16 +116,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
 
@@ -121,21 +156,13 @@ module RuboCop
           "attr_#{kind} :#{method_name.to_s.chomp('=')}"
         end
 
-        def autocorrect(node)
-          if node.def_type?
-            autocorrect_instance(node)
-          elsif node.defs_type? && node.children.first.self_type?
-            autocorrect_class(node)
-          end
-        end
-
         def autocorrect_instance(node)
           kind = trivial_accessor_kind(node)
 
           return unless names_match?(node) && !node.predicate_method? && kind
 
           lambda do |corrector|
-            corrector.replace(node.source_range,
+            corrector.replace(node,
                               accessor(kind, node.method_name))
           end
         end
@@ -155,6 +182,10 @@ module RuboCop
             )
           end
         end
+
+        def top_level_node?(node)
+          node.parent.nil?
+        end
       end
     end
   end

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

@@ -3,10 +3,27 @@
 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
+      #   unless foo_bar.nil?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
+      #
+      #   # good
+      #   if foo_bar.present?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
       class UnlessElse < Cop
+        include RangeHelp
+
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
-              'positive case first.'.freeze
+              'positive case first.'
 
         def on_if(node)
           return unless node.unless? && node.else?
@@ -15,12 +32,11 @@ module RuboCop
         end
 
         def autocorrect(node)
-          condition, = *node
-          body_range = range_between_condition_and_else(node, condition)
+          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'.freeze)
+            corrector.replace(node.loc.keyword, 'if')
             corrector.replace(body_range, else_range.source)
             corrector.replace(else_range, body_range.source)
           end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for accessing the first element of `String#unpack`
+      # which can be replaced with the shorter method `unpack1`.
+      #
+      # @example
+      #
+      #   # bad
+      #   'foo'.unpack('h*').first
+      #   'foo'.unpack('h*')[0]
+      #   'foo'.unpack('h*').slice(0)
+      #   'foo'.unpack('h*').at(0)
+      #
+      #   # good
+      #   'foo'.unpack1('h*')
+      #
+      class UnpackFirst < Cop
+        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
+          '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+
+        def_node_matcher :unpack_and_first_element?, <<~PATTERN
+          {
+            (send $(send (...) :unpack $(...)) :first)
+            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+          }
+        PATTERN
+
+        def on_send(node)
+          unpack_and_first_element?(node) do |unpack_call, unpack_arg|
+            range = first_element_range(node, unpack_call)
+            message = format(MSG,
+                             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|
+              corrector.remove(first_element_range(node, unpack_call))
+              corrector.replace(unpack_call.loc.selector, 'unpack1')
+            end
+          end
+        end
+
+        private
+
+        def first_element_range(node, unpack_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    unpack_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -4,40 +4,41 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for variable interpolation (like "#@ivar").
+      #
+      # @example
+      #   # bad
+      #   "His name is #$name"
+      #   /check #$pattern/
+      #   "Let's go to the #@store"
+      #
+      #   # good
+      #   "His name is #{$name}"
+      #   /check #{$pattern}/
+      #   "Let's go to the #{@store}"
       class VariableInterpolation < Cop
-        MSG = 'Replace interpolated variable `%s` ' \
-              'with expression `#{%s}`.'.freeze
+        include Interpolation
 
-        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
-
-        private
+        MSG = 'Replace interpolated variable `%<variable>s` ' \
+              'with expression `#{%<variable>s}`.'
 
-        def check_for_interpolation(node)
+        def on_node_with_interpolations(node)
           var_nodes(node.children).each do |var_node|
             add_offense(var_node)
           end
         end
 
-        def message(node)
-          format(MSG, node.source, node.source)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
+            corrector.replace(node, "{#{node.source}}")
           end
         end
 
+        private
+
+        def message(node)
+          format(MSG, variable: node.source)
+        end
+
         def var_nodes(nodes)
           nodes.select { |n| n.variable? || n.reference? }
         end

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

@@ -3,9 +3,22 @@
 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
+      #   case foo
+      #   when 1; 'baz'
+      #   when 2; 'bar'
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1 then 'baz'
+      #   when 2 then 'bar'
+      #   end
       class WhenThen < Cop
-        MSG = 'Do not use `when x;`. Use `when x then` instead.'.freeze
+        MSG = 'Do not use `when x;`. Use `when x then` instead.'
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body

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

@@ -4,8 +4,32 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of `do` in multi-line `while/until` statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   while x.any? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   while x.any?
+      #     do_something(x.pop)
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   until x.empty? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   until x.empty?
+      #     do_something(x.pop)
+      #   end
       class WhileUntilDo < Cop
-        MSG = 'Do not use `do` with multi-line `%s`.'.freeze
+        MSG = 'Do not use `do` with multi-line `%<keyword>s`.'
 
         def on_while(node)
           handle(node)
@@ -19,11 +43,9 @@ module RuboCop
           return unless node.multiline? && node.do?
 
           add_offense(node, location: :begin,
-                            message: format(MSG, node.keyword))
+                            message: format(MSG, keyword: node.keyword))
         end
 
-        private
-
         def autocorrect(node)
           do_range = node.condition.source_range.end.join(node.loc.begin)
 

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

@@ -4,12 +4,31 @@ module RuboCop
   module Cop
     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 configurable.
+      # if written as a modifier while/until. The maximum line length is
+      # configured in the `Layout/LineLength` cop.
+      #
+      # @example
+      #   # bad
+      #   while x < 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #
+      # @example
+      #   # bad
+      #   until x > 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 until x > 10
       class WhileUntilModifier < Cop
         include StatementModifier
 
-        MSG = 'Favor modifier `%s` usage when having a single-line body.'.freeze
+        MSG = 'Favor modifier `%<keyword>s` usage when ' \
+              'having a single-line body.'
 
         def on_while(node)
           check(node)
@@ -19,22 +38,22 @@ module RuboCop
           check(node)
         end
 
-        private
-
         def autocorrect(node)
           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, node.keyword))
+                            message: format(MSG, keyword: node.keyword))
         end
       end
     end

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

@@ -14,18 +14,14 @@ module RuboCop
       # cop. For example, a `MinSize` of `3` will not enforce a style on an
       # array of 2 or fewer elements.
       #
-      # @example
-      #   EnforcedStyle: percent (default)
-      #
+      # @example EnforcedStyle: percent (default)
       #   # good
       #   %w[foo bar baz]
       #
       #   # bad
       #   ['foo', 'bar', 'baz']
       #
-      # @example
-      #   EnforcedStyle: brackets
-      #
+      # @example EnforcedStyle: brackets
       #   # good
       #   ['foo', 'bar', 'baz']
       #
@@ -36,11 +32,9 @@ module RuboCop
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
-        include PercentLiteral
 
-        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
-        ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
-        QUESTION_MARK_SIZE = '?'.size
+        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
+        ARRAY_MSG = 'Use `[]` for an array of words.'
 
         class << self
           attr_accessor :largest_brackets
@@ -56,16 +50,18 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           if style == :percent
-            correct_percent(node, 'w')
+            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)
 
@@ -75,9 +71,9 @@ module RuboCop
 
         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
 
@@ -86,10 +82,18 @@ module RuboCop
         end
 
         def correct_bracketed(node)
-          words = node.children.map { |w| to_string_literal(w.children[0]) }
+          words = node.children.map do |word|
+            if word.dstr_type?
+              string_literal = to_string_literal(word.source)
+
+              trim_string_interporation_escape_character(string_literal)
+            else
+              to_string_literal(word.children[0])
+            end
+          end
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+            corrector.replace(node, "[#{words.join(', ')}]")
           end
         end
       end