omg-activesupport 8.0.0.alpha1

data/lib/active_support/broadcast_logger.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support Broadcast Logger
+  #
+  # The Broadcast logger is a logger used to write messages to multiple IO. It is commonly used
+  # in development to display messages on STDOUT and also write them to a file (development.log).
+  # With the Broadcast logger, you can broadcast your logs to a unlimited number of sinks.
+  #
+  # The BroadcastLogger acts as a standard logger and all methods you are used to are available.
+  # However, all the methods on this logger will propagate and be delegated to the other loggers
+  # that are part of the broadcast.
+  #
+  # Broadcasting your logs.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Add a logger to the broadcast.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   broadcast = BroadcastLogger.new(stdout_logger)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast.broadcast_to(file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Modifying the log level for all broadcasted loggers.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.level = Logger::FATAL # Modify the log level for the whole broadcast.
+  #
+  # Stop broadcasting log to a sink.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  #   broadcast.stop_broadcasting_to(file_logger)
+  #   broadcast.info("Hello world!") # Writes the log *only* to STDOUT.
+  #
+  # At least one sink has to be part of the broadcast. Otherwise, your logs will not
+  # be written anywhere. For instance:
+  #
+  #   broadcast = BroadcastLogger.new
+  #   broadcast.info("Hello world") # The log message will appear nowhere.
+  #
+  # If you are adding a custom logger with custom methods to the broadcast,
+  # the `BroadcastLogger` will proxy them and return the raw value, or an array
+  # of raw values, depending on how many loggers in the broadcasts responded to
+  # the method:
+  #
+  #   class MyLogger < ::Logger
+  #     def loggable?
+  #       true
+  #     end
+  #   end
+  #
+  #   logger = BroadcastLogger.new
+  #   logger.loggable? # => A NoMethodError exception is raised because no loggers in the broadcasts could respond.
+  #
+  #   logger.broadcast_to(MyLogger.new(STDOUT))
+  #   logger.loggable? # => true
+  #   logger.broadcast_to(MyLogger.new(STDOUT))
+  #   puts logger.broadcasts # => [MyLogger, MyLogger]
+  #   logger.loggable? # [true, true]
+  class BroadcastLogger
+    include ActiveSupport::LoggerSilence
+
+    # Returns all the logger that are part of this broadcast.
+    attr_reader :broadcasts
+    attr_reader :formatter
+    attr_accessor :progname
+
+    def initialize(*loggers)
+      @broadcasts = []
+      @progname = "Broadcast"
+
+      broadcast_to(*loggers)
+    end
+
+    # Add logger(s) to the broadcast.
+    #
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #   broadcast_logger.broadcast_to(Logger.new(STDOUT), Logger.new(STDERR))
+    def broadcast_to(*loggers)
+      @broadcasts.concat(loggers)
+    end
+
+    # Remove a logger from the broadcast. When a logger is removed, messages sent to
+    # the broadcast will no longer be written to its sink.
+    #
+    #   sink = Logger.new(STDOUT)
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #
+    #   broadcast_logger.stop_broadcasting_to(sink)
+    def stop_broadcasting_to(logger)
+      @broadcasts.delete(logger)
+    end
+
+    def level
+      @broadcasts.map(&:level).min
+    end
+
+    def <<(message)
+      dispatch { |logger| logger.<<(message) }
+    end
+
+    def add(...)
+      dispatch { |logger| logger.add(...) }
+    end
+    alias_method :log, :add
+
+    def debug(...)
+      dispatch { |logger| logger.debug(...) }
+    end
+
+    def info(...)
+      dispatch { |logger| logger.info(...) }
+    end
+
+    def warn(...)
+      dispatch { |logger| logger.warn(...) }
+    end
+
+    def error(...)
+      dispatch { |logger| logger.error(...) }
+    end
+
+    def fatal(...)
+      dispatch { |logger| logger.fatal(...) }
+    end
+
+    def unknown(...)
+      dispatch { |logger| logger.unknown(...) }
+    end
+
+    def formatter=(formatter)
+      dispatch { |logger| logger.formatter = formatter }
+
+      @formatter = formatter
+    end
+
+    def level=(level)
+      dispatch { |logger| logger.level = level }
+    end
+    alias_method :sev_threshold=, :level=
+
+    def local_level=(level)
+      dispatch do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
+    end
+
+    def close
+      dispatch { |logger| logger.close }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::DEBUG to be written
+    # to at least one broadcast. +False+ otherwise.
+    def debug?
+      @broadcasts.any? { |logger| logger.debug? }
+    end
+
+    # Sets the log level to Logger::DEBUG for the whole broadcast.
+    def debug!
+      dispatch { |logger| logger.debug! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::INFO to be written
+    # to at least one broadcast. +False+ otherwise.
+    def info?
+      @broadcasts.any? { |logger| logger.info? }
+    end
+
+    # Sets the log level to Logger::INFO for the whole broadcast.
+    def info!
+      dispatch { |logger| logger.info! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::WARN to be written
+    # to at least one broadcast. +False+ otherwise.
+    def warn?
+      @broadcasts.any? { |logger| logger.warn? }
+    end
+
+    # Sets the log level to Logger::WARN for the whole broadcast.
+    def warn!
+      dispatch { |logger| logger.warn! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::ERROR to be written
+    # to at least one broadcast. +False+ otherwise.
+    def error?
+      @broadcasts.any? { |logger| logger.error? }
+    end
+
+    # Sets the log level to Logger::ERROR for the whole broadcast.
+    def error!
+      dispatch { |logger| logger.error! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::FATAL to be written
+    # to at least one broadcast. +False+ otherwise.
+    def fatal?
+      @broadcasts.any? { |logger| logger.fatal? }
+    end
+
+    # Sets the log level to Logger::FATAL for the whole broadcast.
+    def fatal!
+      dispatch { |logger| logger.fatal! }
+    end
+
+    def initialize_copy(other)
+      @broadcasts = []
+      @progname = other.progname.dup
+      @formatter = other.formatter.dup
+
+      broadcast_to(*other.broadcasts.map(&:dup))
+    end
+
+    private
+      def dispatch(&block)
+        @broadcasts.each { |logger| block.call(logger) }
+        true
+      end
+
+      def method_missing(name, ...)
+        loggers = @broadcasts.select { |logger| logger.respond_to?(name) }
+
+        if loggers.none?
+          super
+        elsif loggers.one?
+          loggers.first.send(name, ...)
+        else
+          loggers.map { |logger| logger.send(name, ...) }
+        end
+      end
+
+      def respond_to_missing?(method, include_all)
+        @broadcasts.any? { |logger| logger.respond_to?(method, include_all) }
+      end
+  end
+end

data/lib/active_support/builder.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+begin
+  require "builder"
+rescue LoadError => e
+  warn "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end

data/lib/active_support/cache/coder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "entry"
+
+module ActiveSupport
+  module Cache
+    class Coder # :nodoc:
+      def initialize(serializer, compressor, legacy_serializer: false)
+        @serializer = serializer
+        @compressor = compressor
+        @legacy_serializer = legacy_serializer
+      end
+
+      def dump(entry)
+        return @serializer.dump(entry) if @legacy_serializer
+
+        dump_compressed(entry, Float::INFINITY)
+      end
+
+      def dump_compressed(entry, threshold)
+        return @serializer.dump_compressed(entry, threshold) if @legacy_serializer
+
+        # If value is a string with a supported encoding, use it as the payload
+        # instead of passing it through the serializer.
+        if type = type_for_string(entry.value)
+          payload = entry.value.b
+        else
+          type = OBJECT_DUMP_TYPE
+          payload = @serializer.dump(entry.value)
+        end
+
+        if compressed = try_compress(payload, threshold)
+          payload = compressed
+          type = type | COMPRESSED_FLAG
+        end
+
+        expires_at = entry.expires_at || -1.0
+
+        version = dump_version(entry.version) if entry.version
+        version_length = version&.bytesize || -1
+
+        packed = SIGNATURE.b
+        packed << [type, expires_at, version_length].pack(PACKED_TEMPLATE)
+        packed << version if version
+        packed << payload
+      end
+
+      def load(dumped)
+        return @serializer.load(dumped) if !signature?(dumped)
+
+        type = dumped.unpack1(PACKED_TYPE_TEMPLATE)
+        expires_at = dumped.unpack1(PACKED_EXPIRES_AT_TEMPLATE)
+        version_length = dumped.unpack1(PACKED_VERSION_LENGTH_TEMPLATE)
+
+        expires_at = nil if expires_at < 0
+        version = load_version(dumped.byteslice(PACKED_VERSION_INDEX, version_length)) if version_length >= 0
+        payload = dumped.byteslice((PACKED_VERSION_INDEX + [version_length, 0].max)..)
+
+        compressor = @compressor if type & COMPRESSED_FLAG > 0
+        serializer = STRING_DESERIALIZERS[type & ~COMPRESSED_FLAG] || @serializer
+
+        LazyEntry.new(serializer, compressor, payload, version: version, expires_at: expires_at)
+      end
+
+      private
+        SIGNATURE = "\x00\x11".b.freeze
+
+        OBJECT_DUMP_TYPE = 0x01
+
+        STRING_ENCODINGS = {
+          0x02 => Encoding::UTF_8,
+          0x03 => Encoding::BINARY,
+          0x04 => Encoding::US_ASCII,
+        }
+
+        COMPRESSED_FLAG = 0x80
+
+        PACKED_TEMPLATE = "CEl<"
+        PACKED_TYPE_TEMPLATE = "@#{SIGNATURE.bytesize}C"
+        PACKED_EXPIRES_AT_TEMPLATE = "@#{[0].pack(PACKED_TYPE_TEMPLATE).bytesize}E"
+        PACKED_VERSION_LENGTH_TEMPLATE = "@#{[0].pack(PACKED_EXPIRES_AT_TEMPLATE).bytesize}l<"
+        PACKED_VERSION_INDEX = [0].pack(PACKED_VERSION_LENGTH_TEMPLATE).bytesize
+
+        MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+        class StringDeserializer
+          def initialize(encoding)
+            @encoding = encoding
+          end
+
+          def load(payload)
+            payload.force_encoding(@encoding)
+          end
+        end
+
+        STRING_DESERIALIZERS = STRING_ENCODINGS.transform_values { |encoding| StringDeserializer.new(encoding) }
+
+        class LazyEntry < Cache::Entry
+          def initialize(serializer, compressor, payload, **options)
+            super(payload, **options)
+            @serializer = serializer
+            @compressor = compressor
+            @resolved = false
+          end
+
+          def value
+            if !@resolved
+              @value = @serializer.load(@compressor ? @compressor.inflate(@value) : @value)
+              @resolved = true
+            end
+            @value
+          end
+
+          def mismatched?(version)
+            super.tap { |mismatched| value if !mismatched }
+          rescue Cache::DeserializationError
+            true
+          end
+        end
+
+        def signature?(dumped)
+          dumped.is_a?(String) && dumped.start_with?(SIGNATURE)
+        end
+
+        def type_for_string(value)
+          STRING_ENCODINGS.key(value.encoding) if value.instance_of?(String)
+        end
+
+        def try_compress(string, threshold)
+          if @compressor && string.bytesize >= threshold
+            compressed = @compressor.deflate(string)
+            compressed if compressed.bytesize < string.bytesize
+          end
+        end
+
+        def dump_version(version)
+          if version.encoding != Encoding::UTF_8 || version.start_with?(MARSHAL_SIGNATURE)
+            Marshal.dump(version)
+          else
+            version.b
+          end
+        end
+
+        def load_version(dumped_version)
+          if dumped_version.start_with?(MARSHAL_SIGNATURE)
+            Marshal.load(dumped_version)
+          else
+            dumped_version.force_encoding(Encoding::UTF_8)
+          end
+        end
+    end
+  end
+end

data/lib/active_support/cache/entry.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module ActiveSupport
+  module Cache
+    # This class is used to represent cache entries. Cache entries have a value, an optional
+    # expiration time, and an optional version. The expiration time is used to support the :race_condition_ttl option
+    # on the cache. The version is used to support the :version option on the cache for rejecting
+    # mismatches.
+    #
+    # Since cache entries in most instances will be serialized, the internals of this class are highly optimized
+    # using short instance variable names that are lazily defined.
+    class Entry # :nodoc:
+      class << self
+        def unpack(members)
+          new(members[0], expires_at: members[1], version: members[2])
+        end
+      end
+
+      attr_reader :version
+
+      # Creates a new cache entry for the specified value. Options supported are
+      # +:compressed+, +:version+, +:expires_at+ and +:expires_in+.
+      def initialize(value, compressed: false, version: nil, expires_in: nil, expires_at: nil, **)
+        @value      = value
+        @version    = version
+        @created_at = 0.0
+        @expires_in = expires_at&.to_f || expires_in && (expires_in.to_f + Time.now.to_f)
+        @compressed = true if compressed
+      end
+
+      def value
+        compressed? ? uncompress(@value) : @value
+      end
+
+      def mismatched?(version)
+        @version && version && @version != version
+      end
+
+      # Checks if the entry is expired. The +expires_in+ parameter can override
+      # the value set when the entry was created.
+      def expired?
+        @expires_in && @created_at + @expires_in <= Time.now.to_f
+      end
+
+      def expires_at
+        @expires_in ? @created_at + @expires_in : nil
+      end
+
+      def expires_at=(value)
+        if value
+          @expires_in = value.to_f - @created_at
+        else
+          @expires_in = nil
+        end
+      end
+
+      # Returns the size of the cached value. This could be less than
+      # <tt>value.bytesize</tt> if the data is compressed.
+      def bytesize
+        case value
+        when NilClass
+          0
+        when String
+          @value.bytesize
+        else
+          @s ||= Marshal.dump(@value).bytesize
+        end
+      end
+
+      def compressed? # :nodoc:
+        defined?(@compressed)
+      end
+
+      def compressed(compress_threshold)
+        return self if compressed?
+
+        case @value
+        when nil, true, false, Numeric
+          uncompressed_size = 0
+        when String
+          uncompressed_size = @value.bytesize
+        else
+          serialized = Marshal.dump(@value)
+          uncompressed_size = serialized.bytesize
+        end
+
+        if uncompressed_size >= compress_threshold
+          serialized ||= Marshal.dump(@value)
+          compressed = Zlib::Deflate.deflate(serialized)
+
+          if compressed.bytesize < uncompressed_size
+            return Entry.new(compressed, compressed: true, expires_at: expires_at, version: version)
+          end
+        end
+        self
+      end
+
+      def local?
+        false
+      end
+
+      # Duplicates the value in a class. This is used by cache implementations that don't natively
+      # serialize entries to protect against accidental cache modifications.
+      def dup_value!
+        if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
+          if @value.is_a?(String)
+            @value = @value.dup
+          else
+            @value = Marshal.load(Marshal.dump(@value))
+          end
+        end
+      end
+
+      def pack
+        members = [value, expires_at, version]
+        members.pop while !members.empty? && members.last.nil?
+        members
+      end
+
+      private
+        def uncompress(value)
+          marshal_load(Zlib::Inflate.inflate(value))
+        end
+
+        def marshal_load(payload)
+          Marshal.load(payload)
+        rescue ArgumentError => error
+          raise Cache::DeserializationError, error.message
+        end
+    end
+  end
+end