familia 2.0.0.pre16 → 2.0.0.pre17

data/lib/familia/features/relationships/participation/participant_methods.rb

@@ -23,8 +23,10 @@ module Familia
         # ├── add_to_customer_domains(customer, score)    # Add myself to customer's domains
         # ├── remove_from_customer_domains(customer)      # Remove myself from customer's domains
         # ├── score_in_customer_domains(customer)         # Get my score (sorted_set only)
-        # ├── update_score_in_customer_domains(customer)  # Update my score (sorted_set only)
         # └── position_in_customer_domains(customer)      # Get my position (list only)
+        #
+        # Note: To update scores, use the DataType API directly:
+        #   customer.domains.add(domain.identifier, new_score, xx: true)
 
         module Builder
           extend CollectionOperations
@@ -126,7 +128,9 @@ module Familia
 
           # Build score-related methods for sorted sets
           # Creates: domain.score_in_customer_domains(customer)
-          #          domain.update_score_in_customer_domains(customer, new_score)
+          #
+          # Note: Score updates use DataType API directly:
+          #   customer.domains.add(domain.identifier, new_score, xx: true)
           def self.build_score_methods(participant_class, target_name, collection_name)
             # Get score method
             score_method = "score_in_#{target_name}_#{collection_name}"

data/lib/familia/features/transient_fields.rb

@@ -1,6 +1,7 @@
 # lib/familia/features/transient_fields.rb
 
 require_relative 'transient_fields/redacted_string'
+require_relative 'transient_fields/transient_field_type'
 
 module Familia
   module Features
@@ -104,7 +105,7 @@ module Familia
     # (HashiCorp Vault, AWS Secrets Manager) or languages with secure memory handling.
     #
     module TransientFields
-      Familia::Base.add_feature self, :transient_fields, depends_on: nil
+      Familia::Base.add_feature self, :transient_fields, depends_on: nil, field_group: :transient_fields
 
       def self.included(base)
         Familia.trace :LOADED, self, base if Familia.debug?
@@ -143,8 +144,12 @@ module Familia
           @transient_fields ||= []
           @transient_fields << name unless @transient_fields.include?(name)
 
+          # Add to field_groups if the group exists
+          if field_groups&.key?(:transient_fields)
+            field_groups[:transient_fields] << name
+          end
+
           # Use the field type system for proper integration
-          require_relative 'transient_fields/transient_field_type'
           field_type = TransientFieldType.new(name, as: as, **kwargs.merge(fast_method: false))
           register_field_type(field_type)
         end

data/lib/familia/features.rb

@@ -4,7 +4,7 @@
 require_relative 'features/autoloader'
 
 module Familia
-  FeatureDefinition = Data.define(:name, :depends_on)
+  FeatureDefinition = Data.define(:name, :depends_on, :field_group)
 
   # Familia::Features
   #
@@ -147,6 +147,11 @@ module Familia
       calling_location = caller_locations(1, 1)&.first
       options[:calling_location] = calling_location&.path
 
+      # Initialize field group if feature declares one
+      if feature_def&.field_group && respond_to?(:field_group)
+        field_group(feature_def.field_group)
+      end
+
       # Add feature options if the class supports them (Horreum classes)
       add_feature_options(feature_name, **options) if respond_to?(:add_feature_options)
 

data/lib/familia/field_type.rb

@@ -117,25 +117,7 @@ module Familia
         klass.define_method :"#{method_name}=" do |value|
           instance_variable_set(:"@#{field_name}", value)
 
-          # If this field is the identifier and object_identifier feature is loaded,
-          # update objid_lookup mapping when identifier is set after objid generation
-          if respond_to?(:objid) &&
-             self.class.respond_to?(:identifier_field) &&
-             self.class.identifier_field == field_name &&
-             self.class.respond_to?(:objid_lookup)
-            current_objid = instance_variable_get(:@objid)
-            self.class.objid_lookup[current_objid] = value if current_objid && value
-          end
 
-          # If this field is the identifier and external_identifier feature is loaded,
-          # update extid_lookup mapping when identifier is set after extid generation
-          if respond_to?(:extid) &&
-             self.class.respond_to?(:identifier_field) &&
-             self.class.identifier_field == field_name &&
-             self.class.respond_to?(:extid_lookup)
-            current_extid = instance_variable_get(:@extid)
-            self.class.extid_lookup[current_extid] = value if current_extid && value
-          end
         end
       end
     end

