persistence 0.0.1.alpha → 0.0.1

data/lib/persistence/object/complex/attributes/attributes_array.rb

@@ -0,0 +1,32 @@
+
+###
+# Module used for common methods for attributes arrays.
+#
+module ::Persistence::Object::Complex::Attributes::AttributesArray
+  
+  #####################
+  #  has_attributes?  #
+  #####################
+  
+  ###
+  # Query whether this array includes attribute(s).
+  #
+  # @overload has_attributes?( attribute_name, ... )
+  #
+  #     @param attribute_name [Symbol,String] Attribute to query.
+  #
+  # @return [true,false] Whether this hash/array includes attribute(s).
+  #
+  def has_attributes?( *attributes )
+    
+    has_attributes = false
+    
+    attributes.each do |this_attribute|
+      break unless has_attributes = include?( this_attribute )
+    end
+  
+    return has_attributes
+    
+  end
+  
+end

data/lib/persistence/object/complex/attributes/attributes_hash.rb

@@ -0,0 +1,187 @@
+
+###
+# Module used for common methods for attributes hashes.
+#
+module ::Persistence::Object::Complex::Attributes::AttributesHash
+
+  include ::AccessorUtilities::AccessorMath
+  
+  ##################
+  #  pre_set_hook  #
+  ##################
+  
+  def pre_set_hook( key, value )
+    
+    case value
+      when nil, :reader, :writer, :accessor
+      else
+        raise ArgumentError, 'Permitted values: :reader, :writer, :accessor.'
+    end
+    
+    return value
+    
+  end
+  
+  ###################
+  #  post_set_hook  #
+  ###################
+
+  def post_set_hook( key, value )
+    
+    # create method in configuration_instance
+    
+  end
+
+  #########
+  #  add  #
+  #########
+  
+  ###
+  # Adds :reader, :writer or :accessor to key.
+  #
+  def add( key, reader_writer_accessor )
+    
+    # figure out actual addition value
+    existing_status = self[ key ]
+    
+    if actual_status = status_minus_other_status( reader_writer_accessor, existing_status )
+    
+      # if we have an addition value, do so directly      
+      new_status = status_plus_other_status( existing_status, actual_status )
+
+      store_without_hooks( key, new_status )
+
+      # update corresponding structures for addition
+      unless @without_hooks
+        update_for_addition( key, actual_status )
+      end
+      
+    end
+    
+    return new_status
+          
+  end
+
+  #######################
+  #  add_without_hooks  #
+  #######################
+  
+  ###
+  # @private
+  #
+  # Adds :reader, :writer or :accessor to key.
+  #   Used to prevent loops when array/hash relays to other arrays/hashes.
+  #
+  def add_without_hooks( key, reader_writer_accessor )
+    
+    @without_hooks = true
+    
+    add( key, reader_writer_accessor )
+    
+    @without_hooks = false
+    
+  end
+
+  ##############
+  #  subtract  #
+  ##############
+  
+  ###
+  # Subtracts :reader, :writer or :accessor to key.
+  #
+  def subtract( key, reader_writer_accessor )
+    
+    # figure out actual subtraction value
+    existing_status = self[ key ]
+    
+    result_value = status_minus_other_status( existing_status, reader_writer_accessor )
+
+    if actual_status = status_minus_other_status( reader_writer_accessor, result_value )
+    
+      # if we have an actual value we are subtracting, do so directly (no hooks)
+      if new_status = status_minus_other_status( existing_status, actual_status )
+        store_without_hooks( key, new_status )
+      elsif existing_status
+        delete( key )
+      end
+      
+      # update corresponding structures for subtraction (pass actually-subtracted value)
+      unless @without_hooks
+        update_for_subtraction( key, actual_status )
+      end
+      
+    end
+    
+    return result_value
+          
+  end
+
+  ############################
+  #  subtract_without_hooks  #
+  ############################
+  
+  ###
+  # @private
+  #
+  # Subtracts :reader, :writer or :accessor from key.
+  #   Used to prevent loops when array/hash relays to other arrays/hashes.
+  #
+  def subtract_without_hooks( key, reader_writer_accessor )
+
+    @without_hooks = true
+    
+    subtract( key, reader_writer_accessor )
+    
+    @without_hooks = false
+
+  end
+
+  ############
+  #  delete  #
+  ############
+  
+  ###
+  # Deletes attribute and updates corresponding hashes/arrays.
+  #
+  # @param attribute Attribute to delete.
+  #
+  # @return [:reader,:writer,:accessor,nil] Setting removed.
+  #
+  def delete( attribute )
+    
+    deleted_reader_writer_accessor_setting = super( attribute )
+    
+    unless @without_hooks
+      update_for_subtraction( attribute, :accessor )
+    end
+    
+    return deleted_reader_writer_accessor_setting
+    
+  end
+
+  #####################
+  #  has_attributes?  #
+  #####################
+  
+  ###
+  # Query whether this hash includes attribute(s).
+  #
+  # @overload has_attributes?( attribute_name, ... )
+  #
+  #     @param attribute_name [Symbol,String] Attribute to query.
+  #
+  # @return [true,false] Whether this hash/array includes attribute(s).
+  #
+  def has_attributes?( *attributes )
+    
+    has_attributes = false
+    
+    attributes.each do |this_attribute|
+      break unless has_attributes = has_key?( this_attribute )
+    end
+  
+    return has_attributes
+    
+  end
+  
+end

