rubocop 0.42.0 → 0.52.1

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

@@ -1,60 +1,83 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the consistent use of action filters methods.
+      # This cop enforces the consistent use of action filter methods.
       #
-      # The cop is configurable and the enforce the use of older
+      # The cop is configurable and can enforce the use of the older
       # something_filter methods or the newer something_action methods.
+      #
+      # 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
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
-
-        FILTER_METHODS = [
-          :after_filter,
-          :append_after_filter,
-          :append_around_filter,
-          :append_before_filter,
-          :around_filter,
-          :before_filter,
-          :prepend_after_filter,
-          :prepend_around_filter,
-          :prepend_before_filter,
-          :skip_after_filter,
-          :skip_around_filter,
-          :skip_before_filter,
-          :skip_filter
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
+
+        FILTER_METHODS = %i[
+          after_filter
+          append_after_filter
+          append_around_filter
+          append_before_filter
+          around_filter
+          before_filter
+          prepend_after_filter
+          prepend_around_filter
+          prepend_before_filter
+          skip_after_filter
+          skip_around_filter
+          skip_before_filter
+          skip_filter
         ].freeze
 
-        ACTION_METHODS = [
-          :after_action,
-          :append_after_action,
-          :append_around_action,
-          :append_before_action,
-          :around_action,
-          :before_action,
-          :prepend_after_action,
-          :prepend_around_action,
-          :prepend_before_action,
-          :skip_after_action,
-          :skip_around_action,
-          :skip_before_action,
-          :skip_action_callback
+        ACTION_METHODS = %i[
+          after_action
+          append_after_action
+          append_around_action
+          append_before_action
+          around_action
+          before_action
+          prepend_after_action
+          prepend_around_action
+          prepend_before_action
+          skip_after_action
+          skip_around_action
+          skip_before_action
+          skip_action_callback
         ].freeze
 
-        def on_block(node)
-          method, _args, _body = *node
+        minimum_target_rails_version 4.0
 
-          check_method_node(method)
+        def on_block(node)
+          check_method_node(node.send_node)
         end
 
         def on_send(node)
-          receiver, _method_name, *_args = *node
-
-          check_method_node(node) if receiver.nil?
+          check_method_node(node) unless node.receiver
         end
 
         def autocorrect(node)
@@ -67,17 +90,14 @@ module RuboCop
         private
 
         def check_method_node(node)
-          _receiver, method_name, *_args = *node
-          return unless offending_method?(method_name)
+          return unless bad_methods.include?(node.method_name)
 
-          add_offense(node, :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
+          add_offense(node, location: :selector)
         end
 
-        def offending_method?(method_name)
-          bad_methods.include?(method_name)
+        def message(node)
+          format(MSG, prefer: preferred_method(node.method_name),
+                      current: node.method_name)
         end
 
         def bad_methods

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that ActiveSupport aliases to core ruby methods
+      # are not used.
+      #
+      # @example
+      #   # good
+      #   'some_string'.start_with?('prefix')
+      #   'some_string'.end_with?('suffix')
+      #   [1, 2, 'a'] << 'b'
+      #   [1, 2, 'a'].unshift('b')
+      #
+      #   # bad
+      #   'some_string'.starts_with?('prefix')
+      #   'some_string'.ends_with?('suffix')
+      #   [1, 2, 'a'].append('b')
+      #   [1, 2, 'a'].prepend('b')
+      #
+      class ActiveSupportAliases < Cop
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+
+        ALIASES = {
+          starts_with?: {
+            original: :start_with?, matcher: '(send str :starts_with? _)'
+          },
+          ends_with?: {
+            original: :end_with?, matcher: '(send str :ends_with? _)'
+          },
+          append: { original: :<<, matcher: '(send array :append _)' },
+          prepend: { original: :unshift, matcher: '(send array :prepend _)' }
+        }.freeze
+
+        ALIASES.each do |aliased_method, options|
+          def_node_matcher aliased_method, options[:matcher]
+        end
+
+        def on_send(node)
+          ALIASES.each_key do |aliased_method|
+            register_offense(node, aliased_method) if
+              public_send(aliased_method, node)
+          end
+        end
+
+        def autocorrect(node)
+          return false if append(node)
+          lambda do |corrector|
+            method_name = node.loc.selector.source
+            replacement = ALIASES[method_name.to_sym][:original]
+            corrector.replace(node.loc.selector, replacement.to_s)
+          end
+        end
+
+        private
+
+        def register_offense(node, method_name)
+          add_offense(
+            node,
+            message: format(MSG, prefer: ALIASES[method_name][:original],
+                                 current: method_name)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that jobs subclass ApplicationJob with Rails 5.0.
+      #
+      # @example
+      #
+      #  # good
+      #  class Rails5Job < ApplicationJob
+      #    # ...
+      #  end
+      #
+      #  # bad
+      #  class Rails4Job < ActiveJob::Base
+      #    # ...
+      #  end
+      class ApplicationJob < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = 'Jobs should subclass `ApplicationJob`.'.freeze
+        SUPERCLASS = 'ApplicationJob'.freeze
+        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'.freeze
+
+        # rubocop:disable Layout/ClassStructure
+        include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, self.class::SUPERCLASS)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that models subclass ApplicationRecord with Rails 5.0.
+      #
+      # @example
+      #
+      #  # good
+      #  class Rails5Model < ApplicationRecord
+      #    # ...
+      #  end
+      #
+      #  # bad
+      #  class Rails4Model < ActiveRecord::Base
+      #    # ...
+      #  end
+      class ApplicationRecord < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = 'Models should subclass `ApplicationRecord`.'.freeze
+        SUPERCLASS = 'ApplicationRecord'.freeze
+        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'.freeze
+
+        # rubocop:disable Layout/ClassStructure
+        include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, self.class::SUPERCLASS)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cops checks for code that can be changed to `blank?`.
+      # Settings:
+      #   NilOrEmpty: Convert checks for `nil` or `empty?` to `blank?`
+      #   NotPresent: Convert usages of not `present?` to `blank?`
+      #   UnlessPresent: Convert usages of `unless` `present?` to `blank?`
+      #
+      # @example
+      #   # NilOrEmpty: true
+      #     # bad
+      #     foo.nil? || foo.empty?
+      #     foo == nil || foo.empty?
+      #
+      #     # good
+      #     foo.blank?
+      #
+      #   # NotPresent: true
+      #     # bad
+      #     !foo.present?
+      #
+      #     # good
+      #     foo.blank?
+      #
+      #   # UnlessPresent: true
+      #     # bad
+      #     something unless foo.present?
+      #     unless foo.present?
+      #       something
+      #     end
+      #
+      #     # good
+      #     something if foo.blank?
+      #     if foo.blank?
+      #       something
+      #     end
+      class Blank < Cop
+        MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
+                             '`%<current>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 $_ :empty?)
+                (send (send (send $_ :empty?) :!) :!)
+              }
+          )
+        PATTERN
+
+        def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
+
+        def_node_matcher :unless_present?, <<-PATTERN
+          (:if $(send $_ :present?) {nil? (...)} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless cop_config['NotPresent']
+
+          not_present?(node) do |receiver|
+            add_offense(node,
+                        message: format(MSG_NOT_PRESENT,
+                                        prefer: replacement(receiver),
+                                        current: node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+
+          nil_or_empty?(node) do |variable1, variable2|
+            return unless variable1 == variable2
+
+            add_offense(node,
+                        message: format(MSG_NIL_OR_EMPTY,
+                                        prefer: replacement(variable1),
+                                        current: node.source))
+          end
+        end
+
+        def on_if(node)
+          return unless cop_config['UnlessPresent']
+          return unless node.unless?
+
+          unless_present?(node) do |method_call, receiver|
+            range = unless_condition(node, method_call)
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG_UNLESS_PRESENT,
+                                        prefer: replacement(receiver),
+                                        current: range.source))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_call, variable1 = unless_present?(node)
+
+            if method_call
+              corrector.replace(node.loc.keyword, 'if')
+              range = method_call.loc.expression
+            else
+              variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
+              range = node.loc.expression
+            end
+
+            corrector.replace(range, replacement(variable1))
+          end
+        end
+
+        private
+
+        def unless_condition(node, method_call)
+          if node.modifier_form?
+            node.loc.keyword.join(node.loc.expression.end)
+          else
+            node.loc.expression.begin.join(method_call.loc.expression)
+          end
+        end
+
+        def replacement(node)
+          node.respond_to?(:source) ? "#{node.source}.blank?" : 'blank?'
+        end
+      end
+    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