cohitre-relaxdb 0.2.2

data/lib/more/grapher.rb

@@ -0,0 +1,48 @@
+module RelaxDB
+  
+  #
+  # The GraphCreator uses dot to create a graphical model of an entire CouchDB database
+  # It probably only makes sense to run it on a database of a limited size
+  # The created graphs can be very useful for exploring relationships
+  # Run ruby scratch/grapher_demo.rb for an example
+  #
+  class GraphCreator
+    
+    def self.create
+      system "mkdir -p graphs"
+      
+      data = JSON.parse(RelaxDB.db.get("_all_docs").body)
+      all_ids = data["rows"].map { |r| r["id"] }
+      all_ids = all_ids.reject { |id| id =~ /_/ }
+      
+      dot = "digraph G { \nrankdir=LR;\nnode [shape=record];\n"
+      all_ids.each do |id|
+        doc = RelaxDB.load(id)
+        atts = "#{doc.class}\\l|"
+        doc.properties.each do |prop|
+          # we don't care about the revision
+          next if prop == :_rev 
+          
+          prop_val = doc.instance_variable_get("@#{prop}".to_sym)
+          atts << "#{prop}\\l#{prop_val}|" if prop_val
+        end
+        atts = atts[0, atts.length-1]
+        
+        dot << %Q%#{doc._id} [ label ="#{atts}"];\n%
+        
+        doc.class.belongs_to_rels.each do |relationship, opts|
+          id = doc.instance_variable_get("@#{relationship}_id".to_sym)
+          dot << %Q%#{id} -> #{doc._id} [ label = "#{relationship}"];\n% if id
+        end
+                  
+      end
+      dot << "}"
+      
+      File.open("graphs/data.dot", "w") { |f| f.write(dot) }
+      
+      system "dot -Tpng -o graphs/all_docs.png graphs/data.dot"
+    end
+    
+  end
+  
+end

data/lib/relaxdb.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'extlib'
+require 'json'
+require 'uuid'
+
+require 'cgi'
+require 'net/http'
+require 'logger'
+require 'parsedate'
+require 'pp'
+require 'tempfile'
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'relaxdb/all_delegator'
+require 'relaxdb/belongs_to_proxy'
+require 'relaxdb/design_doc'
+require 'relaxdb/document'
+require 'relaxdb/extlib'
+require 'relaxdb/has_many_proxy'
+require 'relaxdb/has_one_proxy'
+require 'relaxdb/paginate_params'
+require 'relaxdb/paginator'
+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'
+require 'relaxdb/view_uploader'
+require 'relaxdb/views'
+require 'more/grapher.rb'
+
+module RelaxDB
+end

data/lib/relaxdb/all_delegator.rb

