rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/performance/redundant_match.rb

@@ -8,13 +8,13 @@ module RuboCop
       # index/`nil` and is more performant.
       #
       # @example
-      #   @bad
+      #   # bad
       #   do_something if str.match(/regex/)
       #   while regex.match('str')
       #     do_something
       #   end
       #
-      #   @good
+      #   # good
       #   method(str =~ /regex/)
       #   return value unless regex =~ 'str'
       class RedundantMatch < Cop

data/lib/rubocop/cop/performance/redundant_merge.rb

@@ -11,8 +11,8 @@ module RuboCop
       #   hash.merge!({'key' => 'value'})
       #   hash.merge!(a: 1, b: 2)
       class RedundantMerge < Cop
-        AREF_ASGN = '%s[%s] = %s'.freeze
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
         def_node_matcher :redundant_merge_candidate, <<-PATTERN
           (send $!nil? :merge! [(hash $...) !kwsplat_type?])
@@ -46,7 +46,7 @@ module RuboCop
           redundant_merge_candidate(node) do |receiver, pairs|
             assignments = to_assignments(receiver, pairs).join('; ')
 
-            format(MSG, assignments, node.source)
+            format(MSG, prefer: assignments, current: node.source)
           end
         end
 
@@ -94,7 +94,9 @@ module RuboCop
 
             key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
 
-            format(AREF_ASGN, receiver.source, key, value.source)
+            format(AREF_ASGN, receiver: receiver.source,
+                              key: key,
+                              value: value.source)
           end
         end
 

data/lib/rubocop/cop/performance/redundant_sort_by.rb

@@ -7,16 +7,16 @@ module RuboCop
       # `sort`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   array.sort_by { |x| x }
       #   array.sort_by do |var|
       #     var
       #   end
       #
-      #   @good
+      #   # good
       #   array.sort
       class RedundantSortBy < Cop
-        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
+        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'.freeze
 
         def_node_matcher :redundant_sort_by, <<-PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
@@ -28,7 +28,7 @@ module RuboCop
 
             add_offense(node,
                         location: range,
-                        message: format(MSG, var_name, var_name))
+                        message: format(MSG, var: var_name))
           end
         end
 

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -64,7 +64,8 @@ module RuboCop
         minimum_target_ruby_version 2.4
 
         MSG =
-          'Use `match?` instead of `%s` when `MatchData` is not used.'.freeze
+          'Use `match?` instead of `%<current>s` when `MatchData` ' \
+          'is not used.'.freeze
 
         def_node_matcher :match_method?, <<-PATTERN
           {
@@ -147,7 +148,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.loc.selector.source)
+          format(MSG, current: node.loc.selector.source)
         end
 
         def last_match_used?(match_node)

data/lib/rubocop/cop/performance/size.rb

@@ -32,12 +32,12 @@ module RuboCop
           add_offense(node, location: :selector)
         end
 
-        private
-
         def autocorrect(node)
           ->(corrector) { corrector.replace(node.loc.selector, 'size') }
         end
 
+        private
+
         def eligible_node?(node)
           return false unless node.method?(:count) && !node.arguments?
 

data/lib/rubocop/cop/performance/start_with.rb

@@ -7,11 +7,11 @@ module RuboCop
       # `String#start_with?` would suffice.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc' =~ /\Aab/
       #   'abc'.match(/\Aab/)
       #
-      #   @good
+      #   # good
       #   'abc'.start_with?('ab')
       class StartWith < Cop
         MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -7,19 +7,19 @@ module RuboCop
       # `tr` or `delete`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   'abc'.gsub('b', 'd')
       #   'abc'.gsub('a', '')
       #   'abc'.gsub(/a/, 'd')
       #   'abc'.gsub!('a', 'd')
       #
-      #   @good
+      #   # good
       #   'abc'.gsub(/.*/, 'a')
       #   'abc'.gsub(/a+/, 'd')
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
-        MSG = 'Use `%s` instead of `%s`.'.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
         DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
         DELETE = 'delete'.freeze
         TR = 'tr'.freeze
@@ -151,7 +151,7 @@ module RuboCop
           replacement_method =
             replacement_method(node, first_source, second_source)
 
-          format(MSG, replacement_method, node.method_name)
+          format(MSG, prefer: replacement_method, current: node.method_name)
         end
 
         def method_suffix(node)

