persistence 0.0.1.alpha → 0.0.1

data/lib/requires.rb

@@ -0,0 +1,146 @@
+
+basepath = 'persistence'
+
+files = [ ]
+
+# Abstract Adapter
+files.concat [
+  
+  'adapter/abstract',
+  'adapter/abstract/enable_disable',
+  'adapter/abstract/primary_key/id_property_string',
+  'adapter/abstract/primary_key/simple'
+  
+]
+
+# Mock Adapter
+files.concat [
+  
+  'adapter/mock/bucket/index/index_interface',
+  'adapter/mock/bucket/index',
+  'adapter/mock/bucket/bucket_interface',
+  'adapter/mock/bucket',
+  'adapter/mock/cursor/cursor_interface',
+  'adapter/mock/cursor',
+  'adapter/mock/adapter_interface',
+  'adapter/mock'
+  
+]
+
+# Object
+files.concat [
+
+  'object/parse_persistence_args',
+
+  'object/index',
+  
+  'object/index_hash',
+
+  'object/index/block_index/block_index_interface',
+  'object/index/block_index',
+  'object/index/explicit_index/explicit_index_interface',
+  'object/index/explicit_index',
+
+  'object/flat/file/file_persistence',
+  
+  'object/flat/file/contents',
+  'object/flat/file/path',
+  
+  'object/flat/file/class_instance',
+  'object/flat/file/object_instance',
+  
+  'object/class_instance',
+  'object/object_instance',
+
+  'object/flat/class_instance',
+  'object/flat/object_instance',
+
+  'object/complex/attributes/attributes_array',
+  'object/complex/attributes/attributes_hash',
+  'object/complex/attributes/default_atomic_non_atomic',
+  'object/complex/attributes/hash_to_port',
+  'object/complex/attributes',
+
+  'object/complex/complex_object',
+
+  'object/complex/class_and_object_instance',
+  'object/complex/class_instance',
+  'object/complex/object_instance',
+
+  'object/complex/array/class_instance',
+  'object/complex/array/object_instance',
+
+  'object/complex/hash/class_instance',
+  'object/complex/hash/object_instance',
+  
+  'object/complex',
+  'object/complex/array',
+  'object/complex/hash',
+
+  'object/flat',
+  'object/flat/file',
+
+  'object/autodetermine',
+  'object',
+
+]
+
+# Port
+files.concat [
+
+  'port/controller',
+
+  'port/port_interface',
+
+  'port/bucket/bucket_interface',
+  'port/bucket',
+
+  'port'
+
+]
+
+# Cursor
+files.concat [
+
+  'cursor/cursor_interface',
+  'cursor/atomic',
+
+  'cursor'
+
+]
+
+# Complex Index
+files.concat [
+
+  'object/complex/index/attribute_index/attribute_index_interface',
+  'object/complex/index/attribute_index'
+
+]
+
+# Port Index
+files.concat [
+
+  'port/bucket/bucket_index'
+
+]
+
+# Exceptions
+files.concat [
+  
+  'exception/block_required',
+  'exception/conflicting_index_already_declared',
+  'exception/duplicate_violates_unique_index',
+  'exception/indexing_block_failed_to_generate_keys',
+  'exception/indexing_object_requires_keys',
+  
+  'exception/no_port_enabled',
+  'exception/explicit_index_required',
+  'exception/key_value_required'
+  
+]
+
+files.each do |this_file|
+  require_relative( File.join( basepath, this_file ) + '.rb' )
+end
+
+require_relative( basepath + '.rb' )

data/spec/Integration_spec.rb

