persistence-adapter-flat_file 0.0.1

data/lib/persistence/adapter/flat_file/bucket/index.rb

@@ -0,0 +1,6 @@
+
+class ::Persistence::Adapter::FlatFile::Bucket::Index
+
+  include ::Persistence::Adapter::FlatFile::Bucket::Index::IndexInterface
+
+end

data/lib/persistence/adapter/flat_file/bucket/index/index_interface.rb

@@ -0,0 +1,240 @@
+
+module ::Persistence::Adapter::FlatFile::Bucket::Index::IndexInterface
+
+  include ::Persistence::Adapter::FlatFile::PathHelpers
+  include ::Persistence::Adapter::FlatFile::Serialization
+  
+  ################
+  #  initialize  #
+  ################
+
+  def initialize( index_name, parent_bucket, permits_duplicates )
+
+    @name = index_name
+
+    @parent_bucket = parent_bucket
+
+    @permits_duplicates = permits_duplicates
+    
+  end
+
+  ###################
+  #  adapter_class  #
+  ###################
+  
+  def adapter_class
+    
+    return @parent_bucket.parent_adapter.class
+    
+  end
+
+  ###########
+  #  count  #
+  ###########
+  
+  def count
+    
+    glob_list = Dir.glob( File.join( directory__index, '*' ) )
+
+    return glob_list.count
+    
+  end
+
+  ############
+  #  delete  #
+  ############
+
+  def delete
+
+    directories = [ directory__index,
+                    directory__reverse_index ]
+
+    # delete index data
+    directories.each do |this_directory|
+
+      # delete all indexed contents
+      Dir[ File.join( this_directory, '*' ) ].each do |this_file|
+        File.delete( this_file )
+      end
+
+      # delete index
+      Dir.delete( this_directory )
+
+    end
+
+  end
+
+  ############
+  #  cursor  #
+  ############
+
+  def cursor
+
+    return ::Persistence::Adapter::FlatFile::Cursor.new( @parent_bucket, self )
+
+  end
+
+  #########################
+  #  permits_duplicates?  #
+  #########################
+
+  def permits_duplicates?
+    
+    return @permits_duplicates
+
+  end
+
+  ###################
+  #  get_object_id  #
+  ###################
+
+  def get_object_id( key )
+
+    file__id_for_key = file__index( key )
+    
+    return open_read_unserialize_and_close( file__id_for_key )
+
+  end
+
+  #####################
+  #  index_object_id  #
+  #####################
+  
+  def index_object_id( global_id, value )
+
+    file_path = file__index( value )
+
+    if permits_duplicates?
+
+      if File.exists?( file_path )
+        
+        open_read_unserialize_perform_action_serialize_write_and_close( file_path ) do |ids|
+          ids.push( global_id ).sort.uniq
+        end
+        
+      else
+
+        # index value => ID
+        create_or_update_value_serialize_and_write( file_path, [ global_id ] )
+
+      end
+            
+    else
+      
+      if File.exists?( file_path )
+        
+        # check to make sure that we do not already have an index value with a different ID
+        open_read_unserialize_perform_action_serialize_write_and_close( file_path ) do |id|
+
+          # If we already have a file for this index value and it holds this object's id,
+          # then we don't need to do anything.
+          # Otherwise we have a duplicate key in a unique index, which is a problem.
+          unless id == global_id
+            raise ::Persistence::Exception::DuplicateViolatesUniqueIndex.new( 
+                  'Attempt to create entry in index named :' + @name.to_s + 
+                  ' would create duplicates in a unique index.' )
+          end
+
+        end
+
+      else
+
+        # index value => ID
+        create_or_update_value_serialize_and_write( file_path, global_id )
+
+      end
+      
+    end
+
+    # index ID => value for updating keys if they change
+    object_index_location = file__reverse_index_keys_for_global_id( @parent_bucket.name, 
+                                                                    @name, 
+                                                                    global_id )
+    create_or_update_value_serialize_and_write( object_index_location, value )
+    
+    return self
+
+  end
+
+  ################################
+  #  delete_keys_for_object_id!  #
+  ################################
+
+  def delete_keys_for_object_id!( global_id )
+
+    key = open_read_unserialize_and_close( file__reverse_index_keys_for_global_id( @parent_bucket.name, @name, global_id ) )
+
+    files = [ file__reverse_index_keys_for_global_id( @parent_bucket.name, @name, global_id ),
+              file__index( key ) ]
+
+    files.each do |this_file|
+      File.delete( this_file )
+    end
+
+    return self
+
+  end
+
+  ######################
+  #  directory__index  #
+  ######################
+  
+  def directory__index
+
+    directory__index = File.join( @parent_bucket.parent_adapter.home_directory,
+                                  'indexes',
+                                  @parent_bucket.name.to_s,
+                                  @name.to_s )
+
+    ensure_directory_path_exists( directory__index )
+
+    return directory__index
+
+  end
+
+  ##############################
+  #  directory__reverse_index  #
+  ##############################
+  
+  # Bucket Index IDs:        <home_directory>/global_ids/bucket/
+  def directory__reverse_index
+
+    directory__reverse_index = File.join( @parent_bucket.parent_adapter.home_directory,
+                                          'indexes',
+                                          'reverse_index',
+                                          @parent_bucket.name.to_s,
+                                          @name.to_s )
+
+    ensure_directory_path_exists( directory__reverse_index )
+
+    return directory__reverse_index
+
+  end
+
+  ############################################
+  #  file__reverse_index_keys_for_global_id  #
+  ############################################
+
+  # Global IDs:              <home_directory>/global_ids/bucket/file__path_encoded_name_from_key.ruby_serialize.txt
+  def file__reverse_index_keys_for_global_id( bucket_name, index_name, global_id )
+
+    return File.join( directory__reverse_index,
+                      global_id.to_s + adapter_class::SerializationExtension )
+
+  end
+
+  #################
+  #  file__index  #
+  #################
+  
+  # Global ID:               <home_directory>/indexes/bucket/file__path_encoded_name_from_key.ruby_serialize.txt
+  def file__index( key )
+
+    key = key.to_s if key.is_a?( Class )
+
+    return File.join( directory__index,
+                      file__path_encoded_name_from_key( key ) + adapter_class::SerializationExtension )
+
+  end
+
+end

