tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.1.2/lib/active_record/testing/query_assertions.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Assertions
+    module QueryAssertions
+      # Asserts that the number of SQL queries executed in the given block matches the expected count.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_count(1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_count { Post.first }
+      #
+      # Any unmaterialized transactions will be materialized to ensure only
+      # queries attempted intside the block are counted.
+      #
+      # If the +:include_schema+ option is provided, any queries (including
+      # schema related) are counted. Setting this option also skips leasing a
+      # connection to materialize pending transactions since we want to count
+      # queries executed at connection open (e.g., type map).
+      #
+      #   assert_queries_count(1, include_schema: true) { Post.columns }
+      #
+      def assert_queries_count(count = nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions unless include_schema
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_count", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          if count
+            assert_equal count, queries.size, "#{queries.size} instead of #{count} queries were executed. Queries: #{queries.join("\n\n")}"
+          else
+            assert_operator queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+          result
+        end
+      end
+
+      # Asserts that no SQL queries are executed in the given block.
+      #
+      #   assert_no_queries { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      #
+      #   assert_no_queries(include_schema: true) { Post.columns }
+      #
+      def assert_no_queries(include_schema: false, &block)
+        assert_queries_count(0, include_schema: include_schema, &block)
+      end
+
+      # Asserts that the SQL queries executed in the given block match expected pattern.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_match(/LIMIT \?/, count: 1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_match(/LIMIT \?/) { Post.first }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are considered.
+      #
+      #   assert_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_queries_match(match, count: nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_match", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          matched_queries = queries.select { |query| match === query }
+
+          if count
+            assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          else
+            assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+
+          result
+        end
+      end
+
+      # Asserts that no SQL queries matching the pattern are executed in the given block.
+      #
+      #   assert_no_queries_match(/SELECT/i) { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are counted.
+      #
+      #   assert_no_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_no_queries_match(match, include_schema: false, &block)
+        assert_queries_match(match, count: 0, include_schema: include_schema, &block)
+      end
+
+      class SQLCounter # :nodoc:
+        attr_reader :log_full, :log_all
+
+        def initialize
+          @log_full = []
+          @log_all = []
+        end
+
+        def log
+          @log_full.map(&:first)
+        end
+
+        def call(*, payload)
+          return if payload[:cached]
+
+          sql = payload[:sql]
+          @log_all << sql
+
+          unless payload[:name] == "SCHEMA"
+            bound_values = (payload[:binds] || []).map do |value|
+              value = value.value_for_database if value.respond_to?(:value_for_database)
+              value
+            end
+
+            @log_full << [sql, bound_values]
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.1.2/lib/active_record/timestamp.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # = Active Record \Timestamp
+  #
+  # Active Record automatically timestamps create and update operations if the
+  # table has fields named <tt>created_at/created_on</tt> or
+  # <tt>updated_at/updated_on</tt>.
+  #
+  # Timestamping can be turned off by setting:
+  #
+  #   config.active_record.record_timestamps = false
+  #
+  # Timestamps are in UTC by default but you can use the local timezone by setting:
+  #
+  #   config.active_record.default_timezone = :local
+  #
+  # == Time Zone aware attributes
+  #
+  # Active Record keeps all the <tt>datetime</tt> and <tt>time</tt> columns
+  # timezone aware. By default, these values are stored in the database as UTC
+  # and converted back to the current <tt>Time.zone</tt> when pulled from the database.
+  #
+  # This feature can be turned off completely by setting:
+  #
+  #   config.active_record.time_zone_aware_attributes = false
+  #
+  # You can also specify that only <tt>datetime</tt> columns should be time-zone
+  # aware (while <tt>time</tt> should not) by setting:
+  #
+  #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
+  #
+  # You can also add database-specific timezone aware types. For example, for PostgreSQL:
+  #
+  #   ActiveRecord::Base.time_zone_aware_types += [:tsrange, :tstzrange]
+  #
+  # Finally, you can indicate specific attributes of a model for which time zone
+  # conversion should not applied, for instance by setting:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     self.skip_time_zone_conversion_for_attributes = [:written_on]
+  #   end
+  module Timestamp
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :record_timestamps, default: true
+    end
+
+    def initialize_dup(other) # :nodoc:
+      super
+      clear_timestamp_attributes
+    end
+
+    module ClassMethods # :nodoc:
+      def touch_attributes_with_time(*names, time: nil)
+        names = names.map(&:to_s)
+        names = names.map { |name| attribute_aliases[name] || name }
+        attribute_names = timestamp_attributes_for_update_in_model
+        attribute_names |= names
+        attribute_names.index_with(time || current_time_from_proper_timezone)
+      end
+
+      def timestamp_attributes_for_create_in_model
+        @timestamp_attributes_for_create_in_model ||=
+          (timestamp_attributes_for_create & column_names).freeze
+      end
+
+      def timestamp_attributes_for_update_in_model
+        @timestamp_attributes_for_update_in_model ||=
+          (timestamp_attributes_for_update & column_names).freeze
+      end
+
+      def all_timestamp_attributes_in_model
+        @all_timestamp_attributes_in_model ||=
+          (timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model).freeze
+      end
+
+      def current_time_from_proper_timezone
+        with_connection { |c| c.default_timezone == :utc ? Time.now.utc : Time.now }
+      end
+
+      protected
+        def reload_schema_from_cache(recursive = true)
+          @timestamp_attributes_for_create_in_model = nil
+          @timestamp_attributes_for_update_in_model = nil
+          @all_timestamp_attributes_in_model = nil
+          super
+        end
+
+      private
+        def timestamp_attributes_for_create
+          ["created_at", "created_on"].map! { |name| attribute_aliases[name] || name }
+        end
+
+        def timestamp_attributes_for_update
+          ["updated_at", "updated_on"].map! { |name| attribute_aliases[name] || name }
+        end
+    end
+
+  private
+    def init_internals
+      super
+      @_touch_record = nil
+    end
+
+    def _create_record
+      if record_timestamps
+        current_time = current_time_from_proper_timezone
+
+        all_timestamp_attributes_in_model.each do |column|
+          _write_attribute(column, current_time) unless _read_attribute(column)
+        end
+      end
+
+      super
+    end
+
+    def _update_record
+      record_update_timestamps
+
+      super
+    end
+
+    def create_or_update(touch: true, **)
+      @_touch_record = touch
+      super
+    end
+
+    def record_update_timestamps
+      if @_touch_record && should_record_timestamps?
+        current_time = current_time_from_proper_timezone
+
+        timestamp_attributes_for_update_in_model.each do |column|
+          next if will_save_change_to_attribute?(column)
+          _write_attribute(column, current_time)
+        end
+      end
+
+      yield if block_given?
+    end
+
+    def should_record_timestamps?
+      record_timestamps && (!partial_updates? || has_changes_to_save?)
+    end
+
+    def timestamp_attributes_for_create_in_model
+      self.class.timestamp_attributes_for_create_in_model
+    end
+
+    def timestamp_attributes_for_update_in_model
+      self.class.timestamp_attributes_for_update_in_model
+    end
+
+    def all_timestamp_attributes_in_model
+      self.class.all_timestamp_attributes_in_model
+    end
+
+    def current_time_from_proper_timezone
+      self.class.current_time_from_proper_timezone
+    end
+
+    def max_updated_column_timestamp
+      timestamp_attributes_for_update_in_model
+        .filter_map { |attr| (v = self[attr]) && (v.is_a?(::Time) ? v : v.to_time) }
+        .max
+    end
+
+    # Clear attributes and changed_attributes
+    def clear_timestamp_attributes
+      all_timestamp_attributes_in_model.each do |attribute_name|
+        if self[attribute_name]
+          self[attribute_name] = nil
+          clear_attribute_change(attribute_name)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.1.2/lib/active_record/transaction.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest"
+
+module ActiveRecord
+  # Class specifies the interface to interact with the current transaction state.
+  #
+  # It can either map to an actual transaction/savepoint, or represent the
+  # absence of a transaction.
+  #
+  # == State
+  #
+  # We say that a transaction is _finalized_ when it wraps a real transaction
+  # that has been either committed or rolled back.
+  #
+  # A transaction is _open_ if it wraps a real transaction that is not finalized.
+  #
+  # On the other hand, a transaction is _closed_ when it is not open. That is,
+  # when it represents absence of transaction, or it wraps a real but finalized
+  # one.
+  #
+  # You can check whether a transaction is open or closed with the +open?+ and
+  # +closed?+ predicates:
+  #
+  #  if Article.current_transaction.open?
+  #    # We are inside a real and not finalized transaction.
+  #  end
+  #
+  # Closed transactions are +blank?+ too.
+  #
+  # == Callbacks
+  #
+  # After updating the database state, you may sometimes need to perform some extra work, or reflect these
+  # changes in a remote system like clearing or updating a cache:
+  #
+  #   def publish_article(article)
+  #     article.update!(published: true)
+  #     NotificationService.article_published(article)
+  #   end
+  #
+  # The above code works but has one important flaw, which is that it no longer works properly if called inside
+  # a transaction, as it will interact with the remote system before the changes are persisted:
+  #
+  #   Article.transaction do
+  #     article = create_article(article)
+  #     publish_article(article)
+  #   end
+  #
+  # The callbacks offered by ActiveRecord::Transaction allow to rewriting this method in a way that is compatible
+  # with transactions:
+  #
+  #   def publish_article(article)
+  #     article.update!(published: true)
+  #     Article.current_transaction.after_commit do
+  #       NotificationService.article_published(article)
+  #     end
+  #   end
+  #
+  # In the above example, if +publish_article+ is called inside a transaction, the callback will be invoked
+  # after the transaction is successfully committed, and if called outside a transaction, the callback will be invoked
+  # immediately.
+  #
+  # == Caveats
+  #
+  # When using after_commit callbacks, it is important to note that if the callback raises an error, the transaction
+  # won't be rolled back as it was already committed. Relying solely on these to synchronize state between multiple
+  # systems may lead to consistency issues.
+  class Transaction
+    def initialize(internal_transaction) # :nodoc:
+      @internal_transaction = internal_transaction
+      @uuid = nil
+    end
+
+    # Registers a block to be called after the transaction is fully committed.
+    #
+    # If there is no currently open transactions, the block is called
+    # immediately, unless the transaction is finalized, in which case attempting
+    # to register the callback raises ActiveRecord::ActiveRecordError.
+    #
+    # If the transaction has a parent transaction, the callback is transferred to
+    # the parent when the current transaction commits, or dropped when the current transaction
+    # is rolled back. This operation is repeated until the outermost transaction is reached.
+    #
+    # If the callback raises an error, the transaction remains committed.
+    def after_commit(&block)
+      if @internal_transaction.nil?
+        yield
+      else
+        @internal_transaction.after_commit(&block)
+      end
+    end
+
+    # Registers a block to be called after the transaction is rolled back.
+    #
+    # If there is no currently open transactions, the block is not called. But
+    # if the transaction is finalized, attempting to register the callback
+    # raises ActiveRecord::ActiveRecordError.
+    #
+    # If the transaction is successfully committed but has a parent
+    # transaction, the callback is automatically added to the parent transaction.
+    #
+    # If the entire chain of nested transactions are all successfully committed,
+    # the block is never called.
+    def after_rollback(&block)
+      @internal_transaction&.after_rollback(&block)
+    end
+
+    # Returns true if the transaction exists and isn't finalized yet.
+    def open?
+      !closed?
+    end
+
+    # Returns true if the transaction doesn't exist or is finalized.
+    def closed?
+      @internal_transaction.nil? || @internal_transaction.closed?
+    end
+
+    alias_method :blank?, :closed?
+
+    # Returns a UUID for this transaction or +nil+ if no transaction is open.
+    def uuid
+      if @internal_transaction
+        @uuid ||= Digest::UUID.uuid_v4
+      end
+    end
+
+    NULL_TRANSACTION = new(nil).freeze
+  end
+end