mongoose 0.2.0 → 0.2.5

data/lib/mongoose/util.rb

@@ -3,6 +3,24 @@
 module Mongoose
 
 module Util
+  SINGULAR_TO_PLURAL = Hash.new { |h, k| h[k] = k.to_s + 's' }
+  PLURAL_TO_SINGULAR = Hash.new do |h, k| 
+                         h[k] =  if md = k.to_s.match(/\A(.*)s\z/)
+                                   md[1]
+                                 else
+                                   raise(ArgumentError, "Please use " +
+                                    "plural_form for this special case")
+                                 end
+                       end
+
+  SPECIAL_PLURALIZATION_CASES = { "child" => "children", "person" => "people",
+  "mouse" => "mice" }
+  
+  SINGULAR_TO_PLURAL.update SPECIAL_PLURALIZATION_CASES
+  PLURAL_TO_SINGULAR.update SPECIAL_PLURALIZATION_CASES.invert
+
+
+                                                        
 # converts from things like user_name to things like UserName
 def self.us_case_to_class_case(name)
   name.to_s.split(/_/).map do |word|
@@ -12,22 +30,17 @@ end
 
 # converts from things like UserName to things like user_name
 def self.class_case_to_us_case(name)
-  decapitalized = name.to_s.sub(/^./) { |match| match.downcase }
-  decapitalized.gsub(/[A-Z]/) { |match| "_" + match.downcase }
+  name.split(/(?=[A-Z])/).map { |s| s.downcase }.join('_')
 end
 
 # Adds an s
 def self.pluralize(name)
-  name.to_s + 's'
+  SINGULAR_TO_PLURAL[name]
 end
 
 # chops an s
 def self.singularize(name)
-  if md = name.to_s.match(/^(.+?)s\z/)
-    md[1]
-  else
-    raise RuntimeError, "#{name} is not plural"
-  end
+  PLURAL_TO_SINGULAR[name]
 end
 
 def self.col_name_for_class(name)

data/test/tc_relations.rb

@@ -21,6 +21,16 @@ class Flight < Mongoose::Table
   belongs_to :pilot
 end
 
+class Ox < Mongoose::Table
+  plural_form 'oxen'
+  belongs_to :farmer
+end
+
+class Farmer < Mongoose::Table
+  has_many :oxen
+end
+
+
 class TestRelations < Test::Unit::TestCase
   def setup
     @db = Mongoose::Database.new(:path => Dir.tmpdir)
@@ -44,6 +54,14 @@ class TestRelations < Test::Unit::TestCase
       tbl.add_column(:pilot_id, :integer)
     end
 
+    @db.create_table(:ox) do |tbl|
+      tbl.add_column(:farmer_id, :integer)
+    end
+
+    @db.create_table(:farmer) do |tbl|
+      tbl.add_column(:name, :string)
+    end
+
     @doolittle = Pilot.create :name => 'Doolittle, James', :years_flying => 15
     @amelia = Pilot.create :name => 'Earhart, Amelia', :years_flying => 10
 
@@ -60,12 +78,17 @@ class TestRelations < Test::Unit::TestCase
      :destination => 'Phillipines'
     Flight.create :pilot_id => @amelia.id, :origin => 'China',
      :destination => 'Unknown'
+
+    @farmer = Farmer.create :name => 'Old McDonald'
+    Ox.create :farmer_id => @farmer.id
   end
 
   def teardown
     @db.drop_table(:pilot)
     @db.drop_table(:plane)
     @db.drop_table(:flight)
+    @db.drop_table(:farmer)
+    @db.drop_table(:ox)
     @db.close
   end
 
@@ -93,10 +116,14 @@ class TestRelations < Test::Unit::TestCase
 
   def test_belongs_to_002
     red_baron = Pilot.create :name => 'Baron, The Red', :years_flying => 50
-    spitfire = Plane.find(:first) { name == 'Spitfire'}
+    spitfire = Plane.find(:first) { |p| p.name == 'Spitfire' }
     spitfire.pilot = red_baron
 
     assert('Baron, The Red', spitfire.pilot.name)
     assert_equal('Spitfire', red_baron.plane.name)
   end
+
+  def test_plural_form
+    assert_equal(1, @farmer.oxen.size)
+  end
 end

data/test/tc_table.rb

@@ -35,6 +35,9 @@ class TestTable < Test::Unit::TestCase
   def teardown
     @db.drop_table(:plane)
     @db.close
