paulcarey-relaxdb 0.1.0

data/lib/relaxdb/belongs_to_proxy.rb

@@ -0,0 +1,29 @@
+module RelaxDB
+
+  class BelongsToProxy
+
+    attr_reader :target
+  
+    def initialize(client, relationship)
+      @client = client
+      @relationship = relationship
+      @target = nil
+    end
+  
+    def target
+      return @target if @target
+            
+      id = @client.instance_variable_get("@#{@relationship}_id")
+      @target = RelaxDB.load(id) if id
+    end
+  
+    def target=(new_target)
+      id = new_target ? new_target._id : nil
+      @client.instance_variable_set("@#{@relationship}_id", id) 
+      
+      @target = new_target
+    end
+    
+  end
+
+end

data/lib/relaxdb/design_doc.rb

@@ -0,0 +1,50 @@
+module RelaxDB
+
+  class DesignDocument
+  
+    def initialize(client_class, data)
+      @client_class = client_class
+      @data = data
+    end
+      
+    def add_map_view(view_name, function)
+      add_view(view_name, "map", function)
+    end
+    
+    def add_reduce_view(view_name, function)
+      add_view(view_name, "reduce", function)
+    end
+    
+    def add_view(view_name, type, function)
+      @data["views"] ||= {}
+      @data["views"][view_name] ||= {}
+      @data["views"][view_name][type] = function
+      self            
+    end
+  
+    def save
+      database = RelaxDB.db    
+      resp = database.put("#{@data['_id']}", @data.to_json)
+      @data["_rev"] = JSON.parse(resp.body)["rev"]
+      self
+    end
+  
+    def self.get(client_class)
+      begin
+        database = RelaxDB.db
+        resp = database.get("_design/#{client_class}")
+        DesignDocument.new(client_class, JSON.parse(resp.body))
+      rescue => e
+        DesignDocument.new(client_class, {"_id" => "_design/#{client_class}"} )
+      end
+    end  
+    
+    def destroy!
+      # Implicitly prevent the object from being resaved by failing to update its revision
+      RelaxDB.db.delete("#{@data["_id"]}?rev=#{@data["_rev"]}")
+      self      
+    end
+  
+  end
+  
+end

data/lib/relaxdb/document.rb

@@ -0,0 +1,298 @@
+module RelaxDB
+    
+  class Document
+    
+    # Used to store validation messages
+    attr_accessor :errors
+    
+    # Define properties and property methods
+    
+    def self.property(prop, opts={})
+      # Class instance varibles are not inherited, so the default properties must be explicitly listed 
+      # Perhaps a better solution exists. Revise. I think extlib contains a solution for this...
+      @properties ||= [:_id, :_rev]
+      @properties << prop
+
+      define_method(prop) do
+        instance_variable_get("@#{prop}".to_sym)        
+      end
+
+      define_method("#{prop}=") do |val|
+        instance_variable_set("@#{prop}".to_sym, val)
+      end
+      
+      if opts[:default]
+        define_method("set_default_#{prop}") do
+          default = opts[:default]
+          default = default.is_a?(Proc) ? default.call : default
+          instance_variable_set("@#{prop}".to_sym, default)
+        end
+      end
+      
+      if opts[:validator]
+        define_method("validate_#{prop}") do |prop_val|
+          opts[:validator].call(prop_val)
+        end
+      end
+      
+      if opts[:validation_msg]
+        define_method("#{prop}_validation_msg") do
+          opts[:validation_msg]
+        end
+      end
+      
+    end
+
+    def self.properties
+      # Ensure that classes that don't define their own properties still function as CouchDB objects
+      @properties ||= [:_id, :_rev]
+    end
+
+    def properties
+      self.class.properties
+    end
+    
+    # Specifying these properties here (after property method has been defined) 
+    # is kinda ugly. Consider a better solution.
+    property :_id 
+    property :_rev    
+    
+    def initialize(hash={})
+      # The default _id will be overwritten if loaded from CouchDB
+      self._id = UuidGenerator.uuid 
+      
+      @errors = {}
+
+      # Set default properties if this object has not known CouchDB
+      unless hash["_rev"]
+        properties.each do |prop|
+         if methods.include?("set_default_#{prop}")
+           send("set_default_#{prop}")
+         end
+        end
+      end
+      
+      set_attributes(hash)
+    end
+    
+    def set_attributes(data)
+      data.each do |key, val|
+        # Only set instance variables on creation - object references are resolved on demand
+
+        # If the variable name ends in _at try to convert it to a Time
+        if key =~ /_at$/
+            val = Time.local(*ParseDate.parsedate(val)) rescue val
+        end
+        
+        # Ignore param keys that don't have a corresponding writer
+        # This allows us to comfortably accept a hash containing superflous data 
+        # such as a params hash in a controller 
+        if methods.include? "#{key}="
+          send("#{key}=".to_sym, val)
+        end
+                
+      end
+    end  
+    
+    def inspect
+      s = "#<#{self.class}:#{self.object_id}"
+      properties.each do |prop|
+        prop_val = instance_variable_get("@#{prop}".to_sym)
+        s << ", #{prop}: #{prop_val.inspect}" if prop_val
+      end
+      self.class.belongs_to_rels.each do |relationship|
+        id = instance_variable_get("@#{relationship}_id".to_sym)
+        s << ", #{relationship}_id: #{id}" if id
+      end
+      s << ">"
+    end
+            
+    def to_json
+      data = {}
+      self.class.belongs_to_rels.each do |relationship|
+        id = instance_variable_get("@#{relationship}_id".to_sym)
+        data["#{relationship}_id"] = id if id
+      end
+      properties.each do |prop|
+        prop_val = instance_variable_get("@#{prop}".to_sym)
+        data["#{prop}"] = prop_val if prop_val
+      end
+      data["class"] = self.class.name
+      data.to_json      
+    end
+    
+    def save
+      set_created_at_if_new
+      
+      if validates?
+        resp = RelaxDB.db.put("#{_id}", to_json)
+        self._rev = JSON.parse(resp.body)["rev"]
+        self
+      else
+        false
+      end
+    end  
+    
+    def validates?
+      success = true
+      properties.each do |prop|
+        if methods.include? "validate_#{prop}"
+          prop_val = instance_variable_get("@#{prop}")
+          unless send("validate_#{prop}", prop_val)
+            success = false
+            if methods.include? "#{prop}_validation_msg"
+              @errors["#{prop}".to_sym] = send("#{prop}_validation_msg")
+            end
+          end
+        end
+      end
+      success
+    end
+        
+    def unsaved?
+      instance_variable_get(:@_rev).nil?
+    end
+    
+    def set_created_at_if_new
+      if unsaved? and methods.include? "created_at"
+        # Don't override it if it's already been set
+        unless instance_variable_get(:@created_at)
+          instance_variable_set(:@created_at, Time.now)
+        end
+      end
+    end
+       
+    def create_or_get_proxy(klass, relationship, opts=nil)
+      proxy_sym = "@proxy_#{relationship}".to_sym
+      proxy = instance_variable_get(proxy_sym)
+      unless proxy
+        proxy = opts ? klass.new(self, relationship, opts) : klass.new(self, relationship)
+      end
+      instance_variable_set(proxy_sym, proxy)
+      proxy     
+    end
+    
+    # Returns true if CouchDB considers other to be the same as self
+    def ==(other)
+      other && _id == other._id
+    end
+   
+    # Deprecated. This method was experimental and will be removed
+    # once multi key GETs are available in CouchDB.
+    def self.references_many(relationship, opts={})
+      # Treat the representation as a standard property 
+      properties << relationship
+      
+      # Keep track of the relationship so peers can be disassociated on destroy
+      @references_many_rels ||= []
+      @references_many_rels << relationship
+     
+      define_method(relationship) do
+        array_sym = "@#{relationship}".to_sym
+        instance_variable_set(array_sym, []) unless instance_variable_defined? array_sym
+
+        create_or_get_proxy(RelaxDB::ReferencesManyProxy, relationship, opts)
+      end
+    
+      define_method("#{relationship}=") do |val|
+        # Sharp edge - do not invoke this method
+        instance_variable_set("@#{relationship}".to_sym, val)
+      end           
+    end
+   
+    def self.references_many_rels
+      # Don't force clients to check its instantiated
+      @references_many_rels ||= []
+    end
+   
+    def self.has_many(relationship, opts={})
+      @has_many_rels ||= []
+      @has_many_rels << relationship
+      
+      define_method(relationship) do
+        create_or_get_proxy(HasManyProxy, relationship, opts)
+      end
+      
+      define_method("#{relationship}=") do
+        raise "You may not currently assign to a has_many relationship - may be implemented"
+      end      
+    end
+
+    def self.has_many_rels
+      # Don't force clients to check its instantiated
+      @has_many_rels ||= []
+    end
+            
+    def self.has_one(relationship)
+      @has_one_rels ||= []
+      @has_one_rels << relationship
+      
+      define_method(relationship) do      
+        create_or_get_proxy(HasOneProxy, relationship).target
+      end
+      
+      define_method("#{relationship}=") do |new_target|
+        create_or_get_proxy(HasOneProxy, relationship).target = new_target
+      end
+    end
+    
+    def self.has_one_rels
+      @has_one_rels ||= []      
+    end
+            
+    def self.belongs_to(relationship)
+      @belongs_to_rels ||= []
+      @belongs_to_rels << relationship
+
+      define_method(relationship) do
+        create_or_get_proxy(BelongsToProxy, relationship).target
+      end
+      
+      define_method("#{relationship}=") do |new_target|
+        create_or_get_proxy(BelongsToProxy, relationship).target = new_target
+      end
+      
+      # Allows all writers to be invoked from the hash passed to initialize 
+      define_method("#{relationship}_id=") do |id|
+        instance_variable_set("@#{relationship}_id".to_sym, id)
+      end
+      
+    end
+    
+    def self.belongs_to_rels
+      # Don't force clients to check that it's instantiated
+      @belongs_to_rels ||= []
+    end
+    
+    def self.all_relationships
+      belongs_to_rels + has_one_rels + has_many_rels + references_many_rels
+    end
+        
+    def self.all
+      @all_delegator ||= AllDelegator.new(self)      
+    end
+                
+    # destroy! nullifies all relationships with peers and children before deleting 
+    # itself in CouchDB
+    # The nullification and deletion are not performed in a transaction
+    def destroy!
+      self.class.references_many_rels.each do |rel|
+        send(rel).clear
+      end
+      
+      self.class.has_many_rels.each do |rel|
+        send(rel).clear
+      end
+      
+      self.class.has_one_rels.each do |rel|
+        send("#{rel}=".to_sym, nil)
+      end
+      
+      # Implicitly prevent the object from being resaved by failing to update its revision
+      RelaxDB.db.delete("#{_id}?rev=#{_rev}")
+      self
+    end
+            
+  end
+  
+end

data/lib/relaxdb/has_many_proxy.rb

@@ -0,0 +1,81 @@
+module RelaxDB
+
+  class HasManyProxy
+
+    include Enumerable
+  
+    def initialize(client, relationship, opts)
+      @client = client 
+      @relationship = relationship
+      @opts = opts
+
+      @target_class = opts[:class] 
+      @relationship_as_viewed_by_target = (opts[:known_as] || client.class.name.downcase).to_s
+
+      @children = load_children
+    end
+
+    def <<(obj)
+      return false unless obj.validates?
+      return false if @children.include?(obj)
+      
+      obj.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+      obj.save
+      @children << obj
+      self
+    end
+  
+    def clear
+      @children.each do |c|
+        break_back_link c
+      end
+      @children.clear
+    end
+  
+    def delete(obj)
+      obj = @children.delete(obj)
+      break_back_link(obj) if obj
+    end
+  
+    def break_back_link(obj)
+      if obj
+        obj.send("#{@relationship_as_viewed_by_target}=".to_sym, nil)
+        obj.save
+      end
+    end
+  
+    def empty?
+      @children.empty?
+    end
+  
+    def size
+      @children.size
+    end
+  
+    def [](*args)
+      @children[*args]
+    end
+  
+    def each(&blk)
+      @children.each(&blk)
+    end
+  
+    def reload
+      @children = load_children
+    end
+  
+    def load_children
+      view_path = "_view/#{@client.class}/#{@relationship}?key=\"#{@client._id}\""
+      design_doc = @client.class
+      view_name = @relationship
+      map_function = ViewCreator.has_n(@target_class, @relationship_as_viewed_by_target)
+      @children = RelaxDB.retrieve(view_path, design_doc, view_name, map_function)
+    end
+  
+    def inspect
+      @children.inspect
+    end
+  
+  end
+
+end

data/lib/relaxdb/has_one_proxy.rb

@@ -0,0 +1,45 @@
+module RelaxDB
+
+  class HasOneProxy
+  
+    def initialize(client, relationship)
+      @client = client
+      @relationship = relationship
+      @target_class = @relationship.to_s.capitalize      
+      @relationship_as_viewed_by_target = client.class.to_s.downcase
+      
+      @target = nil
+    end
+    
+    def target
+      return @target if @target    
+      @target = load_target
+    end
+  
+    # All database changes performed by this method would ideally be done in a transaction
+    def target=(new_target)
+      # Nullify any existing relationship on assignment
+      old_target = target
+      if old_target
+        old_target.send("#{@relationship_as_viewed_by_target}=".to_sym, nil)
+        old_target.save
+      end
+    
+      @target = new_target
+      unless @target.nil?
+        @target.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+        @target.save
+      end
+    end
+  
+    def load_target
+      design_doc = @client.class
+      view_name = @relationship
+      view_path = "_view/#{design_doc}/#{view_name}?key=\"#{@client._id}\""
+      map_function = ViewCreator.has_n(@target_class, @relationship_as_viewed_by_target)
+      RelaxDB.retrieve(view_path, design_doc, view_name, map_function)[0]
+    end
+        
+  end
+
+end