data/lib/rubocop/cop/performance/times_map.rb

@@ -8,13 +8,12 @@ module RuboCop
       # with an explicit array creation.
       #
       # @example
-      #
-      #   @bad
+      #   # bad
       #   9.times.map do |i|
       #     i.to_s
       #   end
       #
-      #   @good
+      #   # good
       #   Array.new(9) do |i|
       #     i.to_s
       #   end
@@ -31,6 +30,18 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          map_or_collect, count = times_map_call(node)
+
+          replacement =
+            "Array.new(#{count.source}" \
+            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
+
+          lambda do |corrector|
+            corrector.replace(map_or_collect.loc.expression, replacement)
+          end
+        end
+
         private
 
         def check(node)
@@ -54,18 +65,6 @@ module RuboCop
           {(block $(send (send $!nil? :times) {:map :collect}) ...)
            $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
         PATTERN
-
-        def autocorrect(node)
-          map_or_collect, count = times_map_call(node)
-
-          replacement =
-            "Array.new(#{count.source}" \
-            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
-
-          lambda do |corrector|
-            corrector.replace(map_or_collect.loc.expression, replacement)
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/performance/uri_default_parser.rb

@@ -14,8 +14,8 @@ module RuboCop
       #   URI::DEFAULT_PARSER
       #
       class UriDefaultParser < Cop
-        MSG = 'Use `%sURI::DEFAULT_PARSER` instead of ' \
-              '`%sURI::Parser.new`.'.freeze
+        MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of ' \
+              '`%<double_colon>sURI::Parser.new`.'.freeze
 
         def_node_matcher :uri_parser_new?, <<-PATTERN
           (send
@@ -26,7 +26,7 @@ module RuboCop
         def on_send(node)
           return unless uri_parser_new?(node) do |captured_value|
             double_colon = captured_value ? '::' : ''
-            message = format(MSG, double_colon, double_colon)
+            message = format(MSG, double_colon: double_colon)
 
             add_offense(node, message: message)
           end

data/lib/rubocop/cop/rails/action_filter.rb

@@ -10,6 +10,28 @@ module RuboCop
       #
       # If the TargetRailsVersion is set to less than 4.0, the cop will enforce
       # the use of filter methods.
+      #
+      # @example EnforcedStyle: action (default)
+      #   # bad
+      #   after_filter :do_stuff
+      #   append_around_filter :do_stuff
+      #   skip_after_filter :do_stuff
+      #
+      #   # good
+      #   after_action :do_stuff
+      #   append_around_action :do_stuff
+      #   skip_after_action :do_stuff
+      #
+      # @example EnforcedStyle: filter
+      #   # bad
+      #   after_action :do_stuff
+      #   append_around_action :do_stuff
+      #   skip_after_action :do_stuff
+      #
+      #   # good
+      #   after_filter :do_stuff
+      #   append_around_filter :do_stuff
+      #   skip_after_filter :do_stuff
       class ActionFilter < Cop
         extend TargetRailsVersion
         include ConfigurableEnforcedStyle

data/lib/rubocop/cop/rails/active_support_aliases.rb

@@ -44,8 +44,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           return false if append(node)
           lambda do |corrector|
@@ -55,6 +53,8 @@ module RuboCop
           end
         end
 
+        private
+
         def register_offense(node, method_name)
           add_offense(
             node,

data/lib/rubocop/cop/rails/application_job.rb

@@ -9,12 +9,12 @@ module RuboCop
       #
       #  # good
       #  class Rails5Job < ApplicationJob
-      #    ...
+      #    # ...
       #  end
       #
       #  # bad
       #  class Rails4Job < ActiveJob::Base
-      #    ...
+      #    # ...
       #  end
       class ApplicationJob < Cop
         extend TargetRailsVersion
@@ -25,7 +25,9 @@ module RuboCop
         SUPERCLASS = 'ApplicationJob'.freeze
         BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'.freeze
 
+        # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
       end
     end
   end

data/lib/rubocop/cop/rails/application_record.rb

@@ -9,12 +9,12 @@ module RuboCop
       #
       #  # good
       #  class Rails5Model < ApplicationRecord
-      #    ...
+      #    # ...
       #  end
       #
       #  # bad
       #  class Rails4Model < ActiveRecord::Base
-      #    ...
+      #    # ...
       #  end
       class ApplicationRecord < Cop
         extend TargetRailsVersion
@@ -25,7 +25,9 @@ module RuboCop
         SUPERCLASS = 'ApplicationRecord'.freeze
         BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'.freeze
 
+        # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
       end
     end
   end

data/lib/rubocop/cop/rails/create_table_with_timestamps.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks the migration for which timestamps are not included
+      # when creating a new table.
+      # In many cases, timestamps are useful information and should be added.
+      #
+      # @example
+      #   # bad
+      #   create_table :users
+      #
+      #   # bad
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #   end
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #
+      #     t.timestamps
+      #   end
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #
+      #     t.datetime :created_at, default: -> { 'CURRENT_TIMESTAMP' }
+      #   end
+      #
+      #   # good
+      #   create_table :users do |t|
+      #     t.string :name
+      #     t.string :email
+      #
+      #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
+      #   end
+      class CreateTableWithTimestamps < Cop
+        MSG = 'Add timestamps when creating a new table.'.freeze
+
+        def_node_matcher :create_table_with_block?, <<-PATTERN
+          (block
+            (send nil? :create_table ...)
+            (args (arg _var))
+            _)
+        PATTERN
+
+        def_node_search :timestamps_included?, <<-PATTERN
+          (send _var :timestamps ...)
+        PATTERN
+
+        def_node_search :created_at_or_updated_at_included?, <<-PATTERN
+          (send _var :datetime (sym {:created_at :updated_at}) ...)
+        PATTERN
+
+        def on_send(node)
+          return unless node.command?(:create_table)
+          parent = node.parent
+
+          if create_table_with_block?(parent)
+            if parent.body.nil? || !time_columns_included?(parent.body)
+              add_offense(parent)
+            end
+          else
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def time_columns_included?(node)
+          timestamps_included?(node) || created_at_or_updated_at_included?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/delegate.rb

@@ -56,18 +56,17 @@ module RuboCop
         MSG = 'Use `delegate` to define delegations.'.freeze
 
         def on_def(node)
-          method_name, args, body = *node
-          return unless trivial_delegate?(method_name, args, body)
+          return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
+
           add_offense(node, location: :keyword)
         end
 
-        private
-
         def autocorrect(node)
           method_name, _args, body = *node
-          delegation = ["delegate :#{body.children[1]}",
-                        "to: :#{body.children[0].children[1]}"]
+          delegation = ["delegate :#{body.method_name}",
+                        "to: :#{body.receiver.method_name}"]
+
           if method_name == prefixed_method_name(body)
             delegation << ['prefix: true']
           end
@@ -77,33 +76,31 @@ module RuboCop
           end
         end
 
-        def trivial_delegate?(method_name, args, body)
-          body && delegate?(body) && !body.csend_type? &&
+        private
+
+        def trivial_delegate?(def_node)
+          method_name, args, body = *def_node
+
+          delegate?(body) &&
             method_name_matches?(method_name, body) &&
             arguments_match?(args, body)
         end
 
         def delegate?(body)
-          receiver, = *body
-          receiver.respond_to?(:type) && receiver.send_type? &&
-            receiver.child_nodes.empty?
+          body && body.send_type? && body.receiver &&
+            body.receiver.send_type? && !body.receiver.receiver
         end
 
-        def arguments_match?(args, body)
-          _receiver, _method_name, *arguments = *body
-          arg_array = Array(args)
-          argument_array = Array(arguments)
-          arg_array.size == argument_array.size && (
-            arg_array == argument_array ||
+        def arguments_match?(arg_array, body)
+          argument_array = body.arguments
+
+          arg_array == argument_array ||
             arg_array.map(&:children) == argument_array.map(&:children)
-          )
         end
 
         def method_name_matches?(method_name, body)
-          _receiver, property_name, *_args = *body
-          method_name == property_name ||
-            (include_prefix_case? &&
-              method_name == prefixed_method_name(body))
+          method_name == body.method_name ||
+            include_prefix_case? && method_name == prefixed_method_name(body)
         end
 
         def include_prefix_case?
@@ -111,9 +108,7 @@ module RuboCop
         end
 
         def prefixed_method_name(body)
-          receiver, property_name, *_args = *body
-          _receiver, target, *_args = *receiver
-          [target, property_name].join('_').to_sym
+          [body.receiver.method_name, body.method_name].join('_').to_sym
         end
 
         def private_or_protected_delegation(node)