mongoose 0.2.0 → 0.2.5

data/lib/mongoose/error.rb

@@ -0,0 +1,9 @@
+module Mongoose
+
+class MongooseError < StandardError
+end
+
+class RecordNotFound < MongooseError
+end
+
+end

data/lib/mongoose/query.rb

@@ -0,0 +1,52 @@
+module Mongoose
+
+class Property
+  attr_reader :property_name, :subquery_no, :subquery_type, :comparison, :arg
+  def initialize(name, query, subquery_no, subquery_type)
+    @property_name = name
+    @query = query
+    @subquery_no = subquery_no
+    @subquery_type = subquery_type
+  end
+
+  [:>, :<=, :==, :<=, :<, :between, :one_of].each do |comparison|
+    define_method(comparison) do |*arg|
+      @comparison = comparison
+      @arg = arg
+      @query.add_predicate(self)
+    end
+  end
+
+end
+
+
+class Query
+  attr_reader :predicates
+  def initialize
+    @predicates = []
+    @subquery_type = :and
+    @subquery_no = 0
+  end
+
+  def find(&block)
+    yield self
+  end
+
+  def add_predicate(pred)
+    @predicates << pred
+  end
+
+  def method_missing(name, *args)
+    @subquery_no += 1 if @subquery_type == :and
+    Property.new(name, self, @subquery_no, @subquery_type)
+  end
+
+  def any(&block)
+    @subquery_type = :or
+    @subquery_no += 1
+    yield
+    @subquery_type = :and
+  end
+end
+
+end

data/lib/mongoose/table.rb

@@ -39,6 +39,14 @@ class Table
     self.db.tables[self][:columns]
   end
 
+  #-----------------------------------------------------------------------------
+  # Table.content_columns
+  #-----------------------------------------------------------------------------
+  def self.content_columns
+    self.db.tables[self][:columns] = self.columns.reject { |c| 
+     c.name == :id || c.name =~ /(_id|_count)$/ }
+  end
+
   #-----------------------------------------------------------------------------
   # Table.column_names
   #-----------------------------------------------------------------------------
@@ -53,6 +61,14 @@ class Table
     self.db.path
   end
 
+  #-----------------------------------------------------------------------------
+  # Table.plural_form
+  #-----------------------------------------------------------------------------
+  def self.plural_form(pluralized)
+    Util::SINGULAR_TO_PLURAL[Util.class_case_to_us_case(self.to_s)] = pluralized
+    Util::PLURAL_TO_SINGULAR[pluralized] = Util.class_case_to_us_case(self.to_s)
+  end
+
   #-----------------------------------------------------------------------------
   # Table.validates_presence_of
   #-----------------------------------------------------------------------------
@@ -73,7 +89,7 @@ class Table
     define_method(kind.to_sym) do 
       klass = Object.const_get(class_name)
       parent_id = @id
-      Collection.new(self, klass.find { send(col) == parent_id })
+      Collection.new(self, klass.find { |r| r.send(col) == parent_id })
     end
   end
 
@@ -88,7 +104,7 @@ class Table
     define_method(kind.to_sym) do
       klass = Object.const_get(class_name)
       parent_id = @id
-      klass.find(:first) { send(col) == parent_id }
+      klass.find(:first) { |r| r.send(col) == parent_id }
     end
   end
 
@@ -165,6 +181,18 @@ class Table
       define_method(col_name) do
         self.columns.detect { |c| c.name == col_name.to_sym }
       end
+
+      define_method("find_by_#{col_name}".to_sym) do |other|
+        if col_name == :id
+          self.find(other)
+        else
+          self.find(:first) { |tbl| tbl.send(col_name) == other }
+        end
+      end
+
+      define_method("find_all_by_#{col_name}".to_sym) do |other, *args|
+        self.find(*args) { |tbl| tbl.send(col_name) == other }
+      end
     end
 
     self.class_eval do
@@ -235,109 +263,199 @@ class Table
   # Table.find
   #-----------------------------------------------------------------------------
   def self.find(*args, &block)
-    # 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) }
+    options = {}
+    if args.size == 0
+      args = [:all]
+    elsif args.first.is_a?(Hash)
+      options = args.first
+      args = [:all]
+    elsif args.first.is_a?(Integer)
+      if args.last.is_a?(Hash)
+        options = args.last
+        args = args[0...-1]
       end
+    elsif args.first == :first
+      options = args.last if args.last.is_a?(Hash)
+      options[:limit] = 1
+      args = [:all]
+    elsif args.first == :all
+      options = args.last if args.last.is_a?(Hash)
+    end
+
+    case args.first
+      when :all   then self.find_every(options, &block)
+      else             self.find_from_ids(args, options)
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.find_from_ids
+  #-----------------------------------------------------------------------------
+  def self.find_from_ids(args, options)
+    if args.size == 1
+      result = self.get_rec(args.first)
     else
