rod 0.6.2 → 0.6.3

data/lib/rod.rb

@@ -1,6 +1,11 @@
 require 'inline'
 require 'english/inflect'
-require 'active_model'
+require 'active_model/deprecated_error_methods'
+require 'active_model/validator'
+require 'active_model/naming'
+require 'active_model/translation'
+require 'active_model/validations'
+require 'active_model/dirty'
 require 'active_support/dependencies'
 
 # XXX This should be done in a different way, since a library should not
@@ -17,6 +22,9 @@ require 'rod/join_element'
 require 'rod/cache'
 require 'rod/collection_proxy'
 require 'rod/model'
+require 'rod/reference_updater'
 require 'rod/string_element'
 require 'rod/string_ex'
-require 'rod/segmented_index'
+require 'rod/index/base'
+require 'rod/index/flat_index'
+require 'rod/index/segmented_index'

data/lib/rod/abstract_database.rb

@@ -1,7 +1,7 @@
 require 'singleton'
 require 'yaml'
-require 'rod/segmented_index'
-require 'fileutils'
+require 'rod/index/base'
+require 'rod/utils'
 
 module Rod
   # This class implements the database abstraction, i.e. it
@@ -13,9 +13,14 @@ module Rod
     # a given model (set of classes).
     include Singleton
 
+    include Utils
+
     # The meta-data of the DataBase.
     attr_reader :metadata
 
+    # The path which the database instance is located on.
+    attr_reader :path
+
     # Initializes the classes linked with this database and the handler.
     def initialize
       @classes ||= self.special_classes
@@ -58,12 +63,7 @@ module Rod
         klass.send(:build_structure)
         remove_file(klass.path_for_data(@path))
         klass.indexed_properties.each do |property,options|
-          path = klass.path_for_index(@path,property,options)
-          if test(?d,path)
-            remove_files(path + "*")
-          elsif test(?f,path)
-            remove_file(path)
-          end
+          klass.index_for(property,options).destroy
         end
         next if special_class?(klass)
         remove_files_but(klass.inline_library)
@@ -116,17 +116,20 @@ module Rod
       end
       generate_c_code(@path, self.classes)
       @handler = _init_handler(@path)
+      metadata_copy = @metadata.dup
+      metadata_copy.delete("Rod")
       self.classes.each do |klass|
-        meta = @metadata[klass.name]
+        meta = metadata_copy.delete(klass.name)
         if meta.nil?
           # new class
           next
         end
-        unless klass.compatible?(meta,self) || options[:generate] || options[:migrate]
+        unless klass.compatible?(meta) || options[:generate] || options[:migrate]
             raise IncompatibleVersion.
               new("Incompatible definition of '#{klass.name}' class.\n" +
-                  "Database and runtime versions are different:\n" +
-                  "  #{meta}\n  #{klass.metadata(self)}")
+                  "Database and runtime versions are different:\n  " +
+                  klass.difference(meta).
+                  map{|e1,e2| "DB: #{e1} vs. RT: #{e2}"}.join("\n  "))
         end
         set_count(klass,meta[:count])
         file_size = File.new(klass.path_for_data(@path)).size
@@ -142,15 +145,20 @@ module Rod
           set_page_count(new_class,pages)
         end
       end
+      if metadata_copy.size > 0
+        @handler = nil
+        raise DatabaseError.new("The following classes are missing in runtime:\n - " +
+                                metadata_copy.keys.join("\n - "))
+      end
       _open(@handler)
       if options[:migrate]
         empty_data = "\0" * _page_size
         self.classes.each do |klass|
           next unless klass.to_s =~ LEGACY_RE
           new_class = klass.name.sub(LEGACY_RE,"").constantize
-          old_metadata = klass.metadata(self)
+          old_metadata = klass.metadata
           old_metadata.merge!({:superclass => old_metadata[:superclass].sub(LEGACY_RE,"")})
-          unless new_class.compatible?(old_metadata,self)
+          unless new_class.compatible?(old_metadata)
             File.open(new_class.path_for_data(@path),"w") do |out|
               send("_#{new_class.struct_name}_page_count",@handler).
                 times{|i| out.print(empty_data)}
@@ -267,6 +275,18 @@ module Rod
                                            class_id, @handler)
     end
 