data/lib/familia/horreum/{core/connection.rb → connection.rb}

@@ -149,6 +149,7 @@ module Familia
       # @see MultiResult For details on the return value structure
       # @see #batch_update For similar atomic field updates with MultiResult
       def transaction(&)
+        ensure_relatives_initialized!
         Familia::Connection::TransactionCore.execute_transaction(-> { dbclient }, &)
       end
       alias multi transaction
@@ -243,12 +244,32 @@ module Familia
       # @see MultiResult For details on the return value structure
       # @see Familia.transaction For atomic command execution
       def pipelined(&block)
+        ensure_relatives_initialized!
         Familia::Connection::PipelineCore.execute_pipeline(-> { dbclient }, &block)
       end
       alias pipeline pipelined
 
       private
 
+      # Ensures that related fields have been initialized before entering transactions or pipelines.
+      #
+      # This prevents Redis::Future errors when lazy initialization would occur inside
+      # transaction/pipeline blocks. When commands execute inside transactions, Redis returns
+      # Future objects that don't respond to standard methods, causing cryptic NoMethodError.
+      #
+      # @raise [RuntimeError] if instance has relations but they haven't been initialized
+      # @note Skips check for class methods - they create temporary instances internally
+      # @note Uses singleton class to avoid polluting instance variables
+      def ensure_relatives_initialized!
+        return if is_a?(Class)  # Class methods handle their own instances
+        return unless self.class.respond_to?(:relations?) && self.class.relations?
+        return if singleton_class.instance_variable_defined?(:"@relatives_initialized")
+
+        raise "#{self.class} has related fields but they haven't been initialized. " \
+              "Did you override initialize without calling super? " \
+              "Related fields: #{self.class.related_fields.keys.join(', ')}"
+      end
+
       # Builds the class-level connection chain with handlers in priority order
       def build_connection_chain
         # Cache handlers at class level to avoid creating new instances per model instance

data/lib/familia/horreum/{subclass/definition.rb → definition.rb}

@@ -1,7 +1,6 @@
-# lib/familia/horreum/subclass/definition.rb
+# lib/familia/horreum/definition.rb
 
-require_relative 'related_fields_management'
-require_relative '../shared/settings'
+require_relative 'settings'
 
 module Familia
   VALID_STRATEGIES = %i[raise skip ignore warn overwrite].freeze
@@ -32,6 +31,10 @@ module Familia
     @dump_method = nil
     @load_method = nil
 
+    # Field groups
+    @field_groups = nil
+    @current_field_group = nil
+
     # DefinitionMethods - Class-level DSL methods for defining Horreum model structure
     #
     # This module is extended into classes that include Familia::Horreum,
@@ -48,6 +51,84 @@ module Familia
       include Familia::Settings
       include Familia::Horreum::RelatedFieldsManagement # Provides DataType field methods
 
+      # Defines a field group to organize related fields.
+      #
+      # Field groups provide a way to categorize and query fields by purpose or feature.
+      # When a block is provided, fields defined within the block are automatically
+      # added to the group. Without a block, an empty group is initialized.
+      #
+      # @param name [Symbol, String] the name of the field group
+      # @yield optional block for defining fields within the group
+      # @return [Array<Symbol>] the array of field names in the group
+      #
+      # @raise [Familia::Problem] if attempting to nest field groups
+      #
+      # @example Manual field grouping
+      #   class User < Familia::Horreum
+      #     field_group :personal_info do
+      #       field :name
+      #       field :email
+      #     end
+      #   end
+      #
+      #   User.personal_info  # => [:name, :email]
+      #
+      # @example Initialize empty group
+      #   class User < Familia::Horreum
+      #     field_group :placeholder
+      #   end
+      #
+      #   User.placeholder  # => []
+      #
+      def field_group(name, &block)
+
+        # Prevent nested field groups
+        if @current_field_group
+          raise Familia::Problem,
+            "Cannot define field group :#{name} while :#{@current_field_group} is being defined. " \
+            "Nested field groups are not supported."
+        end
+
+        # Initialize group
+        field_groups[name.to_sym] ||= []
+
+        if block_given?
+          @current_field_group = name.to_sym
+          begin
+            instance_eval(&block)
+          ensure
+            @current_field_group = nil
+          end
+        else
+          Familia.ld "[field_group] Created field group :#{name} but no block given" if Familia.debug?
+        end
+
+        field_groups[name.to_sym]
+      end
+
+      # Returns the list of all field group names defined for the class.
+      #
+      # @return [Array<Symbol>] array of field group names
+      #
+      # @example
+      #   class User < Familia::Horreum
+      #     field_group :personal_info do
+      #       field :name
+      #     end
+      #     field_group :metadata do
+      #       field :created_at
+      #     end
+      #   end
+      #
+      #   User.field_groups  # => [
+      #     :personal_info => [...],
+      #     :metadata => [..]
+      #   ]
+      #
+      def field_groups
+        @field_groups ||= {}
+      end
+
       # Sets or retrieves the unique identifier field for the class.
       #
       # This method defines or returns the field or method that contains the unique
