rubocop-rails 2.0.0

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

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

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

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

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

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

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

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

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