mongoose 0.1.0 → 0.1.1

data/lib/mongoose/table.rb

@@ -67,7 +67,7 @@ class Table
   #-----------------------------------------------------------------------------
   def self.has_many(kind)
     table_name = Util.singularize(kind.to_s).to_sym
-    class_name = Util.us_case_to_class_case(table_name.to_s)
+    class_name = Util.us_case_to_class_case(table_name)
     col = Util.col_name_for_class(self.to_s)
 
     define_method(kind.to_sym) do 
@@ -82,7 +82,7 @@ class Table
   #-----------------------------------------------------------------------------
   def self.has_one(kind)
     table_name = kind.to_sym
-    class_name = Util.us_case_to_class_case(table_name.to_s)
+    class_name = Util.us_case_to_class_case(table_name)
     col = Util.col_name_for_class(self.to_s)
 
     define_method(kind.to_sym) do
@@ -95,7 +95,8 @@ class Table
   # Table.belongs_to
   #-----------------------------------------------------------------------------
   def self.belongs_to(kind)
-    class_name = Util.us_case_to_class_case(kind.to_sym)
+    table_name = kind.to_sym
+    class_name = Util.us_case_to_class_case(table_name)
 
     define_method(kind) do
       klass = Object.const_get(class_name.to_s)
@@ -113,28 +114,14 @@ class Table
   # Table.last_id_used
   #-----------------------------------------------------------------------------
   def self.last_id_used
-    self.db.tables[self][:last_id_used]
-  end
-
-  #-----------------------------------------------------------------------------
-  # Table.last_id_used=
-  #-----------------------------------------------------------------------------
-  def self.last_id_used=(value)
-    self.db.tables[self][:last_id_used] = value
+    self.class.read_header[:last_id_used]
   end
 
   #-----------------------------------------------------------------------------
   # Table.deleted_recs_counter
   #-----------------------------------------------------------------------------
   def self.deleted_recs_counter
-    self.db.tables[self][:deleted_recs_counter]
-  end
-
-  #-----------------------------------------------------------------------------
-  # Table.deleted_recs_counter=
-  #-----------------------------------------------------------------------------
-  def self.deleted_recs_counter=(value)
-    self.db.tables[self][:deleted_recs_counter]=(value)
+    self.class.read_header[:deleted_recs_counter]
   end
 
   #-----------------------------------------------------------------------------
@@ -149,21 +136,16 @@ class Table
   # Table.write_header
   #-----------------------------------------------------------------------------
   def self.write_header(header)
-    File.open(File.join(self.path, self.table_name.to_s + TBL_HDR_EXT), 'w') do |f|
-      YAML.dump(header, f)
-    end
+    File.open(File.join(self.path, self.table_name.to_s + TBL_HDR_EXT), 'w'
+     ) { |f| YAML.dump(header, f) }
   end
 
   #-----------------------------------------------------------------------------
   # Table.init_table
   #-----------------------------------------------------------------------------
   def self.init_table
- 
     tbl_header = self.read_header
 
-    self.last_id_used = tbl_header[:last_id_used]
-    self.deleted_recs_counter = tbl_header[:deleted_recs_counter]
-
     self.read_header[:columns].each do |c| 
       self.init_column(c[:name], c[:data_type], Object.full_const_get(c[:class])
        ) 
@@ -385,9 +367,7 @@ class Table
   # initialize
   #-----------------------------------------------------------------------------
   def initialize(*values)
-    self.class.columns.zip(values).each do |c,v|
-      send("#{c.name}=", v)
-    end
+    self.class.columns.zip(values).each { |c,v| send("#{c.name}=", v) }
   end
 
   #-----------------------------------------------------------------------------
@@ -395,25 +375,23 @@ class Table
   #-----------------------------------------------------------------------------
   def save
     self.class.columns.each do |c|
