rubocop 0.71.0 → 0.72.0

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

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

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

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for scope calls where it was passed
-      # a method (usually a scope) instead of a lambda/proc.
-      #
-      # @example
-      #
-      #   # bad
-      #   scope :something, where(something: true)
-      #
-      #   # good
-      #   scope :something, -> { where(something: true) }
-      class ScopeArgs < Cop
-        MSG = 'Use `lambda`/`proc` instead of a plain method call.'
-
-        def_node_matcher :scope?, '(send nil? :scope _ $send)'
-
-        def on_send(node)
-          scope?(node) do |second_arg|
-            add_offense(second_arg)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of methods which skip
-      # validations which are listed in
-      # https://guides.rubyonrails.org/active_record_validations.html#skipping-validations
-      #
-      # Methods may be ignored from this rule by configuring a `Whitelist`.
-      #
-      # @example
-      #   # bad
-      #   Article.first.decrement!(:view_count)
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      #   Article.first.increment!(:view_count)
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      #   person.toggle :active
-      #   product.touch
-      #   Billing.update_all("category = 'authorized', author = 'David'")
-      #   user.update_attribute(:website, 'example.com')
-      #   user.update_columns(last_request_at: Time.current)
-      #   Post.update_counters 5, comment_count: -1, action_count: 1
-      #
-      #   # good
-      #   user.update(website: 'example.com')
-      #   FileUtils.touch('file')
-      #
-      # @example Whitelist: ["touch"]
-      #   # bad
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      #   person.toggle :active
-      #
-      #   # good
-      #   user.touch
-      #
-      class SkipsModelValidations < Cop
-        MSG = 'Avoid using `%<method>s` because it skips validations.'
-
-        METHODS_WITH_ARGUMENTS = %w[decrement!
-                                    decrement_counter
-                                    increment!
-                                    increment_counter
-                                    toggle!
-                                    update_all
-                                    update_attribute
-                                    update_column
-                                    update_columns
-                                    update_counters].freeze
-
-        def_node_matcher :good_touch?, <<-PATTERN
-          (send (const nil? :FileUtils) :touch ...)
-        PATTERN
-
-        def on_send(node)
-          return if whitelist.include?(node.method_name.to_s)
-          return unless blacklist.include?(node.method_name.to_s)
-          return if allowed_method?(node)
-          return if good_touch?(node)
-
-          add_offense(node, location: :selector)
-        end
-        alias on_csend on_send
-
-        private
-
-        def message(node)
-          format(MSG, method: node.method_name)
-        end
-
-        def allowed_method?(node)
-          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) &&
-            !node.arguments?
-        end
-
-        def blacklist
-          cop_config['Blacklist'] || []
-        end
-
-        def whitelist
-          cop_config['Whitelist'] || []
-        end
-      end
-    end
-  end
-end