@@ -98,21 +179,21 @@ module Familia
       #
       def field(name, as: name, fast_method: :"#{name}!", on_conflict: :raise, category: nil)
         # Use field type system for consistency
-        require_relative '../../field_type'
+        require_relative '../field_type'
 
         # Create appropriate field type based on category
         field_type = if category == :transient
-                       require_relative '../../features/transient_fields/transient_field_type'
-                       TransientFieldType.new(name, as: as, fast_method: false, on_conflict: on_conflict)
-                     else
-                       # For regular fields and other categories, create custom field type with category override
-                       custom_field_type = Class.new(FieldType) do
-                         define_method :category do
-                           category || :field
-                         end
-                       end
-                       custom_field_type.new(name, as: as, fast_method: fast_method, on_conflict: on_conflict)
-                     end
+          require_relative '../features/transient_fields/transient_field_type'
+          TransientFieldType.new(name, as: as, fast_method: false, on_conflict: on_conflict)
+        else
+          # For regular fields and other categories, create custom field type with category override
+          custom_field_type = Class.new(FieldType) do
+            define_method :category do
+              category || :field
+            end
+          end
+          custom_field_type.new(name, as: as, fast_method: fast_method, on_conflict: on_conflict)
+        end
 
         register_field_type(field_type)
       end
@@ -123,8 +204,8 @@ module Familia
       # @param blk [Proc] a block that returns the suffix (optional).
       # @return [String, Symbol] the current suffix or Familia.default_suffix if none is set.
       #
-      def suffix(a = nil, &blk)
-        @suffix = a || blk if a || !blk.nil?
+      def suffix(val = nil, &blk)
+        @suffix = val || blk if val || !blk.nil?
         @suffix || Familia.default_suffix
       end
 
@@ -137,8 +218,8 @@ module Familia
       # which typically occurs with anonymous classes that haven't had their prefix
       # explicitly set.
       #
-      def prefix(a = nil)
-        @prefix = a if a
+      def prefix(val = nil)
+        @prefix = val if val
         @prefix || begin
           if name.nil?
             raise Problem, 'Cannot generate prefix for anonymous class. ' \
@@ -148,9 +229,9 @@ module Familia
         end
       end
 
-      def logical_database(v = nil)
-        Familia.trace :LOGICAL_DATABASE_DEF, "instvar:#{@logical_database}", v if Familia.debug?
-        @logical_database = v unless v.nil?
+      def logical_database(num = nil)
+        Familia.trace :LOGICAL_DATABASE_DEF, "instvar:#{@logical_database}", num if Familia.debug?
+        @logical_database = num unless num.nil?
         @logical_database || parent&.logical_database
       end
 
@@ -221,6 +302,12 @@ module Familia
         # Complete the registration after installation. If we do this beforehand
         # we can run into issues where it looks like it's already installed.
         field_types[field_type.name] = field_type
+
+        # Add to current field group if one is active
+        if @current_field_group
+          @field_groups[@current_field_group] << field_type.name
+        end
+
         # Freeze the field_type to ensure immutability (maintains Data class heritage)
         field_type.freeze
       end
@@ -303,16 +390,6 @@ module Familia
         @feature_options[feature_name.to_sym]
       end
 
-      # Create and register a transient field type
-      #
-      # @param name [Symbol] The field name
-      #
-      def transient_field(name, **)
-        require_relative '../../features/transient_fields/transient_field_type'
-        field_type = TransientFieldType.new(name, **, fast_method: false)
-        register_field_type(field_type)
-      end
-
       private
 
       # Hook to detect silent overwrites and handle conflicts

