persistence 0.0.1.alpha → 0.0.1

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

@@ -0,0 +1,267 @@
+
+###
+# Methods applied to Class instances of complex objects enabled with persistence capabilities.
+#
+module ::Persistence::Object::Complex::ClassInstance
+
+  include ::Persistence::Object::Complex::Attributes
+  
+  include ::Persistence::Object::Complex::ClassAndObjectInstance
+  
+  include ::CascadingConfiguration::Array::Unique
+  
+  ################
+  #  attr_index  #
+  ################
+
+  ###
+  # Declare an index on attribute(s).
+  #
+  # @overload attr_index( attribute_name, ... )
+  #
+  #   @param attribute_name Name of object property to index. Creates accessor if method by name 
+  #     does not already exist.
+  #
+  # @return self
+  #
+  def attr_index( *attributes )
+
+   parent_bucket = instance_persistence_bucket
+
+   attributes.each do |this_attribute|
+     index_instance = ::Persistence::Object::Complex::Index::AttributeIndex.new( this_attribute, parent_bucket, false )
+     index_instance.attribute_name = this_attribute
+     indexes[ this_attribute ] = attribute_indexes[ this_attribute ] = index_instance
+   end
+
+   return self
+
+  end
+
+  ########################
+  #  attr_index_ordered  #
+  ########################
+
+  ###
+  # Declare an ordered index on attribute(s). PENDING.
+  #
+  # @overload attr_index( attribute_name, ... )
+  #
+  #   @param attribute_name Name of object property to index. Creates accessor if method by name 
+  #     does not already exist.
+  #
+  # @return self
+  #
+  def attr_index_ordered( attributes, & ordering_block )
+ 
+   raise 'pending'
+ 
+   parent_bucket = instance_persistence_bucket
+
+   attributes.each do |this_attribute|
+     index_instance = ::Persistence::Object::Complex::Index::AttributeIndex.new( this_attribute, 
+                                                                                 parent_bucket,
+                                                                                 true,
+                                                                                 ordering_block )
+     index_instance.attribute_name = this_attribute
+     indexes[ this_attribute ] = attribute_indexes[ this_attribute ] = index_instance
+   end
+
+   return self
+
+  end
+
+  ################################
+  #  attr_index_with_duplicates  #
+  ################################
+
+  ###
+  # Declare an index permitting duplicates on attribute(s).
+  #
+  # @overload attr_index_with_duplicates( attribute_name, ... )
+  #
+  #   @param attribute_name Name of object property to index. Creates accessor if method by name 
+  #     does not already exist.
+  #
+  # @return self
+  #
+  def attr_index_with_duplicates( attribute )
+
+   index_instance = ::Persistence::Object::Complex::Index::AttributeIndex.new( attribute, 
+                                                                               instance_persistence_bucket, 
+                                                                               true )
+   index_instance.attribute_name = attribute
+   indexes[ attribute ] = attribute_indexes[ attribute ] = index_instance
+
+   return self
+
+  end
+
+  ########################################
+  #  attr_index_ordered_with_duplicates  #
+  ########################################
+
+  ###
+  # Declare an ordered index permitting duplicates on attribute(s). PENDING.
+  #
+  # @overload attr_index_ordered_with_duplicates( attribute_name, ... )
+  #
+  #   @param attribute_name Name of object property to index. Creates accessor if method by name 
+  #     does not already exist.
+  #
+  # @return self
+  #
+  def attr_index_ordered_with_duplicates( attribute, duplicates_ordering_proc = nil, & ordering_block )
+
+    raise 'pending'
+
+    index_instance = ::Persistence::Object::Complex::Index::AttributeIndex.new( attribute, 
+                                                                                parent_bucket,
+                                                                                true,
+                                                                                ordering_block,
+                                                                                duplicates_ordering_proc )
+    index_instance.attribute_name = attribute
+    indexes[ attribute ] = attribute_indexes[ attribute ] = index_instance
+
+    return self
+
+  end
+
+  ##########################
+  #  has_attribute_index?  #
+  ##########################
+  
+  ###
+  # Query whether attribute index(es) exist for object.
+  #
+  # @overload has_attribute_index?( index_name, ... )
+  #
+  #   @param index_name Name of requested index.
+  #
+  # @return [true,false] Whether index(es) exist.
+  #
+  def has_attribute_index?( *attributes )
+  
+    has_index = false
+  
+    attributes.each do |this_attribute|
+      break unless has_index = attribute_indexes.has_key?( this_attribute.accessor_name )
+    end
+  
+    return has_index
+  
+  end
+
+  ############
+  #  cease!  #
+  ############
+
+  def cease!( *args )
+
+    if persistence_hash_in_port = super
+
+      persistence_hash_in_port.each do |this_attribute, this_value|
+
+        if this_value.is_a?( ::Persistence::Object::Complex::ComplexObject ) and 
+           delete_cascades?( global_id, this_value.persistence_id )
+
+          this_value.cease!
+
+        end
+
+      end
+
+    end
+    
+    return persistence_hash_in_port
+    
+  end
+  
+  ###############
+  #  attr_flat  #
+  ###############
+
+  ###
+  # Declare that an attribute should be treated as a flat object by persistence port, regardless whether it
+  #   actually is a flat object.
+  #
+  # @overload attr_flat( attribute_name, ... )
+  #   
+  #   @param attribute_name Name of attribute to treat as flat object.
+  #
+  # @return self
+  #
+  def attr_flat( *attributes )
+
+    if attributes.empty?
+      persists_flat[ nil ] = true
+    else
+      attributes.each do |this_attribute|
+        persists_flat.push( this_attribute )
+      end
+    end
+    
+    return self
+    
+  end
+
+  ################
+  #  attr_flat!  #
+  ################
+
+  ###
+  # Declare {self#attr_flat} on all attributes.
+  # 
+  # @return self
+  #
+  def attr_flat!
+    
+    attr_flat( *persistent_attribute_writers )
+
+    return self
+    
+  end
+
+  ####################
+  #  persists_flat?  #
+  ####################
+
+  ###
+  # Query whether attribute(s) are being treated explicitly as flat objects.
+  #
+  # @overload has_attribute_index?( attribute_name, ... )
+  #
+  #   @param attribute_name Attribute(s) in question.
+  #
+  # @return [true,false] Whether attributes(es) are being treated explicitly as flat objects.
+  #
+  def persists_flat?( *attributes )
+
+    should_persist_flat = false
+
+    if attributes.empty?
+      should_persist_flat = persists_flat.include?( nil )
+    else
+      attributes.each do |this_attribute|
+        break unless should_persist_flat = persists_flat.include?( this_attribute )
+      end
+    end
+    
+    return should_persist_flat
+    
+  end
+
+  ###################
+  #  persists_flat  #
+  ###################
+
+  ###
+  # @method persists_flat
+  #
+  # Hash that tracks attributes specified to persist as if they are flat objects.
+  #
+  # @return [CompositingHash{Symbol,String=>true}] Hash with attribute details.
+  #
+  attr_unique_array :persists_flat
+
+end

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

