rod 0.7.0 → 0.7.1

data/changelog.txt

@@ -1,3 +1,24 @@
+0.7.1
+- #189 guard object load against empty strings.
+- Don't close hash index when it is destroyed.
+- #188 don't raise exception when HashIndex closed
+- Make the HashIndex exceptions more informative.
+- #187 collection proxy is cleared in assignment
+- Tiny change of diagnostic messages
+- #174 progress for fields migration
+- #181 store only added/updated hash index pairs
+- #180 save collections in index no in Abstract DB
+- #179 raise exception during iteration
+- Fix saving of empty collection proxy.
+- #176 copy index file if its type is the same
+- #168 copy unmodified classes during migration
+- #166 true index type still supported
+- #171 encode strings to utf-8 when searching in hash index
+- #170 fix save for hash index
+- #169 missing each implementation in hash index
+- #167 copy special classes data to backup
+- #165 fix invalid topological class sorting algorithm
+- #164 invalid variable in load metadata
 0.7.0
 - #142 migrate indices during model migration
 - #134 Berkeley DB Hash for indexing properties

data/features/collection_proxy.feature

@@ -138,3 +138,8 @@ Feature: collection proxy specification
     When I delete an item at position 0 5 times
     Then the collection proxy should be empty
     And the collection proxy should behave like an array
+
+  Scenario: modifying collection during interation
+    Given the initial size of the collection proxy is 5
+    # Can't figure out anything better.
+    Then an exception should be raised when the collection is modified during iteration

data/features/steps/collection_proxy.rb

@@ -87,3 +87,16 @@ Then /^the collection proxy should be empty$/ do
   @proxy.to_a.should be_empty
 end
 
+#Then an exception should be raised when the collection is modified during iteration
+Then /^an exception should be raised when the collection is modified during iteration$/ do
+  (lambda do
+    @proxy.each do |item|
+      @proxy << create_item(@offset)
+    end
+  end).should raise_exception
+  (lambda do
+    @proxy.each do |item|
+      @proxy.detete_at(0)
+    end
+  end).should raise_exception
+end

data/lib/rod.rb

@@ -7,6 +7,8 @@ require 'active_model/translation'
 require 'active_model/validations'
 require 'active_model/dirty'
 require 'active_support/dependencies'
+require 'active_support/deprecation/behaviors'
+require 'active_support/deprecation/reporting'
 
 # XXX This should be done in a different way, since a library should not
 # impose on a user of another library specific way of using it.

data/lib/rod/abstract_database.rb

@@ -159,6 +159,12 @@ module Rod
       @metadata = load_metadata
       create_legacy_classes
       FileUtils.mkdir_p(@path + BACKUP_PREFIX)
+      # Copy special classes data.
+      special_classes.each do |klass|
+        file = klass.path_for_data(@path)
+        puts "Copying #{file} to #{@path + BACKUP_PREFIX}" if $ROD_DEBUG
+        FileUtils.cp(file,@path + BACKUP_PREFIX)
+      end
       Dir.glob(@path + "*").each do |file|
         # Don't move the directory itself and speciall classes data.
         unless file.to_s == @path + BACKUP_PREFIX[0..-2] ||
@@ -218,7 +224,7 @@ module Rod
         unless skip_indices
           self.classes.each do |klass|
             klass.indexed_properties.each do |property,options|
-              write_index(klass,property,options)
+              klass.index_for(property,options).save
             end
           end
         end
@@ -357,27 +363,6 @@ module Rod
       send("_#{klass.struct_name}_page_count=",@handler,value)
     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
-    # * +:segmented+ - marshalled index is stored in many files
-    def write_index(klass,property,options)
-      raise DatabaseError.new("Readonly database.") if readonly_data?
-      class_index = klass.index_for(property,options)
-      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
-        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?
@@ -411,7 +396,7 @@ module Rod
       end
       unless valid_version?(metadata["Rod"][:version])
         raise IncompatibleVersion.new("Incompatible versions - library #{VERSION} vs. " +
-                                      "file #{metatdata["Rod"][:version]}")
+                                      "file #{metadata["Rod"][:version]}")
       end
       metadata
     end
@@ -467,29 +452,20 @@ module Rod
       special_names = special_classes.map{|k| k.name}
       special_names << "Rod"
       superclasses = {}