data/lib/familia/horreum/{subclass/management.rb → management.rb}

@@ -1,6 +1,4 @@
-# lib/familia/horreum/subclass/management.rb
-
-require_relative 'related_fields_management'
+# lib/familia/horreum/management.rb
 
 module Familia
   class Horreum

data/lib/familia/horreum/{core/serialization.rb → persistence.rb}

@@ -1,4 +1,4 @@
-# lib/familia/horreum/serialization.rb
+# lib/familia/horreum/persistence.rb
 
 module Familia
   # Familia::Horreum
@@ -34,7 +34,7 @@ module Familia
     # Serialization - Instance-level methods for object persistence and retrieval
     # Handles conversion between Ruby objects and Valkey hash storage
     #
-    module Serialization
+    module Persistence
       # Persists the object to Valkey storage with automatic timestamping.
       #
       # Saves the current object state to Valkey storage, automatically setting
@@ -68,11 +68,18 @@ module Familia
         self.updated = Familia.now.to_i if respond_to?(:updated)
 
         # Commit our tale to the Database chronicles
-        #
+        # Wrap in transaction for atomicity between save and indexing
         ret = commit_fields(update_expiration: update_expiration)
 
-        # Add to class-level instances collection after successful save
-        self.class.instances.add(identifier, Familia.now) if ret && self.class.respond_to?(:instances)
+        # Auto-index for class-level indexes after successful save
+        # Use transaction to ensure atomicity with the save operation
+        if ret
+          transaction do |conn|
+            auto_update_class_indexes
+            # Add to class-level instances collection after successful save
+            self.class.instances.add(identifier, Familia.now) if self.class.respond_to?(:instances)
+          end
+        end
 
         Familia.ld "[save] #{self.class} #{dbkey} #{ret} (update_expiration: #{update_expiration})"
 
@@ -128,7 +135,7 @@ module Familia
         Familia.ld "[save_if_not_exists]: #{self.class} #{identifier_field}=#{identifier}"
         Familia.trace :SAVE_IF_NOT_EXISTS, nil, uri if Familia.debug?
 
-        dbclient.watch(dbkey) do
+        success = dbclient.watch(dbkey) do
           if dbclient.exists(dbkey).positive?
             dbclient.unwatch
             raise Familia::RecordExistsError, dbkey
@@ -140,6 +147,16 @@ module Familia
 
           result.is_a?(Array) # transaction succeeded
         end
+
+        # Auto-index for class-level indexes after successful save
+        # Use transaction to ensure atomicity with the save operation
+        if success
+          transaction do |conn|
+            auto_update_class_indexes
+          end
+        end
+
+        success
       end
 
       # Commits object fields to the DB storage.
@@ -361,169 +378,6 @@ module Familia
         self
       end
 
