julewire-core 1.0.0 → 1.0.1

data/lib/julewire/core/serialization/bounded_traversal.rb

@@ -22,16 +22,13 @@ module Julewire
             max_hash_keys: DEFAULT_MAX_HASH_KEYS,
             max_string_bytes: DEFAULT_MAX_STRING_BYTES
           )
-            {
-              "truncated" => true,
-              "truncated_fields" => Array(fields).uniq,
-              "limits" => {
-                "max_array_items" => max_array_items,
-                "max_depth" => max_depth,
-                "max_hash_keys" => max_hash_keys,
-                "max_string_bytes" => max_string_bytes
-              }
-            }
+            TruncationMetadata.build(
+              fields,
+              max_array_items: max_array_items,
+              max_depth: max_depth,
+              max_hash_keys: max_hash_keys,
+              max_string_bytes: max_string_bytes
+            )
           end
         end
 
@@ -110,15 +107,17 @@ module Julewire
           fields = nil
           result = {}
           track_paths = @track_paths
+          visited = 0
           value.each do |raw_key, item|
-            if result.length >= @max_hash_keys
+            if visited >= @max_hash_keys
               fields = append_truncation_field(fields, "hash_keys")
               break
             end
 
+            visited += 1
             child = walk_value(item, depth + 1, raw_key, track_paths ? path_for(path, raw_key) : nil)
             child_truncated = consume_truncated
-            key = key_value(raw_key)
+            key = key_value(raw_key, depth, path)
             key_truncated = consume_truncated
             result[key] = child
             fields = record_hash_truncation(fields, raw_key, key, key_truncated, child_truncated)
@@ -130,19 +129,23 @@ module Julewire
           fields = nil
           result = {}
           track_paths = @track_paths
+          visited = 0
           value.each do |raw_key, item|
+            # The hash cap bounds visited input entries, not final output keys, so
+            # serialized-key collisions and compacted entries cannot hide work.
+            if visited >= @max_hash_keys
+              fields = append_truncation_field(fields, "hash_keys")
+              break
+            end
+
+            visited += 1
             next if raw_omitted_value?(item)
 
             child = walk_value(item, depth + 1, raw_key, track_paths ? path_for(path, raw_key) : nil)
             child_truncated = consume_truncated
             next if omitted_value?(child)
 
-            if result.length >= @max_hash_keys
-              fields = append_truncation_field(fields, "hash_keys")
-              break
-            end
-
-            key = key_value(raw_key)
+            key = key_value(raw_key, depth, path)
             key_truncated = consume_truncated
             result[key] = child
             fields = record_hash_truncation(fields, raw_key, key, key_truncated, child_truncated)
@@ -159,12 +162,14 @@ module Julewire
         def walk_full_array(value, depth, path)
           fields = nil
           result = []
+          visited = 0
           value.each do |item|
-            if result.length >= @max_array_items
+            if visited >= @max_array_items
               fields = append_truncation_field(fields, "array_items")
               break
             end
 
+            visited += 1
             child = walk_value(item, depth + 1, nil, path)
             child_truncated = consume_truncated
             result << child
@@ -176,18 +181,20 @@ module Julewire
         def walk_compact_array(value, depth, path)
           fields = nil
           result = []
+          visited = 0
           value.each do |item|
+            if visited >= @max_array_items
+              fields = append_truncation_field(fields, "array_items")
+              break
+            end
+
+            visited += 1
             next if raw_omitted_value?(item)
 
             child = walk_value(item, depth + 1, nil, path)
             child_truncated = consume_truncated
             next if omitted_value?(child)
 
-            if result.length >= @max_array_items
-              fields = append_truncation_field(fields, "array_items")
-              break
-            end
-
             result << child
             fields = append_truncation_field(fields, "array_items") if child_truncated
           end
@@ -198,7 +205,7 @@ module Julewire
 
         def raw_omitted_value?(_value) = false
 
-        def key_value(key)
+        def key_value(key, _depth = nil, _path = nil)
           clear_truncated(key.is_a?(String) ? copy_string(key) : key)
         end
 
@@ -259,8 +266,7 @@ module Julewire
         end
 
         def append_truncation_field(fields, field)
-          (fields ||= []) << field
-          fields
+          TruncationMetadata.append_field(fields, field)
         end
 
         def path_for(parent_path, key)

data/lib/julewire/core/serialization/serializer.rb

@@ -152,7 +152,7 @@ module Julewire
 
         def raw_omitted_value?(value) = DeepCompactEmpty.omitted?(value)
 
-        def key_value(key) = serialize_key(key)
+        def key_value(key, _depth = nil, _path = nil) = serialize_key(key)
 
         def error_value(error) = clear_truncated(unserializable_marker(error))
 

