mongoose 0.2.0 → 0.2.5

data/README

@@ -1,4 +1,4 @@
-= Mongoose 0.2.0
+= Mongoose 0.2.5
 
 A database management system written in Ruby.  It has an ActiveRecord-like
 interface, uses Skiplists for its indexing, and Marshal for its data 
@@ -15,6 +15,8 @@ provided much of the inspiration for the query language.  Also, Ezra has
 graciously taken the time to give me pointers on how to make Mongoose's query
 language and api better.
 
+Thanks to everyone who has given me feedback so far on Mongoose.
+
 Thanks to everyone who gave me feedback on KirbyBase.  I have tried to put all
 the lessons learned from developing that library to good use here.
 
@@ -64,7 +66,7 @@ db.create_table(:plane) do |tbl|
   tbl.add_column(:range, :integer)
 end
 
-# Add a record.
+# Add a record.  You can also use #create.
 rec = Plane.new
 rec.name = 'P-51'
 rec.country = 'USA'
@@ -75,18 +77,18 @@ rec.save
 # Various ways to find a record; should be familiar to ActiveRecord users.
 Plane.find(1)  # Find record with id equal 1.
 
-Plane.find { speed > 350 }  # Find all planes with speed > 350.
+Plane.find { |plane| plane.speed > 350 }  # Find all planes with speed > 350.
 
 Plane.find  # Find all records.
 
-Plane.find(:first) { country == 'USA' }  # Find first plane from USA.
+Plane.find(:first) { |plane| plane.country == 'USA' }  # Find first plane from USA.
 
-Plane.find do                   # Find all planes from either USA or
-  any do                        # Great Britain with speed > 400.
-    country == 'USA'
-    country == 'Great Britain'
+Plane.find do |plane|                  # Find all planes from either USA or
+  plane.any do                         # Great Britain with speed > 400.
+    plane.country == 'USA'
+    plane.country == 'Great Britain'
   end
-  speed > 400
+  plane.speed > 400
 end
 
 # Delete a record.
@@ -101,7 +103,8 @@ db.close
 * README - this file
 * install.rb - install script
 * changes.txt - history of changes.
-* lib directory - dbms module
+* lib directory - dbms module
+* bin directory - import, export scripts
 * test directory - unit tests
 * examples directory - many example scripts demonstrating features.
 * images directory - images used in manual.

data/bin/mongoose_export.rb

@@ -0,0 +1,17 @@
+begin
+  require 'rubygems'
+  require_gem 'Mongoose'
+rescue LoadError
+  require 'mongoose'
+end
+
+raise "Must supply class name to export!" unless ARGV.size > 0
+
+class_name = ARGV[0]
+filename = 1
+filename = ARGV[1] if ARGV.size > 1
+
+Object.const_set(ARGV[0], Class.new(Mongoose::Table))
+
+db = Mongoose::Database.new
+Object.const_get(class_name).export(filename)

data/bin/mongoose_import.rb

@@ -0,0 +1,17 @@
+begin
+  require 'rubygems'
+  require_gem 'Mongoose'
+rescue LoadError
+  require 'mongoose'
+end
+
+raise "Must supply class name to import!" unless ARGV.size > 0
+
+class_name = ARGV[0]
+filename = 0
+filename = ARGV[1] if ARGV.size > 1
+
+Object.const_set(ARGV[0], Class.new(Mongoose::Table))
+
+db = Mongoose::Database.new
+Object.const_get(class_name).import(filename)

data/changes.txt

@@ -23,3 +23,27 @@
   eliminated the string eval.  Thanks Logan!
 * Included a new example from Daniel Sheppard that shows how to integrate
   ActiveRecord validations into Mongoose.
