rubocop 0.49.1 → 0.52.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.3 or later, use unary plus operator to unfreeze a string
+      # literal instead of `String#dup` and `String.new`.
+      # Unary plus operator is faster than `String#dup`.
+      #
+      # Note: `String.new` (without operator) is not exactly the same as `+''`.
+      # These differ in encoding. `String.new.encoding` is always `ASCII-8BIT`.
+      # However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
+      # So, if you expect `ASCII-8BIT` encoding, disable this cop.
+      #
+      # @example
+      #   # bad
+      #   ''.dup
+      #   "something".dup
+      #   String.new
+      #   String.new('')
+      #   String.new('something')
+      #
+      #   # good
+      #   +'something'
+      #   +''
+      class UnfreezeString < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
+
+        MSG = 'Use unary plus to get an unfrozen string literal.'.freeze
+
+        def_node_matcher :dup_string?, <<-PATTERN
+          (send {str dstr} :dup)
+        PATTERN
+
+        def_node_matcher :string_new?, <<-PATTERN
+          {
+            (send (const nil? :String) :new {str dstr})
+            (send (const nil? :String) :new)
+          }
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if dup_string?(node) || string_new?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `URI::Parser.new`
+      # can be replaced by `URI::DEFAULT_PARSER`.
+      #
+      # @example
+      #   # bad
+      #   URI::Parser.new
+      #
+      #   # good
+      #   URI::DEFAULT_PARSER
+      #
+      class UriDefaultParser < Cop
+        MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of ' \
+              '`%<double_colon>sURI::Parser.new`.'.freeze
+
+        def_node_matcher :uri_parser_new?, <<-PATTERN
+          (send
+            (const
+              (const ${nil? cbase} :URI) :Parser) :new)
+        PATTERN
+
+        def on_send(node)
+          return unless uri_parser_new?(node) do |captured_value|
+            double_colon = captured_value ? '::' : ''
+            message = format(MSG, double_colon: double_colon)
+
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            double_colon = uri_parser_new?(node) ? '::' : ''
+
+            corrector.replace(
+              node.loc.expression, "#{double_colon}URI::DEFAULT_PARSER"
+            )
+          end
+        end
+      end
+    end
+  end
+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
@@ -70,7 +92,7 @@ module RuboCop
         def check_method_node(node)
           return unless bad_methods.include?(node.method_name)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         def message(node)

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

@@ -38,14 +38,12 @@ module RuboCop
         end
 
         def on_send(node)
-          ALIASES.keys.each do |aliased_method|
+          ALIASES.each_key do |aliased_method|
             register_offense(node, aliased_method) if
               public_send(aliased_method, node)
           end
         end
 
-        private
-
         def autocorrect(node)
           return false if append(node)
           lambda do |corrector|
@@ -55,11 +53,12 @@ module RuboCop
           end
         end
 
+        private
+
         def register_offense(node, method_name)
           add_offense(
             node,
-            :expression,
-            format(MSG, ALIASES[method_name][:original], method_name)
+            message: format(MSG, ALIASES[method_name][:original], method_name)
           )
         end
       end

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
@@ -23,9 +23,11 @@ module RuboCop
 
         MSG = 'Jobs should subclass `ApplicationJob`.'.freeze
         SUPERCLASS = 'ApplicationJob'.freeze
-        BASE_PATTERN = '(const (const nil :ActiveJob) :Base)'.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
@@ -23,9 +23,11 @@ module RuboCop
 
         MSG = 'Models should subclass `ApplicationRecord`.'.freeze
         SUPERCLASS = 'ApplicationRecord'.freeze
-        BASE_PATTERN = '(const (const nil :ActiveRecord) :Base)'.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/blank.rb

@@ -38,17 +38,21 @@ module RuboCop
       #       something
       #     end
       class Blank < Cop
-        MSG_NIL_OR_EMPTY = 'Use `%s.blank?` instead of `%s`.'.freeze
+        MSG_NIL_OR_EMPTY = 'Use `%s` instead of `%s`.'.freeze
         MSG_NOT_PRESENT = 'Use `%s` instead of `%s`.'.freeze
-        MSG_UNLESS_PRESENT = 'Use `if %s.blank?` instead of `%s`.'.freeze
+        MSG_UNLESS_PRESENT = 'Use `if %s` instead of `%s`.'.freeze
 