data/lib/julewire/core/serialization/truncation_metadata.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Core
+    module Serialization
+      module TruncationMetadata
+        KEYS = {
+          string: {
+            truncated: "truncated",
+            truncated_fields: "truncated_fields",
+            limits: "limits",
+            max_array_items: "max_array_items",
+            max_depth: "max_depth",
+            max_hash_keys: "max_hash_keys",
+            max_string_bytes: "max_string_bytes"
+          }.freeze,
+          symbol: {
+            truncated: :truncated,
+            truncated_fields: :truncated_fields,
+            limits: :limits,
+            max_array_items: :max_array_items,
+            max_depth: :max_depth,
+            max_hash_keys: :max_hash_keys,
+            max_string_bytes: :max_string_bytes
+          }.freeze
+        }.freeze
+        METADATA_KEYS = KEYS.fetch(:symbol).values_at(:truncated, :truncated_fields, :limits).freeze
+        METADATA_KEY_NAMES = METADATA_KEYS.map(&:to_s).freeze
+        LIMIT_KEYS = KEYS.fetch(:symbol).values_at(
+          :max_array_items,
+          :max_depth,
+          :max_hash_keys,
+          :max_string_bytes
+        ).freeze
+        LIMIT_KEY_NAMES = LIMIT_KEYS.map(&:to_s).freeze
+        [KEYS, METADATA_KEYS, METADATA_KEY_NAMES, LIMIT_KEYS, LIMIT_KEY_NAMES].each do |constant|
+          ::Ractor.make_shareable(constant) if defined?(::Ractor) && ::Ractor.respond_to?(:make_shareable)
+        end
+        private_constant :KEYS, :METADATA_KEYS, :METADATA_KEY_NAMES, :LIMIT_KEYS, :LIMIT_KEY_NAMES
+
+        class << self
+          def build(fields, max_array_items:, max_depth:, max_hash_keys:, max_string_bytes:, key_style: :string,
+                    compact_limits: false, freeze_values: false)
+            keys = KEYS.fetch(key_style)
+            limits = limits_hash(
+              keys,
+              max_array_items: max_array_items,
+              max_depth: max_depth,
+              max_hash_keys: max_hash_keys,
+              max_string_bytes: max_string_bytes,
+              compact_limits: compact_limits
+            )
+            metadata = {
+              keys.fetch(:truncated) => true,
+              keys.fetch(:truncated_fields) => field_list(fields),
+              keys.fetch(:limits) => limits
+            }
+            freeze_values ? deep_freeze(metadata, keys) : metadata
+          end
+
+          def append_field(fields, field)
+            fields ||= []
+            fields << field unless fields.include?(field)
+            fields
+          end
+
+          def valid?(value, max_fields: nil)
+            return false unless value.is_a?(Hash)
+            return false unless valid_top_level_keys?(value)
+            return false unless fetch_key(value, :truncated) == true
+
+            fields = fetch_key(value, :truncated_fields)
+            limits = fetch_key(value, :limits)
+            valid_fields?(fields, max_fields: max_fields) && valid_limits?(limits)
+          end
+
+          private
+
+          def field_list(fields)
+            Array(fields).uniq
+          end
+
+          def limits_hash(keys, max_array_items:, max_depth:, max_hash_keys:, max_string_bytes:, compact_limits:)
+            limits = {
+              keys.fetch(:max_array_items) => max_array_items,
+              keys.fetch(:max_depth) => max_depth,
+              keys.fetch(:max_hash_keys) => max_hash_keys,
+              keys.fetch(:max_string_bytes) => max_string_bytes
+            }
+            compact_limits ? limits.compact : limits
+          end
+
+          def deep_freeze(metadata, keys)
+            metadata.fetch(keys.fetch(:truncated_fields)).each(&:freeze)
+            metadata.fetch(keys.fetch(:truncated_fields)).freeze
+            metadata.fetch(keys.fetch(:limits)).freeze
+            metadata.freeze
+          end
+
+          def fetch_key(value, key)
+            return value[key] if value.key?(key)
+
+            value[key.to_s]
+          end
+
+          def valid_top_level_keys?(value)
+            return false if value.length > METADATA_KEYS.length * 2
+
+            value.keys.all? { known_key?(it, METADATA_KEYS, METADATA_KEY_NAMES) } &&
+              METADATA_KEYS.all? { value.key?(it) || value.key?(it.to_s) }
+          end
+
+          def valid_fields?(fields, max_fields:)
+            return false unless fields.is_a?(Array)
+
+            seen = 0
+            fields.each do |field|
+              seen += 1
+              return false if max_fields && seen > max_fields
+              return false unless field.is_a?(String) || field.is_a?(Symbol)
+            end
+            true
+          end
+
+          def valid_limits?(limits)
+            return false unless limits.is_a?(Hash)
+            return false if limits.length > LIMIT_KEYS.length * 2
+
+            limits.all? do |key, value|
+              known_key?(key, LIMIT_KEYS, LIMIT_KEY_NAMES) && (value.nil? || value.is_a?(Integer))
+            end
+          end
+
+          def known_key?(key, symbol_keys, string_keys)
+            symbol_keys.include?(key) || string_keys.include?(key)
+          end
+        end
+      end
+      private_constant :TruncationMetadata
+    end
+  end
+end