ceritium-relaxdb 0.2.8

data/lib/relaxdb/validators.rb

@@ -0,0 +1,11 @@
+module RelaxDB
+  
+  module Validators
+   
+    def validator_required(att, o)
+      !att.blank?
+    end
+    
+  end
+  
+end

data/lib/relaxdb/view_object.rb

@@ -0,0 +1,34 @@
+module RelaxDB
+
+  # An immuntable object typically used to display the results of a view
+  class ViewObject
+  
+    def initialize(hash)
+      hash.each do |k, v|
+
+        if k.to_s =~ /_at$/
+          v = Time.local(*ParseDate.parsedate(v)) rescue v
+        end
+
+        instance_variable_set("@#{k}", v)
+        meta_class.instance_eval do
+          define_method(k.to_sym) do
+            instance_variable_get("@#{k}".to_sym)
+          end
+        end      
+      end
+    end
+  
+    def self.create(obj)
+      if obj.instance_of? Array
+        obj.inject([]) { |arr, o| arr << ViewObject.new(o) }
+      elsif obj.instance_of? Hash
+        ViewObject.new(obj)
+      else
+        obj
+      end
+    end
+  
+  end
+
+end

data/lib/relaxdb/view_result.rb

@@ -0,0 +1,18 @@
+module RelaxDB
+
+  class ViewResult < DelegateClass(Array)
+    
+    attr_reader :offset, :total_rows
+  
+    def initialize(result_hash)
+      objs = RelaxDB.create_from_hash(result_hash)
+      
+      @offset = result_hash["offset"]
+      @total_rows = result_hash["total_rows"]
+      
+      super(objs)
+    end
+  
+  end
+
+end

data/lib/relaxdb/view_uploader.rb