@@ -0,0 +1,53 @@
+
+require_relative '../lib/persistence.rb'
+
+require 'date'
+
+require_relative 'persistence/adapter/mock_helpers.rb'
+
+# FIX - Date needs to be treated as a string in and out
+
+describe ::Persistence do
+
+  it 'can create some objects with sub-objects and get them back' do
+    
+    ::Persistence.enable_port( :mock, ::Persistence::Adapter::Mock.new )
+
+    user = ::Persistence::Adapter::Abstract::Mock::User.new.persist!
+    user.populate
+    
+    user.persistence_bucket.should == ::Persistence::Adapter::Abstract::Mock::User.instance_persistence_bucket
+    user.persistence_bucket.name.should == ::Persistence::Adapter::Abstract::Mock::User.to_s.to_sym
+    
+    user.address.persistence_bucket.should == ::Persistence::Adapter::Abstract::Mock::User::Address.instance_persistence_bucket
+    user.address.persistence_bucket.name.should == ::Persistence::Adapter::Abstract::Mock::User::Address.to_s.to_sym
+    
+    user.alternate_address.persistence_bucket.should == ::Persistence::Adapter::Abstract::Mock::User::Address.instance_persistence_bucket
+    user.alternate_address.persistence_bucket.name.should == ::Persistence::Adapter::Abstract::Mock::User::Address.to_s.to_sym
+    
+    user.notes.persistence_bucket.should == ::Persistence::Adapter::Abstract::Mock::NotesArray.instance_persistence_bucket
+    user.notes.persistence_bucket.name.should == ::Persistence::Adapter::Abstract::Mock::NotesArray.to_s.to_sym
+    
+    user.dictionary.persistence_bucket.should == ::Persistence::Adapter::Abstract::Mock::DictionaryHash.instance_persistence_bucket
+    user.dictionary.persistence_bucket.name.should == ::Persistence::Adapter::Abstract::Mock::DictionaryHash.to_s.to_sym
+    
+    user.notes[0].persistence_bucket.should == ::Persistence::Adapter::Abstract::Mock::Note.instance_persistence_bucket
+    user.notes[0].persistence_bucket.name.should == ::Persistence::Adapter::Abstract::Mock::Note.to_s.to_sym
+    
+    notes_array = ::Persistence::Adapter::Abstract::Mock::NotesArray.persist( user.notes.persistence_id )
+    notes_array.should == user.notes
+    
+    dictionary_hash = ::Persistence::Adapter::Abstract::Mock::DictionaryHash.persist( user.dictionary.persistence_id )
+    dictionary_hash.should == user.dictionary
+    
+    persisted_user = ::Persistence::Adapter::Abstract::Mock::User.persist( user.persistence_id )
+    persisted_user.class.should == ::Persistence::Adapter::Abstract::Mock::User
+    
+    persisted_user.should == user
+    
+    ::Persistence.disable_port( :mock )
+    
+  end
+
+end
+

data/spec/Persistence_spec.rb

@@ -0,0 +1,175 @@
+
+require_relative '../lib/persistence.rb'
+
+describe ::Persistence do
+  
+  before :all do
+    ::Persistence.enable_port( :mock, ::Persistence::Adapter::Mock.new )
+  end
+
+  after :all do
+    ::Persistence.disable_port( :mock )
+  end
+
+  it "can persist an object to and from a default bucket with an arbitrary key method" do
+    class ::Persistence::MockUserObject3
+      include ::Persistence
+      attr_accessor :username, :firstname, :lastname
+      attr_index    :username
+    end
+    user = ::Persistence::MockUserObject3.new
+    user.username   = 'user'
+    user.firstname = 'first'
+    user.lastname  = 'last'
+    user.persist!
+    ::Persistence::MockUserObject3.persist( :username => 'user' ).should == user
+  end
+
+  it "can persist an object to and from a default bucket with an arbitrary key variable" do
+    class ::Persistence::MockUserObject4
+      include ::Persistence
+      attr_accessor :username, :firstname, :lastname
+      attr_index  :username
+    end
+    user = ::Persistence::MockUserObject4.new
+    user.username   = 'user'
+    user.firstname = 'first'
+    user.lastname  = 'last'
+    user.persist!
+    ::Persistence::MockUserObject4.persist( :username => 'user' ).should == user
+  end
+  
+  it "can persist an object with other objects as members" do
+    class ::Persistence::MockUserObject5
+      include ::Persistence
+      attr_accessor :username, :firstname, :lastname, :address, :alternate_address
+      attr_index  :username
+    end
+    class ::Persistence::MockAddress1
+      include ::Persistence
+      attr_accessor :number, :street, :city, :state, :zipcode
+    end
+  
+    user = ::Persistence::MockUserObject5.new
+    user.username   = 'user'
+    user.firstname = 'first'
+    user.lastname  = 'last'
+  
+    user.address = ::Persistence::MockAddress1.new
+    user.address.number = 42
+    user.address.street = 'Street'
+    user.address.city = 'Some City'
+    user.address.state = 'GA'
+    user.address.zipcode = '30003'
+  
+    user.alternate_address = ::Persistence::MockAddress1.new
+    user.alternate_address.number = 37
+    user.alternate_address.street = 'Another Street'
+    user.alternate_address.city = 'Some Other City'
+    user.alternate_address.state = 'TX'
+    user.alternate_address.zipcode = '70004'
+    user.persist!
+  
+    # here we should be looking for:
+    # * username            => 'user' => looks for 'user' with bucket (should find it and replace it)
+    # * address             => should get ID from existing user if user exists => needs to check if existing user address is same ID
+    # * alternate_ddress    => should also get ID from existing user if user exists => needs to check if existing alternate address is same ID
+  
+    ::Persistence::MockUserObject5.persist( :username => 'user' ).should == user
+  
+    user.alternate_address.number = 48
+  
+    user.alternate_address.persist!
+  
+    ::Persistence::MockUserObject5.persist( :username => 'user' ).should == user
+  
+  end
+  
+  it "can persist an object with other objects as members that have atomic properties" do
+    class ::Persistence::MockUserObject6
+      include ::Persistence
+      attr_accessor :username, :firstname, :lastname, :address, :alternate_address
+      attr_index  :username
+    end
+    class ::Persistence::MockAddress1
+      include ::Persistence
+      attr_accessor :number, :street, :city, :state, :zipcode
+      attr_atomic_accessor :number
+      attrs_atomic!
+    end
+    
+    ::Persistence::MockAddress1.atomic_attribute?( :number ).should == true
+  
+    user = ::Persistence::MockUserObject6.new
+    user.username   = 'user'
+    user.firstname = 'first'
+    user.lastname  = 'last'
+  
+    user.persist!
+  
+    user.address = ::Persistence::MockAddress1.new
+    user.address.number = 42
+    user.address.street = 'Street'
+    user.address.city = 'Some City'
+    user.address.state = 'GA'
+    user.address.zipcode = '30003'
+  
+    user.alternate_address = ::Persistence::MockAddress1.new
+    user.alternate_address.number = 37
+    user.alternate_address.street = 'Another Street'
+    user.alternate_address.city = 'Some Other City'
+    user.alternate_address.state = 'TX'
+    user.alternate_address.zipcode = '70004'
+  
+    persisted_user = ::Persistence::MockUserObject6.persist( :username => 'user' )
+    persisted_user.should == user
+  
+    user.alternate_address.number = 48
+  
+    ::Persistence::MockUserObject6.persist( :username => 'user' ).should == user
+  
+  end
+  
+  it "can persist an object with hash members" do
+    class ::Persistence::MockHashContainerClass1
+      include ::Persistence
+      attr_accessor  :some_hash, :storage_key
+      attr_index     :storage_key
+    end
+    class ::Persistence::MockHash < Hash
+      include ::Persistence
+    end
+  
+    hash_container                  = ::Persistence::MockHashContainerClass1.new
+    hash_container.storage_key      = :hash_container
+    hash_container.some_hash             = ::Persistence::MockHash.new
+    hash_container.some_hash[ :hash_key ] = :hash_data
+    
+    hash_container.persist!
+    ::Persistence::MockHashContainerClass1.persist( :storage_key => :hash_container ).should == hash_container
+    
+  end
+  
+  it "can persist an object with array members" do
+    class ::Persistence::MockArrayContainerClass1
+      include ::Persistence
+      attr_accessor  :array, :storage_key
+      attr_index     :storage_key
+    end
+    class ::Persistence::MockSubArray < Array
+      include ::Persistence
+    end
+  
+    storage_key                         = :array_container
+    array_data                          = :array_data
+    array_container                     = ::Persistence::MockArrayContainerClass1.new
+    array_container.storage_key         = storage_key
+    array_container.array               = ::Persistence::MockSubArray.new
+    array_container.array.push( array_data )
+    
+    array_container.persist!
+    ::Persistence::MockArrayContainerClass1.persist( :storage_key => storage_key ).should == array_container
+    
+  end
+  
+end