+        # `(send nil $_)` is not actually a valid match for an offense. Nodes
+        # that have a single method call on the left hand side
+        # (`bar || foo.empty?`) will blow up when checking
+        # `(send (:nil) :== $_)`.
         def_node_matcher :nil_or_empty?, <<-PATTERN
           (or
               {
                 (send $_ :!)
                 (send $_ :nil?)
-                (send $_ :== (:nil))
-                (send (:nil) :== $_)
+                (send $_ :== nil)
+                (send nil :== $_)
               }
               {
                 (send $_ :empty?)
@@ -60,7 +64,7 @@ module RuboCop
         def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
 
         def_node_matcher :unless_present?, <<-PATTERN
-          (:if $(send $_ :present?) {nil (...)} ...)
+          (:if $(send $_ :present?) {nil? (...)} ...)
         PATTERN
 
         def on_send(node)
@@ -68,23 +72,22 @@ module RuboCop
 
           not_present?(node) do |receiver|
             add_offense(node,
-                        :expression,
-                        format(MSG_NOT_PRESENT,
-                               replacement(receiver),
-                               node.source))
+                        message: format(MSG_NOT_PRESENT,
+                                        replacement(receiver),
+                                        node.source))
           end
         end
 
         def on_or(node)
           return unless cop_config['NilOrEmpty']
-          return unless node.lhs.receiver && node.rhs.receiver
 
           nil_or_empty?(node) do |variable1, variable2|
             return unless variable1 == variable2
 
             add_offense(node,
-                        :expression,
-                        format(MSG_NIL_OR_EMPTY, variable1.source, node.source))
+                        message: format(MSG_NIL_OR_EMPTY,
+                                        replacement(variable1),
+                                        node.source))
           end
         end
 
@@ -96,10 +99,10 @@ module RuboCop
             range = unless_condition(node, method_call)
 
             add_offense(node,
-                        range,
-                        format(MSG_UNLESS_PRESENT,
-                               receiver.source,
-                               range.source))
+                        location: range,
+                        message: format(MSG_UNLESS_PRESENT,
+                                        replacement(receiver),
+                                        range.source))
           end
         end
 
@@ -107,7 +110,7 @@ module RuboCop
           lambda do |corrector|
             method_call, variable1 = unless_present?(node)
 
-            if method_call && variable1
+            if method_call
               corrector.replace(node.loc.keyword, 'if')
               range = method_call.loc.expression
             else

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/date.rb

@@ -58,7 +58,8 @@ module RuboCop
 
           return if safe_chain?(node) || safe_to_time?(node)
 
-          add_offense(node, :selector, format(MSG_SEND, node.method_name))
+          add_offense(node, location: :selector,
+                            message: format(MSG_SEND, node.method_name))
         end
 
         private
@@ -70,10 +71,10 @@ module RuboCop
 
           method_name = (chain & bad_days).join('.')
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             "Date.#{method_name}",
-                             "Time.zone.#{method_name}"))
+          add_offense(node, location: :selector,
+                            message: format(MSG,
+                                            "Date.#{method_name}",
+                                            "Time.zone.#{method_name}"))
         end
 
         def extract_method_chain(node)
@@ -98,7 +99,7 @@ module RuboCop
           return unless node.method?(:to_time)
 
           if node.receiver.str_type?
-            zone_regexp = /[+-][\d:]+\z/
+            zone_regexp = /([+-][\d:]+|\dZ)\z/
 
             node.receiver.str_content.match(zone_regexp)
           else

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

@@ -3,8 +3,17 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations, that could have been created
-      # automatically with delegate method.
+      # This cop looks for delegations that could have been created
+      # automatically with the `delegate` method.
+      #
+      # Safe navigation `&.` is ignored because Rails' `allow_nil`
+      # option checks not just for nil but also delegates if nil
+      # responds to the delegated method.
+      #
+      # The `EnforceForPrefixed` option (defaulted to `true`) means that
+      # using the target object as a prefix of the method name
+      # without using the `delegate` method will be a violation.
+      # When set to `false`, this case is legal.
       #
       # @example
       #   # bad
@@ -15,6 +24,18 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo
       #
+      #   # good
+      #   def bar
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # EnforceForPrefixed: true
       #   # bad
       #   def foo_bar
       #     foo.bar
@@ -23,27 +44,29 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo, prefix: true
       #
+      #   # EnforceForPrefixed: false
       #   # good
-      #   private
-      #   def bar
+      #   def foo_bar
       #     foo.bar
       #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
       class Delegate < Cop
         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, :keyword, MSG)
-        end
 
-        private
+          add_offense(node, location: :keyword)
+        end
 
         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
@@ -53,38 +76,39 @@ module RuboCop
           end
         end
 
-        def trivial_delegate?(method_name, args, body)
-          body && delegate?(body) &&
+        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 ||
-            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?
+          cop_config['EnforceForPrefixed']
         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)