-      result = []
-      # If passed a query block...
-      if block 
-        self.query.clear
-        query_start = true
-        sub_q = false
-        sub_q_start = false
-        sub_q_result = []
-
-        # Grab the query block
-        instance_eval(&block) 
-
-        # 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
+      result = self.apply_options_to_result(args.collect { |a| 
+       self.get_rec(a) }, options)
+    end
+    return result
+  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
+  #-----------------------------------------------------------------------------
+  # Table.find_every
+  #-----------------------------------------------------------------------------
+  def self.find_every(options, &block)
+    # If no block was supplied, just grab all the keys from the id column's
+    # index.
+    if block
+      result = self.find_from_block(&block)
+    else
+      result = self.id.keys
+    end
+    return nil if result.nil?
 
-          # 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])
+    return self.apply_options_to_result(
+     result.collect { |k| self.get_rec(k) }, options)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.find_from_block
+  #-----------------------------------------------------------------------------
+  def self.find_from_block(&block)
+    result = []
+    or_result = []
+    query = Query.new
+    query.find(&block)
+
+    subquery_no = nil
+    subquery_type = nil
+
+    # Step through the query block...
+    query.predicates.each do |pred|
+      # Retain the previous subquery_no and subquery_type.  This will help 
+      # determine if I am still in an #any block or just finished an #any block.
+      previous_subquery_no = subquery_no
+      previous_subquery_type = subquery_type
+      subquery_no = pred.subquery_no
+      subquery_type = pred.subquery_type
+
+      # If subquery number has not changed, must be in the middle of an #any 
+      # block.  Therefore, we are going to do a union of the the comparison's 
+      # results to the current or_result.
+      if previous_subquery_no == subquery_no
+        or_result = or_result | send(pred.property_name).send(pred.comparison, 
+         *pred.arg)
+      # Otherwise, we are starting either a new :and predicate or a new #any 
+      # block.
+      else
+        # Therefore, the first thing we want to check if the previous subquery 
+        #  was an #any block, and add it's result to the overall result array.
+        if previous_subquery_type == :or
+          # If the previous subquery was an #any block and it was the first
+          # subquery in the main query block, initialize the result array
+          # to the whole subqquery's result.
+          if previous_subquery_no == 1
+            result = or_result
+          # Otherwise, just do an intersection between the or_result and the 
+          # overall result.
+          else
+            result = result & or_result
           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)
+        # If the subquery type is :and, then we are just going to add it
+        # to the existing result.
+        if subquery_type == :and
+          # If this is the first subquery, then we just make the overall
+          # result equal to the comparison's result
+          if subquery_no == 1
+            result = send(pred.property_name).send(pred.comparison, *pred.arg) 
+          # Otherwise, we are going to do an intersection on the
+          # comparison's result and the overall result.
           else
-            result[0...args[1][:limit]].collect { |r| self.get_rec(r) }
+            result = result & send(pred.property_name).send(pred.comparison, 
+             *pred.arg)
           end
+        # If the subquery type is :or, and it the subquery number is not
+        # equal to the previous subquery number, then we know we are 
+        # at the first predicate of an #any block and we can initialize the
+        # the subquery's result array to whatever the subquery returns.
+        else
+          or_result = send(pred.property_name).send(pred.comparison, *pred.arg)
         end
-      # Otherwise, just return the whole damn result set.
+      end
+    end
+    # Now that we are doing executing the whole query, we need to check if
+    # the last subquery was an #any block, so that we can make sure the
+    # results of this subquery get added into the overall query results.
+    if subquery_type == :or
+      if subquery_no == 1
+        result = or_result
       else
-        result.collect { |r| self.get_rec(r) }
+        result = result & or_result
       end
     end
+
+    return result
   end
 
   #-----------------------------------------------------------------------------
-  # Table.any
+  # Table.apply_options_to_result
   #-----------------------------------------------------------------------------
-  def self.any
-    self.query << :any_begin
-    yield
-    self.query << :any_end
-  end
+  def self.apply_options_to_result(result, options)
+    return result if result.empty?
+
+    result = self.sort_result(result, *options[:order]) if options.has_key?(
+     :order)
+    result = result[options[:offset]-1..-1] if options.has_key?(:offset)
+    
+    if options.has_key?(:limit)
+      if options[:limit] == 1
+        result = result.first
+      else
+        result = result[0...options[:limit]]
+      end
+    end
+    return result
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.sort_result
+  #-----------------------------------------------------------------------------
+  def self.sort_result(result, *order)
+    sort_cols_arrs = []
+    order.each do |sort_col|
+      if sort_col.to_s[0..0] == '-'
+        sort_cols_arrs << [sort_col.to_s[1..-1].to_sym, :desc]
+      elsif sort_col.to_s[0..0] == '+'
+        sort_cols_arrs << [sort_col.to_s[1..-1].to_sym, :asc]
+      else
+        sort_cols_arrs << [sort_col, :asc]
+      end
+    end
+
+    return result.sort do |a,b|
+      x = []
+      y = []
+      sort_cols_arrs.each do |s|
+        if [:integer, :float].include?(send(s.first).data_type)
+          a_value = a.send(s.first) || 0
+          b_value = b.send(s.first) || 0
+        else
+          a_value = a.send(s.first)
+          b_value = b.send(s.first)
+        end
+        if s.last == :desc
+          x << b_value
+          y << a_value
+        else
+          x << a_value
+          y << b_value
+        end
+      end
+
+      x <=> y
+    end
+  end
 
   #-----------------------------------------------------------------------------
   # Table.get_rec
@@ -359,7 +477,7 @@ class Table
     raise IndexCorruptError, "Index ID does not match table ID!", caller \
      unless rec_arr[1] == id
 
-    rec = self.new(*rec_arr[1..-1])
+    rec = self.new(Hash[*self.column_names.zip(rec_arr[1..-1]).flatten])
     return rec
   end
 
@@ -375,11 +493,103 @@ class Table
     end
   end
 
+  #-----------------------------------------------------------------------------
+  # Table.export
+  #-----------------------------------------------------------------------------
+  def self.export(filename=1)
+    if filename.is_a?(Integer)
+      out_file = IO.open(1, 'w')
+    else
+      out_file = File.open(filename, 'w')
+    end
+    CSV::Writer.generate(out_file) do |out|
+      self.find.each do |rec|
+        out << self.column_names.collect {|n| rec.send(n)}
+      end
+    end
+
+    out_file.close
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.import
+  #-----------------------------------------------------------------------------
+  def self.import(filename=0)
+    if filename.is_a?(Integer)
+      in_file = IO.open(1, 'r')
+    else
+      in_file = File.open(filename, 'r')
+    end
+
+    CSV::Reader.parse(in_file) do |row|
+      rec = new
+      self.columns.zip(row) do |col, value|
+        rec.send("#{col.name}=", col.convert_to_native(value)) unless \
+         value.nil?
+      end
+      rec.save
+    end
+    in_file.close
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.exists?
+  #-----------------------------------------------------------------------------
+  def self.exists?(id)
+    if self.id[id]
+      true
+    else
+      false
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.destroy_all
+  #-----------------------------------------------------------------------------
+  def self.destroy_all(&block)
+    self.find(:all, &block).each { |r| p r.destroy }
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.destroy
+  #-----------------------------------------------------------------------------
+  def self.destroy(id)
+    self.find(id).destroy
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.delete_all
+  #-----------------------------------------------------------------------------
+  def self.delete_all(&block)
+    self.find(:all, &block).each { |r| p r.delete }
+  end
+
+  #-----------------------------------------------------------------------------
+  # Table.delete
+  #-----------------------------------------------------------------------------
+  def self.delete(id)
+    self.find(id).delete
+  end
+
   #-----------------------------------------------------------------------------
   # initialize
   #-----------------------------------------------------------------------------
-  def initialize(*values)
-    self.class.columns.zip(values).each { |c,v| send("#{c.name}=", v) }
+  def initialize(values=nil)
+    unless values.nil?
+      values.each do |k,v|
+        send("#{k}=", v) if self.class.column_names.include? k
+      end
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # update_attributes
+  #-----------------------------------------------------------------------------
+  def update_attributes(values)
+    values.each do |k,v|
+      send("#{k}=", v) if self.class.column_names.include? k
+    end
+    save
   end
 
   #-----------------------------------------------------------------------------
@@ -396,10 +606,8 @@ class Table
 
     # Add new record.
     if @id.nil?
-      id = increment_last_id_used
-      append_record(id, self.class.column_names[1..-1].collect { |col_name| 
-       send(col_name) })
-      @id = id
+      @id = append_record(self.class.column_names[1..-1].collect { |c_name| 
+       send(c_name) })
     # Update existing record.
     else
       update_record(@id, self.class.columns[1..-1].collect { |c| send(c.name) })
@@ -407,6 +615,13 @@ class Table
     return true
   end
 
+  #-----------------------------------------------------------------------------
+  # delete
+  #-----------------------------------------------------------------------------
+  def delete
+    destroy
+  end
+
   #-----------------------------------------------------------------------------
   # destroy
   #-----------------------------------------------------------------------------
@@ -451,7 +666,8 @@ class Table
   #-----------------------------------------------------------------------------
   # append_record
   #-----------------------------------------------------------------------------
-  def append_record(id, values)
+  def append_record(values)
+    id = increment_last_id_used
     fpos = nil
    
     self.class.with_table(File::RDWR) do |fptr|
@@ -471,6 +687,7 @@ class Table
         c.add_index_rec(values[i-1], id) unless values[i-1].nil?
       end
     end
+    return id
   end
 
   #-----------------------------------------------------------------------------
@@ -481,6 +698,10 @@ class Table
 
     fpos_rec_start = self.class.id[id]
 
+    raise(RecordNotFound, 
+     "No #{self.class.table_name} record found with id: #{id}") if \
+     fpos_rec_start.nil?
+
     self.class.with_table(File::RDWR) do |fptr|
       fptr.seek(fpos_rec_start)