synthra 0.1.0

data/lib/synthra/types/core/collections.rb

@@ -0,0 +1,513 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module Core
+      # Array type generator
+      #
+      # Generates arrays of elements using a specified type generator.
+      # Supports both positional and named argument syntax.
+      #
+      # @example Generate array of text
+      #   array_type = ArrayType.new
+      #   array_type.generate(rng, context, { element: "text", size: 1..5 }, :random)
+      #
+      class ArrayType < Base
+        # Generate a random array
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [String, Object] :element element type name or generator
+        # @option args [Range, Integer, Hash] :size size specification (default: 0..10)
+        # @return [Array] generated array
+        #
+        def generate(rng, context, args, mode)
+          element_type = resolve_type(args[:element] || args[:element_type] || "text")
+          size_range = extract_size_range(args)
+          size = rng.int(size_range.min, size_range.max)
+
+          size.times.map do
+            element_type.generate(rng, context, {}, mode)
+          end
+        end
+
+        # Generate a random array
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Array] generated array
+        #
+        def generate_random(rng, context, args)
+          generate(rng, context || Generator::Context.new, args, :random)
+        end
+
+        # Generate edge case array values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Array, nil, Integer] edge case value
+        #
+        def generate_edge(rng, context, args)
+          rng.sample([
+            [],
+            [nil],
+            [""],
+            [0],
+            [1, 2, 3]
+          ])
+        end
+
+        # Generate invalid array values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object] invalid array value
+        #
+        def generate_invalid(rng, context, args)
+          rng.sample([
+            nil,
+            "not an array",
+            123,
+            {}
+          ])
+        end
+
+        private
+
+        # Resolve element type to a type generator
+        #
+        # Looks up the type generator for the element type. If not found
+        # in the registry, assumes it's a schema reference and creates
+        # an ObjectType generator.
+        #
+        # @param element_type [String, Object] element type name or generator
+        # @return [Base] type generator instance
+        #
+        def resolve_type(element_type)
+          case element_type
+          when String
+            begin
+              Types::Registry.lookup(element_type)
+            rescue Errors::UnknownTypeError
+              # Assume it's a schema reference
+              Core::ObjectType.new(element_type)
+            end
+          when Base
+            element_type
+          else
+            # Default to Text if element_type is not a string or Base instance
+            Types::Registry.lookup("text")
+          end
+        end
+
+        # Extract size range from arguments
+        #
+        # Converts various size specifications into a Range object.
+        #
+        # @param args [Hash] type arguments
+        # @return [Range] size range
+        #
+        def extract_size_range(args)
+          case args[:size]
+          when Range
+            args[:size]
+          when Integer
+            args[:size]..args[:size]
+          when Hash
+            min = args[:size][:min] || args[:size]["min"] || 0
+            max = args[:size][:max] || args[:size]["max"] || 10
+            min..max
+          else
+            0..10  # Default range
+          end
+        end
+      end
+
+      # Object type generator (nested schema reference)
+      #
+      # Generates a complete object by referencing another schema definition.
+      # The referenced schema is looked up in the registry and generated
+      # recursively.
+      #
+      # @example Generate nested object
+      #   object_type = ObjectType.new("Address")
+      #   object_type.generate(rng, context, {}, :random)
+      #
+      class ObjectType < Base
+        attr_reader :schema_name
+
+        # Create a new ObjectType generator
+        #
+        # @param schema_name [String, nil] name of the schema to reference
+        #
+        def initialize(schema_name = nil)
+          @schema_name = schema_name
+        end
+
+        # Generate a nested schema object
+        #
+        # Looks up the referenced schema in the registry and generates
+        # a complete object from it.
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [String] :schema schema name (if not set in initialize)
+        # @return [Hash] generated object
+        #
+        def generate(rng, context, args, mode)
+          case mode
+          when :invalid
+            return generate_invalid(rng, context, args)
+          when :edge
+            return generate_edge(rng, context, args)
+          end
+
+          schema_name = @schema_name || args[:schema] || args["schema"]
+          return {} unless schema_name
+
+          registry = context&.registry
+          return {} unless registry
+
+          schema = registry.schema(schema_name)
+          return {} unless schema
+
+          # Get depth and resolver from context for proper recursion handling
+          # :nocov: context is guaranteed non-nil here (the `return {} unless registry`
+          # guard above already exits when context — and thus registry — is nil), so the
+          # `&.` nil-receiver else-arms below are unreachable.
+          depth = context&.depth || 0
+          resolver = context&.resolver
+          # :nocov:
+          
+          # Generate new seed from current rng for unique nested values
+          # This ensures each nested schema generates different data
+          nested_seed = rng.int(0, 2**31 - 1)
+          
+          # Pass current context as parent_context so nested schemas can access parent fields via copy()
+          schema.generate(seed: nested_seed, registry: registry, mode: mode, depth: depth + 1, resolver: resolver, parent_context: context)
+
+        rescue StandardError
+          {}
+        end
+
+
+        # Generate a random nested object
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Hash] generated object
+        #
+        def generate_random(rng, context, args)
+          generate(rng, context, args, :random)
+        end
+
+        # Generate edge case object values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Hash] edge case value
+        #
+        def generate_edge(rng, context, args)
+          {}
+        end
+
+        # Generate invalid object values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object] invalid object value
+        #
+        def generate_invalid(rng, context, args)
+          rng.sample([
+            nil,
+            [],
+            "not an object",
+            123
+          ])
+        end
+      end
+
+      # Special hash for map_by_field that supports both ID keys and entry name access
+      # This allows copy("users.sender.id") to work while JSON serializes only ID keys
+      class MapByFieldResult < Hash
+        def initialize(id_keyed_data, entries_by_name)
+          super()
+          merge!(id_keyed_data)
+          @entries_by_name = entries_by_name
+        end
+
+        def [](key)
+          # First check entry names (for copy() access)
+          return @entries_by_name[key] if @entries_by_name&.key?(key)
+          return @entries_by_name[key.to_s] if @entries_by_name&.key?(key.to_s)
+          super
+        end
+        
+        # JSON serialization only includes the ID-keyed data
+        def to_json(*args)
+          Hash[self].to_json(*args)
+        end
+        
+        def as_json(*args)
+          Hash[self]
+        end
+      end
+
+      # MapByField type - creates objects with dynamic keys from a field value
+      #
+      # Generates multiple objects and uses a specified field as the key.
+      # Perfect for Twitter-style user maps where ID is the key.
+      #
+      # @example DSL usage
+      #   users: map_by_field("id", sender: TwitterUser, recipient: TwitterUser)
+      #   # Generates: { "123": { id: "123", ... }, "456": { id: "456", ... } }
+      #
+      class MapByField < Base
+        # Generate a map with dynamic keys
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments with :key_field and schema entries
+        # @return [Hash] map with field values as keys
+        #
+        def generate(rng, context, args, mode)
+          case mode
+          when :invalid
+            return generate_invalid(rng, context, args)
+          when :edge
+            return generate_edge(rng, context, args)
+          end
+
+          key_field = args[:key_field] || args["key_field"] || "id"
+          entries = args[:entries] || args["entries"] || {}
+          
+          registry = context&.registry
+          return {} unless registry
+
+          result = {}
+          entries_by_name = {}  # For copy() access via users.sender.id
+          # :nocov: context is guaranteed non-nil here (the `return {} unless registry`
+          # guard above exits when context — and thus registry — is nil), so the `&.`
+          # nil-receiver else-arms on these three reads are unreachable.
+          depth = context&.depth || 0
+          resolver = context&.resolver
+
+          # Get shared context for batch-level caching
+          shared_context = context&.shared_context || {}
+          # :nocov:
+
+          entries.each do |entry_name, entry_config|
+            # Handle both simple schema name and { schema:, shared: } hash
+            is_shared = false
+            if entry_config.is_a?(Hash)
+              schema_name = entry_config[:schema] || entry_config["schema"]
+              is_shared = entry_config[:shared] || entry_config["shared"]
+            else
+              schema_name = entry_config.to_s
+            end
+
+            schema = registry.schema(schema_name) rescue nil
+            next unless schema
+
+            # Check if this entry should be shared across batch
+            shared_key = "map_by_field_#{entry_name}"
+            if is_shared && shared_context.key?(shared_key)
+              # Use cached value from shared context
+              obj = shared_context[shared_key]
+            else
+              # Generate new value
+              nested_seed = rng.int(0, 2**31 - 1)
+              obj = schema.generate(
+                seed: nested_seed,
+                registry: registry,
+                mode: mode,
+                depth: depth + 1,
+                resolver: resolver,
+                parent_context: context
+              )
+
+              # Cache in shared context if marked as shared
+              if is_shared
+                shared_context[shared_key] = obj
+                # :nocov: context is non-nil here (guarded by `return {} unless registry`
+                # earlier, where registry derives from context), so `if context` is always true.
+                context.shared_context = shared_context if context
+                # :nocov:
+              end
+            end
+            
+            # Store by entry name for copy() to access
+            entries_by_name[entry_name.to_s] = obj
+            
+            # Use the specified field as the key for the result
+            key = obj[key_field] || obj[key_field.to_sym]
+            result[key] = obj if key
+          end
+
+          # Create a special hash that has both ID keys and entry name access
+          MapByFieldResult.new(result, entries_by_name)
+        end
+
+        def generate_random(rng, context, args)
+          generate(rng, context, args, :random)
+        end
+
+        def generate_edge(rng, context, args)
+          {}
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, [], "not a map", 123])
+        end
+      end
+
+      # OneOf type - randomly selects one of multiple schemas
+      #
+      # Generates data from one randomly chosen schema from a list.
+      # Perfect for polymorphic types like message payloads, events, etc.
+      #
+      # @example DSL usage
+      #   payload: one_of(MessageCreatePayload, TypingPayload, ReadReceiptPayload)
+      #   # Randomly generates one of the three payload types
+      #
+      # @example With weights
+      #   payload: one_of(CommonPayload:80%, RarePayload:20%)
+      #   # 80% chance of CommonPayload, 20% chance of RarePayload
+      #
+      class OneOf < Base
+        # Generate data from one of the specified schemas
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments with :schemas array
+        # @return [Hash] generated data from the selected schema
+        #
+        def generate(rng, context, args, mode)
+          case mode
+          when :invalid
+            return generate_invalid(rng, context, args)
+          when :edge
+            return generate_edge(rng, context, args)
+          end
+
+          schemas = args[:schemas] || args["schemas"] || []
+          return nil if schemas.empty?
+
+          registry = context&.registry
+          return nil unless registry
+
+          # Select a schema based on weights (if provided)
+          selected = select_schema(rng, schemas)
+          return nil unless selected
+
+          # Get schema name (could be string or hash with weight)
+          schema_name = selected.is_a?(Hash) ? (selected[:schema] || selected["schema"]) : selected.to_s
+
+          schema = registry.schema(schema_name) rescue nil
+          return nil unless schema
+
+          # Generate from the selected schema
+          # :nocov: context is guaranteed non-nil here (the `return nil unless registry`
+          # guard above exits when context — and thus registry — is nil), so the `&.`
+          # nil-receiver else-arms on these three reads are unreachable.
+          depth = context&.depth || 0
+          resolver = context&.resolver
+          shared_context = context&.shared_context
+          # :nocov:
+
+          nested_seed = rng.int(0, 2**31 - 1)
+          schema.generate(
+            seed: nested_seed,
+            registry: registry,
+            mode: mode,
+            depth: depth + 1,
+            resolver: resolver,
+            parent_context: context,
+            shared_context: shared_context
+          )
+        end
+
+        def generate_random(rng, context, args)
+          generate(rng, context, args, :random)
+        end
+
+        def generate_edge(rng, context, args)
+          # In edge mode, return first schema's edge case
+          schemas = args[:schemas] || args["schemas"] || []
+          return nil if schemas.empty?
+
+          registry = context&.registry
+          return nil unless registry
+
+          first_schema = schemas.first
+          schema_name = first_schema.is_a?(Hash) ? (first_schema[:schema] || first_schema["schema"]) : first_schema.to_s
+
+          schema = registry.schema(schema_name) rescue nil
+          return {} unless schema
+
+          # :nocov: context is non-nil here (the `return nil unless registry` guard above
+          # exits when context — and thus registry — is nil), so this `&.` else is unreachable.
+          depth = context&.depth || 0
+          # :nocov:
+          nested_seed = rng.int(0, 2**31 - 1)
+          schema.generate(seed: nested_seed, registry: registry, mode: :edge, depth: depth + 1)
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, "not-an-object", 123, [], {}])
+        end
+
+        private
+
+        # Select a schema based on weights
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param schemas [Array] list of schemas (strings or hashes with weights)
+        # @return [Object] selected schema entry
+        #
+        def select_schema(rng, schemas)
+          # Check if any schema has weights
+          has_weights = schemas.any? { |s| s.is_a?(Hash) && (s[:weight] || s["weight"]) }
+
+          if has_weights
+            # Weighted selection
+            total_weight = schemas.sum do |s|
+              if s.is_a?(Hash)
+                s[:weight] || s["weight"] || 1
+              else
+                1
+              end
+            end
+
+            roll = rng.int(1, total_weight)
+            cumulative = 0
+
+            schemas.each do |s|
+              weight = if s.is_a?(Hash)
+                         s[:weight] || s["weight"] || 1
+                       else
+                         1
+                       end
+              cumulative += weight
+              return s if roll <= cumulative
+            end
+
+            schemas.last  # Fallback
+          else
+            # Equal probability
+            rng.sample(schemas)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/synthra/types/core/defaults.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module Core
+      # Default value type generator
+      #
+      # Returns a default value, optionally with a probability of being used.
+      # If probability is less than 1.0, returns nil some of the time.
+      #
+      # @example Generate default value
+      #   default = DefaultValue.new
+      #   default.generate_random(rng, context, { value: "Anonymous" }, :random)
+      #   # => "Anonymous"
+      #
+      # @example Default value with probability
+      #   default.generate_random(rng, context, { value: "Guest", probability: 0.8 }, :random)
+      #   # => "Guest" (80% of the time) or nil (20% of the time)
+      #
+      class DefaultValue < Base
+        # Generate a default value
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context (not used)
+        # @param args [Hash] type arguments
+        # @option args [Object] :value default value to return
+        # @option args [Float] :probability probability of using default (0.0-1.0, default: 1.0)
+        # @return [Object, nil] default value or nil
+        #
+        def generate_random(rng, context, args)
+          value = args[:value] || args["value"]
+          probability = args[:probability] || args["probability"] || 1.0
+
+          # If probability is less than 1.0, randomly return nil
+          if probability < 1.0
+            rng.rand < probability ? value : nil
+          else
+            value
+          end
+        end
+
+        # Generate edge case default values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object, nil] edge case value
+        #
+        def generate_edge(rng, context, args)
+          value = args[:value] || args["value"]
+          rng.sample([value, nil])
+        end
+
+        # Generate invalid default values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object] invalid value
+        #
+        def generate_invalid(rng, context, args)
+          value = args[:value] || args["value"]
+          case value
+          when String
+            rng.sample([nil, 123, [], {}])
+          when Integer
+            rng.sample([nil, "not a number", [], {}])
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/synthra/types/core/enums.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module Core
+      # Enum type generator
+      #
+      # Generates values from a predefined list, optionally with probability weights.
+      #
+      # @example Simple enum
+      #   enum(active, inactive)
+      #
+      # @example With probabilities
+      #   enum(active: 80%, inactive: 20%)
+      #
+      class Enum < Base
+        # Generate a random enum value
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Array] :values array of enum values (with probabilities)
+        # @option args [Array<String>] :values simple string array
+        # @return [Object] selected enum value
+        #
+        def generate_random(rng, context, args)
+          values = args[:values] || args["values"] || []
+
+          if values.empty?
+            return nil
+          end
+
+          # Check if values are simple strings/objects or have probabilities
+          if values.first.respond_to?(:probability)
+            # Weighted selection
+            weighted_choice(rng, values)
+          else
+            # Simple random selection
+            rng.sample(values)
+          end
+        end
+
+        # Generate edge case enum value
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object] edge case enum value
+        #
+        def generate_edge(rng, context, args)
+          values = args[:values] || args["values"] || []
+          return nil if values.empty?
+
+          # Return first or last value
+          if values.first.respond_to?(:value)
+            candidates = [values.first.value, values.last.value].compact
+          else
+            candidates = [values.first, values.last].compact
+          end
+
+          rng.sample(candidates)
+        end
+
+        # Generate invalid enum value
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object] invalid value
+        #
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, "invalid_enum", [], {}, 123])
+        end
+
+        private
+
+        # Select a value using weighted probabilities
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param values [Array] array of value objects with probabilities
+        # @return [Object] selected value
+        #
+        def weighted_choice(rng, values)
+          total = values.sum { |v| v.probability || 0 }
+          return values.first.value if total.zero?
+
+          random = rng.int(1, total)
+          cumulative = 0
+
+          values.each do |value|
+            cumulative += (value.probability || 0)
+            return value.value if random <= cumulative
+          end
+
+          # Fallback to first value
+          values.first.value
+        end
+      end
+    end
+  end
+end
+