+      # First checks to see if validates_presence_of was set in class def.
       raise "Value required for #{c.name}!" if respond_to?('required?') and \
        required?(c.name) and send(c.name).nil?
+      # Next checks to see if validates_presence_of was set in #add_column.
       raise "Value required for #{c.name}!" if c.required? and send(c.name).nil?
     end
 
+    # Add new record.
     if @id.nil?
-      tbl_header = self.class.read_header
-      self.class.last_id_used += 1
-
-      append_record(self.class.last_id_used, 
-       self.class.column_names[1..-1].collect { |col_name| send(col_name) })
-
-      @id = self.class.last_id_used
-      tbl_header[:last_id_used] = self.class.last_id_used
-      self.class.write_header(tbl_header)
+      id = increment_last_id_used
+      append_record(id, self.class.column_names[1..-1].collect { |col_name| 
+       send(col_name) })
+      @id = id
+    # Update existing record.
     else
       update_record(@id, self.class.columns[1..-1].collect { |c| send(c.name) })
     end
-
     return true
   end
 
@@ -431,12 +409,16 @@ class Table
       raise IndexCorruptError, "Index ID does not match table ID!", caller \
        unless rec[1] == @id
 
+      # First array position of record is the deleted flag:  true means deleted
       rec[0] = true
 
+      # Record is not actually deleted; it just has its deleted flag set to
+      # true.
       write_record(fptr, fpos_rec_start, Marshal.dump(rec))
       increment_deleted_recs_counter
     end
 
+    # Remove all index recs pointing to this record.
     self.class.columns.each_with_index do |c,i|
       if i == 0
         c.remove_index_rec(@id)
@@ -445,6 +427,7 @@ class Table
       end
     end
 
+    # Don't allow any more changes to this record.
     freeze
   end
 
@@ -463,9 +446,12 @@ class Table
       fptr.seek(0, IO::SEEK_END)
       fpos = fptr.tell
 
+      # Append record to end of file, making sure to add deleted flag and record
+      # id to front of record.
       fpos = write_record(fptr, 'end', Marshal.dump([false, id].concat(values)))
     end
 
+    # Update indexes with new record.
     self.class.columns.each_with_index do |c,i|
       if i == 0
         c.add_index_rec(id, fpos)
@@ -495,15 +481,25 @@ class Table
 
       old_rec_length = fptr.tell - fpos_rec_start
 
+      # If updates did not change record length, we can write it back out to
+      # the same spot in the file...
       if new_rec.length == old_rec_length
         write_record(fptr, fpos_rec_start, new_rec)
       else
-        fpos = write_record(fptr, 'end', new_rec)
+        # Set deleted flag to true and update old rec position.  Increment
+        # deleted records counter.
+        old_rec[0] = true
+        write_record(fptr, fpos_rec_start, Marshal.dump(old_rec))
         increment_deleted_recs_counter
+
+        # Append the updated record to the end of the file and update the 
+        # record id index.
+        fpos = write_record(fptr, 'end', new_rec)
         self.class.columns[0].add_index_rec(id, fpos)
       end  
     end
 
+    # Update all of the indexed columns with the updated record data.
     self.class.columns[1..-1].each do |c| 
       unless temp_instance.send(c.name) == send(c.name)
         if c.indexed? 
@@ -514,14 +510,24 @@ class Table
     end
   end
 
+  #-----------------------------------------------------------------------------
+  # increment_last_id_used
+  #-----------------------------------------------------------------------------
+  def increment_last_id_used
+    tbl_header = self.class.read_header
+    tbl_header[:last_id_used] += 1
+    self.class.write_header(tbl_header)
+    return tbl_header[:last_id_used]
+  end
+
   #-----------------------------------------------------------------------------
   # increment_deleted_recs_counter
   #-----------------------------------------------------------------------------
   def increment_deleted_recs_counter
     tbl_header = self.class.read_header