@@ -0,0 +1,47 @@
+module RelaxDB
+  
+  class ViewUploader
+
+    class << self
+      
+      # Methods must start and finish on different lines
+      # The function declaration must start at the beginning of a line
+      # As '-' is used as a delimiter, neither design doc nor view name may contain '-'
+      # Exepcted function declaration form is 
+      #   function DesignDoc-funcname-functype(doc) {
+      # For example 
+      #   function Users-followers-map(doc) {
+      #
+      def upload(filename)
+        lines = File.readlines(filename)
+        extract(lines) do |dd, vn, t, f|
+          RelaxDB::DesignDocument.get(dd).add_view(vn, t, f).save
+        end
+      end
+      
+      def extract(lines)
+        # Index of function declaration matches
+        m = []
+
+        0.upto(lines.size-1) do |p|
+          line = lines[p]
+          m << p if line =~ /^function[^\{]+\{/
+        end
+        # Add one beyond the last line number as the final terminator
+        m << lines.size
+
+        0.upto(m.size-2) do |i|
+          declr = lines[m[i]]
+          declr =~ /(\w)+-(\w)+-(\w)+/
+          declr.sub!($&, '')
+          design_doc, view_name, type = $&.split('-')
+          func = lines[m[i]...m[i+1]].join
+          yield design_doc, view_name, type, func
+        end
+      end
+
+    end
+    
+  end
+  
+end

data/lib/relaxdb/views.rb

@@ -0,0 +1,54 @@
+module RelaxDB
+
+  class ViewCreator
+    
+    def self.all(target_class)
+      map = <<-QUERY
+      function(doc) {
+        if(doc.class == "${target_class}")
+          emit(null, doc);
+      }
+      QUERY
+      map.sub!("${target_class}", target_class.to_s)
+      
+      reduce = <<-QUERY
+      function(keys, values, rereduce) {
+        if (rereduce) {
+          return sum(values);
+        } else {
+          return values.length;
+        }
+      }
+      QUERY
+      
+      [map, reduce]  
+    end
+  
+    def self.has_n(target_class, relationship_to_client)
+      template = <<-MAP_FUNC
+      function(doc) {
+        if(doc.class == "${target_class}" && doc.${relationship_to_client}_id)
+          emit(doc.${relationship_to_client}_id, doc);
+      }
+      MAP_FUNC
+      template.sub!("${target_class}", target_class)
+      template.gsub("${relationship_to_client}", relationship_to_client)
+    end
+  
+    def self.has_many_through(target_class, peers)
+      template = <<-MAP_FUNC
+        function(doc) {
+          if(doc.class == "${target_class}" && doc.${peers}) {
+            var i;
+            for(i = 0; i < doc.${peers}.length; i++) {
+              emit(doc.${peers}[i], doc);
+            }
+          }
+        }
+      MAP_FUNC
+      template.sub!("${target_class}", target_class).gsub!("${peers}", peers)
+    end
+    
+  end
+
+end

data/spec/belongs_to_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::BelongsToProxy do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+
+  describe "belongs_to" do
+    
+    it "should return nil when accessed before assignment" do
+      r = Rating.new
+      r.photo.should == nil
+    end
+
+    it "should be establishable via constructor attribute" do
+      p = Photo.new
+      r = Rating.new :photo => p
+      r.photo.should == p
+    end
+    
+    it "should be establishable via constructor id" do
+      p = Photo.new.save
+      r = Rating.new(:photo_id => p._id).save
+      r.photo.should == p
+    end        
+      
+    it "should establish the parent relationship when supplied a parent and saved" do
+      p = Photo.new.save
+      r = Rating.new
+      r.photo = p
+      # I'm not saying the following is correct or desired - merely codifying how things stand 
+      p.rating.should be_nil 
+      r.save
+      p.rating.should == r
+    end    
+  
+    it "should establish the parent relationship when supplied a parent id and saved" do
+      p = Photo.new.save
+      r = Rating.new(:photo_id => p._id).save
+      p.rating.should == r
+    end        
+
+    it "should return the same object on repeated invocations" do
+      p = Photo.new.save
+      r = Rating.new(:photo => p).save
+      r = RelaxDB.load(r._id)
+      r.photo.object_id.should == r.photo.object_id
+    end    
+
+    it "should be nullified when the parent is destroyed" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      p.destroy!
+      RelaxDB.load(r._id).photo.should be_nil
+    end
+  
+    it "should be preserved across save / load boundary" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      r = RelaxDB.load r._id
+      r.photo.should == p
+    end    
+
+    it "should be able to reference itself via its parent" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      r = RelaxDB.load r._id
+      r.photo.rating.should == r
+    end    
+    
+    it "may be used reciprocally" do
+      C1 = Class.new(RelaxDB::Document) do
+        belongs_to :c2
+      end
+      C2 = Class.new(RelaxDB::Document) do
+        belongs_to :c1
+      end
+      i1, i2 = C1.new, C2.new
+
+      i1.c2 = i2
+      i1.save!
+      i2.c1 = i1
+      i2.save!
+      
+      i1 = RelaxDB.load i1._id
+      i1.c2.should == i2
+      
+      i2 = RelaxDB.load i2._id
+      i2.c1.should == i1
+    end
+    
+    describe "validator" do
+      
+      it "should be passed the _id and object" do
+        a = Atom.new(:_id => "atom").save!
+        c = Class.new(RelaxDB::Document) do
+          belongs_to :foo, :validator => lambda { |foo_id, obj| foo_id.reverse == obj._id }
+        end
+        c.new(:_id => "mota", :foo => a).save!
+      end
+      
+      it "may be used with a predefined validator" do
+        c = Class.new(RelaxDB::Document) do
+          belongs_to :foo, :validator => :required
+        end
+        c.new.save.should be_false
+      end
+
+      it "should be provided with a default error message when validation fails" do
+        c = Class.new(RelaxDB::Document) do
+          belongs_to :foo, :validator => :required
+        end
+        x = c.new
+        x.save
+        x.errors[:foo].should_not be_blank
+      end
+          
+    end
+    
+  end
+
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# A little naiive, needs quite a bit more thought and work
+
+describe RelaxDB::Document, "callbacks" do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+  
+  describe "before_save" do
+  
+    it "should be run before the object is saved" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { |s| s.gem += 1 if s.unsaved? }
+        property :gem
+      end
+      p = c.new(:gem => 5).save
+      p.gem.should == 6
+    end
+    
+    it "should prevent the object from being saved if it returns false" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      c.new.save.should == false
+    end
+    
+    it "should add a description to errors when false is returned" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      x = c.new
+      x.save
+      x.errors[:before_save].should be
+    end    
+
+    it "should not prevent the object from being saved if it returns nil" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { nil }
+      end
+      c.new.save!
+    end
+    
+    it "may be a proc" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      c.new.save.should == false      
+    end
+    
+    it "may be a method" do
+      c = Class.new(RelaxDB::Document) do
+        before_save :never
+        def never; false; end
+      end
+      c.new.save.should == false
+    end
+    
+  end
+  
+  describe "after_save" do
+    
+    it "should be run after the object is saved" do
+      c = Class.new(RelaxDB::Document) do
+        after_save lambda { |s| s.gem +=1 unless s.unsaved? }
+        property :gem
+      end
+      p = c.new(:gem => 5).save
+      p.gem.should == 6
+    end
+    
+  end
+
+end

data/spec/derived_properties_spec.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+class DpInvite < RelaxDB::Document
+  property :event_name, :derived => [:event, lambda { |en, i| i.event.name }]
+  belongs_to :event  
+end
+
+class DpEvent < RelaxDB::Document
+  property :name  
+end
+
+describe RelaxDB::Document, "derived properties" do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+  
+  it "should have its value updated when the source is updated" do
+    e = DpEvent.new(:name => "shindig")
+    i = DpInvite.new(:event => e)
+    i.event_name.should == "shindig"
+  end
+  
+  it "should have its value persisted" do
+    e = DpEvent.new(:name => "shindig").save!
+    i = DpInvite.new(:event => e).save!
+    
+    RelaxDB.db.get_count = 0
+    i = RelaxDB.load i._id
+    i.event_name.should == "shindig"
+    RelaxDB.db.get_count.should == 1
+  end  
+  
+  it "should have its value updated when the source_id is updated for a saved event" do
+    e = DpEvent.new(:name => "shindig").save!
+    i = DpInvite.new(:event_id => e._id)
+    i.event_name.should == "shindig"
+  end  
+  
+  it "will not raise an exception when the source is nil" do
+    # See the rationale in Document.write_derived_props
+    DpInvite.new(:event => nil).save!
+  end  
+      
+  it "should only be updated for registered properties" do
+    invite = Class.new(RelaxDB::Document) do
+      property :event_name, :derived => [:foo, lambda { |en, i| i.event.name }]
+      belongs_to :event
+    end
+    
+    event = Class.new(RelaxDB::Document) do
+      property :name
+    end
+    
+    e = event.new(:name => "shindig")
+    i = invite.new(:event => e)
+    i.event_name.should be_nil
+  end
+  
+  it "should have the existing value passed to the first lambda param" do
+    invite = Class.new(RelaxDB::Document) do
+      property :event_name, :derived => [:event, lambda { |en, i| en.nil? ? i.event.name : "bar" }]
+      belongs_to :event
+    end
+    
+    event = Class.new(RelaxDB::Document) do
+      property :name
+    end
+    
+    e1 = event.new(:name => "shindig")
+    e2 = event.new(:name => "shindig2")
+    i = invite.new(:event => e1)
+    i.event = e2
+    i.event_name.should == "bar"
+  end
+  
+  it "should contintue to be derived post load" do
+    e = DpEvent.new(:name => "shindig").save!
+    i = DpInvite.new(:event => e).save!
+    
+    i = RelaxDB.load i._id
+    i.event_name.should == "shindig"
+    
+    e = DpEvent.new(:name => "gidnihs").save!
+    i.event = e
+    i.event_name.should == "gidnihs"
+  end    
+  
+  describe "multiple properties" do
+
+    it "should be derivable from the same source" do
+      invite = Class.new(RelaxDB::Document) do
+        property :name, :derived => [:event, lambda { |en, i| i.event.name }]
+        property :location, :derived => [:event, lambda { |en, i| i.event.location }]
+        belongs_to :event
+      end
+
+      event = Class.new(RelaxDB::Document) do
+        property :name
+        property :location
+      end
+
+      e = event.new(:name => "shindig", :location => "city17")
+      i = invite.new(:event => e)
+      i.name.should == "shindig"
+      i.location.should == "city17"
+    end     
+    
+  end
+  
+end