@@ -0,0 +1,111 @@
+
+###
+# Class used for persisting references to other complex objects nested inside a complex object.
+# 
+class ::Persistence::Object::Complex::ComplexObject < ::String
+
+  include CascadingConfiguration::Setting
+  
+  ################
+  #  initialize  #
+  ################
+
+  ###
+  #
+  # @param object Object for which ComplexObject instance is used.
+  #
+  def initialize( object )
+    
+    super( object.persistence_id.to_s )
+    
+    self.persistence_port = object.persistence_port
+    self.persistence_bucket = object.persistence_bucket
+  
+  end
+
+  #####################
+  #  delete_cascades  #
+  #####################
+  
+  ###
+  # @!attribute [writer] Whether this object should be deleted when its parent is deleted.
+  #
+  attr_writer :delete_cascades
+
+  #############
+  #  persist  #
+  #############
+  
+  ###
+  # Store object to persistence bucket.
+  #
+  def persist
+    
+    global_id = persistence_id
+    klass = persistence_port.get_class_for_object_id( global_id )
+    
+    return klass.persist( global_id )
+    
+  end
+
+  ####################
+  #  persistence_id  #
+  ####################
+  
+  ###
+  # Get persistence ID.
+  #
+  def persistence_id
+
+    return to_i
+
+  end
+
+  ######################
+  #  persistence_port  #
+  ######################
+  
+  ###
+  # @method persistence_port
+  # 
+  # Get object's persistence port.
+  #
+  attr_instance_setting :persistence_port
+  
+  ########################
+  #  persistence_bucket  #
+  ########################
+  
+  attr_instance_setting :persistence_bucket
+  
+  ###
+  # Get object's persistence bucket.
+  #
+  def persistence_bucket
+    
+    unless return_bucket = super
+      return_bucket = persistence_port.get_bucket_name_for_object_id( persistence_id )
+      self.persistence_bucket = return_bucket
+    end
+    
+    return return_bucket
+    
+  end
+  
+  ######################
+  #  delete_cascades?  #
+  ######################
+  
+  ###
+  # Query whether object should be deleted when parent object is deleted.
+  #
+  # @return [true,false] Whether object delete should cascade.
+  #
+  def delete_cascades?
+
+    return @delete_cascades
+
+  end
+
+end
+

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

