rubocop 0.70.0 → 0.75.0

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

@@ -1,16 +0,0 @@
-# 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

@@ -1,117 +0,0 @@
-# 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

@@ -1,48 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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