+    # Allocates space for polymorphic join elements.
+    def allocate_polymorphic_join_elements(size)
+      raise DatabaseError.new("Readonly database.") if readonly_data?
+      _allocate_polymorphic_join_elements(size,@handler)
+    end
+
+    # Allocates space for join elements.
+    def allocate_join_elements(size)
+      raise DatabaseError.new("Readonly database.") if readonly_data?
+      _allocate_join_elements(size,@handler)
+    end
+
     # Returns the string of given +length+ starting at given +offset+.
     # Options:
     # * +:skip_encoding+ - if set to +true+, the string is left as ASCII-8BIT
@@ -305,25 +325,6 @@ module Rod
       send("_#{klass.struct_name}_page_count=",@handler,value)
     end
 
-    # Reads index of +field+ (with +options+) for +klass+.
-    def read_index(klass,field,options)
-      case options[:index]
-      when :flat,true
-        begin
-          File.open(klass.path_for_index(@path,field,options)) do |input|
-            return {} if input.size == 0
-            return Marshal.load(input)
-          end
-        rescue Errno::ENOENT
-          return {}
-        end
-      when :segmented
-        return SegmentedIndex.new(klass.path_for_index(@path,field,options))
-      else
-        raise RodException.new("Invalid index type '#{options[:index]}'.")
-      end
-    end
-
     # Store index of +field+ (with +options+) of +klass+ in the database.
     # There are two types of indices:
     # * +:flat+ - marshalled index is stored in one file
@@ -331,68 +332,25 @@ module Rod
     def write_index(klass,property,options)
       raise DatabaseError.new("Readonly database.") if readonly_data?
       class_index = klass.index_for(property,options)
-      # Only convert the index, without (re)storing the values.
-      unless options[:convert]
-        class_index.each do |key,ids|
-          unless ids.is_a?(CollectionProxy)
-            proxy = CollectionProxy.new(ids[1],self,ids[0],klass)
-          else
-            proxy = ids
-          end
-          offset = _allocate_join_elements(proxy.size,@handler)
-          proxy.each_id.with_index do |rod_id,index|
-            set_join_element_id(offset, index, rod_id)
-          end
-          class_index[key] = [offset,proxy.size]
-        end
-      end
-      case options[:index]
-      when :flat,true
-        File.open(klass.path_for_index(@path,property,options),"w") do |out|
-          out.puts(Marshal.dump(class_index))
-        end
-      when :segmented
-        path = klass.path_for_index(@path,property,options)
-        if class_index.is_a?(Hash)
-          index = SegmentedIndex.new(path)
-          class_index.each{|k,v| index[k] = v}
-        else
-          index = class_index
-        end
-        index.save
-        index = nil
+      if options[:convert]
+        # Only convert the index, without (re)storing the values.
+        index = Index::Base.create(klass.path_for_index(@path,property),klass,options)
+        index.copy(class_index)
+        class_index = index
       else
-        raise RodException.new("Invalid index type '#{options[:index]}'.")
+        class_index.each do |key,proxy|
+          proxy.save
+        end
       end
+      class_index.save
+      class_index = nil
     end
 
     # Store the object in the database.
     def store(klass,object)
       raise DatabaseError.new("Readonly database.") if readonly_data?
-      new_object = (object.rod_id == 0)
-      if new_object
+      if object.new?
         send("_store_" + klass.struct_name,object,@handler)
-        # set fields' values
-        object.class.fields.each do |name,options|
-          # rod_id is set during _store
-          object.update_field(name) unless name == "rod_id"
-        end
-        # set ids of objects referenced via singular associations
-        object.class.singular_associations.each do |name,options|
-          object.update_singular_association(name,object.send(name))
-        end
-      end
-      # set ids of objects referenced via plural associations
-      # TODO should be disabled, when there are no new elements
-      object.class.plural_associations.each do |name,options|
-        elements = object.send(name) || []
-        if options[:polymorphic]
-          offset = _allocate_polymorphic_join_elements(elements.size,@handler)
-        else
-          offset = _allocate_join_elements(elements.size,@handler)
-        end
-        object.update_count_and_offset(name,elements.size,offset)
-        object.update_plural_association(name,elements)
       end
     end
 
