ric 0.14.2 → 0.14.6

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/notifications/fanout.rb

@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-
-require "mutex_m"
-require "concurrent/map"
-require "set"
-require "active_support/core_ext/object/try"
-
-module ActiveSupport
-  module Notifications
-    # This is a default queue implementation that ships with Notifications.
-    # It just pushes events to all registered log subscribers.
-    #
-    # This class is thread safe. All methods are reentrant.
-    class Fanout
-      include Mutex_m
-
-      def initialize
-        @string_subscribers = Hash.new { |h, k| h[k] = [] }
-        @other_subscribers = []
-        @listeners_for = Concurrent::Map.new
-        super
-      end
-
-      def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
-        subscriber = Subscribers.new(pattern, callable || block, monotonic)
-        synchronize do
-          if String === pattern
-            @string_subscribers[pattern] << subscriber
-            @listeners_for.delete(pattern)
-          else
-            @other_subscribers << subscriber
-            @listeners_for.clear
-          end
-        end
-        subscriber
-      end
-
-      def unsubscribe(subscriber_or_name)
-        synchronize do
-          case subscriber_or_name
-          when String
-            @string_subscribers[subscriber_or_name].clear
-            @listeners_for.delete(subscriber_or_name)
-            @other_subscribers.each { |sub| sub.unsubscribe!(subscriber_or_name) }
-          else
-            pattern = subscriber_or_name.try(:pattern)
-            if String === pattern
-              @string_subscribers[pattern].delete(subscriber_or_name)
-              @listeners_for.delete(pattern)
-            else
-              @other_subscribers.delete(subscriber_or_name)
-              @listeners_for.clear
-            end
-          end
-        end
-      end
-
-      def start(name, id, payload)
-        listeners_for(name).each { |s| s.start(name, id, payload) }
-      end
-
-      def finish(name, id, payload, listeners = listeners_for(name))
-        listeners.each { |s| s.finish(name, id, payload) }
-      end
-
-      def publish(name, *args)
-        listeners_for(name).each { |s| s.publish(name, *args) }
-      end
-
-      def listeners_for(name)
-        # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
-        @listeners_for[name] || synchronize do
-          # use synchronisation when accessing @subscribers
-          @listeners_for[name] ||=
-            @string_subscribers[name] + @other_subscribers.select { |s| s.subscribed_to?(name) }
-        end
-      end
-
-      def listening?(name)
-        listeners_for(name).any?
-      end
-
-      # This is a sync queue, so there is no waiting.
-      def wait
-      end
-
-      module Subscribers # :nodoc:
-        def self.new(pattern, listener, monotonic)
-          subscriber_class = monotonic ? MonotonicTimed : Timed
-
-          if listener.respond_to?(:start) && listener.respond_to?(:finish)
-            subscriber_class = Evented
-          else
-            # Doing all this to detect a block like `proc { |x| }` vs
-            # `proc { |*x| }` or `proc { |**x| }`
-            if listener.respond_to?(:parameters)
-              params = listener.parameters
-              if params.length == 1 && params.first.first == :opt
-                subscriber_class = EventObject
-              end
-            end
-          end
-
-          wrap_all pattern, subscriber_class.new(pattern, listener)
-        end
-
-        def self.wrap_all(pattern, subscriber)
-          unless pattern
-            AllMessages.new(subscriber)
-          else
-            subscriber
-          end
-        end
-
-        class Matcher #:nodoc:
-          attr_reader :pattern, :exclusions
-
-          def self.wrap(pattern)
-            return pattern if String === pattern
-            new(pattern)
-          end
-
-          def initialize(pattern)
-            @pattern = pattern
-            @exclusions = Set.new
-          end
-
-          def unsubscribe!(name)
-            exclusions << -name if pattern === name
-          end
-
-          def ===(name)
-            pattern === name && !exclusions.include?(name)
-          end
-        end
-
-        class Evented #:nodoc:
-          attr_reader :pattern
-
-          def initialize(pattern, delegate)
-            @pattern = Matcher.wrap(pattern)
-            @delegate = delegate
-            @can_publish = delegate.respond_to?(:publish)
-          end
-
-          def publish(name, *args)
-            if @can_publish
-              @delegate.publish name, *args
-            end
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def subscribed_to?(name)
-            pattern === name
-          end
-
-          def matches?(name)
-            pattern && pattern === name
-          end
-
-          def unsubscribe!(name)
-            pattern.unsubscribe!(name)
-          end
-        end
-
-        class Timed < Evented # :nodoc:
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = Thread.current[:_timestack] ||= []
-            timestack.push Time.now
-          end
-
-          def finish(name, id, payload)
-            timestack = Thread.current[:_timestack]
-            started = timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
-          end
-        end
-
-        class MonotonicTimed < Evented # :nodoc:
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = Thread.current[:_timestack_monotonic] ||= []
-            timestack.push Concurrent.monotonic_time
-          end
-
-          def finish(name, id, payload)
-            timestack = Thread.current[:_timestack_monotonic]
-            started = timestack.pop
-            @delegate.call(name, started, Concurrent.monotonic_time, id, payload)
-          end
-        end
-
-        class EventObject < Evented
-          def start(name, id, payload)
-            stack = Thread.current[:_event_stack] ||= []
-            event = build_event name, id, payload
-            event.start!
-            stack.push event
-          end
-
-          def finish(name, id, payload)
-            stack = Thread.current[:_event_stack]
-            event = stack.pop
-            event.payload = payload
-            event.finish!
-            @delegate.call event
-          end
-
-          private
-            def build_event(name, id, payload)
-              ActiveSupport::Notifications::Event.new name, nil, nil, id, payload
-            end
-        end
-
-        class AllMessages # :nodoc:
-          def initialize(delegate)
-            @delegate = delegate
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def publish(name, *args)
-            @delegate.publish name, *args
-          end
-
-          def subscribed_to?(name)
-            true
-          end
-
-          def unsubscribe!(*)
-            false
-          end
-
-          alias :matches? :===
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/notifications/instrumenter.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module ActiveSupport
-  module Notifications
-    # Instrumenters are stored in a thread local.
-    class Instrumenter
-      attr_reader :id
-
-      def initialize(notifier)
-        @id       = unique_id
-        @notifier = notifier
-      end
-
-      # Given a block, instrument it by measuring the time taken to execute
-      # and publish it. Without a block, simply send a message via the
-      # notifier. Notice that events get sent even if an error occurs in the
-      # passed-in block.
-      def instrument(name, payload = {})
-        # some of the listeners might have state
-        listeners_state = start name, payload
-        begin
-          yield payload if block_given?
-        rescue Exception => e
-          payload[:exception] = [e.class.name, e.message]
-          payload[:exception_object] = e
-          raise e
-        ensure
-          finish_with_state listeners_state, name, payload
-        end
-      end
-
-      # Send a start notification with +name+ and +payload+.
-      def start(name, payload)
-        @notifier.start name, @id, payload
-      end
-
-      # Send a finish notification with +name+ and +payload+.
-      def finish(name, payload)
-        @notifier.finish name, @id, payload
-      end
-
-      def finish_with_state(listeners_state, name, payload)
-        @notifier.finish name, @id, payload, listeners_state
-      end
-
-      private
-        def unique_id
-          SecureRandom.hex(10)
-        end
-    end
-
-    class Event
-      attr_reader :name, :time, :end, :transaction_id, :children
-      attr_accessor :payload
-
-      def initialize(name, start, ending, transaction_id, payload)
-        @name           = name
-        @payload        = payload.dup
-        @time           = start
-        @transaction_id = transaction_id
-        @end            = ending
-        @children       = []
-        @cpu_time_start = 0
-        @cpu_time_finish = 0
-        @allocation_count_start = 0
-        @allocation_count_finish = 0
-      end
-
-      # Record information at the time this event starts
-      def start!
-        @time = now
-        @cpu_time_start = now_cpu
-        @allocation_count_start = now_allocations
-      end
-
-      # Record information at the time this event finishes
-      def finish!
-        @cpu_time_finish = now_cpu
-        @end = now
-        @allocation_count_finish = now_allocations
-      end
-
-      # Returns the CPU time (in milliseconds) passed since the call to
-      # +start!+ and the call to +finish!+
-      def cpu_time
-        (@cpu_time_finish - @cpu_time_start) * 1000
-      end
-
-      # Returns the idle time time (in milliseconds) passed since the call to
-      # +start!+ and the call to +finish!+
-      def idle_time
-        duration - cpu_time
-      end
-
-      # Returns the number of allocations made since the call to +start!+ and
-      # the call to +finish!+
-      def allocations
-        @allocation_count_finish - @allocation_count_start
-      end
-
-      # Returns the difference in milliseconds between when the execution of the
-      # event started and when it ended.
-      #
-      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
-      #   end
-      #
-      #   ActiveSupport::Notifications.instrument('wait') do
-      #     sleep 1
-      #   end
-      #
-      #   @event.duration # => 1000.138
-      def duration
-        1000.0 * (self.end - time)
-      end
-
-      def <<(event)
-        @children << event
-      end
-
-      def parent_of?(event)
-        @children.include? event
-      end
-
-      private
-        def now
-          Concurrent.monotonic_time
-        end
-
-        begin
-          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
-
-          def now_cpu
-            Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
-          end
-        rescue
-          def now_cpu
-            0
-          end
-        end
-
-        if defined?(JRUBY_VERSION)
-          def now_allocations
-            0
-          end
-        else
-          def now_allocations
-            GC.stat :total_allocated_objects
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/activesupport-6.1.4.4/lib/active_support/notifications.rb