data/lib/persistence/object/complex/attributes/default_atomic_non_atomic.rb

@@ -0,0 +1,102 @@
+
+###
+# Module used for common methods for persistent attributes hash and arrays.
+#
+module ::Persistence::Object::Complex::Attributes::DefaultAtomicNonAtomic
+    
+  #####################
+  #  default_atomic?  #
+  #####################
+  
+  ###
+  # Query whether attributes default to be atomic.
+  #
+  # @return [true,false] Whether default is atomic.
+  #
+  def default_atomic?
+
+    return @default_atomic
+
+  end
+
+  #########################
+  #  default_non_atomic?  #
+  #########################
+
+  ###
+  # Query whether attributes default to be non-atomic.
+  #
+  # @return [true,false] Whether default is non-atomic.
+  #
+  def default_non_atomic?
+
+    return ! @default_atomic
+
+  end
+
+  #####################
+  #  default_atomic!  #
+  #####################
+
+  ###
+  # Set attributes to default atomic.
+  #
+  def default_atomic!
+    
+    @default_atomic = true
+    
+  end
+
+  ###################################
+  #  default_atomic_without_hooks!  #
+  ###################################
+
+  ###
+  # @private
+  #
+  # Set attributes to default atomic. 
+  #   Used to prevent loops when array/hash relays to other arrays/hashes.
+  #
+  def default_atomic_without_hooks!
+
+    @without_hooks = true
+
+    default_atomic!
+
+    @without_hooks = false
+
+  end
+
+  #########################
+  #  default_non_atomic!  #
+  #########################
+
+  ###
+  # Set attributes to default non-atomic.
+  #
+  def default_non_atomic!
+
+    @default_atomic = false
+
+  end
+
+  #######################################
+  #  default_non_atomic_without_hooks!  #
+  #######################################
+
+  ###
+  # @private
+  #
+  # Set attributes to default non-atomic. Used to prevent loops when array/hash relays to other arrays/hashes.
+  #
+  def default_non_atomic_without_hooks!
+
+    @without_hooks = true
+
+    default_non_atomic!
+
+    @without_hooks = false
+
+  end
+    
+end

data/lib/persistence/object/complex/attributes/hash_to_port.rb

