rubocop 0.70.0 → 0.75.0

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop looks for duplicate values in enum declarations.
-      #
-      # @example
-      #   # bad
-      #   enum status: { active: 0, archived: 0 }
-      #
-      #   # good
-      #   enum status: { active: 0, archived: 1 }
-      #
-      #   # bad
-      #   enum status: [:active, :archived, :active]
-      #
-      #   # good
-      #   enum status: [:active, :archived]
-      class EnumUniqueness < Cop
-        include Duplication
-
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
-
-        def_node_matcher :enum_declaration, <<-PATTERN
-          (send nil? :enum (hash (pair (_ $_) ${array hash})))
-        PATTERN
-
-        def on_send(node)
-          enum_declaration(node) do |name, args|
-            items = args.values
-
-            return unless duplicates?(items)
-
-            consecutive_duplicates(items).each do |item|
-              add_offense(item, message: format(MSG, value: item.source,
-                                                     enum: name))
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that Rails.env is compared using `.production?`-like
-      # methods instead of equality against a string or symbol.
-      #
-      # @example
-      #   # bad
-      #   Rails.env == 'production'
-      #
-      #   # bad, always returns false
-      #   Rails.env == :test
-      #
-      #   # good
-      #   Rails.env.production?
-      class EnvironmentComparison < Cop
-        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`."
-
-        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
-          'evaluate to `false`.'
-
-        def_node_matcher :environment_str_comparison?, <<-PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            :==
-            $str
-          )
-        PATTERN
-
-        def_node_matcher :environment_sym_comparison?, <<-PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            :==
-            $sym
-          )
-        PATTERN
-
-        def on_send(node)
-          environment_str_comparison?(node) do |env_node|
-            env, = *env_node
-            add_offense(node, message: format(MSG, env: env))
-          end
-          environment_sym_comparison?(node) do |_|
-            add_offense(node, message: SYM_MSG)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, replacement(node))
-          end
-        end
-
-        private
-
-        def replacement(node)
-          "#{node.receiver.source}.#{content(node.first_argument)}?"
-        end
-
-        def_node_matcher :content, <<-PATTERN
-          ({str sym} $_)
-        PATTERN
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop enforces that `exit` calls are not used within a rails app.
-      # Valid options are instead to raise an error, break, return, or some
-      # other form of stopping execution of current request.
-      #
-      # There are two obvious cases where `exit` is particularly harmful:
-      #
-      # - Usage in library code for your application. Even though Rails will
-      # rescue from a `SystemExit` and continue on, unit testing that library
-      # code will result in specs exiting (potentially silently if `exit(0)`
-      # is used.)
-      # - Usage in application code outside of the web process could result in
-      # the program exiting, which could result in the code failing to run and
-      # do its job.
-      #
-      # @example
-      #   # bad
-      #   exit(0)
-      #
-      #   # good
-      #   raise 'a bad error has happened'
-      class Exit < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `exit` in Rails applications.'
-        TARGET_METHODS = %i[exit exit!].freeze
-        EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
-
-        def on_send(node)
-          add_offense(node, location: :selector) if offending_node?(node)
-        end
-
-        private
-
-        def offending_node?(node)
-          right_method_name?(node.method_name) &&
-            right_argument_count?(node.arguments) &&
-            right_receiver?(node.receiver)
-        end
-
-        def right_method_name?(method_name)
-          TARGET_METHODS.include?(method_name)
-        end
-
-        # More than 1 argument likely means it is a different
-        # `exit` implementation than the one we are preventing.
-        def right_argument_count?(arg_nodes)
-          arg_nodes.size <= 1
-        end
-
-        # Only register if exit is being called explicitly on `Kernel`,
-        # `Process`, or if receiver node is nil for plain `exit` calls.
-        def right_receiver?(receiver_node)
-          return true unless receiver_node
-
-          _a, receiver_node_class, _c = *receiver_node
-
-          EXPLICIT_RECEIVERS.include?(receiver_node_class)
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of file path joining process
-      # to use `Rails.root.join` clause. It is used to add uniformity when
-      # joining paths.
-      #
-      # @example EnforcedStyle: arguments (default)
-      #   # bad
-      #   Rails.root.join('app/models/goober')
-      #   File.join(Rails.root, 'app/models/goober')
-      #   "#{Rails.root}/app/models/goober"
-      #
-      #   # good
-      #   Rails.root.join('app', 'models', 'goober')
-      #
-      # @example EnforcedStyle: slashes
-      #   # bad
-      #   Rails.root.join('app', 'models', 'goober')
-      #   File.join(Rails.root, 'app/models/goober')
-      #   "#{Rails.root}/app/models/goober"
-      #
-      #   # good
-      #   Rails.root.join('app/models/goober')
-      #
-      class FilePath < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MSG_SLASHES = 'Please use `Rails.root.join(\'path/to\')` ' \
-                      'instead.'
-        MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
-                        'instead.'
-
-        def_node_matcher :file_join_nodes?, <<-PATTERN
-          (send (const nil? :File) :join ...)
-        PATTERN
-
-        def_node_search :rails_root_nodes?, <<-PATTERN
-          (send (const nil? :Rails) :root)
-        PATTERN
-
-        def_node_matcher :rails_root_join_nodes?, <<-PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
-        PATTERN
-
-        def on_dstr(node)
-          return unless rails_root_nodes?(node)
-          return unless node.children.last.source.start_with?('.') ||
-                        node.children.last.source.include?(File::SEPARATOR)
-
-          register_offense(node)
-        end
-
-        def on_send(node)
-          check_for_file_join_with_rails_root(node)
-          check_for_rails_root_join_with_slash_separated_path(node)
-          check_for_rails_root_join_with_string_arguments(node)
-        end
-
-        private
-
-        def check_for_file_join_with_rails_root(node)
-          return unless file_join_nodes?(node)
-          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
-
-          register_offense(node)
-        end
-
-        def check_for_rails_root_join_with_string_arguments(node)
-          return unless style == :slashes
-          return unless rails_root_nodes?(node)
-          return unless rails_root_join_nodes?(node)
-          return unless node.arguments.size > 1
-          return unless node.arguments.all?(&:str_type?)
-
-          register_offense(node)
-        end
-
-        def check_for_rails_root_join_with_slash_separated_path(node)
-          return unless style == :arguments
-          return unless rails_root_nodes?(node)
-          return unless rails_root_join_nodes?(node)
-          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
-
-          register_offense(node)
-        end
-
-        def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
-        end
-
-        def register_offense(node)
-          line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.first_line,
-                                      line_range)
-          add_offense(node, location: source_range)
-        end
-
-        def message(_node)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of `where.first` and
-      # change them to use `find_by` instead.
-      #
-      # @example
-      #   # bad
-      #   User.where(name: 'Bruce').first
-      #   User.where(name: 'Bruce').take
-      #
-      #   # good
-      #   User.find_by(name: 'Bruce')
-      class FindBy < Cop
-        include RangeHelp
-
-        MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        TARGET_SELECTORS = %i[first take].freeze
-
-        def_node_matcher :where_first?, <<-PATTERN
-          (send ({send csend} _ :where ...) {:first :take})
-        PATTERN
-
-        def on_send(node)
-          return unless where_first?(node)
-
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
-
-          add_offense(node, location: range,
-                            message: format(MSG, method: node.method_name))
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          # Don't autocorrect where(...).first, because it can return different
-          # results from find_by. (They order records differently, so the
-          # 'first' record can be different.)
-          return if node.method?(:first)
-
-          where_loc = node.receiver.loc.selector
-          first_loc = range_between(node.loc.dot.begin_pos,
-                                    node.loc.selector.end_pos)
-
-          lambda do |corrector|
-            corrector.replace(where_loc, 'find_by')
-            corrector.replace(first_loc, '')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop is used to identify usages of `all.each` and
-      # change them to use `all.find_each` instead.
-      #
-      # @example
-      #   # bad
-      #   User.all.each
-      #
-      #   # good
-      #   User.all.find_each
-      class FindEach < Cop
-        MSG = 'Use `find_each` instead of `each`.'
-
-        SCOPE_METHODS = %i[
-          all eager_load includes joins left_joins left_outer_joins not preload
-          references unscoped where
-        ].freeze
-        IGNORED_METHODS = %i[order limit select].freeze
-
-        def on_send(node)
-          return unless node.receiver&.send_type? &&
-                        node.method?(:each)
-
-          return unless SCOPE_METHODS.include?(node.receiver.method_name)
-          return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
-        end
-
-        private
-
-        def method_chain(node)
-          node.each_node(:send).map(&:method_name)
-        end
-
-        def ignored_by_find_each?(relation_method)
-          # Active Record's #find_each ignores various extra parameters
-          IGNORED_METHODS.include?(relation_method)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of the has_and_belongs_to_many macro.
-      #
-      # @example
-      #   # bad
-      #   # has_and_belongs_to_many :ingredients
-      #
-      #   # good
-      #   # has_many :ingredients, through: :recipe_ingredients
-      class HasAndBelongsToMany < Cop
-        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
-
-        def on_send(node)
-          return unless node.command?(:has_and_belongs_to_many)
-
-          add_offense(node, location: :selector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop looks for `has_many` or `has_one` associations that don't
-      # specify a `:dependent` option.
-      # It doesn't register an offense if `:through` option was specified.
-      #
-      # @example
-      #   # bad
-      #   class User < ActiveRecord::Base
-      #     has_many :comments
-      #     has_one :avatar
-      #   end
-      #
-      #   # good
-      #   class User < ActiveRecord::Base
-      #     has_many :comments, dependent: :restrict_with_exception
-      #     has_one :avatar, dependent: :destroy
-      #     has_many :patients, through: :appointments
-      #   end
-      class HasManyOrHasOneDependent < Cop
-        MSG = 'Specify a `:dependent` option.'
-
-        def_node_search :active_resource_class?, <<-PATTERN
-          (const (const nil? :ActiveResource) :Base)
-        PATTERN
-
-        def_node_matcher :association_without_options?, <<-PATTERN
-          (send nil? {:has_many :has_one} _)
-        PATTERN
-
-        def_node_matcher :association_with_options?, <<-PATTERN
-          (send nil? {:has_many :has_one} _ (hash $...))
-        PATTERN
-
-        def_node_matcher :dependent_option?, <<-PATTERN
-          (pair (sym :dependent) !nil)
-        PATTERN
-
-        def_node_matcher :present_option?, <<-PATTERN
-          (pair (sym :through) !nil)
-        PATTERN
-
-        def_node_matcher :with_options_block, <<-PATTERN
-          (block
-            (send nil? :with_options
-              (hash $...))
-            (args) ...)
-        PATTERN
-
-        def on_send(node)
-          return if active_resource?(node.parent)
-
-          unless association_without_options?(node)
-            return if valid_options?(association_with_options?(node))
-          end
-
-          return if valid_options_in_with_options_block?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        def valid_options_in_with_options_block?(node)
-          return true unless node.parent
-
-          n = node.parent.begin_type? ? node.parent.parent : node.parent
-
-          contain_valid_options_in_with_options_block?(n)
-        end
-
-        def contain_valid_options_in_with_options_block?(node)
-          if with_options_block(node)
-            return true if valid_options?(with_options_block(node))
-
-            return false unless node.parent
-
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
-          end
-
-          false
-        end
-
-        def valid_options?(options)
-          return true unless options
-          return true if options.any? do |o|
-            dependent_option?(o) || present_option?(o)
-          end
-
-          false
-        end
-
-        def active_resource?(node)
-          return false if node.nil?
-
-          active_resource_class?(node)
-        end
-      end
-    end
-  end
-end