@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/notifications/instrumenter"
-require "active_support/notifications/fanout"
-require "active_support/per_thread_registry"
-
-module ActiveSupport
-  # = Notifications
-  #
-  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for
-  # Ruby.
-  #
-  # == Instrumenters
-  #
-  # To instrument an event you just need to do:
-  #
-  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render plain: 'Foo'
-  #   end
-  #
-  # That first executes the block and then notifies all subscribers once done.
-  #
-  # In the example above +render+ is the name of the event, and the rest is called
-  # the _payload_. The payload is a mechanism that allows instrumenters to pass
-  # extra information to subscribers. Payloads consist of a hash whose contents
-  # are arbitrary and generally depend on the event.
-  #
-  # == Subscribers
-  #
-  # You can consume those events and the information they provide by registering
-  # a subscriber.
-  #
-  #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
-  #     name    # => String, name of the event (such as 'render' from above)
-  #     start   # => Time, when the instrumented block started execution
-  #     finish  # => Time, when the instrumented block ended execution
-  #     id      # => String, unique ID for the instrumenter that fired the event
-  #     payload # => Hash, the payload
-  #   end
-  #
-  # Here, the +start+ and +finish+ values represent wall-clock time. If you are
-  # concerned about accuracy, you can register a monotonic subscriber.
-  #
-  #   ActiveSupport::Notifications.monotonic_subscribe('render') do |name, start, finish, id, payload|
-  #     name    # => String, name of the event (such as 'render' from above)
-  #     start   # => Monotonic time, when the instrumented block started execution
-  #     finish  # => Monotonic time, when the instrumented block ended execution
-  #     id      # => String, unique ID for the instrumenter that fired the event
-  #     payload # => Hash, the payload
-  #   end
-  #
-  # The +start+ and +finish+ values above represent monotonic time.
-  #
-  # For instance, let's store all "render" events in an array:
-  #
-  #   events = []
-  #
-  #   ActiveSupport::Notifications.subscribe('render') do |*args|
-  #     events << ActiveSupport::Notifications::Event.new(*args)
-  #   end
-  #
-  # That code returns right away, you are just subscribing to "render" events.
-  # The block is saved and will be called whenever someone instruments "render":
-  #
-  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render plain: 'Foo'
-  #   end
-  #
-  #   event = events.first
-  #   event.name      # => "render"
-  #   event.duration  # => 10 (in milliseconds)
-  #   event.payload   # => { extra: :information }
-  #
-  # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event's instrumenter
-  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
-  # that order.
-  #
-  # If an exception happens during that particular instrumentation the payload will
-  # have a key <tt>:exception</tt> with an array of two elements as value: a string with
-  # the name of the exception class, and the exception message.
-  # The <tt>:exception_object</tt> key of the payload will have the exception
-  # itself as the value:
-  #
-  #   event.payload[:exception]         # => ["ArgumentError", "Invalid value"]
-  #   event.payload[:exception_object]  # => #<ArgumentError: Invalid value>
-  #
-  # As the earlier example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
-  # is able to take the arguments as they come and provide an object-oriented
-  # interface to that data.
-  #
-  # It is also possible to pass an object which responds to <tt>call</tt> method
-  # as the second parameter to the <tt>subscribe</tt> method instead of a block:
-  #
-  #   module ActionController
-  #     class PageRequest
-  #       def call(name, started, finished, unique_id, payload)
-  #         Rails.logger.debug ['notification:', name, started, finished, unique_id, payload].join(' ')
-  #       end
-  #     end
-  #   end
-  #
-  #   ActiveSupport::Notifications.subscribe('process_action.action_controller', ActionController::PageRequest.new)
-  #
-  # resulting in the following output within the logs including a hash with the payload:
-  #
-  #   notification: process_action.action_controller 2012-04-13 01:08:35 +0300 2012-04-13 01:08:35 +0300 af358ed7fab884532ec7 {
-  #      controller: "Devise::SessionsController",
-  #      action: "new",
-  #      params: {"action"=>"new", "controller"=>"devise/sessions"},
-  #      format: :html,
-  #      method: "GET",
-  #      path: "/login/sign_in",
-  #      status: 200,
-  #      view_runtime: 279.3080806732178,
-  #      db_runtime: 40.053
-  #    }
-  #
-  # You can also subscribe to all events whose name matches a certain regexp:
-  #
-  #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-  #     ...
-  #   end
-  #
-  # and even pass no argument to <tt>subscribe</tt>, in which case you are subscribing
-  # to all events.
-  #
-  # == Temporary Subscriptions
-  #
-  # Sometimes you do not want to subscribe to an event for the entire life of
-  # the application. There are two ways to unsubscribe.
-  #
-  # WARNING: The instrumentation framework is designed for long-running subscribers,
-  # use this feature sparingly because it wipes some internal caches and that has
-  # a negative impact on performance.
-  #
-  # === Subscribe While a Block Runs
-  #
-  # You can subscribe to some event temporarily while some block runs. For
-  # example, in
-  #
-  #   callback = lambda {|*args| ... }
-  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
-  #     ...
-  #   end
-  #
-  # the callback will be called for all "sql.active_record" events instrumented
-  # during the execution of the block. The callback is unsubscribed automatically
-  # after that.
-  #
-  # To record +started+ and +finished+ values with monotonic time,
-  # specify the optional <tt>:monotonic</tt> option to the
-  # <tt>subscribed</tt> method. The <tt>:monotonic</tt> option is set
-  # to +false+ by default.
-  #
-  #   callback = lambda {|name, started, finished, unique_id, payload| ... }
-  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record", monotonic: true) do
-  #     ...
-  #   end
-  #
-  # === Manual Unsubscription
-  #
-  # The +subscribe+ method returns a subscriber object:
-  #
-  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
-  #     ...
-  #   end
-  #
-  # To prevent that block from being called anymore, just unsubscribe passing
-  # that reference:
-  #
-  #   ActiveSupport::Notifications.unsubscribe(subscriber)
-  #
-  # You can also unsubscribe by passing the name of the subscriber object. Note
-  # that this will unsubscribe all subscriptions with the given name:
-  #
-  #   ActiveSupport::Notifications.unsubscribe("render")
-  #
-  # Subscribers using a regexp or other pattern-matching object will remain subscribed
-  # to all events that match their original pattern, unless those events match a string
-  # passed to +unsubscribe+:
-  #
-  #   subscriber = ActiveSupport::Notifications.subscribe(/render/) { }
-  #   ActiveSupport::Notifications.unsubscribe('render_template.action_view')
-  #   subscriber.matches?('render_template.action_view') # => false
-  #   subscriber.matches?('render_partial.action_view') # => true
-  #
-  # == Default Queue
-  #
-  # Notifications ships with a queue implementation that consumes and publishes events
-  # to all log subscribers. You can use any queue implementation you want.
-  #
-  module Notifications
-    class << self
-      attr_accessor :notifier
-
-      def publish(name, *args)
-        notifier.publish(name, *args)
-      end
-
-      def instrument(name, payload = {})
-        if notifier.listening?(name)
-          instrumenter.instrument(name, payload) { yield payload if block_given? }
-        else
-          yield payload if block_given?
-        end
-      end
-
-      # Subscribe to a given event name with the passed +block+.
-      #
-      # You can subscribe to events by passing a String to match exact event
-      # names, or by passing a Regexp to match all events that match a pattern.
-      #
-      #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
-      #   end
-      #
-      # The +block+ will receive five parameters with information about the event:
-      #
-      #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
-      #     name    # => String, name of the event (such as 'render' from above)
-      #     start   # => Time, when the instrumented block started execution
-      #     finish  # => Time, when the instrumented block ended execution
-      #     id      # => String, unique ID for the instrumenter that fired the event
-      #     payload # => Hash, the payload
-      #   end
-      #
-      # If the block passed to the method only takes one parameter,
-      # it will yield an event object to the block:
-      #
-      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
-      #     @event = event
-      #   end
-      def subscribe(pattern = nil, callback = nil, &block)
-        notifier.subscribe(pattern, callback, monotonic: false, &block)
-      end
-
-      def monotonic_subscribe(pattern = nil, callback = nil, &block)
-        notifier.subscribe(pattern, callback, monotonic: true, &block)
-      end
-
-      def subscribed(callback, pattern = nil, monotonic: false, &block)
-        subscriber = notifier.subscribe(pattern, callback, monotonic: monotonic)
-        yield
-      ensure
-        unsubscribe(subscriber)
-      end
-
-      def unsubscribe(subscriber_or_name)
-        notifier.unsubscribe(subscriber_or_name)
-      end
-
-      def instrumenter
-        InstrumentationRegistry.instance.instrumenter_for(notifier)
-      end
-    end
-
-    # This class is a registry which holds all of the +Instrumenter+ objects
-    # in a particular thread local. To access the +Instrumenter+ object for a
-    # particular +notifier+, you can call the following method:
-    #
-    #   InstrumentationRegistry.instrumenter_for(notifier)
-    #
-    # The instrumenters for multiple notifiers are held in a single instance of
-    # this class.
-    class InstrumentationRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
-
-      def initialize
-        @registry = {}
-      end
-
-      def instrumenter_for(notifier)
-        @registry[notifier] ||= Instrumenter.new(notifier)
-      end
-    end
-
-    self.notifier = Fanout.new
-  end
-end