rubocop-rails 2.4.1

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for enums written with array syntax.
+      #
+      # When using array syntax, adding an element in a
+      # position other than the last causes all previous
+      # definitions to shift. Explicitly specifying the
+      # value for each key prevents this from happening.
+      #
+      # @example
+      #   # bad
+      #   enum status: [:active, :archived]
+      #
+      #   # good
+      #   enum status: { active: 0, archived: 1 }
+      #
+      class EnumHash < Cop
+        MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. '\
+              'Use hash syntax instead.'
+
+        def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum (hash $...))
+        PATTERN
+
+        def_node_matcher :array_pair?, <<~PATTERN
+          (pair $_ $array)
+        PATTERN
+
+        def on_send(node)
+          enum?(node) do |pairs|
+            pairs.each do |pair|
+              key, array = array_pair?(pair)
+              next unless key
+
+              add_offense(array, message: format(MSG, enum: enum_name(key)))
+            end
+          end
+        end
+
+        def autocorrect(node)
+          hash = node.children.each_with_index.map do |elem, index|
+            "#{source(elem)} => #{index}"
+          end.join(', ')
+
+          ->(corrector) { corrector.replace(node.loc.expression, "{#{hash}}") }
+        end
+
+        private
+
+        def enum_name(key)
+          case key.type
+          when :sym, :str
+            key.value
+          else
+            key.source
+          end
+        end
+
+        def source(elem)
+          case elem.type
+          when :str
+            elem.value.dump
+          when :sym
+            elem.value.inspect
+          else
+            elem.source
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# 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?, <<~PATTERN
+          (send nil? :enum (hash $...))
+        PATTERN
+
+        def_node_matcher :enum_values, <<~PATTERN
+          (pair $_ ${array hash})
+        PATTERN
+
+        def on_send(node)
+          enum?(node) do |pairs|
+            pairs.each do |pair|
+              enum_values(pair) do |key, args|
+                items = args.values
+
+                next unless duplicates?(items)
+
+                consecutive_duplicates(items).each do |item|
+                  add_offense(item, message: format(
+                    MSG, value: item.source, enum: enum_name(key)
+                  ))
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def enum_name(key)
+          case key.type
+          when :sym, :str
+            key.value
+          else
+            key.source
+          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
+      #   # 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 (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')
+      #
+      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