-      # Converts the object's persistent fields to a hash for external use.
-      #
-      # Serializes persistent field values for external consumption (APIs, logs),
-      # excluding non-loggable fields like encrypted fields for security.
-      # Only non-nil values are included in the resulting hash.
-      #
-      # @return [Hash] Hash with field names as keys and serialized values
-      #   safe for external exposure
-      #
-      # @example Converting an object to hash format for API response
-      #   user = User.new(name: "John", email: "john@example.com", age: 30)
-      #   user.to_h
-      #   # => {"name"=>"John", "email"=>"john@example.com", "age"=>"30"}
-      #   # encrypted fields are excluded for security
-      #
-      # @note Only loggable fields are included for security
-      # @note Only fields with non-nil values are included
-      #
-      def to_h
-        self.class.persistent_fields.each_with_object({}) do |field, hsh|
-          field_type = self.class.field_types[field]
-
-          # Security: Skip non-loggable fields (e.g., encrypted fields)
-          next unless field_type.loggable
-
-          method_name = field_type.method_name
-          val = send(method_name)
-          prepared = serialize_value(val)
-          Familia.ld " [to_h] field: #{field} val: #{val.class} prepared: #{prepared&.class || '[nil]'}"
-
-          # Only include non-nil values in the hash for Valkey
-          # Use string key for database compatibility
-          hsh[field.to_s] = prepared unless prepared.nil?
-        end
-      end
-
-      # Converts the object's persistent fields to a hash for database storage.
-      #
-      # Serializes ALL persistent field values for database storage, including
-      # encrypted fields. This is used internally by commit_fields and other
-      # persistence operations.
-      #
-      # @return [Hash] Hash with field names as keys and serialized values
-      #   ready for database storage
-      #
-      # @note Includes ALL persistent fields, including encrypted fields
-      # @note Only fields with non-nil values are included for storage efficiency
-      #
-      def to_h_for_storage
-        self.class.persistent_fields.each_with_object({}) do |field, hsh|
-          field_type = self.class.field_types[field]
-          method_name = field_type.method_name
-          val = send(method_name)
-          prepared = serialize_value(val)
-          Familia.ld " [to_h_for_storage] field: #{field} val: #{val.class} prepared: #{prepared&.class || '[nil]'}"
-
-          # Only include non-nil values in the hash for Valkey
-          # Use string key for database compatibility
-          hsh[field.to_s] = prepared unless prepared.nil?
-        end
-      end
-
-      # Converts the object's persistent fields to an array.
-      #
-      # Serializes all persistent field values in field definition order,
-      # preparing them for Valkey storage. Each value is processed through
-      # the serialization pipeline to ensure Valkey compatibility.
-      #
-      # @return [Array] Array of serialized field values in field order
-      #
-      # @example Converting an object to array format
-      #   user = User.new(name: "John", email: "john@example.com", age: 30)
-      #   user.to_a
-      #   # => ["John", "john@example.com", "30"]
-      #
-      # @note Values are serialized using the same process as other persistence
-      #   methods to maintain data consistency across operations.
-      #
-      def to_a
-        self.class.persistent_fields.filter_map do |field|
-          field_type = self.class.field_types[field]
-
-          # Security: Skip non-loggable fields (e.g., encrypted fields)
-          next unless field_type.loggable
-
-          method_name = field_type.method_name
-          val = send(method_name)
-          prepared = serialize_value(val)
-          Familia.ld " [to_a] field: #{field} method: #{method_name} val: #{val.class} prepared: #{prepared.class}"
-          prepared
-        end
-      end
-
-      # Serializes a Ruby object for Valkey storage.
-      #
-      # Converts Ruby objects into the DB-compatible string representations using
-      # the Familia distinguisher for type coercion. Falls back to JSON serialization
-      # for complex types (Hash, Array) when the primary distinguisher returns nil.
-      #
-      # The serialization process:
-      # 1. Attempts conversion using Familia.distinguisher with relaxed type checking
-      # 2. For Hash/Array types that return nil, tries custom dump_method or Familia::JsonSerializer.dump
-      # 3. Logs warnings when serialization fails completely
-      #
-      # @param val [Object] The Ruby object to serialize for Valkey storage
-      #
-      # @return [String, nil] The serialized value ready for Valkey storage, or nil
-      #   if serialization failed
-      #
-      # @example Serializing different data types
-      #   serialize_value("hello")        # => "hello"
-      #   serialize_value(42)             # => "42"
-      #   serialize_value({name: "John"}) # => '{"name":"John"}'
-      #   serialize_value([1, 2, 3])      # => "[1,2,3]"
-      #
-      # @note This method integrates with Familia's type system and supports
-      #   custom serialization methods when available on the object
-      #
-      # @see Familia.distinguisher The primary serialization mechanism
-      #
-      def serialize_value(val)
-        # Security: Handle ConcealedString safely - extract encrypted data for storage
-        return val.encrypted_value if val.respond_to?(:encrypted_value)
-
-        prepared = Familia.distinguisher(val, strict_values: false)
-
-        # If the distinguisher returns nil, try using the dump_method but only
-        # use JSON serialization for complex types that need it.
-        if prepared.nil? && (val.is_a?(Hash) || val.is_a?(Array))
-          prepared = val.respond_to?(dump_method) ? val.send(dump_method) : Familia::JsonSerializer.dump(val)
-        end
-
-        # If both the distinguisher and dump_method return nil, log an error
-        Familia.ld "[#{self.class}#serialize_value] nil returned for #{self.class}" if prepared.nil?
-
-        prepared
-      end
-
-      # Converts a Database string value back to its original Ruby type
-      #
-      # This method attempts to deserialize JSON strings back to their original
-      # Hash or Array types. Simple string values are returned as-is.
-      #
-      # @param val [String] The string value from Database to deserialize
-      # @param symbolize [Boolean] Whether to symbolize hash keys (default: true for compatibility)
-      # @return [Object] The deserialized value (Hash, Array, or original string)
-      #
-      def deserialize_value(val, symbolize: true)
-        return val if val.nil? || val == ''
-
-        # Try to parse as JSON first for complex types
-        begin
-          parsed = Familia::JsonSerializer.parse(val, symbolize_names: symbolize)
-          # Only return parsed value if it's a complex type (Hash/Array)
-          # Simple values should remain as strings
-          return parsed if parsed.is_a?(Hash) || parsed.is_a?(Array)
-        rescue Familia::SerializerError
-          # Not valid JSON, return as-is
-        end
-
-        val
-      end
-
       private
 
       # Reset all transient fields to nil