-    self.class.deleted_recs_counter += 1
-    tbl_header[:deleted_recs_counter] = self.class.deleted_recs_counter
+    tbl_header[:deleted_recs_counter] += 1
     self.class.write_header(tbl_header)
+    return tbl_header[:deleted_recs_counter]
   end
 
   #-----------------------------------------------------------------------------
@@ -551,7 +557,7 @@ class Collection
   end
 
   def each
-    records.each { |rec| yield rec }
+    @records.each { |rec| yield rec }
   end
 
   def <<(rec)
@@ -563,6 +569,10 @@ class Collection
   def append(rec)
     self << rec
   end
+
+  def size
+    @records.size
+  end
 end
 
 end

data/lib/mongoose/util.rb

@@ -37,7 +37,7 @@ end
 def self.class_name_for_col(name)
   us_case_to_class_case(name.sub(/_id\z/, ''))
 end
-		
+
 end
 
 end

data/test/tc_relations.rb

@@ -0,0 +1,139 @@
+require 'test/unit'
+require 'tmpdir'
+
+begin
+  require 'rubygems'
+  require_gem 'Mongoose'
+rescue LoadError
+  require 'mongoose'
+end
+
+class Pilot < Mongoose::Table
+  has_one :plane
+  has_many :flights
+end
+
+class Plane < Mongoose::Table
+  belongs_to :pilot
+end
+
+class Flight < Mongoose::Table
+  belongs_to :pilot
+end
+
+class TestRelations < Test::Unit::TestCase
+  def setup
+    @db = Mongoose::Database.new(:path => Dir.tmpdir)
+
+    @db.create_table(:pilot) do |tbl|
+      tbl.add_indexed_column(:pilot_name, :string)
+      tbl.add_column(:years_flying, :integer)
+    end
+
+    @db.create_table(:plane) do |tbl|
+      tbl.add_indexed_column(:plane_name, :string)
+      tbl.add_column(:country, :string)
+      tbl.add_indexed_column(:speed, :integer)
+      tbl.add_column(:range, :integer)
+      tbl.add_column(:pilot_id, :integer)
+    end
+
+    @db.create_table(:flight) do |tbl|
+      tbl.add_column(:origin, :string)
+      tbl.add_column(:destination, :string)
+      tbl.add_column(:pilot_id, :integer)
+    end
+
+    @doolittle = Pilot.new
+    @doolittle.pilot_name = 'Doolittle, James'
+    @doolittle.years_flying = 15
+    @doolittle.save
+
+    @amelia = Pilot.new
+    @amelia.pilot_name = 'Earhart, Amelia'
+    @amelia.years_flying = 10
+    @amelia.save
+
+    rec = Plane.new
+    rec.plane_name = 'P-51'
+    rec.country = 'USA'
+    rec.speed = 402
+    rec.range = 1205
+    rec.pilot_id = @doolittle.id
+    rec.save 
+
+    rec = Plane.new
+    rec.plane_name = 'Spitfire'
+    rec.country = 'Great Britain'
+    rec.speed = 333
+    rec.range = 454
+    rec.pilot_id = @amelia.id
+    rec.save 
+
+    rec = Flight.new
+    rec.pilot_id = @doolittle.id
+    rec.origin = 'Army'
+    rec.destination = 'Nowhere'
+    rec.save
+
+    rec = Flight.new
+    rec.pilot_id = @amelia.id
+    rec.origin = 'USA'
+    rec.destination = 'France'
+
+    rec.save
+    rec = Flight.new
+    rec.pilot_id = @amelia.id
+    rec.origin = 'USA'
+    rec.destination = 'Phillipines'
+    rec.save
+
+    rec = Flight.new
+    rec.pilot_id = @amelia.id
+    rec.origin = 'China'
+    rec.destination = 'Unknown'
+    rec.save
+  end
+
+  def teardown
+    @db.drop_table(:pilot)
+    @db.drop_table(:plane)
+    @db.drop_table(:flight)
+    @db.close
+  end
+
+  def test_has_one
+    assert_equal('P-51', @doolittle.plane.plane_name)
+  end
+
+  def test_has_many_001
+    assert_equal(3, @amelia.flights.size)
+    assert(@amelia.flights.any? {|f| f.destination == 'France'}) 
+  end
+
+  def test_has_many_002
+    rec = Flight.new
+    rec.pilot_id = @amelia.id
+    rec.origin = 'Tuscon'
+    rec.destination = 'Phoenix'
+    @amelia.flights << rec
+
+    assert(@amelia.flights.any? {|f| f.origin == 'Tuscon'})
+  end
+
+  def test_belongs_to_001
+    assert_equal('Earhart, Amelia', Plane.find(2).pilot.pilot_name)
+    assert_equal('Doolittle, James', Flight.find(1).pilot.pilot_name)
+  end
+
+  def test_belongs_to_002
+    red_baron = Pilot.new
+    red_baron.pilot_name = 'Baron, The Red'
+    red_baron.years_flying = 50
+    spitfire = Plane.find(:first) {|plane| plane.plane_name == 'Spitfire'}
+    spitfire.pilot = red_baron
+
+    assert('Baron, The Red', spitfire.pilot.pilot_name)
+    assert_equal('Spitfire', red_baron.plane.plane_name)
+  end
+end

