rubocop-rails 2.0.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for consistent uses of `request.referer` or
+      # `request.referrer`, depending on the cop's configuration.
+      #
+      # @example EnforcedStyle: referer (default)
+      #   # bad
+      #   request.referrer
+      #
+      #   # good
+      #   request.referer
+      #
+      # @example EnforcedStyle: referrer
+      #   # bad
+      #   request.referer
+      #
+      #   # good
+      #   request.referrer
+      class RequestReferer < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `request.%<prefer>s` instead of ' \
+              '`request.%<current>s`.'
+
+        def_node_matcher :referer?, <<-PATTERN
+          (send (send nil? :request) {:referer :referrer})
+        PATTERN
+
+        def on_send(node)
+          referer?(node) do
+            return unless node.method?(wrong_method_name)
+
+            add_offense(node.source_range, location: node.source_range)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node, "request.#{style}") }
+        end
+
+        private
+
+        def message(_node)
+          format(MSG, prefer: style, current: wrong_method_name)
+        end
+
+        def wrong_method_name
+          style == :referer ? :referrer : :referer
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks whether the change method of the migration file is
+      # reversible.
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     change_table :users do |t|
+      #       t.remove :name
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     create_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       change_table :users do |t|
+      #         dir.up do
+      #           t.column :name, :string
+      #         end
+      #
+      #         dir.down do
+      #           t.remove :name
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #   # drop_table
+      #
+      #   # bad
+      #   def change
+      #     drop_table :users
+      #   end
+      #
+      #   # good
+      #   def change
+      #     drop_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      # @example
+      #   # change_column_default
+      #
+      #   # bad
+      #   def change
+      #     change_column_default(:suppliers, :qualification, 'new')
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_column_default(:posts, :state, from: nil, to: "draft")
+      #   end
+      #
+      # @example
+      #   # remove_column
+      #
+      #   # bad
+      #   def change
+      #     remove_column(:suppliers, :qualification)
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_column(:suppliers, :qualification, :string)
+      #   end
+      #
+      # @example
+      #   # remove_foreign_key
+      #
+      #   # bad
+      #   def change
+      #     remove_foreign_key :accounts, column: :owner_id
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_foreign_key :accounts, :branches
+      #   end
+      #
+      # @example
+      #   # change_table
+      #
+      #   # bad
+      #   def change
+      #     change_table :users do |t|
+      #       t.remove :name
+      #       t.change_default :authorized, 1
+      #       t.change :price, :string
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       change_table :users do |t|
+      #         dir.up do
+      #           t.change :price, :string
+      #         end
+      #
+      #         dir.down do
+      #           t.change :price, :integer
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
+      class ReversibleMigration < Cop
+        MSG = '%<action>s is not reversible.'
+        IRREVERSIBLE_CHANGE_TABLE_CALLS = %i[
+          change change_default remove
+        ].freeze
+
+        def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
+          (send nil? ${:change_table_comment :execute :remove_belongs_to} ...)
+        PATTERN
+
+        def_node_matcher :drop_table_call, <<-PATTERN
+          (send nil? :drop_table ...)
+        PATTERN
+
+        def_node_matcher :change_column_default_call, <<-PATTERN
+          (send nil? :change_column_default {[(sym _) (sym _)] (splat _)} $...)
+        PATTERN
+
+        def_node_matcher :remove_column_call, <<-PATTERN
+          (send nil? :remove_column $...)
+        PATTERN
+
+        def_node_matcher :remove_foreign_key_call, <<-PATTERN
+          (send nil? :remove_foreign_key _ $_)
+        PATTERN
+
+        def_node_matcher :change_table_call, <<-PATTERN
+          (send nil? :change_table $_ ...)
+        PATTERN
+
+        def on_send(node)
+          return unless within_change_method?(node)
+          return if within_reversible_or_up_only_block?(node)
+
+          check_irreversible_schema_statement_node(node)
+          check_drop_table_node(node)
+          check_change_column_default_node(node)
+          check_remove_column_node(node)
+          check_remove_foreign_key_node(node)
+        end
+
+        def on_block(node)
+          return unless within_change_method?(node)
+          return if within_reversible_or_up_only_block?(node)
+          return if node.body.nil?
+
+          check_change_table_node(node.send_node, node.body)
+        end
+
+        private
+
+        def check_irreversible_schema_statement_node(node)
+          irreversible_schema_statement_call(node) do |method_name|
+            add_offense(node, message: format(MSG, action: method_name))
+          end
+        end
+
+        def check_drop_table_node(node)
+          drop_table_call(node) do
+            unless node.parent.block_type?
+              add_offense(
+                node,
+                message: format(MSG, action: 'drop_table(without block)')
+              )
+            end
+          end
+        end
+
+        def check_change_column_default_node(node)
+          change_column_default_call(node) do |args|
+            unless all_hash_key?(args.last, :from, :to)
+              add_offense(
+                node,
+                message: format(
+                  MSG, action: 'change_column_default(without :from and :to)'
+                )
+              )
+            end
+          end
+        end
+
+        def check_remove_column_node(node)
+          remove_column_call(node) do |args|
+            if args.to_a.size < 3
+              add_offense(
+                node,
+                message: format(MSG, action: 'remove_column(without type)')
+              )
+            end
+          end
+        end
+
+        def check_remove_foreign_key_node(node)
+          remove_foreign_key_call(node) do |arg|
+            if arg.hash_type?
+              add_offense(
+                node,
+                message: format(MSG,
+                                action: 'remove_foreign_key(without table)')
+              )
+            end
+          end
+        end
+
+        def check_change_table_node(node, block)
+          change_table_call(node) do |arg|
+            if target_rails_version < 4.0
+              add_offense(
+                node,
+                message: format(MSG, action: 'change_table')
+              )
+            elsif block.send_type?
+              check_change_table_offense(arg, block)
+            else
+              block.each_child_node(:send) do |child_node|
+                check_change_table_offense(arg, child_node)
+              end
+            end
+          end
+        end
+
+        def check_change_table_offense(receiver, node)
+          method_name = node.method_name
+          return if receiver != node.receiver &&
+                    !IRREVERSIBLE_CHANGE_TABLE_CALLS.include?(method_name)
+
+          add_offense(
+            node,
+            message: format(MSG, action: "change_table(with #{method_name})")
+          )
+        end
+
+        def within_change_method?(node)
+          node.each_ancestor(:def).any? do |ancestor|
+            ancestor.method?(:change)
+          end
+        end
+
+        def within_reversible_or_up_only_block?(node)
+          node.each_ancestor(:block).any? do |ancestor|
+            ancestor.block_type? &&
+              ancestor.send_node.method?(:reversible) ||
+              ancestor.send_node.method?(:up_only)
+          end
+        end
+
+        def all_hash_key?(args, *keys)
+          return false unless args&.hash_type?
+
+          hash_keys = args.keys.map do |key|
+            key.children.first.to_sym
+          end
+
+          hash_keys & keys == keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop converts usages of `try!` to `&.`. It can also be configured
+      # to convert `try`. It will convert code to use safe navigation.
+      #
+      # @example
+      #   # ConvertTry: false
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #
+      #     foo.try!(:[], 0)
+      #
+      #     # good
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      #
+      #
+      #   # ConvertTry: true
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     # good
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      class SafeNavigation < Cop
+        include RangeHelp
+
+        MSG = 'Use safe navigation (`&.`) instead of `%<try>s`.'
+
+        def_node_matcher :try_call, <<-PATTERN
+          (send !nil? ${:try :try!} $_ ...)
+        PATTERN
+
+        def on_send(node)
+          try_call(node) do |try_method, dispatch|
+            return if try_method == :try && !cop_config['ConvertTry']
+            return unless dispatch.sym_type? && dispatch.value =~ /\w+[=!?]?/
+
+            add_offense(node, message: format(MSG, try: try_method))
+          end
+        end
+
+        def autocorrect(node)
+          method_node, *params = *node.arguments
+          method = method_node.source[1..-1]
+
+          range = range_between(node.loc.dot.begin_pos,
+                                node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, replacement(method, params))
+          end
+        end
+
+        private
+
+        def replacement(method, params)
+          new_params = params.map(&:source).join(', ')
+
+          if method.end_with?('=')
+            "&.#{method[0...-1]} = #{new_params}"
+          elsif params.empty?
+            "&.#{method}"
+          else
+            "&.#{method}(#{new_params})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies possible cases where Active Record save! or related
+      # should be used instead of save because the model might have failed to
+      # save and an exception is better than unhandled failure.
+      #
+      # This will allow:
+      # - update or save calls, assigned to a variable,
+      #   or used as a condition in an if/unless/case statement.
+      # - create calls, assigned to a variable that then has a
+      #   call to `persisted?`.
+      # - calls if the result is explicitly returned from methods and blocks,
+      #   or provided as arguments.
+      # - calls whose signature doesn't look like an ActiveRecord
+      #   persistence method.
+      #
+      # By default it will also allow implicit returns from methods and blocks.
+      # that behavior can be turned off with `AllowImplicitReturn: false`.
+      #
+      # You can permit receivers that are giving false positives with
+      # `AllowedReceivers: []`
+      #
+      # @example
+      #
+      #   # bad
+      #   user.save
+      #   user.update(name: 'Joe')
+      #   user.find_or_create_by(name: 'Joe')
+      #   user.destroy
+      #
+      #   # good
+      #   unless user.save
+      #     # ...
+      #   end
+      #   user.save!
+      #   user.update!(name: 'Joe')
+      #   user.find_or_create_by!(name: 'Joe')
+      #   user.destroy!
+      #
+      #   user = User.find_or_create_by(name: 'Joe')
+      #   unless user.persisted?
+      #     # ...
+      #   end
+      #
+      #   def save_user
+      #     return user.save
+      #   end
+      #
+      # @example AllowImplicitReturn: true (default)
+      #
+      #   # good
+      #   users.each { |u| u.save }
+      #
+      #   def save_user
+      #     user.save
+      #   end
+      #
+      # @example AllowImplicitReturn: false
+      #
+      #   # bad
+      #   users.each { |u| u.save }
+      #   def save_user
+      #     user.save
+      #   end
+      #
+      #   # good
+      #   users.each { |u| u.save! }
+      #
+      #   def save_user
+      #     user.save!
+      #   end
+      #
+      #   def save_user
+      #     return user.save
+      #   end
+      #
+      # @example AllowedReceivers: ['merchant.customers', 'Service::Mailer']
+      #
+      #   # bad
+      #   merchant.create
+      #   customers.builder.save
+      #   Mailer.create
+      #
+      #   module Service::Mailer
+      #     self.create
+      #   end
+      #
+      #   # good
+      #   merchant.customers.create
+      #   MerchantService.merchant.customers.destroy
+      #   Service::Mailer.update(message: 'Message')
+      #   ::Service::Mailer.update
+      #   Services::Service::Mailer.update(message: 'Message')
+      #   Service::Mailer::update
+      #
+      class SaveBang < Cop
+        include NegativeConditional
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
+              'value is not checked.'
+        CREATE_MSG = (MSG +
+                      ' Or check `persisted?` on model returned from ' \
+                      '`%<current>s`.').freeze
+        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is ' \
+                                 'always truthy.'
+
+        CREATE_PERSIST_METHODS = %i[create
+                                    first_or_create find_or_create_by].freeze
+        MODIFY_PERSIST_METHODS = %i[save
+                                    update update_attributes destroy].freeze
+        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
+                           MODIFY_PERSIST_METHODS).freeze
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            variable.assignments.each do |assignment|
+              check_assignment(assignment)
+            end
+          end
+        end
+
+        def check_assignment(assignment)
+          node = right_assignment_node(assignment)
+
+          return unless node&.send_type?
+          return unless persist_method?(node, CREATE_PERSIST_METHODS)
+          return if persisted_referenced?(assignment)
+
+          add_offense_for_node(node, CREATE_MSG)
+        end
+
+        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity
+          return unless persist_method?(node)
+          return if return_value_assigned?(node)
+          return if check_used_in_conditional(node)
+          return if argument?(node)
+          return if implicit_return?(node)
+          return if explicit_return?(node)
+
+          add_offense_for_node(node)
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          save_loc = node.loc.selector
+          new_method = "#{node.method_name}!"
+
+          ->(corrector) { corrector.replace(save_loc, new_method) }
+        end
+
+        private
+
+        def add_offense_for_node(node, msg = MSG)
+          name = node.method_name
+          full_message = format(msg, prefer: "#{name}!", current: name.to_s)
+
+          add_offense(node, location: :selector, message: full_message)
+        end
+
+        def right_assignment_node(assignment)
+          node = assignment.node.child_nodes.first
+
+          return node unless node&.block_type?
+
+          node.send_node
+        end
+
+        def persisted_referenced?(assignment)
+          return unless assignment.referenced?
+
+          assignment.variable.references.any? do |reference|
+            call_to_persisted?(reference.node.parent)
+          end
+        end
+
+        def call_to_persisted?(node)
+          node.send_type? && node.method?(:persisted?)
+        end
+
+        def assignable_node(node)
+          assignable = node.block_node || node
+          while node
+            node = hash_parent(node) || array_parent(node)
+            assignable = node if node
+          end
+          assignable
+        end
+
+        def hash_parent(node)
+          pair = node.parent
+          return unless pair&.pair_type?
+
+          hash = pair.parent
+          return unless hash&.hash_type?
+
+          hash
+        end
+
+        def array_parent(node)
+          array = node.parent
+          return unless array&.array_type?
+
+          array
+        end
+
+        def check_used_in_conditional(node)
+          return false unless conditional?(node)
+
+          unless MODIFY_PERSIST_METHODS.include?(node.method_name)
+            add_offense_for_node(node, CREATE_CONDITIONAL_MSG)
+          end
+
+          true
+        end
+
+        def conditional?(node) # rubocop:disable Metrics/CyclomaticComplexity
+          node = node.block_node || node
+
+          condition = node.parent
+          return false unless condition
+
+          condition.if_type? || condition.case_type? ||
+            condition.or_type? || condition.and_type? ||
+            single_negative?(condition)
+        end
+
+        def allowed_receiver?(node)
+          return false unless node.receiver
+          return false unless cop_config['AllowedReceivers']
+
+          cop_config['AllowedReceivers'].any? do |allowed_receiver|
+            receiver_chain_matches?(node, allowed_receiver)
+          end
+        end
+
+        def receiver_chain_matches?(node, allowed_receiver)
+          allowed_receiver.split('.').reverse.all? do |receiver_part|
+            node = node.receiver
+            return false unless node
+
+            if node.variable?
+              node.node_parts.first == receiver_part.to_sym
+            elsif node.send_type?
+              node.method_name == receiver_part.to_sym
+            elsif node.const_type?
+              const_matches?(node.const_name, receiver_part)
+            end
+          end
+        end
+
+        # Const == Const
+        # ::Const == ::Const
+        # ::Const == Const
+        # Const == ::Const
+        # NameSpace::Const == Const
+        # NameSpace::Const == NameSpace::Const
+        # NameSpace::Const != ::Const
+        # Const != NameSpace::Const
+        def const_matches?(const, allowed_const)
+          parts = allowed_const.split('::').reverse.zip(
+            const.split('::').reverse
+          )
+          parts.all? do |(allowed_part, const_part)|
+            allowed_part == const_part.to_s
+          end
+        end
+
+        def implicit_return?(node)
+          return false unless cop_config['AllowImplicitReturn']
+
+          node = assignable_node(node)
+          method = node.parent
+          return unless method && (method.def_type? || method.block_type?)
+
+          method.children.size == node.sibling_index + 1
+        end
+
+        def argument?(node)
+          assignable_node(node).argument?
+        end
+
+        def explicit_return?(node)
+          ret = assignable_node(node).parent
+          ret && (ret.return_type? || ret.next_type?)
+        end
+
+        def return_value_assigned?(node)
+          assignment = assignable_node(node).parent
+          assignment&.lvasgn_type?
+        end
+
+        def persist_method?(node, methods = PERSIST_METHODS)
+          methods.include?(node.method_name) &&
+            expected_signature?(node) &&
+            !allowed_receiver?(node)
+        end
+
+        # Check argument signature as no arguments or one hash
+        def expected_signature?(node)
+          !node.arguments? ||
+            (node.arguments.one? &&
+              node.method_name != :destroy &&
+              (node.first_argument.hash_type? ||
+              !node.first_argument.literal?))
+        end
+      end
+    end
+  end
+end