+      inverted_superclasses = {}
       @metadata.reject{|k,o| special_names.include?(k)}.each do |k,o|
         superclasses[k] = o[:superclass]
+        inverted_superclasses[o[:superclass]] ||= []
+        inverted_superclasses[o[:superclass]] << k
       end
-      superclass_tree = {}
-      superclasses.each do |klass,superclass|
-        superclass_tree[klass] = []
-        current_superclass = superclass
-        loop do
-          break if current_superclass.nil?
-          superclass_tree[klass] << current_superclass
-          break if current_superclass == "Rod::Model"
-          current_superclass = superclasses[current_superclass]
-        end
-      end
-      superclasses.keys.sort do |klass1,klass2|
-        if superclass_tree[klass1].include?(klass2)
-          1
-        elsif superclass_tree[klass2].include?(klass1)
-          -1
-        else
-          klass1 <=> klass2
-        end
-      end.each do |klass_name|
+      queue = inverted_superclasses["Rod::Model"] || []
+      sorted = []
+      begin
+        klass = queue.shift
+        sorted << klass
+        queue.concat(inverted_superclasses[klass] || [])
+      end until queue.empty?
+      sorted.each do |klass_name|
         metadata = @metadata[klass_name]
         original_name = klass_name
         if module_instance != Object

data/lib/rod/collection_proxy.rb

@@ -14,11 +14,14 @@ module Rod
     # objects. If the klass is nil, the collection holds polymorphic
     # objects.
     def initialize(size,database,offset,klass)
+      raise InvalidArgument.new("collection size",nil) if size.nil?
       @size = size
       @original_size = size
+      raise InvalidArgument.new("collection database",nil) if database.nil?
       @database = database
-      @klass = klass
+      raise InvalidArgument.new("collection offset",nil) if offset.nil?
       @offset = offset
+      @klass = klass
       #@commands = []
       @added = []
       @deleted = []
@@ -134,11 +137,26 @@ module Rod
       element
     end
 
-    # Simple each implementation.
+    # Clears the contents of the collection proxy.
+    def clear
+      @deleted = @original_size.times.to_a
+      @added.clear
+      @map.clear
+      @size = 0
+    end
+
+    # Iterator implementation. It raises an exception when
+    # the collection is modified during iteration.
+    # WARNING: This is not compliant with an Array class!
     def each
       if block_given?
         @size.times do |index|
+          added_size = @added.size
+          deleted_size = @deleted.size
           yield self[index]
+          if added_size != @added.size || deleted_size != @deleted.size
+            raise "Can't modify collection during iteration!"
+          end
         end
       else
         enum_for(:each)

data/lib/rod/constants.rb

@@ -1,5 +1,5 @@
 module Rod
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 
   # The name of file containing the data base.
   DATABASE_FILE = "database.yml"

data/lib/rod/index/base.rb

@@ -13,6 +13,10 @@ module Rod
     # which are used to retrive and assign the values respectively.
     class Base
       include Utils
+
+      # The path of the index.
+      attr_reader :path
+
       # Sets the class this index belongs to.
       def initialize(klass)
         @klass = klass
@@ -38,7 +42,7 @@ module Rod
           proxy = get(key)
         end
         if proxy.nil?
-          proxy = CollectionProxy.new(0,@klass.database,nil,@klass)
+          proxy = CollectionProxy.new(0,@klass.database,0,@klass)
         else
           unless proxy.is_a?(CollectionProxy)
             offset, count = proxy
@@ -56,8 +60,10 @@ module Rod
 
       # Copies the values from +index+ to this index.
       def copy(index)
-        index.each do |key,value|
-          self.set(key,value)
+        index.each.with_index do |key_value,position|
+          self.set(key_value[0],key_value[1])
+          # TODO #182 implement size for index
+          # report_progress(position,index.size) if $ROD_DEBUG
         end
       end
 
@@ -74,6 +80,11 @@ module Rod
         set(key,proxy)
       end
 
+      # The default representation shows the index class and path.
+      def to_s
+        "#{self.class}@#{@path}"
+      end
+
       class << self
         # Creats the proper instance of Index or one of its sublcasses.
         # The +path+ is the path were the index is stored, while +index+ is the previous index instance.
@@ -89,6 +100,10 @@ module Rod
             SegmentedIndex.new(path,klass,options)
           when :hash
             HashIndex.new(path,klass,options)