@@ -0,0 +1,48 @@
+module RelaxDB
+  
+  #
+  # The AllDelegator allows clients to query CouchDB in a natural way
+  #   FooDoc.all - returns all docs in CouchDB of type FooDoc
+  #   FooDoc.all.sorted_by(:att1, :att2) - returns all docs in CouchDB of type FooDoc sorted by att1, then att2
+  #   FooDoc.all.sorted_by(:att1) { |q| q.key("bar") } - returns all docs of type FooDoc where att1 equals "bar"
+  #   FooDoc.all.destroy! - does what it says on the tin
+  #
+  class AllDelegator < Delegator
+    
+    def initialize(class_name)
+      super([])
+      @class_name = class_name
+    end
+    
+    def __getobj__
+      view_path = "_view/#{@class_name}/all"
+      map_function = ViewCreator.all(@class_name)
+      
+      @all = RelaxDB.retrieve(view_path, @class_name, "all", map_function)      
+    end
+
+    def sorted_by(*atts)
+      view = SortedByView.new(@class_name, *atts)
+
+      query = Query.new(@class_name, view.view_name)
+      yield query if block_given?
+      
+      view.query(query)
+    end
+    
+    # Note that this method leaves the corresponding DesignDoc for the associated class intact
+    def destroy!
+      each do |o| 
+        # A reload is required for deleting objects with a self referential references_many relationship
+        # This makes all.destroy! very slow. Given that references_many is now deprecated and will
+        # soon be removed, the required reload is no longer performed.
+        # obj = RelaxDB.load(o._id)
+        # obj.destroy!
+        
+        o.destroy!
+      end
+    end
+            
+  end
+  
+end

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(::CGI::escape(@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(::CGI::escape("_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("#{::CGI::escape(@data["_id"])}?rev=#{@data["_rev"]}")
+      self      
+    end
+  
+  end
+  
+end

data/lib/relaxdb/document.rb

@@ -0,0 +1,386 @@
+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 = Errors.new
+
+      # 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, opts|
+        id = instance_variable_get("@#{relationship}_id".to_sym)
+        data["#{relationship}_id"] = id if id
+        if opts[:denormalise]
+          add_denormalised_data(data, relationship, opts)
+        end
+      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
+    
+    # quick n' dirty denormalisation - explicit denormalisation will probably become a 
+    # permanent fixture of RelaxDB, but quite likely in a different form to this one
+    def add_denormalised_data(data, relationship, opts)
+      obj = send(relationship)
+      if obj
+        opts[:denormalise].each do |prop_name|
+          val = obj.send(prop_name)
+          data["#{relationship}_#{prop_name}"] = val
+        end
+      end
+    end
+    
+    # Order changed as of 30/10/2008 to be consistent with ActiveRecord
+    # Not yet sure of final implemention for hooks - may lean more towards DM than AR
+    def save
+      return false unless validates?
+      return false unless before_save
+            
+      set_created_at if unsaved? 
+      
+      resp = RelaxDB.db.put("#{_id}", to_json)
+      self._rev = JSON.parse(resp.body)["rev"]
+
+      after_save
+
+      self
+    end  
+    
+    def validates?
+      total_success = true
+      properties.each do |prop|
+        if methods.include? "validate_#{prop}"
+          prop_val = instance_variable_get("@#{prop}")
+          success = send("validate_#{prop}", prop_val) rescue false
+          unless success
+            if methods.include? "#{prop}_validation_msg"
+              @errors["#{prop}".to_sym] = send("#{prop}_validation_msg")
+            end
+          end
+          total_success &= success          
+        end
+      end
+      total_success &= validate
+      total_success
+    end
+    
+    def validate
+      true
+    end
+        
+    # Hmm. Rename... never_saved? newnew?
+    def unsaved?
+      @_rev.nil?
+    end
+    alias_method :new_record?, :unsaved?
+    alias_method :new_document?, :unsaved?
+    
+    def to_param
+      self._id
+    end
+    alias_method :id, :to_param
+    
+    def set_created_at
+      if methods.include? "created_at"
+        # Don't override it if it's already been set
+        @created_at = Time.now if @created_at.nil?
+      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, opts={})
+      @belongs_to_rels ||= {}
+      @belongs_to_rels[relationship] = opts
+
+      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
+
+      # Allows belongs_to relationships to be used by the paginator
+      define_method("#{relationship}_id") do
+        instance_variable_get("@#{relationship}_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.name)
+    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
+    
+    #
+    # Callbacks - define these in a module and mix'em'in ?
+    #
+    def self.before_save(callback)
+      before_save_callbacks << callback
+    end 
+    
+    def self.before_save_callbacks
+      @before_save ||= []
+    end       
+    
+    def before_save
+      self.class.before_save_callbacks.each do |callback|
+        resp = callback.is_a?(Proc) ? callback.call(self) : send(callback)
+        return false unless resp
+      end
+    end
+    
+    def self.after_save(callback)
+      after_save_callbacks << callback
+    end
+    
+    def self.after_save_callbacks
+      @after_save_callbacks ||= []
+    end
+    
+    def after_save
+      self.class.after_save_callbacks.each do |callback|
+        callback.is_a?(Proc) ? callback.call(self) : send(callback)
+      end
+    end
+    
+    def self.paginate_by(page_params, *view_keys)
+      paginate_params = PaginateParams.new
+      yield paginate_params
+      raise paginate_params.error_msg if paginate_params.invalid? 
+      
+      paginator = Paginator.new(paginate_params, page_params)
+                  
+      design_doc_name = self.name
+      view = SortedByView.new(design_doc_name, *view_keys)
+      query = Query.new(design_doc_name, view.view_name)
+      query.merge(paginate_params)
+      
+      docs = view.query(query)
+      docs.reverse! if paginate_params.order_inverted?
+      
+      paginator.add_next_and_prev(docs, design_doc_name, view.view_name, view_keys)
+      
+      docs
+    end
+                
+  end
+  
+end