data/test/tc_table.rb

@@ -74,7 +74,17 @@ class TestTable < Test::Unit::TestCase
     assert_equal(1205, rec.range)
   end
 
-  def test_update_record
+  def test_update_record_001
+    rec = Plane.find(2)
+    rec.country = 'England'
+    rec.save
+
+    rec = Plane.find(2)
+
+    assert_equal('England', rec.country)
+  end 
+
+  def test_update_record_002
     rec = Plane.find(1)
     rec.speed = 405
     rec.save
@@ -84,14 +94,23 @@ class TestTable < Test::Unit::TestCase
     assert_equal(rec.speed, 405)
   end 
 
-  def test_find_001
+  def find_001
     rec = Plane.find(:first) { |plane| plane.name == 'P-51' }
 
     assert(rec.is_a?(Plane))
     assert_equal(rec.name, 'P-51')
+  end
+
+  def test_find_001
+    find_001
+
+    @db.close
+    @db = Mongoose::Database.new(:path => Dir.tmpdir)
+    
+    find_001
   end 
 
-  def test_find_002
+  def find_002
     recs = Plane.find { |plane| plane.name == 'P-51' }
 
     assert_equal(recs.size, 1)
@@ -105,7 +124,16 @@ class TestTable < Test::Unit::TestCase
     assert_equal(recs[1].name, 'Spitfire')
   end 
 
-  def test_find_003
+  def test_find_002
+    find_002
+
+    @db.close
+    @db = Mongoose::Database.new(:path => Dir.tmpdir)
+    
+    find_002
+  end 
+
+  def find_003
     recs = Plane.find do |plane| 
       plane.any do
         plane.country == 'USA'
@@ -135,7 +163,16 @@ class TestTable < Test::Unit::TestCase
     assert_equal(recs.first.name, 'P-51')
   end 
 
-  def test_find_004
+  def test_find_003
+    find_003
+
+    @db.close
+    @db = Mongoose::Database.new(:path => Dir.tmpdir)
+    
+    find_003
+  end 
+
+  def find_004
     recs = Plane.find { |plane| plane.name.one_of('P-51', 'ME-109') } 
     assert_equal(recs.size, 2)
 
@@ -156,6 +193,15 @@ class TestTable < Test::Unit::TestCase
     assert_equal(2, recs.size)
   end 
 
+  def test_find_004
+    find_004
+
+    @db.close
+    @db = Mongoose::Database.new(:path => Dir.tmpdir)
+    
+    find_004
+  end 
+
   def test_destroy
     rec = Plane.find(:first) { |plane| plane.name == 'P-51' }
     rec.destroy