data/lib/persistence/adapter/flat_file/class_name.rb

@@ -0,0 +1,4 @@
+
+class ::Persistence::Adapter::FlatFile::ClassName < ::String
+  
+end

data/lib/persistence/adapter/flat_file/cursor.rb

@@ -0,0 +1,6 @@
+
+class ::Persistence::Adapter::FlatFile::Cursor
+  
+  include ::Persistence::Adapter::FlatFile::Cursor::CursorInterface
+  
+end

data/lib/persistence/adapter/flat_file/cursor/cursor_interface.rb

@@ -0,0 +1,207 @@
+
+module ::Persistence::Adapter::FlatFile::Cursor::CursorInterface
+
+  include ::Persistence::Adapter::FlatFile::PathHelpers
+  include ::Persistence::Adapter::FlatFile::Serialization
+
+  ################
+  #  initialize  #
+  ################
+
+  def initialize( parent_bucket_instance, parent_index_instance = nil )
+
+    @parent_bucket = parent_bucket_instance
+    @parent_index = parent_index_instance
+
+    # we're iterating a directory of files named after their key_digest and containing their global ID
+    @key_to_id_directory = ( @parent_index ? @parent_index.instance_eval { directory__index }
+                                           : @parent_bucket.instance_eval { directory__ids_in_bucket } )
+    
+    # instantiate enumerator to track our current position
+    init_current_position
+    
+  end
+  
+  ############################
+  #  supports_bucket_order?  #
+  ############################
+  
+  def supports_bucket_order?
+    
+    return true
+    
+  end
+
+  ###########################
+  #  supports_index_order?  #
+  ###########################
+
+  def supports_index_order?
+    
+    return false
+
+  end
+  
+  ###########
+  #  close  #
+  ###########
+  
+  def close
+    
+    # nothing required
+
+  end
+  
+  ###################
+  #  adapter_class  #
+  ###################
+  
+  def adapter_class
+    
+    return @parent_bucket.parent_adapter.class
+    
+  end
+  
+  ################
+  #  persisted?  #
+  ################
+
+  # persisted? is responsible for setting the cursor position
+  def persisted?( *args )
+
+    has_key = false
+    no_key  = false
+    case args.count
+    when 1
+      key = args[0]
+    when 0
+      no_key = true
+    end
+    
+    # if we have no args we are asking whether any keys exist
+    if no_key
+
+      init_current_position
+
+      has_key = true unless ::Dir[ @key_to_id_directory ].empty?
+      
+    else
+
+      # check if we have a position that currently points to key - if so we are done
+      if has_key = ( current_key == key )
+        return has_key
+      end
+
+      init_current_position
+
+      # Find location of key in Directory enumerator.
+      # It seems we can't use Dir#seek because there is no direct way to find the index from a file path.
+      # Please prove me wrong if you can!
+      begin
+
+        until has_key = ( current_key == key )
+          self.next
+        end
+      rescue StopIteration
+      end
+
+    end
+    
+    return has_key
+
+  end
+
+  ###########
+  #  first  #
+  ###########
+  
+  # first should set the cursor position and return the first ID or object hash
+  def first
+    
+    @current_position.rewind
+
+    return current
+    
+  end
+
+  #############
+  #  current  #
+  #############
+  
+  # current should return the current ID or object hash
+  def current
+
+    current = nil
+
+    if @current_position
+      current = open_read_unserialize_and_close( File.join( @key_to_id_directory, 
+                                                            @current_position.peek ) )
+    end
+
+    return current
+
+  end
+
+  #################
+  #  current_key  #
+  #################
+  
+  # current should return the current ID or object hash
+  def current_key
+
+    current_key = nil
+    
+    if @parent_index
+      encoded_key_as_file_name = @current_position.peek
+      encoded_key = encoded_key_as_file_name.split( '.' )[ 0 ]
+      current_key = file__key_from_path_encoded_name( encoded_key )
+    else
+      current_key = current
+    end
+
+    return current_key
+    
+  end
+  
+  ##########
+  #  next  #
+  ##########
+  
+  def next
+
+    @current_position.next
+
+    return current
+
+  end
+
+  ##################################################################################################
+      private ######################################################################################
+  ##################################################################################################
+
+  ###########################
+  #  init_current_position  #
+  ###########################
+
+  def init_current_position( directory = nil )
+    
+    if directory
+      @key_to_id_directory = directory
+    end
+    
+    if @current_position
+
+      @current_position.rewind
+
+    else
+
+      current_position_entries = Dir.new( @key_to_id_directory ).entries
+      current_position_entries.delete( '.' )
+      current_position_entries.delete( '..' )
+      @current_position = current_position_entries.each
+
+    end
+
+  end
+
+end