rubocop-rails 2.0.0

data/lib/rubocop-rails.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'rack/utils'
+
+require_relative 'rubocop/rails'
+require_relative 'rubocop/rails/version'
+require_relative 'rubocop/rails/inject'
+
+RuboCop::Rails::Inject.defaults!
+
+require_relative 'rubocop/cop/rails_cops'

data/lib/rubocop/cop/mixin/target_rails_version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target rails version.
+    module TargetRailsVersion
+      def minimum_target_rails_version(version)
+        @minimum_target_rails_version = version
+      end
+
+      def support_target_rails_version?(version)
+        @minimum_target_rails_version <= version
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the consistent use of action filter methods.
+      #
+      # 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 `%<prefer>s` over `%<current>s`.'
+
+        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 = %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
+
+        minimum_target_rails_version 4.0
+
+        def on_block(node)
+          check_method_node(node.send_node)
+        end
+
+        def on_send(node)
+          check_method_node(node) unless node.receiver
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source).to_s)
+          end
+        end
+
+        private
+
+        def check_method_node(node)
+          return unless bad_methods.include?(node.method_name)
+
+          add_offense(node, location: :selector)
+        end
+
+        def message(node)
+          format(MSG, prefer: preferred_method(node.method_name),
+                      current: node.method_name)
+        end
+
+        def bad_methods
+          style == :action ? FILTER_METHODS : ACTION_METHODS
+        end
+
+        def good_methods
+          style == :action ? ACTION_METHODS : FILTER_METHODS
+        end
+
+        def preferred_method(method)
+          good_methods[bad_methods.index(method.to_sym)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks that ActiveRecord aliases are not used. The direct method names
+      # are more clear and easier to read.
+      #
+      # @example
+      #   #bad
+      #   Book.update_attributes!(author: 'Alice')
+      #
+      #   #good
+      #   Book.update!(author: 'Alice')
+      class ActiveRecordAliases < Cop
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        ALIASES = {
+          update_attributes: :update,
+          update_attributes!: :update!
+        }.freeze
+
+        def on_send(node)
+          ALIASES.each do |bad, good|
+            next unless node.method?(bad)
+
+            add_offense(node,
+                        message: format(MSG, prefer: good, current: bad),
+                        location: :selector,
+                        severity: :warning)
+            break
+          end
+        end
+
+        alias on_csend on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.loc.selector,
+              ALIASES[node.method_name].to_s
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for overriding built-in Active Record methods instead of using
+      # callbacks.
+      #
+      # @example
+      #   # bad
+      #   class Book < ApplicationRecord
+      #     def save
+      #       self.title = title.upcase!
+      #       super
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Book < ApplicationRecord
+      #     before_save :upcase_title
+      #
+      #     def upcase_title
+      #       self.title = title.upcase!
+      #     end
+      #   end
+      #
+      class ActiveRecordOverride < Cop
+        MSG =
+          'Use %<prefer>s callbacks instead of overriding the Active Record ' \
+          'method `%<bad>s`.'
+        BAD_METHODS = %i[create destroy save update].freeze
+        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base
+                                   ActiveRecord::Base].freeze
+
+        def on_def(node)
+          return unless BAD_METHODS.include?(node.method_name)
+
+          parent_class_name = find_parent_class_name(node)
+          return unless active_model?(parent_class_name)
+
+          return unless node.descendants.any?(&:zsuper_type?)
+
+          add_offense(node, message: message(node.method_name))
+        end
+
+        private
+
+        def active_model?(parent_class_name)
+          ACTIVE_RECORD_CLASSES.include?(parent_class_name)
+        end
+
+        def callback_names(method_name)
+          names = %w[before_ around_ after_].map do |prefix|
+            "`#{prefix}#{method_name}`"
+          end
+
+          names[-1] = "or #{names.last}"
+
+          names.join(', ')
+        end
+
+        def message(method_name)
+          format(MSG, prefer: callback_names(method_name), bad: method_name)
+        end
+
+        def find_parent_class_name(node)
+          return nil unless node
+
+          if node.class_type?
+            parent_class_name = node.node_parts[1]
+
+            return nil if parent_class_name.nil?
+
+            return parent_class_name.source
+          end
+
+          find_parent_class_name(node.parent)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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`.'
+
+        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`.'
+        SUPERCLASS = 'ApplicationJob'
+        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'
+
+        # 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`.'
+        SUPERCLASS = 'ApplicationRecord'
+        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'
+
+        # 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/assert_not.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Use `assert_not` instead of `assert !`.
+      #
+      # @example
+      #   # bad
+      #   assert !x
+      #
+      #   # good
+      #   assert_not x
+      #
+      class AssertNot < RuboCop::Cop::Cop
+        MSG = 'Prefer `assert_not` over `assert !`.'
+
+        def_node_matcher :offensive?, '(send nil? :assert (send ... :!) ...)'
+
+        def on_send(node)
+          add_offense(node) if offensive?(node)
+        end
+
+        def autocorrect(node)
+          expression = node.loc.expression
+
+          lambda do |corrector|
+            corrector.replace(
+              expression,
+              corrected_source(expression.source)
+            )
+          end
+        end
+
+        private
+
+        def corrected_source(source)
+          source.gsub(/^assert(\(| ) *! */, 'assert_not\\1')
+        end
+      end
+    end
+  end
+end