+
+    File.delete(File.join(Dir.tmpdir, 'plane.csv')) if File.exists?(File.join(
+     Dir.tmpdir, 'plane.csv'))
   end
 
   def test_table_exists
@@ -44,6 +47,14 @@ class TestTable < Test::Unit::TestCase
     assert_equal(5, Plane.columns.size)
   end
 
+  def test_add_record_from_hash
+    rec = Plane.new(:name => 'Zero', :country => 'Japan', :speed => 377,
+     :range => 888)
+    rec.save
+
+    assert_equal(1, Plane.find_all_by_name('Zero').size)
+  end
+
   def test_add_record
     rec = Plane.new
     rec.name = 'Zero'
@@ -62,6 +73,14 @@ class TestTable < Test::Unit::TestCase
     assert_equal(888, rec2.range)
   end
 
+  def test_update_attributes
+    rec = Plane.find(2)
+    rec.update_attributes(:country => 'England', :speed => 119)
+    
+    assert_equal('England', Plane.find(2).country)
+    assert_equal(119, Plane.find(2).speed)
+  end
+
   def test_update_record_001
     rec = Plane.find(2)
     rec.country = 'England'
@@ -83,7 +102,7 @@ class TestTable < Test::Unit::TestCase
   end 
 
   def find_001
-    rec = Plane.find(:first) { name == 'P-51' }
+    rec = Plane.find(:first) { |p| p.name == 'P-51' }
 
     assert(rec.is_a?(Plane))
     assert_equal(rec.name, 'P-51')
@@ -99,7 +118,7 @@ class TestTable < Test::Unit::TestCase
   end 
 
   def find_002
-    recs = Plane.find { name == 'P-51' }
+    recs = Plane.find { |p| p.name == 'P-51' }
 
     assert_equal(recs.size, 1)
     assert(recs.first.is_a?(Plane))
@@ -122,30 +141,61 @@ class TestTable < Test::Unit::TestCase
   end 
 
   def find_003
-    recs = Plane.find do 
-      any do
-        country == 'USA'
-        country == 'Great Britain'
+    recs = Plane.find do |p|
+      p.any do
+        p.country == 'USA'
+        p.country == 'Great Britain'
       end
     end
     assert_equal(recs.size, 3)
 
-    recs = Plane.find do 
-      any do
-        country == 'USA'
-        country == 'Great Britain'
+    recs = Plane.find do |p|
+      p.any do
+        p.country == 'USA'
+        p.country == 'Great Britain'
       end
-      speed > 400
+      p.speed > 400
     end
     assert_equal(recs.size, 2)
 
-    recs = Plane.find do 
-      any do
-        country == 'USA'
-        country == 'Great Britain'
+    recs = Plane.find do |p|
+      p.speed > 400
+      p.any do
+        p.country == 'USA'
+        p.country == 'Great Britain'
       end
-      speed > 400
-      range > 1000
+    end
+    assert_equal(recs.size, 2)
+
+    recs = Plane.find do |p|
+      p.any do
+        p.country == 'USA'
+        p.country == 'Great Britain'
+      end
+      p.speed > 400
+      p.range > 1000
+    end
+    assert_equal(recs.size, 1)
+    assert_equal(recs.first.name, 'P-51')
+
+    recs = Plane.find do |p|
+      p.speed > 400
+      p.range > 1000
+      p.any do
+        p.country == 'USA'
+        p.country == 'Great Britain'
+      end
+    end
+    assert_equal(recs.size, 1)
+    assert_equal(recs.first.name, 'P-51')
+
+    recs = Plane.find do |p|
+      p.speed > 400
+      p.any do
+        p.country == 'USA'
+        p.country == 'Great Britain'
+      end
+      p.range > 1000
     end
     assert_equal(recs.size, 1)
     assert_equal(recs.first.name, 'P-51')
@@ -161,23 +211,23 @@ class TestTable < Test::Unit::TestCase
   end 
 
   def find_004
-    recs = Plane.find { name.one_of('P-51', 'ME-109') } 
+    recs = Plane.find { |p| p.name.one_of('P-51', 'ME-109') } 
     assert_equal(recs.size, 2)
 
-    recs = Plane.find { country.one_of('USA', 'Germany') } 
+    recs = Plane.find { |p| p.country.one_of('USA', 'Germany') } 
     assert_equal(recs.size, 3)
 