+          when true
+            ActiveSupport::Deprecation.
+              warn("Index type 'true' is deprecated. It will be removed in ROD 0.8.0")
+            FlatIndex.new(path,klass,options)
           else
             raise RodException.new("Invalid index type #{type}")
           end

data/lib/rod/index/flat_index.rb

@@ -16,11 +16,18 @@ module Rod
 
       # Stores the index on disk.
       def save
+        # The index was not loaded nor modified.
+        return if @index.nil?
         File.open(@path,"w") do |out|
           proxy_index = {}
           #load_index unless loaded?
-          @index.each{|k,col| proxy_index[k] = [col.offset,col.size]}
+          @index.each_key do |key|
+            col = self[key]
+            col.save
+            proxy_index[key] = [col.offset,col.size]
+          end
           out.puts(Marshal.dump(proxy_index))
+          @index = nil
         end
       end
 

data/lib/rod/index/hash_index.rb

@@ -6,7 +6,7 @@ module Rod
     # This implementation of index is based on the
     # Berkeley DB Hash access method.
     class HashIndex < Base
-      # Wrapper class for the database struct.
+      # Wrapper class for the database C struct.
       class Handle
       end
 
@@ -15,23 +15,30 @@ module Rod
       def initialize(path,klass,options={})
         @path = path + ".db"
         @klass = klass
-        _open(@path,:create => true)
-        @index = {}
+        open(@path,:create => true)
       end
 
       # Stores the index on disk.
       def save
-        @index.each do |key,collection|
+        raise RodException.new("The index #{self} is not opened!") unless opened?
+        if @index.empty?
+          close
+          return
+        end
+        @index.keys.each do |key|
+          collection = self[key]
+          key = key.encode("utf-8") if key.is_a?(String)
           key = Marshal.dump(key)
+          collection.save
           _put(key,collection.offset,collection.size)
         end
-        _close()
+        close
       end
 
       # Clears the contents of the index.
       def destroy
-        _close()
-        _open(@path,:truncate => true)
+        close if opened?
+        open(@path,:truncate => true)
       end
 
       # Simple iterator.
@@ -40,7 +47,9 @@ module Rod
           @index.each do |key,value|
             yield key,value
           end
-          _each do |key,value|
+          open(@path) unless opened?
+          _each_key do |key|
+            next if key.empty?
             key = Marshal.load(key)
             unless @index[key]
               yield key,self[key]
@@ -51,10 +60,46 @@ module Rod
         end
       end
 
+      # Copies the index from the given +index+.
+      # The index have to cleared before being copied.
+      def copy(index)
+        close if opened?
+        open(@path,:truncate => true)
+        super(index)
+      end
+
       protected
+      # Opens the index - initializes the index C structures
+      # and the cache.
+      # Options:
+      # * +:truncate+ - clears the contents of the index
+      # * +:create+ - creates the index if it doesn't exist
+      def open(path,options={})
+        raise RodException.new("The index #{@path} is already opened!") if opened?
+        _open(path,options)
+        @opened = true
+        @index = {} if @index.nil?
+      end
+
+      # Closes the disk - frees the C structure and clears the cache.
+      def close
+        return unless opened?
+        _close()
+        @opened = false
+        @index.clear
+      end
+
+      # Checks if the index is opened.
+      def opened?
+        @opened
+      end
+
+      # Returns a value of the index for a given +key+.
       def get(key)
         return @index[key] if @index.has_key?(key)
         begin
+          open(@path) unless opened?
+          key = key.encode("utf-8") if key.is_a?(String)
           value = _get(Marshal.dump(key))
         rescue Rod::KeyMissing => ex
           value = nil
@@ -62,11 +107,12 @@ module Rod
         @index[key] = value
       end
 
+      # Sets the +value+ for the +key+ in the internal cache.
       def set(key,value)
         @index[key] = value
       end
 
-
+      # C definition of the RodException.
       def self.rod_exception
         str =<<-END
         |VALUE rodException(){
@@ -78,6 +124,7 @@ module Rod
         str.margin
       end
 
+      # C definition of the index struct.
       def self.entry_struct
         str =<<-END
         |typedef struct rod_entry {
@@ -88,33 +135,24 @@ module Rod
         str.margin
       end
 
+      # Converts the key to the C representation.
       def self.convert_key
         str =<<-END
-        |DBT _convert_key(VALUE key){
+        |void _convert_key(VALUE key, DBT *db_key_p){
         |  long int_key;
         |  double float_key;
         |  DBT db_key;
         |
+        |  db_key = *db_key_p;
         |  memset(&db_key, 0, sizeof(DBT));
-        |  if(rb_obj_is_kind_of(key,rb_cInteger)){
-        |    int_key = NUM2LONG(key);
-        |    db_key.data = &int_key;
-        |    db_key.size = sizeof(long);
-        |  } else if(rb_obj_is_kind_of(key,rb_cFloat)){
-        |    float_key = NUM2DBL(key);
-        |    db_key.data = &float_key;
-        |    db_key.size = sizeof(double);
-        |  } else {
-        |    db_key.data = RSTRING_PTR(key);
-        |    db_key.size = RSTRING_LEN(key);
-        |  }
-        |  // is it legal?
-        |  return db_key;
+        |  db_key.data = RSTRING_PTR(key);
+        |  db_key.size = RSTRING_LEN(key);
         |}
         END
         str.margin
       end
 
+      # The C definition of the KeyMissing exception.
       def self.key_missing_exception
         str =<<-END
         |VALUE keyMissingException(){
@@ -191,8 +229,34 @@ module Rod
         builder.c(str.margin)
 
         str =<<-END
-        |void _each(){
+        |void _each_key(){
+        |  VALUE handle;
+        |  DB *db_pointer;
+        |  DBC *cursor;
+        |  DBT db_key, db_value;
+        |  int return_value;
+        |  rod_entry_struct *entry;
+        |  VALUE key;
         |
+        |  handle = rb_iv_get(self,"@handle");
+        |  Data_Get_Struct(handle,DB,db_pointer);
+        |  if(db_pointer != NULL){
+        |    db_pointer->cursor(db_pointer,NULL,&cursor,0);
+        |    memset(&db_key, 0, sizeof(DBT));
+        |    memset(&db_value, 0, sizeof(DBT));
+        |    db_key.flags = DB_DBT_MALLOC;
+        |    while((return_value = cursor->get(cursor, &db_key, &db_value, DB_NEXT)) == 0){
+        |      key = rb_str_new((char *)db_key.data,db_key.size);
+        |      free(db_key.data);
+        |      rb_yield(key);
+        |    }
+        |    if(return_value != DB_NOTFOUND){
+        |      rb_raise(rodException(),"%s",db_strerror(return_value));
+        |    }
+        |    cursor->close(cursor);
+        |  } else {
+        |    rb_raise(rodException(),"DB handle is NULL\\n");
+        |  }
         |}
         END
         builder.c(str.margin)
@@ -210,10 +274,14 @@ module Rod
         |  Data_Get_Struct(handle,DB,db_pointer);
         |  if(db_pointer != NULL){
         |    memset(&db_value, 0, sizeof(DBT));
-        |    db_key = _convert_key(key);
         |    db_value.data = &entry;
         |    db_value.ulen = sizeof(rod_entry_struct);
         |    db_value.flags = DB_DBT_USERMEM;
+        |
+        |    memset(&db_key, 0, sizeof(DBT));
+        |    db_key.data = RSTRING_PTR(key);
+        |    db_key.size = RSTRING_LEN(key);
+        |
         |    return_value = db_pointer->get(db_pointer, NULL, &db_key, &db_value, 0);
         |    if(return_value == DB_NOTFOUND){
         |      rb_raise(keyMissingException(),"%s",db_strerror(return_value));
@@ -243,16 +311,18 @@ module Rod
         |
         |  handle = rb_iv_get(self,"@handle");
         |  Data_Get_Struct(handle,DB,db_pointer);
+        |  memset(&db_key, 0, sizeof(DBT));
+        |  db_key.data = RSTRING_PTR(key);
+        |  db_key.size = RSTRING_LEN(key);
         |  memset(&db_value, 0, sizeof(DBT));
         |  entry.offset = offset;
         |  entry.size = size;
-        |  db_key = _convert_key(key);
         |  db_value.data = &entry;
         |  db_value.size = sizeof(rod_entry_struct);
         |  if(db_pointer != NULL){
         |    return_value = db_pointer->put(db_pointer, NULL, &db_key, &db_value, 0);
         |    if(return_value != 0){
-        |      rb_raise(keyMissingException(),"%s",db_strerror(return_value));
+        |      rb_raise(rodException(),"%s",db_strerror(return_value));
         |    }
         |  } else {
         |    rb_raise(rodException(),"DB handle is NULL\\n");

data/lib/rod/index/segmented_index.rb

@@ -27,7 +27,11 @@ module Rod
         @buckets.each do |bucket_number,hash|
           File.open(path_for(bucket_number),"w") do |out|
             proxy_index = {}
-            hash.each{|k,col| proxy_index[k] = [col.offset,col.size]}
+            hash.each_key do |key|
+              col = self[key]
+              col.save
+              proxy_index[key] = [col.offset,col.size]
+            end
             out.puts(Marshal.dump(proxy_index))
           end
         end

data/lib/rod/model.rb

@@ -8,6 +8,7 @@ module Rod
   class Model < AbstractModel
     include ActiveModel::Validations
     include ActiveModel::Dirty
+    extend Utils
     extend Enumerable
 
     # A list of updaters that has to be notified when the +rod_id+
@@ -259,11 +260,11 @@ module Rod
       if properties[property][:index].nil?
         raise RodException.new("Property '#{property}' doesn't have an index!")
       end
-      index_for(property,properties[property]).destroy
-      instance_variable_set("@#{property}_index",nil)
       index = index_for(property,properties[property])
-      self.each do |object|
+      index.destroy
+      self.each.with_index do |object,position|
         index[object.send(property)] << object
+        report_progress(position,self.count) if $ROD_DEBUG
       end
     end
 
@@ -476,7 +477,19 @@ module Rod
       old_metadata = self.metadata
       old_metadata.merge!({:superclass => old_metadata[:superclass].sub(LEGACY_RE,"")})
       new_class = self.name.sub(LEGACY_RE,"").constantize
-      return if new_class.compatible?(old_metadata)
+      if new_class.compatible?(old_metadata)
+        backup_path = self.path_for_data(database.path)
+        new_path = new_class.path_for_data(database.path)
+        puts "Copying #{backup_path} to #{new_path}" if $ROD_DEBUG
+        FileUtils.cp(backup_path,new_path)
+        new_class.indexed_properties.each do |name,options|
+          backup_path = self.index_for(name,options).path
+          new_path = new_class.index_for(name,options).path
+          puts "Copying #{backup_path} to #{new_path}" if $ROD_DEBUG
+          FileUtils.cp(backup_path,new_path)
+        end
+        return
+      end
       database.send(:allocate_space,new_class)
 
       puts "Migrating #{new_class}" if $ROD_DEBUG
@@ -509,22 +522,26 @@ module Rod
                               old_object.send("_#{name}_length",position+1))
               new_object.send("_#{name}_offset=",position+1,
                               old_object.send("_#{name}_offset",position+1))
+              report_progress(position,self.count) if $ROD_DEBUG
             end
           else
             self.count.times do |position|
               new_object.send("_#{name}=",position + 1,
                               old_object.send("_#{name}",position + 1))
+              report_progress(position,self.count) if $ROD_DEBUG
             end
           end
         elsif self.singular_association?(name)
           self.count.times do |position|
             new_object.send("_#{name}=",position + 1,
                             old_object.send("_#{name}",position + 1))
+            report_progress(position,self.count) if $ROD_DEBUG
           end
           if options[:polymorphic]
             self.count.times do |position|
               new_object.send("_#{name}__class=",position + 1,
                               old_object.send("_#{name}__class",position + 1))
+              report_progress(position,self.count) if $ROD_DEBUG
             end
           end
         else
@@ -533,9 +550,10 @@ module Rod
                             old_object.send("_#{name}_count",position + 1))
             new_object.send("_#{name}_offset=",position + 1,
                             old_object.send("_#{name}_offset",position + 1))
+            report_progress(position,self.count) if $ROD_DEBUG
           end
         end
-        puts "done" if $ROD_DEBUG
+        puts " done" if $ROD_DEBUG
       end
       # Migrate the indices.
       new_class.indexed_properties.each do |name,options|
@@ -544,14 +562,18 @@ module Rod
         if old_index_type.nil?
           print "-  building index #{options[:index]} for '#{name}'... " if $ROD_DEBUG
           new_class.rebuild_index(name)
-          puts "done" if $ROD_DEBUG
+          puts " done" if $ROD_DEBUG
+        elsif options[:index] == old_index_type
+          backup_path = self.index_for(name,options).path
+          new_path = new_class.index_for(name,options).path
+          puts "Copying #{backup_path} to #{new_path}" if $ROD_DEBUG
+          FileUtils.cp(backup_path,new_path)
         else
-          # TODO if index is the same, its file should be copied
           print "-  copying index #{options[:index]} for '#{name}'... " if $ROD_DEBUG
           new_index = new_class.index_for(name,options)
           old_index = index_for(name,self.properties[name])
           new_index.copy(old_index)
-          puts "done" if $ROD_DEBUG
+          puts " done" if $ROD_DEBUG
         end
       end
     end
@@ -978,7 +1000,7 @@ module Rod
                 end
                 value = database.read_string(length, offset, options)
                 if options[:type] == :object
-                  value = Marshal.load(value)
+                  value = Marshal.load(value) rescue nil
                 end
                 # caching Ruby representation
                 # don't use writer - avoid change tracking
@@ -1085,6 +1107,7 @@ module Rod
         # setter
         define_method("#{name}=") do |value|
           proxy = send(name)
+          proxy.clear
           value.each do |object|
             proxy << object
           end

data/lib/rod/utils.rb

@@ -25,5 +25,20 @@ module Rod
     def remove_files_but(name)
       remove_files(name.sub(INLINE_PATTERN_RE,"*"),name)
     end
+
+    # Reports progress of long-running operation.
+    # The +index+ is the current operation's step
+    # of +count+ steps.
+    def report_progress(index,count)
+      step = (count.to_f/50).to_i
+      return if step == 0
+      if index % step == 0
+        if index % (5 * step) == 0
+          print "#{(index / (5 * step) * 10)}%"
+        else
+          print "."
+        end
+      end
+    end
   end
 end

data/tests/migration_create.rb

@@ -49,4 +49,7 @@ count.times do |index|
   users << user2
 end
 
+house = House.new(:name => "cottage house")
+house.store
+
 Database.instance.close_database

data/tests/migration_migrate.rb

@@ -36,4 +36,7 @@ count.times do |index|
   user.store
 end
 
+# Force the creation of index key with empty proxy.
+House.find_by_name("doesn't exist")
+
 Database.instance.close_database

data/tests/migration_model1.rb

@@ -29,3 +29,7 @@ class UserFile < Model
   field :data, :string
   field :path, :string
 end
+
+class House < Model
+  field :name, :string, :index => :hash
+end

data/tests/migration_model2.rb

@@ -70,3 +70,7 @@ class UserFile < Model
   field :name, :string, :index => :flat
 end
 
+# The whole class is the same.
+class House < Model
+  field :name, :string, :index => :hash
+end

data/tests/migration_verify.rb

@@ -8,9 +8,17 @@ Rod::Database.development_mode = true
 Database.instance.open_database("tmp/migration")
 
 count = (ARGV[0] || 10).to_i
+key_count = 0
+User.index_for(:street,:index => :hash).each do |key,proxy|
+  key_count += 1
+  proxy.to_a.should == User.find_all_by_street(key).to_a
+  proxy.count.should > 0
+end
+key_count.should > 0
 count.times do |index|
   user1 = User[index*2]
   user1.should_not == nil
+  user1.name.should == "John#{index}"
   user = User.find_by_name("John#{index}")
   user.should == user1
   users = User.find_all_by_city("City#{index}")
@@ -41,7 +49,7 @@ count.times do |index|
   user = User.find_by_name("Amanda#{index}")
   user.should == user2
   user = User.find_by_city("Bigcity#{index}")
-  #user.should == user2
+  user.should == user2
   user = User.find_by_street("Small street#{index}")
   user.should == user2
   user2.name.should == "Amanda#{index}"
@@ -72,4 +80,10 @@ users.size.should == 2
 users[0].should == User[0]
 users[1].should == User[1]
 
+house = House.find_by_name("cottage house")
+house.should_not == nil
+house.name.should == "cottage house"
+house = House.find_by_name("doesn't exist")
+house.should == nil
+
 Database.instance.close_database

metadata

@@ -2,7 +2,7 @@
 name: rod
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors: 
 - Aleksander Pohl
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-12 00:00:00 Z
+date: 2011-11-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: RubyInline