data/spec/example_objects.rb

@@ -0,0 +1,6 @@
+
+###
+# Example objects are provided to show what objects including Persistence look like.
+#
+module ::Persistence::ExampleObjects
+end

data/spec/example_objects/complex_object.rb

@@ -0,0 +1,7 @@
+
+###
+# Example of Complex object.
+#
+class ::Persistence::ExampleObjects::ComplexObject
+  
+end

data/spec/example_objects/complex_object/array_object.rb

@@ -0,0 +1,7 @@
+
+###
+# Example of Array object.
+#
+class ::Persistence::ExampleObjects::ComplexObject::ArrayObject
+  
+end

data/spec/example_objects/complex_object/hash_object.rb

@@ -0,0 +1,7 @@
+
+###
+# Example of Hash object.
+#
+class ::Persistence::ExampleObjects::ComplexObject::HashObject
+  
+end

data/spec/example_objects/flat_object.rb

@@ -0,0 +1,7 @@
+
+###
+# Example of Flat object.
+#
+class ::Persistence::ExampleObjects::FlatObject < ::String
+  include ::Persistence
+end

data/spec/example_objects/flat_object/file_object.rb

@@ -0,0 +1,7 @@
+
+###
+# Example of File object.
+#
+class ::Persistence::ExampleObjects::FlatObject::FileObject
+  
+end

data/spec/persistence/adapter/enable_disable_spec.rb

@@ -0,0 +1,29 @@
+
+require_relative '../../../lib/persistence.rb'
+
+describe ::Persistence::Adapter::Abstract::EnableDisable do
+
+  ################
+  #  initialize  #
+  ################
+
+  it 'can initialize with a home directory specified' do
+    class ::Persistence::Adapter::Abstract::EnableDisable::Mock
+      include ::Persistence::Adapter::Abstract::EnableDisable
+    end
+    home_directory_location = '/tmp/persistence_spec_home_directory'
+    ::Persistence::Adapter::Abstract::EnableDisable::Mock.new( home_directory_location ).instance_eval do
+      enabled?.should == false
+      enable
+      enabled?.should == true
+      disable
+      enabled?.should == false
+      enable
+      File.exists?( home_directory_location ).should == true
+      self.home_directory.should == home_directory_location
+      Dir.delete( home_directory_location )
+      File.exists?( home_directory_location ).should == false
+    end    
+  end
+
+end