-    recs = Plane.find { speed.between(351, 400) }
+    recs = Plane.find { |p| p.speed.between(351, 400) }
     assert_equal(0, recs.size)
 
-    recs = Plane.find { speed.between(351, 400, true) }
+    recs = Plane.find { |p| p.speed.between(351, 400, true) }
     assert_equal(1, recs.size)
     assert_equal('ME-109', recs.first.name)
 
-    recs = Plane.find { range.between(450, 501) }
+    recs = Plane.find { |p| p.range.between(450, 501) }
     assert_equal(1, recs.size)
 
-    recs = Plane.find { range.between(450, 501, false, true) }
+    recs = Plane.find { |p| p.range.between(450, 501, false, true) }
     assert_equal(2, recs.size)
   end 
 
@@ -190,12 +240,82 @@ class TestTable < Test::Unit::TestCase
     find_004
   end 
 
-  def test_destroy
-    rec = Plane.find(:first) { name == 'P-51' }
+  def find_005
+    assert_equal('P-51', Plane.find(1).name) 
+
+    recs = Plane.find(1,3) 
+    assert_equal(2, recs.size)
+  end
+
+  def test_find_005
+    find_005
+
+    @db.close
+    @db = Mongoose::Database.new(:path => Dir.tmpdir)
+
+    find_005
+  end
+
+  def test_find_by_001
+    assert_equal('Spitfire', Plane.find_by_name('Spitfire').name)
+    assert_equal('P-51', Plane.find_by_id(1).name)
+  end
+
+  def test_find_all_by_001
+    assert(2, Plane.find_all_by_country('USA').size)
+    assert('P-38', Plane.find_all_by_country('USA', :order => :name).first.name)
+  end
+
+  def test_destroy_001
+    rec = Plane.find(:first) { |p| p.name == 'P-51' }
     rec.destroy
 
     recs = Plane.find 
 
     assert_equal(recs.size, 3)
   end 
+
+  def test_destroy_002
+    Plane.destroy(1)
+
+    assert_nil(Plane.find(1))
+  end 
+
+  def test_content_columns
+    assert_equal([:name,:country,:speed,:range], 
+     Plane.content_columns.collect {|c| c.name})
+  end
+
+  def test_exists?
+    assert(Plane.exists?(1))
+    assert(!Plane.exists?(0))
+  end
+
+  def test_limit_001
+    assert_equal(2, Plane.find(:limit => 2).size)
+  end
+
+  def test_order_001
+    assert_equal('ME-109', Plane.find(:order => :name).first.name)
+    assert_equal('ME-109', Plane.find(:first, :order => :name).name)
+    assert_equal('P-38', Plane.find(:order => [:country, :name])[2].name)
+    assert_equal('P-38', Plane.find(:first, :offset => 3, 
+     :order => [:country, :name]).name)
+    assert_equal('P-51', Plane.find(:order => [:country, -:name])[2].name)
+    assert_equal('P-51', Plane.find(:first, :offset => 3, 
+     :order => [:country, -:name]).name)
+  end
+
+  def test_offset_001
+    assert_equal('Spitfire', Plane.find(:first, :order => :country, :offset => 2
+     ).name)
+  end
+
+  def test_export_import
+    Plane.export(File.join(Dir.tmpdir, 'plane.csv'))
+    assert(File.exists?(File.join(Dir.tmpdir, 'plane.csv')))
+
+    Plane.import(File.join(Dir.tmpdir, 'plane.csv'))
+    assert_equal(4, Plane.find.size)
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: mongoose
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2006-07-21 00:00:00 -04:00
+  version: 0.2.5
+date: 2006-07-25 00:00:00 -04:00
 summary: Mongoose is a pure_ruby database management system.
 require_paths: 
 - lib
@@ -36,6 +36,10 @@ files:
 - lib/mongoose/table.rb
 - lib/mongoose/util.rb
 - lib/mongoose/column.rb
+- lib/mongoose/query.rb
+- lib/mongoose/error.rb
+- bin/mongoose_import.rb
+- bin/mongoose_export.rb
 - README
 - changes.txt
 - test/tc_database.rb
@@ -51,8 +55,9 @@ rdoc_options: []
 
 extra_rdoc_files: []
 
-executables: []
-
+executables: 
+- mongoose_import.rb
+- mongoose_export.rb
 extensions: []
 
 requirements: