paulcarey-relaxdb 0.2.8 → 0.3.0

data/lib/relaxdb/references_many_proxy.rb

@@ -25,6 +25,7 @@ module RelaxDB
         obj.send(@relationship_as_viewed_by_target).send(:<<, @client, true) 
     
         # Bulk save to ensure relationship is persisted on both sides
+        # TODO: Should this be bulk_save! ? Probably.
         RelaxDB.bulk_save(@client, obj)
       end
     
@@ -88,11 +89,8 @@ module RelaxDB
     
     # Resolves the actual ids into real objects via a single GET to CouchDB
     def resolve
-      design_doc = @client.class
-      view_name = @relationship
-      view_path = "_view/#{design_doc}/#{view_name}?key=\"#{@client._id}\""
-      map_function = ViewCreator.has_many_through(@target_class, @relationship_as_viewed_by_target)
-      @peers = RelaxDB.retrieve(view_path, design_doc, view_name, map_function)
+      view_name = "#{@client.class}_#{@relationship}"
+      @peers = RelaxDB.view(view_name, :key => @client._id)      
     end
     
   end

data/lib/relaxdb/relaxdb.rb

@@ -10,7 +10,26 @@ module RelaxDB
   class <<self
 
     def configure(config)
-      @@db = CouchDB.new(config)
+      @@db = CouchDB.new config
+      
+      raise "A design_doc must be provided" unless config[:design_doc]
+      @dd = config[:design_doc]
+    end
+    
+    # This is a temporary method that helps the transition as RelaxDB moves to a single 
+    # design doc per application.
+    def dd
+      @dd
+    end
+    
+    def enable_view_creation default=true
+      @create_views = default
+    end
+    
+    # Set in configuration and consulted by view_by, has_many, has_one, references_many and all
+    # Views will be added to CouchDB iff this is true
+    def create_views?
+      @create_views
     end
   
     def db
@@ -53,7 +72,7 @@ module RelaxDB
         resp = db.post("_bulk_docs", { "docs" => objs }.to_json )
         data = JSON.parse(resp.body)
     
-        data["new_revs"].each do |new_rev|
+        data.each do |new_rev|
           obj = docs[ new_rev["id"] ]
           obj._rev = new_rev["rev"]
           obj.post_save
@@ -72,6 +91,10 @@ module RelaxDB
         false
       end
     end
+    
+    def reload(obj)
+      load(obj._id)
+    end
   
     def load(ids)
       # RelaxDB.logger.debug(caller.inject("#{db.name}/#{ids}\n") { |a, i| a += "#{i}\n" })
@@ -99,32 +122,19 @@ module RelaxDB
       
       res
     end
-    
-    # Used internally by RelaxDB
-    def retrieve(view_path, design_doc=nil, view_name=nil, map_func=nil, reduce_func=nil)
-      begin
-        resp = db.get(view_path)
-      rescue => e
-        dd = DesignDocument.get(design_doc).add_map_view(view_name, map_func)
-        dd.add_reduce_view(view_name, reduce_func) if reduce_func
-        dd.save
-        resp = db.get(view_path)
-      end
-      
-      data = JSON.parse(resp.body)
-      ViewResult.new(data)
-    end
-      
-    # Requests the given view from CouchDB and returns a hash.
-    # This method should typically be wrapped in one of merge, instantiate, or reduce_result.
-    def view(design_doc, view_name)
-      q = Query.new(design_doc, view_name)
-      yield q if block_given?
+          
+    def view(view_name, params = {})
+      q = Query.new(view_name, params)
       
       resp = q.keys ? db.post(q.view_path, q.keys) : db.get(q.view_path)
-      JSON.parse(resp.body)      
+      hash = JSON.parse(resp.body)
+      
+      if q.raw then hash
+      elsif q.reduce then reduce_result hash
+      else ViewResult.new hash
+      end      
     end
-    
+        
     # Should be invoked on the result of a join view
     # Merges all rows based on merge_key and returns an array of ViewOject
     def merge(data, merge_key)
@@ -137,32 +147,29 @@ module RelaxDB
       
       merged.values.map { |v| ViewObject.create(v) }
     end
-    
-    # Creates RelaxDB::Document objects from the result
-    def instantiate(data)
-      create_from_hash(data)
-    end
-    
-    # Returns a scalar, an object, or an Array of objects
+        
     def reduce_result(data)
-      obj = data["rows"][0] && data["rows"][0]["value"]
-      ViewObject.create(obj)      
+      res = create_from_hash data
+      res.size == 0 ? nil :
+        res.size == 1 ? res[0] : res
     end
     
-    def paginate_view(page_params, design_doc, view_name, *view_keys)
-      paginate_params = PaginateParams.new
-      yield paginate_params
+    def paginate_view(view_name, atts)      
+      page_params = atts.delete :page_params
+      view_keys = atts.delete :attributes
+      
+      paginate_params = PaginateParams.new atts
       raise paginate_params.error_msg if paginate_params.invalid? 
       
       paginator = Paginator.new(paginate_params, page_params)
                   
-      query = Query.new(design_doc, view_name)
+      query = Query.new(view_name, atts)
       query.merge(paginate_params)
       
       docs = ViewResult.new(JSON.parse(db.get(query.view_path).body))
       docs.reverse! if paginate_params.order_inverted?
       
-      paginator.add_next_and_prev(docs, design_doc, view_name, view_keys)
+      paginator.add_next_and_prev(docs, view_name, view_keys)
       
       docs
     end
@@ -172,14 +179,13 @@ module RelaxDB
     end
   
     def create_object(data)
-      # revise use of string 'class' - it's a reserved word in JavaScript
-      klass = data.delete("class")
+      klass = data.is_a?(Hash) && data.delete("relaxdb_class")
       if klass
-        k = Module.const_get(klass)
-        k.new(data)
+        k = klass.split("::").inject(Object) { |x, y| x.const_get y }
+        k.new data
       else 
-        # data is not of a known class
-        ViewObject.create(data)
+        # data is a scalar or not of a known class
+        ViewObject.create data
       end
     end
         

data/lib/relaxdb/server.rb

@@ -68,10 +68,10 @@ module RelaxDB
         
     # Used for test instrumentation only i.e. to assert that 
     # an expected number of requests have been issued
-    attr_accessor :get_count, :put_count
+    attr_accessor :get_count, :put_count, :post_count
         
     def initialize(config)
-      @get_count, @put_count = 0, 0
+      @get_count, @post_count, @put_count = 0, 0, 0
       @server = RelaxDB::Server.new(config[:host], config[:port])
       @logger = config[:logger] ? config[:logger] : Logger.new(Tempfile.new('couchdb.log'))
     end
@@ -106,14 +106,14 @@ module RelaxDB
       @server.delete("/#{@db}/#{path}")
     end
     
-    # *ignored allows methods to invoke get or post indifferently via send
-    def get(path=nil, *ignored)
+    def get(path=nil)
       @get_count += 1
       @logger.info("GET /#{@db}/#{unesc(path)}")
       @server.get("/#{@db}/#{path}")
     end
         
     def post(path=nil, json=nil)
+      @post_count += 1
       @logger.info("POST /#{@db}/#{unesc(path)} #{json}")
       @server.post("/#{@db}/#{path}", json)
     end

data/lib/relaxdb/view_uploader.rb

@@ -6,17 +6,19 @@ module RelaxDB
       
       # 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 '-'
+      # As '-' is used as a delimiter, the view name may not contain '-'
       # Exepcted function declaration form is 
-      #   function DesignDoc-funcname-functype(doc) {
+      #   function funcname-functype(doc) {
       # For example 
-      #   function Users-followers-map(doc) {
+      #   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
+        dd = RelaxDB::DesignDocument.get(RelaxDB.dd)
+        extract(lines) do |vn, t, f|
+          dd.add_view(vn, t, f)
         end
+        dd.save
       end
       
       def extract(lines)
@@ -32,11 +34,11 @@ module RelaxDB
 
         0.upto(m.size-2) do |i|
           declr = lines[m[i]]
-          declr =~ /(\w)+-(\w)+-(\w)+/
+          declr =~ /(\w)+-(\w)+/
           declr.sub!($&, '')
-          design_doc, view_name, type = $&.split('-')
+          view_name, type = $&.split('-')
           func = lines[m[i]...m[i+1]].join
-          yield design_doc, view_name, type, func
+          yield view_name, type, func
         end
       end
 

data/lib/relaxdb/views.rb

@@ -2,51 +2,111 @@ module RelaxDB
 
   class ViewCreator
     
-    def self.all(target_class)
+    def self.all(kls)
+      class_name = kls[0]
       map = <<-QUERY
-      function(doc) {
-        if(doc.class == "${target_class}")
+      function(doc) {        
+        var class_match = #{kls_check kls}
+        if (class_match) {
           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;
+            
+      View.new "#{class_name}_all", map, sum_reduce_func      
+    end
+    
+    def self.by_att_list(kls, *atts)
+      class_name = kls[0]
+      key = atts.map { |a| "doc.#{a}" }.join(", ")
+      key = atts.size > 1 ? key.sub(/^/, "[").sub(/$/, "]") : key
+      prop_check = atts.map { |a| "doc.#{a} !== undefined" }.join(" && ")
+    
+      map = <<-QUERY
+      function(doc) {
+        var class_match = #{kls_check kls}
+        if(class_match && #{prop_check}) {
+          emit(#{key}, doc);
         }
       }
       QUERY
       
-      [map, reduce]  
+      view_name = "#{class_name}_by_" << atts.join("_and_")
+      View.new view_name, map, sum_reduce_func
     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)
+    def self.has_n(client_class, relationship, target_class, relationship_to_client)
+      map = <<-QUERY
+        function(doc) {
+          if(doc.relaxdb_class == "#{target_class}" && doc.#{relationship_to_client}_id)
+            emit(doc.#{relationship_to_client}_id, doc);
+        }
+      QUERY
+      
+      view_name = "#{client_class}_#{relationship}"
+      View.new view_name, map
     end
   
-    def self.has_many_through(target_class, peers)
-      template = <<-MAP_FUNC
+    def self.references_many(client_class, relationship, target_class, peers)
+      map = <<-QUERY
         function(doc) {
-          if(doc.class == "${target_class}" && doc.${peers}) {
+          if(doc.relaxdb_class == "#{target_class}" && doc.#{peers}) {
             var i;
-            for(i = 0; i < doc.${peers}.length; i++) {
-              emit(doc.${peers}[i], doc);
+            for(i = 0; i < doc.#{peers}.length; i++) {
+              emit(doc.#{peers}[i], doc);
             }
           }
         }
-      MAP_FUNC
-      template.sub!("${target_class}", target_class).gsub!("${peers}", peers)
+      QUERY
+      
+      view_name = "#{client_class}_#{relationship}"
+      View.new view_name, map
+    end
+    
+    def self.kls_check kls
+      kls_names = kls.map{ |k| %Q("#{k}") }.join(",")
+      "[#{kls_names}].indexOf(doc.relaxdb_class) >= 0;"
+    end
+    
+    def self.sum_reduce_func
+      <<-QUERY
+      function(keys, values, rereduce) {
+        if (rereduce) {
+          return sum(values);
+        } else {
+          return values.length;
+        }
+      }
+      QUERY
+    end    
+    
+  end
+  
+  class View
+    
+    attr_reader :view_name
+        
+    def initialize view_name, map_func, reduce_func = nil
+      @view_name = view_name
+      @map_func = map_func
+      @reduce_func = reduce_func
+    end
+    
+    def design_doc
+      @design_doc ||= DesignDocument.get(RelaxDB.dd) 
+    end
+    
+    def save
+      dd = design_doc
+      dd.add_map_view(@view_name, @map_func)
+      dd.add_reduce_view(@view_name, @reduce_func) if @reduce_func
+      dd.save
+    end
+    
+    def exists?
+      dd = design_doc
+      dd.data["views"] && dd.data["views"][@view_name]
     end
     
   end

data/lib/relaxdb.rb

@@ -28,7 +28,6 @@ require 'relaxdb/query'
 require 'relaxdb/references_many_proxy'
 require 'relaxdb/relaxdb'
 require 'relaxdb/server'
-require 'relaxdb/sorted_by_view'
 require 'relaxdb/uuid_generator'
 require 'relaxdb/view_object'
 require 'relaxdb/view_result'

data/readme.rb

@@ -0,0 +1,79 @@
+# README code is extracted from this file (pagination code excepted).
+
+require 'rubygems'
+require 'lib/relaxdb'
+
+RelaxDB.configure :host => "localhost", :port => 5984, :design_doc => "app" #, :logger => Logger.new(STDOUT)
+RelaxDB.delete_db "relaxdb_scratch" rescue :ok
+RelaxDB.use_db "relaxdb_scratch"
+RelaxDB.enable_view_creation # creates views when class definition is executed
+
+class User < RelaxDB::Document
+  property :name
+end
+
+class Invite < RelaxDB::Document
+  
+  property :created_at
+  
+  property :event_name
+  
+  property :state, :default => "awaiting_response",
+    :validator => lambda { |s| %w(accepted rejected awaiting_response).include? s }
+  
+  references :sender, :validator => :required
+  
+  references :recipient, :validator => :required
+  
+  property :sender_name,
+   :derived => [:sender, lambda { |p, o| o.sender.name } ]
+  
+  view_by :sender_name
+  view_by :sender_id
+  view_by :recipient_id, :created_at, :descending => true
+  
+  def on_update_conflict
+    puts "conflict!"
+  end
+  
+end
+
+# Saving objects
+
+sofa = User.new(:name => "sofa").save!
+futon = User.new(:name => "futon").save!
+
+i = Invite.new :sender => sofa, :recipient => futon, :event_name => "CouchCamp"
+i.save!
+
+# Loading and querying
+
+il = RelaxDB.load i._id
+puts i == il # true
+
+ir = Invite.by_sender_name "sofa"
+puts i == ir # true
+
+ix = Invite.by_sender_name(:key => "sofa").first
+puts i == ix # true
+
+# Denormalization
+
+puts ix.sender_name # prints sofa, no requests to CouchDB made
+puts ix.sender.name # prints sofa, a single CouchDB request made
+
+# Saving with conflicts
+
+idup = i.dup
+i.save!
+idup.save # conflict printed
+
+# Saving with and without validations
+
+i = Invite.new :sender => sofa, :name => "daily show"
+i.save! rescue :ok # save! throws an exception on validation failure or conflict
+i.save # returns false rather than throwing an exception
+puts i.errors.inspect # {:recipient=>"invalid:"}
+
+i.validation_skip_list << :recipient # Any and all validations may be skipped
+i.save # succeeds

data/spec/belongs_to_spec.rb

@@ -4,12 +4,7 @@ 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"
+    setup_test_db
   end
 
   describe "belongs_to" do

data/spec/callbacks_spec.rb

@@ -5,12 +5,12 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 describe RelaxDB::Document, "callbacks" do
   
   before(:all) do
-    RelaxDB.configure(:host => "localhost", :port => 5984)  
+    RelaxDB.configure :host => "localhost", :port => 5984, :design_doc => "spec_doc"
   end
 
   before(:each) do
-    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
-    RelaxDB.use_db "relaxdb_spec_db"
+    RelaxDB.delete_db "relaxdb_spec" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec"
   end
   
   describe "before_save" do
@@ -31,6 +31,22 @@ describe RelaxDB::Document, "callbacks" do
       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 }

data/spec/derived_properties_spec.rb

@@ -12,13 +12,8 @@ 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"
+    setup_test_db
   end
   
   it "should have its value updated when the source is updated" do
@@ -36,7 +31,7 @@ describe RelaxDB::Document, "derived properties" do
     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)

data/spec/design_doc_spec.rb

@@ -4,12 +4,12 @@ require File.dirname(__FILE__) + '/spec_models.rb'
 describe RelaxDB::DesignDocument do
   
   before(:all) do
-    RelaxDB.configure(:host => "localhost", :port => 5984)  
+    RelaxDB.configure :host => "localhost", :port => 5984, :design_doc => "spec_doc"
   end
 
   before(:each) do
-    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
-    RelaxDB.use_db "relaxdb_spec_db"
+    RelaxDB.delete_db "relaxdb_spec" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec"
   end
 
   describe "#save" do