data/lib/relaxdb/query.rb

@@ -0,0 +1,48 @@
+module RelaxDB
+
+  # A Query is used to build the query string made against a view
+  # All parameter values are first JSON encoded and then URL encoded
+  # Nil values are set to the empty string
+  # All parameter calls return self so calls may be chained => q.startkey("foo").endkey("bar").count(2)
+  
+  #
+  # The query object is currently inconsistent with the RelaxDB object idiom. Consider
+  #   paul = User.new(:name => "paul").save; Event.new(:host=>paul).save
+  # but an event query requires
+  #   Event.all.sorted_by(:host_id) { |q| q.key(paul._id) } 
+  # rather than
+  #   Event.all.sorted_by(:host) { |q| q.key(paul) }  
+  # I feel that both forms should be supported
+  #
+  class Query
+    
+    @@params = %w(key startkey startkey_docid endkey endkey_docid count update descending skip group)
+    
+    @@params.each do |param|
+      define_method(param.to_sym) do |val|
+        val ||= ""
+        instance_variable_set("@#{param}".to_sym, val)
+        self
+      end
+    end
+    
+    def initialize(design_doc, view_name)
+      @design_doc = design_doc
+      @view_name = view_name
+    end
+    
+    def view_path
+      uri = "_view/#{@design_doc}/#{@view_name}"
+      
+      query = ""
+      @@params.each do |param|
+        val = instance_variable_get("@#{param}")
+        query << "&#{param}=#{::CGI::escape(val.to_json)}" if val
+      end
+    
+      uri << query.sub(/^&/, "?")
+    end
+        
+  end
+
+end

data/lib/relaxdb/references_many_proxy.rb

@@ -0,0 +1,99 @@
+module RelaxDB
+
+  class ReferencesManyProxy
+    
+    include Enumerable
+  
+    def initialize(client, relationship, opts)
+      @client = client
+      @relationship = relationship
+    
+      @target_class = opts[:class]
+      @relationship_as_viewed_by_target = opts[:known_as].to_s
+    end
+  
+    def <<(obj, reciprocal_invocation=false)
+      return false if peer_ids.include? obj._id
+      
+      @peers << obj if @peers
+      peer_ids << obj._id
+    
+      unless reciprocal_invocation
+        # Set the other side of the relationship, ensuring this method isn't called again
+        obj.send(@relationship_as_viewed_by_target).send(:<<, @client, true) 
+    
+        # Bulk save to ensure relationship is persisted on both sides
+        RelaxDB.bulk_save(@client, obj)
+      end
+    
+      self
+    end
+  
+    def clear
+      resolve
+      @peers.each do |peer|
+        peer.send(@relationship_as_viewed_by_target).send(:delete_from_self, @client)
+      end
+    
+      # Important to resolve in the database before in memory, although an examination of the
+      # contents of the bulk_save will look wrong as this object will still list all its peers
+      RelaxDB.bulk_save(@client, *@peers)
+      
+      peer_ids.clear
+      @peers.clear
+    end
+    
+    def delete(obj)
+      deleted = obj.send(@relationship_as_viewed_by_target).send(:delete_from_self, @client)
+      if deleted
+        delete_from_self(obj)
+        RelaxDB.bulk_save(@client, obj)
+      end
+      deleted
+    end
+  
+    def delete_from_self(obj)
+      @peers.delete(obj) if @peers
+      peer_ids.delete(obj._id)
+    end
+        
+    def empty?
+      peer_ids.empty?
+    end
+
+    def size
+      peer_ids.size
+    end
+  
+    def [](*args)
+      resolve
+      @peers[*args]
+    end
+  
+    def each(&blk)
+      resolve
+      @peers.each(&blk)    
+    end
+      
+    def inspect
+      @client.instance_variable_get("@#{@relationship}".to_sym).inspect
+    end
+  
+    private
+  
+    def peer_ids
+      @client.instance_variable_get("@#{@relationship}".to_sym)
+    end
+    
+    # Resolves the actual ids into real objects via a single GET to CouchDB. Called internally by each
+    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)
+    end
+    
+  end
+  
+end