@@ -0,0 +1,40 @@
+
+###
+# @private
+#
+# Hash subclass used for encapsulating common process of translation from Ruby key/value to storage key/value.
+#
+class ::Persistence::Object::Complex::Attributes::HashToPort < ::Hash
+
+  attr_accessor :persistence_object
+
+  #########
+  #  []=  #
+  #########
+  
+  ###
+  #
+  # @private
+  #
+  # Automatically convert key/value to primary key/storage value. 
+  #
+  def []=( key, value )
+
+    primary_key = nil
+    attribute_value_to_port = nil
+    
+    # if we don't have a persistence port we want to compare objects by their properties
+    if persistence_object.persistence_port
+      attribute_key_to_port   = persistence_object.persist_as_sub_object_or_attribute_and_return_id_or_value( key )
+      primary_key             = persistence_object.persistence_bucket.primary_key_for_attribute_name( persistence_object, attribute_key_to_port )
+      attribute_value_to_port = persistence_object.persist_as_sub_object_or_attribute_and_return_id_or_value( value )
+    else
+      primary_key             = key
+      attribute_value_to_port = value
+    end
+    
+    super( primary_key, attribute_value_to_port )
+
+  end
+  
+end

data/lib/persistence/object/complex/class_and_object_instance.rb

@@ -0,0 +1,132 @@
+
+###
+# Methods applied to both Class and Object instances of complex objects enabled with persistence capabilities.
+#
+module ::Persistence::Object::Complex::ClassAndObjectInstance
+
+  include ::CascadingConfiguration::Hash
+
+  ##########################
+  #  attr_delete_cascades  #
+  ##########################
+  
+  ###
+  #
+  # @private
+  #
+  # @method delete_cascades
+  #
+  # @return [CompositingHash{Symbol,String=>true,false}] Hash containing cascading delete data for attributes.
+  #
+  attr_configuration_hash :delete_cascades
+  
+  ###
+  # Declare that deleting object should also delete attribute(s).
+  #
+  # @overload attr_delete_cascades( attribute_name, ... )
+  #
+  #   @param attribute_name Attribute(s) in question.
+  #
+  # @return self
+  #
+  def attr_delete_cascades( *attributes )
+    
+    attributes.each do |this_attribute|
+      delete_cascades[ this_attribute.accessor_name ] = true
+    end
+    
+    return self
+    
+  end
+
+  ##################################
+  #  attr_delete_does_not_cascade  #
+  ##################################
+
+  ###
+  # Declare that deleting object should not delete attribute(s).
+  #
+  # @overload attr_delete_cascades( attribute_name, ... )
+  #
+  #   @param attribute_name Attribute(s) in question.
+  #
+  # @return self
+  #
+  def attr_delete_does_not_cascade( *attributes )
+    
+    attributes.each do |this_attribute|
+      delete_cascades[ this_attribute.accessor_name ] = false
+    end
+    
+    return self
+    
+  end
+
+  ###########################
+  #  attr_delete_cascades!  #
+  ###########################
+
+  ###
+  # Declare that deleting object should also delete declared attributes.
+  #
+  # @return self
+  #
+  def attr_delete_cascades!
+
+    return attr_delete_cascades( *persistent_attributes.keys )
+
+  end
+
+
+  ###################################
+  #  attr_delete_does_not_cascade!  #
+  ###################################
+
+  ###
+  # Declare that deleting object should not delete declared attributes.
+  #
+  # @return self
+  #
+  def attr_delete_does_not_cascade!
+
+    return attr_delete_does_not_cascade( *persistent_attributes.keys )
+
+  end
+
+  ######################
+  #  delete_cascades?  #
+  ######################
+  
+  ###
+  # Query whether deleting object will also delete attribute
+  #
+  # @param attribute_name Attribute in question.
+  #
+  # @return [true,false] Whether deleting object will cascade to delete object at attribute.
+  #
+  def delete_cascades?( attribute_name )
+
+    should_cascade = false
+
+    accessor_name = attribute_name.accessor_name
+
+    # delete_cascades is a cascading array that automatically handles inheritance
+    if ( should_cascade = delete_cascades[ accessor_name ] ) == nil
+
+      if attribute_value = persistence_port.get_attribute( self, accessor_name ) and
+         attribute_value.is_a?( ::Persistence::Object::Complex::ComplexObject )
+
+        should_cascade = attribute_value.delete_cascades?
+
+      end
+
+      should_cascade = true if should_cascade.nil?
+      delete_cascades[ accessor_name ] = should_cascade
+
+    end
+
+    return should_cascade
+
+  end
+
+end