mongoose 0.1.0

data/lib/mongoose/table.rb

@@ -0,0 +1,568 @@
+module Mongoose
+
+#-------------------------------------------------------------------------------
+# Table class
+#-------------------------------------------------------------------------------
+class Table
+  #-----------------------------------------------------------------------------
+  # Table.db
+  #-----------------------------------------------------------------------------
+  def self.db
+    @@db
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.db=
+  #-----------------------------------------------------------------------------
+  def self.db=(db)
+    @@db = db
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.query
+  #-----------------------------------------------------------------------------
+  def self.query
+    self.db.tables[self][:query]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.table_name
+  #-----------------------------------------------------------------------------
+  def self.table_name
+    self.db.tables[self][:table_name]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.columns
+  #-----------------------------------------------------------------------------
+  def self.columns
+    self.db.tables[self][:columns]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.column_names
+  #-----------------------------------------------------------------------------
+  def self.column_names
+    self.db.tables[self][:columns].collect { |c| c.name }
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.path
+  #-----------------------------------------------------------------------------
+  def self.path
+    self.db.path
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.validates_presence_of
+  #-----------------------------------------------------------------------------
+  def self.validates_presence_of(*col_names)
+    define_method(:required?) do |col_name|
+      col_names.include?(col_name)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.has_many
+  #-----------------------------------------------------------------------------
+  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)
+    col = Util.col_name_for_class(self.to_s)
+
+    define_method(kind.to_sym) do 
+      klass = Object.const_get(class_name)
+      Collection.new(self, klass.find { |r|
+       r.send(col) == self.instance_eval { @id } })
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.has_one
+  #-----------------------------------------------------------------------------
+  def self.has_one(kind)
+    table_name = kind.to_sym
+    class_name = Util.us_case_to_class_case(table_name.to_s)
+    col = Util.col_name_for_class(self.to_s)
+
+    define_method(kind.to_sym) do
+      klass = Object.const_get(class_name)
+      klass.find(:first) { |r| r.send(col) == self.instance_eval { @id } }
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.belongs_to
+  #-----------------------------------------------------------------------------
+  def self.belongs_to(kind)
+    class_name = Util.us_case_to_class_case(kind.to_sym)
+
+    define_method(kind) do
+      klass = Object.const_get(class_name.to_s)
+      klass.find(send("#{kind}_id".to_sym))
+    end
+
+    define_method("#{kind}=".to_sym) do |other|
+      other.save
+      send("#{kind}_id=".to_sym, other.id.to_i)
+      save
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # 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
+  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)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.read_header
+  #-----------------------------------------------------------------------------
+  def self.read_header
+    YAML.load(File.open(File.join(self.path, self.table_name.to_s +
+     TBL_HDR_EXT), 'r'))
+  end
+  
+  #-----------------------------------------------------------------------------
+  # 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
+  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])
+       ) 
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.init_column
+  #-----------------------------------------------------------------------------
+  def self.init_column(col_name, col_def, col_class)
+    col = col_class.create(self, col_name, col_def)
+
+    self.columns << col
+
+    meth = <<-END_OF_STRING
+    def self.#{col_name}
+      self.columns.detect { |c| c.name == "#{col_name}".to_sym } 
+    end
+    END_OF_STRING
+    self.class_eval(meth)
+
+    self.class_eval do
+      attr_accessor col_name
+    end
+
+    col.init_index if col.indexed?
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.close
+  #-----------------------------------------------------------------------------
+  def self.close
+    self.columns.each { |c| c.close }
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.get_all_recs
+  #-----------------------------------------------------------------------------
+  def self.get_all_recs
+    self.with_table do |fptr|
+      begin
+        while true
+          fpos = fptr.tell
+          rec_arr = Marshal.load(fptr)
+
+          yield rec_arr[1..-1], fpos unless rec_arr[0]
+        end
+      rescue EOFError
+      end
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.add_column
+  #-----------------------------------------------------------------------------
+  def self.add_column(col_name, col_def, col_class=Column)
+    self.init_column(col_name, col_def, col_class)
+
+    tbl_header = self.read_header
+
+    tbl_header[:columns] << { :name => col_name, :data_type => col_def, 
+                          :class => col_class.to_s }
+
+    self.write_header(tbl_header)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.add_indexed
+  #-----------------------------------------------------------------------------
+  def self.add_indexed_column(col_name, col_def)
+    self.add_column(col_name, col_def, SkipListIndexColumn)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.find
+  #-----------------------------------------------------------------------------
+  def self.find(*args)
+    # If searching for just one id or a group of ids...
+    if args[0].is_a?(Integer)
+      if args.size == 1
+        self.get_rec(args[0])
+      else
+        args.collect { |a| self.get_rec(a) }
+      end
+    else
+      result = []
+      # If passed a query block...
+      if block_given?
+        self.query.clear
+        query_start = true
+        sub_q = false
+        sub_q_start = false
+        sub_q_result = []
+
+        # Grab the query block
+        yield self 
+
+        # Step through the query block...
+        self.query.each_with_index do |q,i|
+          # If this is the start of an #any sub-block within the main block,
+          # mark it as so and start grabbing the sub-block query.
+          if q == :any_begin
+            sub_q = :true
+            sub_q_start = true
+            sub_q_result = []
+            next
+          end
+          # If this is the end of an #any sub-block within the main block,
+          # mark it as so, and add the sub-block's query results to the current
+          # results of the main query.
+          if q == :any_end
+            sub_q = false
+            if query_start
+              query_start = false
+              result = sub_q_result
+            else
+              result = result & sub_q_result
+            end
+            sub_q_result = nil
+            next
+          end
+
+          # If currently within a sub-block query, execute and add it's results
+          # to the current sub-block query results.
+          if sub_q
+            if sub_q_start
+              sub_q_start = false
+              sub_q_result = q[0].send(q[1], *q[2]) 
+            else        
+              sub_q_result = sub_q_result | q[0].send(q[1], *q[2])
+            end
+            next
+          end
+
+          # If this is the beginning of the query start a new result set, 
+          # otherwise, add the results of the current line of the query to
+          # the existing result set.
+          if query_start
+            query_start = false
+            result = q[0].send(q[1], *q[2]) 
+          else        
+            result = result & q[0].send(q[1], *q[2])
+          end
+        end
+      # If did not pass a query block, just grab all of the ids in the table...
+      else  
+        result = self.id.keys
+      end
+
+      # If no matching records found, return nil.
+      if result.nil?
+        nil
+      # If user just wants first record, return first record.
+      elsif args[0] == :first 
+        self.get_rec(result.first)
+      # If user specified a paramaters hash, see if they specified a limit and
+      # return that many records.
+      elsif args[1].is_a?(Hash)
+        if args[1].has_key?(:limit)
+          if args[1][:limit] == 1
+            self.get_rec(result.first)
+          else
+            result[0...args[1][:limit]].collect { |r| self.get_rec(r) }
+          end
+        end
+      # Otherwise, just return the whole damn result set.
+      else
+        result.collect { |r| self.get_rec(r) }
+      end
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.any
+  #-----------------------------------------------------------------------------
+  def self.any
+    self.query << :any_begin
+    yield
+    self.query << :any_end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.get_rec
+  #-----------------------------------------------------------------------------
+  def self.get_rec(id)
+    fpos = self.id[id]
+
+    return nil if fpos.nil?
+    rec_arr = []
+
+    self.with_table(File::RDONLY) do |fptr|
+      fptr.seek(fpos)
+      rec_arr = Marshal.load(fptr)
+    end      
+
+    raise IndexCorruptError, "Index references deleted record!", caller \
+     if rec_arr[0]
+
+    raise IndexCorruptError, "Index ID does not match table ID!", caller \
+     unless rec_arr[1] == id
+
+    rec = self.new(*rec_arr[1..-1])
+    return rec
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.with_table
+  #-----------------------------------------------------------------------------
+  def self.with_table(access='r')
+    begin
+      yield fptr = open(File.join(self.db.path, self.table_name.to_s + TBL_EXT), 
+       access)
+    ensure
+      fptr.close
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # initialize
+  #-----------------------------------------------------------------------------
+  def initialize(*values)
+    self.class.columns.zip(values).each do |c,v|
+      send("#{c.name}=", v)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # save
+  #-----------------------------------------------------------------------------
+  def save
+    self.class.columns.each do |c|
+      raise "Value required for #{c.name}!" if respond_to?('required?') and \
+       required?(c.name) and send(c.name).nil?
+      raise "Value required for #{c.name}!" if c.required? and send(c.name).nil?
+    end
+
+    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)
+    else
+      update_record(@id, self.class.columns[1..-1].collect { |c| send(c.name) })
+    end
+
+    return true
+  end
+
+  #-----------------------------------------------------------------------------
+  # destroy
+  #-----------------------------------------------------------------------------
+  def destroy
+    fpos_rec_start = self.class.id[@id]
+
+    self.class.with_table(File::RDWR) do |fptr|
+      fptr.seek(fpos_rec_start)
+
+      rec = Marshal.load(fptr)
+      
+      raise IndexCorruptError, "Index ID does not match table ID!", caller \
+       unless rec[1] == @id
+
+      rec[0] = true
+
+      write_record(fptr, fpos_rec_start, Marshal.dump(rec))
+      increment_deleted_recs_counter
+    end
+
+    self.class.columns.each_with_index do |c,i|
+      if i == 0
+        c.remove_index_rec(@id)
+      elsif c.indexed?
+        c.remove_index_rec(send(c.name), @id)
+      end
+    end
+
+    freeze
+  end
+
+  #-----------------------------------------------------------------------------
+  # Private Methods
+  #-----------------------------------------------------------------------------
+  private
+
+  #-----------------------------------------------------------------------------
+  # append_record
+  #-----------------------------------------------------------------------------
+  def append_record(id, values)
+    fpos = nil
+   
+    self.class.with_table(File::RDWR) do |fptr|
+      fptr.seek(0, IO::SEEK_END)
+      fpos = fptr.tell
+
+      fpos = write_record(fptr, 'end', Marshal.dump([false, id].concat(values)))
+    end
+
+    self.class.columns.each_with_index do |c,i|
+      if i == 0
+        c.add_index_rec(id, fpos)
+      elsif c.indexed?
+        c.add_index_rec(values[i-1], id) unless values[i-1].nil?
+      end
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # update_record
+  #-----------------------------------------------------------------------------
+  def update_record(id, values)
+    temp_instance = self.class.get_rec(id)
+
+    fpos_rec_start = self.class.id[id]
+
+    self.class.with_table(File::RDWR) do |fptr|
+      fptr.seek(fpos_rec_start)
+
+      old_rec = Marshal.load(fptr)
+
+      new_rec = Marshal.dump(old_rec[0..1].concat(values))
+      
+      raise IndexCorruptError, "Index ID does not match table ID!", caller \
+       unless old_rec[1] == id
+
+      old_rec_length = fptr.tell - fpos_rec_start
+
+      if new_rec.length == old_rec_length
+        write_record(fptr, fpos_rec_start, new_rec)
+      else
+        fpos = write_record(fptr, 'end', new_rec)
+        increment_deleted_recs_counter
+        self.class.columns[0].add_index_rec(id, fpos)
+      end  
+    end
+
+    self.class.columns[1..-1].each do |c| 
+      unless temp_instance.send(c.name) == send(c.name)
+        if c.indexed? 
+          c.remove_index_rec(temp_instance.send(c.name), id)
+          c.add_index_rec(send(c.name), id) unless send(c.name).nil?
+        end
+      end 
+    end
+  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
+    self.class.write_header(tbl_header)
+  end
+
+  #-----------------------------------------------------------------------------
+  # write_record
+  #-----------------------------------------------------------------------------
+  def write_record(fptr, pos, record)
+    if pos == 'end'
+      fptr.seek(0, IO::SEEK_END)
+    else
+      fptr.seek(pos)
+    end
+
+    fpos_rec_start = fptr.tell
+
+    fptr.write(record)
+    return fpos_rec_start
+  end
+end
+
+
+class Collection
+  include Enumerable
+
+  def initialize(owner=nil, records=[])
+    @owner = owner
+    @records = records
+  end
+
+  def each
+    records.each { |rec| yield rec }
+  end
+
+  def <<(rec)
+    col_name = (@owner.class.table_name.to_s + "_id").to_sym
+    rec.send("#{col_name}=".to_sym, @owner.instance_eval { @id })
+    rec.save
+  end
+
+  def append(rec)
+    self << rec
+  end
+end
+
+end