+
+2006-07-25:: Version 0.2.5
+* Logan Capaldo submitted a patch to the Util module to make pluralization
+  a lot smarter.  He also added method Table.plural_form.  And he updated the
+  test cases to test these changes.  Thanks Logan!
+* Refactored the query engine code.  Thanks to Logan Capaldo for code and ideas
+  to get me going.
+* John Long brought up a great point about losing access to instance variables
+  from the calling object, using the present scheme of #instance_eval(&block)
+  in Table.find.  Therefore, I am going back to requiring that the table class
+  be passed as a block parameter and that column names be qualified by the
+  table's class name.
+* Added Table.import, Table.export methods.
+* Added Table.destroy, Table.destroy_all, Table.content_columns, Table.exists? 
+  methods.
+* Major cleanup of Table.find.  First, I have split the functionality up into
+  separate methods.  Second, I believe I have got all of the basic options
+  working: :first, :all, one id, mulitple ids, :order, :limit, :offset.
+* Added dynamic attribute-base finder methods, i.e. Plane.find_by_country and
+  Plane.find_all_by_country.
+* Fixed Plane.initialize so that it does the right thing, i.e. if you pass it a
+  hash, it will create a new record initialized to those values.
+* Added Table#update_attributes method.
+* Added Table#delete , Table#delete_all methods.

data/example/simple_examples.rb

@@ -12,6 +12,7 @@ unless ARGV[0] == 'keep-data'
   end
 end
 
+# Create the table class.
 class Plane < Mongoose::Table
   validates_presence_of :name, :speed
 end
@@ -30,12 +31,13 @@ unless ARGV[0] == 'keep-data'
 
   # Add records.
   Plane.create :name => 'P-51', :country => 'USA', :speed => 402, :range => 1205
-  Plane.create :name => 'Spitfire', :country => 'Great Britain', :speed => 333,
+  Plane.create :name => 'Spitfire', :country => 'Great Britain', :speed => 351,
    :range => 454
   Plane.create :name => 'ME-109', :country => 'Germany', :speed => 354, 
    :range => 501
 
-  # Forgot value for speed, which is a required field.
+  # Forgot value for speed, which is a required field.  Notice
+  # validates_presence_of in the class definition above.
   begin
   Plane.create :name => 'P-39', :country => 'USA', :range => 701
   rescue RuntimeError => e
@@ -49,52 +51,87 @@ puts "\n\nFind P-51 record by ID"
 p_51 = Plane.find(1)
 p p_51
 
-if p_51
-  # Change speed on P-51 record and save.
-  p_51.speed = 405
-  p_51.save
-end
+# Change speed on P-51 record and save.
+p_51.speed = 405
+p_51.save
 
 puts "\n\nFind all records with speed greater than 350 mph"
-result = Plane.find { speed > 350 }
+result = Plane.find { |plane| plane.speed > 350 }
 p result
 
-puts "\n\nFind all US planes with speed greater than 300 mph"
-result = Plane.find { country == 'USA' and speed > 300 }
+
+puts "\n\nFind all US planes with speed greater than 350 mph"
+result = Plane.find { |plane| plane.country == 'USA' and plane.speed > 350 }
 p result
 
 puts "\n\nFind all British planes with speed greater than 300 mph"
-result = Plane.find do  
-  country == 'Great Britain' and speed > 300 
+result = Plane.find do |plane| 
+  plane.country == 'Great Britain' and plane.speed > 300 
 end
 p result
 
 puts "\n\nFind all Allied planes"
-result = Plane.find do  
-  any do
-    country == 'USA'
-    country == 'Great Britain'
+result = Plane.find do |plane| 
+  plane.any do 
+    plane.country == 'USA'
+    plane.country == 'Great Britain'
   end
 end
 p result
 
-puts "\n\nFind all Allied planes with speed greater than 400 mph"
-result = Plane.find do  
-  any do
-    country == 'USA'
-    country == 'Great Britain'
+puts "\n\nFind all Allied planes with speed greater than 350 mph"
+result = Plane.find do |plane| 
+  plane.any do 
+    plane.country == 'USA'
+    plane.country == 'Great Britain'
   end
-  speed > 400
+  plane.speed > 350
 end
 p result
 
-# Delete Spitfire record.
-spitfire = Plane.find(:first) { name == 'Spitfire' }
-
-spitfire.destroy if spitfire
+puts "\n\nFind all Allied planes with speed between 300  and 350 mph"
+result = Plane.find do |plane| 
+  plane.any do 
+    plane.country == 'USA'
+    plane.country == 'Great Britain'
+  end
+  plane.speed.between(300, 350)
+end
+p result
 
 puts "\n\nFind all records in table."
 result = Plane.find
 p result
 
+puts "\n\nFind by dynamic finder method."
+result = Plane.find_by_name('ME-109') 
+p result
+
+puts "\n\nSort result set by name."
+result = Plane.find(:all, :order => :name)
+p result
+
+puts "\n\nSort by country, then name."
+result = Plane.find(:order => [:country, :name])
+p result
+
+puts "\n\nSort by speed descending."
+result = Plane.find(:order => -:speed)
+p result
+
+puts "\n\nLimit number of records returned."
+result = Plane.find(:order => :name, :limit => 2)
+p result
+
+puts "\n\nSpecify offset."
+result = Plane.find(:order => :name, :offset => 3)
+p result
+
+# Delete Spitfire record.
+spitfire = Plane.find(:first) { |plane| plane.name == 'Spitfire' }
+spitfire.destroy if spitfire
+
+puts "\n\nShow only content columns."
+Plane.content_columns.each { |c| puts c.name }
+
 db.close

data/lib/mongoose.rb

@@ -1,10 +1,23 @@
 require 'yaml'
+require 'pp'
+require 'forwardable'
+require 'time'
+require 'date'
+
+begin
+  require 'faster_csv'
+rescue LoadError
+  require 'csv'
+end
+
 require 'mongoose/database'
 require 'mongoose/table'
 require 'mongoose/column'
 require 'mongoose/skiplist'
 require 'mongoose/linear_search'
+require 'mongoose/query'
 require 'mongoose/util'
+require 'mongoose/error'
 
 #
 # :main:Mongoose
@@ -22,7 +35,7 @@ require 'mongoose/util'
 #
 module Mongoose
 
-VERSION = '0.2.0'
+VERSION = '0.2.5'
 DATA_TYPES = [:string, :integer, :float, :time, :date, :datetime, :boolean]
 TBL_EXT = '.mgt'
 TBL_HDR_EXT = '.mgh'
@@ -30,14 +43,41 @@ TBL_IDX_EXT = '.mgi'
 
 end
 
-#---------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
 # Object
-#---------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
 class Object
   def full_const_get(name)
       list = name.split("::")
       obj = Object
       list.each {|x| obj = obj.const_get(x) }
       obj
+  end
+end
+
+
+#-------------------------------------------------------------------------------
+# Symbol
+#-------------------------------------------------------------------------------
+class Symbol
+  #-----------------------------------------------------------------------------
+  # -@
+  #-----------------------------------------------------------------------------
+  #
+  # This allows you to put a minus sign in front of a field name in order
+  # to specify descending sort order.
+  def -@
+      ("-"+self.to_s).to_sym
+  end
+
+  #-----------------------------------------------------------------------------
+  # +@
+  #-----------------------------------------------------------------------------
+  #
+  # This allows you to put a plus sign in front of a field name in order
+  # to specify ascending sort order.
+  def +@
+      ("+"+self.to_s).to_sym
   end
 end

data/lib/mongoose/column.rb

@@ -1,5 +1,3 @@
-require 'forwardable'
-
 module Mongoose
 
 #-------------------------------------------------------------------------------
@@ -11,14 +9,32 @@ class BaseColumn
 
   private_class_method :new
 
+  extend Forwardable
+  def_delegator(:@idx, :>, :>)
+  def_delegator(:@idx, :>=, :>=)
+  def_delegator(:@idx, :==, :==)
+  def_delegator(:@idx, :<, :<)
+  def_delegator(:@idx, :<=, :<=)
+  def_delegator(:@idx, :between, :between)
+  def_delegator(:@idx, :one_of, :one_of)
+
+  #-----------------------------------------------------------------------
+  # BaseColumn.valid_data_type?
+  #-----------------------------------------------------------------------
   def self.valid_data_type?(data_type)
     DATA_TYPES.include?(data_type)
   end
 
+  #-----------------------------------------------------------------------
+  # BaseColumn.create_table
+  #-----------------------------------------------------------------------
   def self.create(tbl_class, name, col_def)
     return new(tbl_class, name, col_def)
   end
 
+  #-----------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------
   def initialize(tbl_class, name, col_def)
     @tbl_class = tbl_class
     @name = name
@@ -27,17 +43,47 @@ class BaseColumn
     @required = false
   end
 
+  #-----------------------------------------------------------------------
+  # indexed?
+  #-----------------------------------------------------------------------
   def indexed?
     @indexed
   end
 
+  #-----------------------------------------------------------------------
+  # required?
+  #-----------------------------------------------------------------------
   def required?
     @required
   end
 
+  #-----------------------------------------------------------------------
+  # close
+  #-----------------------------------------------------------------------
   def close
   end
 
+  #-----------------------------------------------------------------------
+  # convert_to_native
+  #-----------------------------------------------------------------------
+  def convert_to_native(value)
+    case @data_type
+    when :string
+      value.to_s
+    when :integer
+      value.to_i
+    when :float
+      value.to_f
+    when :time
+      Time.parse(value)
+    when :date
+      Date.parse(value)
+    when :datetime
+      DateTime.parse(value)
+    when :boolean
+      true if [true, 'true', 1].include?(value)
+    end
+  end
 end  
 
 
@@ -45,38 +91,13 @@ end
 # Column class
 #-------------------------------------------------------------------------------
 class Column < BaseColumn
+  #-----------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------
   def initialize(tbl_class, name, col_def)
     super
     @idx = LinearSearch.new(self)
   end
-
-  def >(other)
-    @tbl_class.query << [@idx, :>, other]
-  end
-
-  def >=(other)
-    @tbl_class.query << [@idx, :>=, other]
-  end
-
-  def <(other)
-    @tbl_class.query << [@idx, :<, other]
-  end
-
-  def <=(other)
-    @tbl_class.query << [@idx, :<=, other]
-  end
-
-  def ==(other)
-    @tbl_class.query << [@idx, :==, other]
-  end
-
-  def between(*other)
-    @tbl_class.query << [@idx, :between, other]
-  end
-
-  def one_of(*other)
-    @tbl_class.query << [@idx, :one_of, other]
-  end
 end
 
 
@@ -145,51 +166,31 @@ end
 # SkipListIndexColumn class
 #-------------------------------------------------------------------------------
 class SkipListIndexColumn < IndexedColumn
+  #-----------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------
   def initialize(tbl_class, name, col_def)
     @idx = SkipList.new(self)
     super
   end
 
+  #-----------------------------------------------------------------------
+  # clear_index
+  #-----------------------------------------------------------------------
   def clear_index
     @idx = SkipList.new(self)
   end
 
-  def >(other)
-    @tbl_class.query << [@idx, :>, other]
-  end
-
-  def >=(other)
-    @tbl_class.query << [@idx, :>=, other]
-  end
-
-  def <(other)
-    @tbl_class.query << [@idx, :<, other]
-  end
-
-  def <=(other)
-    @tbl_class.query << [@idx, :<=, other]
-  end
-
-  def ==(other)
-    @tbl_class.query << [@idx, :==, other]
-  end
-
-  def search(other)
-    @tbl_class.query << [@idx, :search, other]
-  end
-
-  def between(*other)
-    @tbl_class.query << [@idx, :between, other]
-  end
-
-  def one_of(*other)
-    @tbl_class.query << [@idx, :one_of, other]
-  end
-
+  #-----------------------------------------------------------------------
+  # rebuild_index_file
+  #-----------------------------------------------------------------------
   def rebuild_index_file
     with_index_file('w') { |fptr| fptr.write(Marshal.dump(@idx.dump_to_hash)) }
   end
 
+  #-----------------------------------------------------------------------
+  # rebuild_index_from_table
+  #-----------------------------------------------------------------------
   def rebuild_index_from_table
     clear_index
     i = @tbl_class.columns.index(self)
@@ -199,15 +200,24 @@ class SkipListIndexColumn < IndexedColumn
     end
   end
 
+  #-----------------------------------------------------------------------
+  # rebuild_index_from_index_file
+  #-----------------------------------------------------------------------
   def rebuild_index_from_index_file
     clear_index
     with_index_file { |fptr| @idx.load_from_hash(Marshal.load(fptr)) }
   end
 
+  #-----------------------------------------------------------------------
+  # add_index_rec
+  #-----------------------------------------------------------------------
   def add_index_rec(key, value)
     @idx.store(key, value)
   end
 
+  #-----------------------------------------------------------------------
+  # remove_index_rec
+  #-----------------------------------------------------------------------
   def remove_index_rec(key, value)
     @idx.remove(key, value)
   end
@@ -218,38 +228,111 @@ end
 # IDColumn class
 #-------------------------------------------------------------------------------
 class IDColumn < IndexedColumn
-  extend Forwardable
-
+  def_delegator(:@idx, :==, :[])
   def_delegator(:@idx, :[], :[])
   def_delegator(:@idx, :keys, :keys)
 
+  #-----------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------
   def initialize(tbl_class, name, col_def)
     @idx = {}
     super
   end
 
+  #-----------------------------------------------------------------------
+  # clear_index
+  #-----------------------------------------------------------------------
   def clear_index
     @idx = {}
   end
 
+  #-----------------------------------------------------------------------
+  # >
+  #-----------------------------------------------------------------------
+  def >(other)
+    return @idx.keys.select { |k| k > other }
+  end
+
+  #-----------------------------------------------------------------------
+  # >=
+  #-----------------------------------------------------------------------
+  def >=(other)
+    return @idx.keys.select { |k| k >= other }
+  end
+
+  #-----------------------------------------------------------------------
+  # <
+  #-----------------------------------------------------------------------
+  def <(other)
+    return @idx.keys.select { |k| k < other }
+  end
+
+  #-----------------------------------------------------------------------
+  # <=
+  #-----------------------------------------------------------------------
+  def <=(other)
+    return @idx.keys.select { |k| k <= other }
+  end
+
+  #-----------------------------------------------------------------------
+  # between
+  #-----------------------------------------------------------------------
+  def between(search_start, search_end, start_inclusive=false, 
+   end_inclusive=false)
+    return @idx.keys.select do |k| 
+      if k == search_start and start_inclusive
+        true
+      elsif k > search_start and k < search_end
+        true
+      elsif k == search_end and end_inclusive
+        true
+      else
+        false
+      end
+    end
+  end
+
+  #-----------------------------------------------------------------------
+  # one_of
+  #-----------------------------------------------------------------------
+  def one_of(*other)
+    return @idx.keys.select { |k| other.include?(k) }
+  end
+
+  #-----------------------------------------------------------------------
+  # rebuild_index_file
+  #-----------------------------------------------------------------------
   def rebuild_index_file
     with_index_file('w') { |fptr| fptr.write(Marshal.dump(@idx)) }
   end
 
+  #-----------------------------------------------------------------------
+  # rebuild_index_from_table
+  #-----------------------------------------------------------------------
   def rebuild_index_from_table
     clear_index
     @tbl_class.get_all_recs { |rec, fpos| add_index_rec(rec[0], fpos) }
   end
 
+  #-----------------------------------------------------------------------
+  # rebuild_index_from_index_file
+  #-----------------------------------------------------------------------
   def rebuild_index_from_index_file
     clear_index
     with_index_file { |fptr| @idx = Marshal.load(fptr) }
   end
 
+  #-----------------------------------------------------------------------
+  # add_index_rec
+  #-----------------------------------------------------------------------
   def add_index_rec(id, fpos)
     @idx[id] = fpos
   end
 
+  #-----------------------------------------------------------------------
+  # remove_index_rec
+  #-----------------------------------------------------------------------
   def remove_index_rec(id)
     @idx.delete(id)
   end