@@ -547,6 +401,55 @@ module Familia
           Familia.ld "[reset_transient_fields!] Reset #{field_name} to nil"
         end
       end
+
+      # Automatically update class-level indexes after save
+      #
+      # Iterates through class-level indexing relationships and calls their
+      # corresponding add_to_class_* methods to populate indexes. Only processes
+      # class-level indexes (where target_class == self.class), skipping
+      # instance-scoped indexes which require parent context.
+      #
+      # Uses idempotent Redis commands (HSET for unique_index) so repeated calls
+      # are safe and have negligible performance overhead. Note that multi_index
+      # always requires within: parameter, so only unique_index benefits from this.
+      #
+      # @return [void]
+      #
+      # @example Automatic indexing on save
+      #   class Customer < Familia::Horreum
+      #     feature :relationships
+      #     unique_index :email, :email_lookup
+      #   end
+      #
+      #   customer = Customer.new(email: 'test@example.com')
+      #   customer.save  # Automatically calls add_to_class_email_lookup
+      #
+      # @note Only class-level unique_index declarations auto-populate.
+      #   Instance-scoped indexes (with within:) require manual population:
+      #   employee.add_to_company_badge_index(company)
+      #
+      # @see Familia::Features::Relationships::Indexing For index declaration details
+      #
+      def auto_update_class_indexes
+        return unless self.class.respond_to?(:indexing_relationships)
+
+        self.class.indexing_relationships.each do |rel|
+          # Skip instance-scoped indexes (require parent context)
+          # Instance-scoped indexes must be manually populated because they need
+          # the parent object reference (e.g., employee.add_to_company_badge_index(company))
+          unless rel.target_class == self.class
+            Familia.ld <<~LOG_MESSAGE
+              [auto_update_class_indexes] Skipping #{rel.index_name} (requires parent context)
+            LOG_MESSAGE
+            next
+          end
+
+          # Call the existing add_to_class_* methods
+          add_method = :"add_to_class_#{rel.index_name}"
+          send(add_method) if respond_to?(add_method)
+        end
+      end
+
     end
   end
 end

data/lib/familia/horreum/{subclass/related_fields_management.rb → related_fields.rb}

@@ -1,4 +1,4 @@
-# lib/familia/horreum/related_fields_management.rb
+# lib/familia/horreum/related_fields.rb
 
 module Familia
 
@@ -170,7 +170,27 @@ module Familia
 
         related_fields[name] = RelatedFieldDefinition.new(name, klass, opts)
 
-        attr_reader name
+        # Create lazy-initializing accessor that calls initialize_relatives if needed
+        define_method name do
+          ivar = :"@#{name}"
+          value = instance_variable_get(ivar)
+
+          # If nil and we haven't initialized relatives, do it now
+          # Check singleton class to avoid polluting instance variables
+          if value.nil? && !singleton_class.instance_variable_defined?(:"@relatives_initialized")
+            initialize_relatives
+            value = instance_variable_get(ivar)
+          end
+
+          # If still nil after lazy initialization attempt, raise helpful error
+          # Only raise if we tried to initialize but it's still nil
+          if value.nil? && singleton_class.instance_variable_defined?(:"@relatives_initialized")
+            raise "#{self.class}##{name} is nil. Did you override initialize without calling super? " \
+                  "(Field is nil after initialization attempt)"
+          end
+
+          value
+        end
 
         define_method :"#{name}=" do |val|
           send(name).replace val