@@ -0,0 +1,14 @@
+
+###
+# Convenience module for extending hash types (singletons and instances) with persistence capabilities.
+#
+module ::Persistence::Object::Complex::Hash
+
+  extend ModuleCluster::Define::ClusterCascades
+  
+  include ::Persistence::Object::Complex
+  
+  include ::Persistence::Object::Complex::Hash::ObjectInstance
+  include_or_extend_cascades_prepend_extends ::Persistence::Object::Complex::Hash::ClassInstance
+
+end

data/lib/persistence/object/complex/hash/class_instance.rb

@@ -0,0 +1,40 @@
+
+###
+# Class methods for hash objects enabled with persistence capabilities.
+#
+module ::Persistence::Object::Complex::Hash::ClassInstance
+
+  #############
+  #  persist  #
+  #############
+  
+  def persist( *args )
+    
+    index, key, no_key = parse_args_for_index_value_no_value( args, true )
+    
+    if index
+      global_id = index.get_object_id( key )
+    else
+      global_id = key
+    end
+    
+    object = new
+    
+    object.persistence_id = global_id
+
+    hash_from_port = instance_persistence_bucket.get_object_hash( global_id )
+
+    hash_from_port.each do |this_key, this_value|
+      if this_value.is_a?( ::Persistence::Object::Complex::ComplexObject )
+        this_value = this_value.persist
+        object[ this_key ] = this_value
+      else
+        object[ this_key ] = this_value
+      end
+    end
+    
+    return object
+    
+  end
+  
+end

data/lib/persistence/object/complex/hash/object_instance.rb

@@ -0,0 +1,63 @@
+
+###
+# Instance methods for hash objects enabled with persistence capabilities.
+#
+module ::Persistence::Object::Complex::Hash::ObjectInstance
+    
+  #############
+  #  persist  #
+  #############
+  
+  def persist( *args )
+    
+    index, key, no_key = parse_args_for_index_value_no_value( args, true )
+    
+    if index
+      global_id = index.get_object_id( key )
+    elsif key
+      global_id = key
+    else
+      global_id = persistence_id
+    end
+    
+    port_hash = persistence_bucket.adapter_bucket.get_object( global_id )
+
+    port_hash.each do |this_key, this_value|
+      if this_value.is_a?( ::Persistence::Object::Complex::ComplexObject )
+        self[ this_key ] = this_value.persist
+      else
+        self[ this_key ] = this_value
+      end
+    end
+    
+    return self
+    
+  end
+
+  ##############################
+  #  persistence_hash_to_port  #
+  ##############################
+
+  def persistence_hash_to_port
+
+    hash_to_port = ::Persistence::Object::Complex::Attributes::HashToPort.new
+    hash_to_port.persistence_object = self
+    
+    self.each do |key, data|
+      key = persist_as_sub_object_or_attribute_and_return_id_or_value( key )
+      hash_to_port[ key ] = data
+    end
+
+    return hash_to_port
+    
+  end
+
+  ############################
+  #  load_persistence_value  #
+  ############################
+  
+  def load_persistence_value( attribute_name, attribute_value )
+    self[ attribute_name ] = attribute_value
+  end
+  
+end