@@ -430,7 +388,8 @@ module Rod
 
     # Retruns the path to the DB as a name of a directory.
     def canonicalize_path(path)
-      path + "/" unless path[-1] == "/"
+      path += "/" unless path[-1] == "/"
+      path
     end
 
     # Special classes used by the database.
@@ -533,28 +492,6 @@ module Rod
       generate_classes(legacy_module)
     end
 
-    # Removes single file.
-    def remove_file(file_name)
-      if test(?f,file_name)
-        File.delete(file_name)
-        puts "Removing #{file_name}" if $ROD_DEBUG
-      end
-    end
-
-    # Remove all files matching the +pattern+.
-    # If +skip+ given, the file with the given name is not deleted.
-    def remove_files(pattern,skip=nil)
-      Dir.glob(pattern).each do |file_name|
-        remove_file(file_name) unless file_name == skip
-      end
-    end
-
-    # Removes all files which are similar (i.e. are generated
-    # by RubyInline for the same class) to +name+
-    # excluding the file with exactly the name given.
-    def remove_files_but(name)
-      remove_files(name.sub(INLINE_PATTERN_RE,"*"),name)
-    end
 
     # Writes the metadata to the database.yml file.
     def write_metadata
@@ -564,7 +501,8 @@ module Rod
       rod_data[:created_at] = self.metadata["Rod"][:created_at] || Time.now
       rod_data[:updated_at] = Time.now
       self.classes.each do |klass|
-        metadata[klass.name] = klass.metadata(self)
+        metadata[klass.name] = klass.metadata
+        metadata[klass.name][:count] = self.count(klass)
       end
       File.open(@path + DATABASE_FILE,"w") do |out|
         out.puts(YAML::dump(metadata))

data/lib/rod/abstract_model.rb

@@ -46,20 +46,40 @@ module Rod
     end
 
     # Returns meta-data (in the form of a hash) for the model.
-    def self.metadata(database)
+    def self.metadata
       meta = {}
-      meta[:count] = database.count(self)
       meta[:superclass] = self.superclass.name
       meta
     end
 
     # Checks if the +metadata+ are compatible with the class definition.
-    def self.compatible?(metadata,database)
-      self_metadata = self.metadata(database)
+    def self.compatible?(metadata)
+      self.difference(metadata).empty?
+    end
+
+    # Calculates the difference between the classes metadata
+    # and the +metadata+ provided.
+    def self.difference(metadata)
+      my_metadata = self.metadata
       other_metadata = metadata.dup
-      self_metadata.delete(:count)
       other_metadata.delete(:count)
-      self_metadata == other_metadata
+      result = []
+      my_metadata.each do |type,values|
+        # TODO #161 the order of properties should be preserved for the
+        # whole class, not only for each type of properties.
+        if [:fields,:has_one,:has_many].include?(type)
+          values.to_a.zip(other_metadata[type].to_a) do |meta1,meta2|
+            if meta1 != meta2
+              result << [meta2,meta1]
+            end
+          end
+        else
+          if other_metadata[type] != values
+            result << [other_metadata[type],values]
+          end
+        end
+      end
+      result
     end
 
   end

data/lib/rod/collection_proxy.rb

@@ -1,26 +1,35 @@
+require 'bsearch'
+require 'rod/reference_updater'
+
 module Rod
-  # This class allows for lazy fetching the objects from
-  # a collection of Rod objects. It holds only a Ruby proc, which
-  # called returns the object with given index.
+  # This class allows for lazy fetching the elements from
+  # a collection of Rod objects.
   class CollectionProxy
     include Enumerable
-    attr_reader :size
+    attr_reader :size, :offset
     alias count size
 
-    # Intializes the proxy with +size+ of the collection
-    # and +fetch+ block for retrieving the object from the database.
+    # Intializes the proxy with its +size+, +database+ it is connected
+    # to, the +offset+ of join elements and the +klass+ of stored
+    # objects. If the klass is nil, the collection holds polymorphic
+    # objects.
     def initialize(size,database,offset,klass)
       @size = size
       @original_size = size
       @database = database
       @klass = klass
       @offset = offset
-      @appended = []
+      #@commands = []
+      @added = []
+      @deleted = []
+      @map = {}
     end
 
     # Returns an object with given +index+.
+    # The +index+ have to be positive and smaller from the collection size.
+    # Otherwise +nil+ is returned.
     def [](index)
-      return nil if index >= @size
+      return nil if index >= @size || index < 0
       rod_id = id_for(index)
       if rod_id.is_a?(Model)
         rod_id
@@ -33,14 +42,98 @@ module Rod
 
     # Appends element to the end of the collection.
     def <<(element)
-      if element.rod_id == 0
-        @appended << [element,element.class]
+      if element.nil?
+        pair = [0,NilClass]
       else
-        @appended << [element.rod_id,element.class]
+        if element.new?
+          pair = [element,element.class]
+        else
+          pair = [element.rod_id,element.class]
+        end
       end
+      index = @size
+      @map[index] = @added.size
+      @added << pair
+      #@commands << [:append, pair]
       @size += 1
     end
 
+    # Inserts the +element+ at given +index+.
+    # So far the +index+ has to be positive, smaller or equal to size
+    # and only one pair of values is accepted. If these assumptions
+    # are not met, nil is returned.
+    def insert(index,element)
+      return nil if index < 0 || index > @size
+      if element.new?
+        pair = [element,element.class]
+      else
+        pair = [element.rod_id,element.class]
+      end
+      @map.keys.sort.reverse.each do |key|
+        if key >= index
+          value = @map.delete(key)
+          @map[key+1] = value
+        end
+      end
+      @map[index] = @added.size
+      @added << pair
+      #@commands << [:insert,pair]
+      @size += 1
+      self
+    end
+
+    # Removes the +element+ from the collection.
+    def delete(element)
+      indices = []
+      self.each.with_index{|e,i| indices << i if e == element}
+      if indices.empty?
+        if block_given?
+          return yield
+        else
+          return nil
+        end
+      end
+      #@commands << [:delete,indices]
+      indices.each.with_index do |index,offset|
+        self.delete_at(index-offset)
+      end
+      element
+    end
+
+    # Removes the element at +index+ from the colelction.
+    # So far the +index+ has to be positive.
+    def delete_at(index)
+      return nil if index >= @size || index < 0
+      element = self[index]
+      if direct_index = @map[index]
+        @added.delete_at(direct_index)
+        @map.delete(index)
+        @map.keys.sort.each do |key|
+          if key > index
+            value = @map.delete(key)
+            value -= 1 if value > direct_index
+            @map[key-1] = value
+          else
+            if (value = @map[key]) > direct_index
+              @map[key] -= 1
+            end
+          end
+        end
+      else
+        lazy_index = lazy_index(index)
+        position = @deleted.bsearch_upper_boundary{|e| e <=> lazy_index }
+        @deleted.insert(position,lazy_index)
+        @map.keys.sort.each do |key|
+          if key > index
+            @map[key-1] = @map.delete(key)
+          end
+        end
+      end
+      #@commands << [:delete,[index]]
+      @size -= 1
+      element
+    end
+
     # Simple each implementation.
     def each
       if block_given?
@@ -52,50 +145,158 @@ module Rod
       end
     end
 
-    # Iterate over the rod_ids.
-    def each_id
-      if block_given?
-        @size.times do |index|
-          id = id_for(index)
-          if id.is_a?(Model)
-            raise IdException.new(id)
-          else
-            yield id
+    # Returns a collection of added items.
+    def added
+      @added.map do |id_or_object,klass|
+        if id_or_object.is_a?(Model)
+          id_or_object
+        else
+          id_or_object == 0 ? nil : klass.find_by_rod_id(id_or_object)
+        end
+      end
+    end
+
+    # Returns a collection of deleted items.
+    def deleted
+      @deleted.map do |index|
+        if polymorphic?
+          rod_id = @database.polymorphic_join_index(@offset,index)
+          if rod_id != 0
+            klass = Model.get_class(@database.polymorphic_join_class(@offset,index))
           end
+        else
+          klass = @klass
+          rod_id = @database.join_index(@offset,index)
         end
-      else
-        enum_for(:each_id)
+        rod_id == 0 ? nil : klass.find_by_rod_id(rod_id)
       end
     end
 
-    # String representation.
+    # String representation of the collection proxy. Displays only the actual
+    # and the original size.
     def to_s
-      "Proxy:[#{@size}][#{@original_size}]"
+      "Collection:[#{@size}][#{@original_size}]"
+    end
+
+    # Returns true if the collection is empty.
+    def empty?
+      self.count == 0
+    end
+
+    # Saves to collection proxy into disk and returns the collection
+    # proxy's +offset+.
+    # If no element was added nor deleted, nothing happes.
+    def save
+      unless @added.empty? && @deleted.empty?
+        # We cannot reuse the allocated space, since the data
+        # that is copied would be destroyed.
+        if polymorphic?
+          offset = @database.allocate_polymorphic_join_elements(@size)
+        else
+          offset = @database.allocate_join_elements(@size)
+        end
+        pairs =
+          @size.times.map do |index|
+            rod_id = id_for(index)
+            if rod_id.is_a?(Model)
+              object = rod_id
+              if object.new?
+                if polymorphic?
+                  object.reference_updaters <<
+                    ReferenceUpdater.for_plural(self,index,@database)
+                else
+                  object.reference_updaters <<
+                    ReferenceUpdater.for_plural(self,index,@database)
+                end
+                next
+              else
+                rod_id = object.rod_id
+              end
+            end
+            [rod_id,index]
+          end.compact
+        if polymorphic?
+          pairs.each do |rod_id,index|
+            class_id = (rod_id == 0 ? 0 : class_for(index).name_hash)
+            @database.set_polymorphic_join_element_id(offset,index,rod_id,class_id)
+          end
+        else
+          pairs.each do |rod_id,index|
+            @database.set_join_element_id(offset,index,rod_id)
+          end
+        end
+        @offset = offset
+        @added.clear
+        @deleted.clear
+        @map.clear
+        @original_size = @size
+      end
+      @offset
     end
 
     protected
+    # Returns true if the collection proxy is polymorphic, i.e. each
+    # element in the collection might be an instance of a different class.
+    def polymorphic?
+      @klass.nil?
+    end
+
+    # Updates in the database the +rod_id+ of the referenced object,
+    # which is stored at given +index+.
+    def update_reference_id(rod_id,index)
+      if polymorphic?
+        class_id = object.class.name_hash
+        @database.set_polymorphic_join_element_id(@offset, index, rod_id, class_id)
+      else
+        @database.set_join_element_id(@offset, index, rod_id)
+      end
+    end
+
+    # Returns the +rod_id+ of the element for given +index+. The
+    # id is taken from the DB or from in-memory map, depending
+    # on the fact if the collection were modified.
     def id_for(index)
-      if index >= @original_size && !@appended[index - @original_size].nil?
-        @appended[index - @original_size][0]
+      if direct_index = @map[index]
+        @added[direct_index][0]
       else
-        if @klass.nil?
-          @database.polymorphic_join_index(@offset,index)
+        if polymorphic?
+          @database.polymorphic_join_index(@offset,lazy_index(index))
         else
-          @database.join_index(@offset,index)
+          @database.join_index(@offset,lazy_index(index))
         end
       end
     end
 
+    # Returns the +class_id+ of the element for given +index+. The
+    # id is taken from the DB or from in-memory map, depending
+    # on the fact if the collection were modified.
     def class_for(index)
-      if index >= @original_size && !@appended[index - @original_size].nil?
-        @appended[index - @original_size][1]
+      if polymorphic?
+        if direct_index = @map[index]
+          @added[direct_index][1]
+        else
+          Model.get_class(@database.polymorphic_join_class(@offset,lazy_index(index)))
+        end
       else
-        if @klass.nil?
-          Model.get_class(@database.polymorphic_join_class(@offset,index))
+        @klass
+      end
+    end
+
+    # Returns the index in the database corresponding to the given
+    # +index+ of the collection.
+    def lazy_index(index)
+      index -= @map.keys.select{|e| e < index}.size
+      result = 0
+      @deleted.each do |deleted_index|
+        if deleted_index - result > index
+          return result + index
         else
-          @klass
+          index -= deleted_index - result
+          result = deleted_index + 1
         end
       end
+      result + index
     end
   end
 end
+