cohitre-relaxdb 0.2.2

data/lib/relaxdb/extlib.rb

@@ -0,0 +1,3 @@
+class Errors < Hash
+  alias_method :on, :[]
+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.snake_case).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.camel_case      
+      @relationship_as_viewed_by_target = client.class.name.snake_case
+      
+      @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).first
+    end
+        
+  end
+
+end

data/lib/relaxdb/paginate_params.rb

@@ -0,0 +1,54 @@
+module RelaxDB
+
+  class PaginateParams
+        
+    @@params = %w(key startkey startkey_docid endkey endkey_docid count update descending group reduce include_docs)
+  
+    @@params.each do |param|
+      define_method(param.to_sym) do |*val|
+        if val.empty?
+          instance_variable_get("@#{param}")
+        else
+          instance_variable_set("@#{param}", val[0])
+          # null is meaningful to CouchDB. _set allows us to know that a param has been set, even to nil
+          instance_variable_set("@#{param}_set", true)
+          self
+        end
+      end
+    end
+    
+    def initialize
+      # If a client hasn't explicitly set descending, set it to the CouchDB default
+      @descending = false if @descending.nil?
+      # CouchDB defaults reduce to true when a reduce func is present
+      @reduce = false
+    end
+  
+    def update(params)
+      @order_inverted = params[:descending].nil? ? false : @descending ^ params[:descending]
+      @descending = !@descending if @order_inverted
+
+      @endkey = @startkey if @order_inverted
+    
+      @startkey = params[:startkey] || @startkey
+    
+      @skip = 1 if params[:startkey]
+      
+      @startkey_docid = params[:startkey_docid] if params[:startkey_docid]
+      @endkey_docid = params[:endkey_docid] if params[:endkey_docid]
+    end
+  
+    def order_inverted?
+      @order_inverted
+    end
+    
+    def invalid?
+      # Simply because allowing either to be omitted increases the complexity of the paginator
+      # This constraint may be removed in future, but don't hold your breath
+      @startkey_set && @endkey_set ? nil : "Both startkey and endkey must be set"
+    end
+    alias error_msg invalid?
+      
+  end
+
+end

data/lib/relaxdb/paginator.rb

@@ -0,0 +1,78 @@
+module RelaxDB  
+
+  class Paginator
+    
+    attr_reader :paginate_params
+
+    def initialize(paginate_params, page_params)
+      @paginate_params = paginate_params
+      @orig_paginate_params = @paginate_params.clone
+      
+      page_params = page_params.is_a?(String) ? JSON.parse(page_params).to_mash : page_params
+      # Where the magic happens - the original params are updated with the page specific params
+      @paginate_params.update(page_params)
+    end
+
+    def total_doc_count(design_doc, view_name)
+      result = RelaxDB.view(design_doc, view_name) do |q|
+        q.group(true).group_level(0).reduce(true)
+        q.startkey(@orig_paginate_params.startkey).endkey(@orig_paginate_params.endkey).descending(@orig_paginate_params.descending)  
+      end
+      
+      total_docs = RelaxDB.reduce_result(result)
+    end
+    
+    def add_next_and_prev(docs, design_doc, view_name, view_keys)
+      unless docs.empty?
+        no_docs = docs.size
+        offset = docs.offset
+        orig_offset = orig_offset(design_doc, view_name)
+        total_doc_count = total_doc_count(design_doc, view_name)      
+      
+        next_exists = !@paginate_params.order_inverted? ? (offset - orig_offset + no_docs < total_doc_count) : true
+        next_params = create_next(docs.last, view_keys) if next_exists
+    
+        prev_exists = @paginate_params.order_inverted? ? (offset - orig_offset + no_docs < total_doc_count) : 
+          (offset - orig_offset == 0 ? false : true)
+        prev_params = create_prev(docs.first, view_keys) if prev_exists
+      else
+        next_exists = prev_exists = false
+      end
+      
+      docs.meta_class.instance_eval do        
+        define_method(:next_params) { next_exists ? next_params : false }
+        define_method(:next_query) { next_exists ? "page_params=#{::CGI::escape(next_params.to_json)}" : false }
+        
+        define_method(:prev_params) { prev_exists ? prev_params : false }
+        define_method(:prev_query) { prev_exists ? "page_params=#{::CGI::escape(prev_params.to_json)}" : false }
+      end      
+    end
+    
+    def create_next(doc, view_keys)
+      next_key = view_keys.map { |a| doc.send(a) }
+      next_key = next_key.length == 1 ? next_key[0] : next_key
+      next_key_docid = doc._id
+      { :startkey => next_key, :startkey_docid => next_key_docid, :descending => @orig_paginate_params.descending }
+    end
+    
+    def create_prev(doc, view_keys)
+      prev_key = view_keys.map { |a| doc.send(a) }
+      prev_key = prev_key.length == 1 ? prev_key[0] : prev_key
+      prev_key_docid = doc._id
+      prev_params = { :startkey => prev_key, :startkey_docid => prev_key_docid, :descending => !@orig_paginate_params.descending }
+    end
+    
+    def orig_offset(design_doc, view_name)
+      query = Query.new(design_doc, view_name)
+      if @paginate_params.order_inverted?
+        query.startkey(@orig_paginate_params.endkey).descending(!@orig_paginate_params.descending)
+      else
+        query.startkey(@orig_paginate_params.startkey).descending(@orig_paginate_params.descending)
+      end
+      query.reduce(false).count(1)
+      RelaxDB.retrieve(query.view_path).offset
+    end
+    
+  end
+  
+end

data/lib/relaxdb/query.rb

@@ -0,0 +1,74 @@
+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
+    
+    # keys is not included in the standard param as it is significantly different from the others
+    @@params = %w(key startkey startkey_docid endkey endkey_docid count update descending skip group group_level reduce include_docs)
+    
+    @@params.each do |param|
+      define_method(param.to_sym) do |*val|
+        if val.empty?
+          instance_variable_get("@#{param}")
+        else 
+          instance_variable_set("@#{param}", val[0])
+          # null is meaningful to CouchDB. _set allows us to know that a param has been set, even to nil        
+          instance_variable_set("@#{param}_set", true)
+          self
+        end
+      end
+    end
+        
+    def initialize(design_doc, view_name)
+      @design_doc = design_doc
+      @view_name = view_name
+    end
+    
+    def keys(keys=nil)
+      if keys.nil?
+        @keys
+      else 
+        @keys = { :keys => keys }.to_json
+      end
+    end
+    
+    def view_path
+      uri = "_view/#{@design_doc}/#{@view_name}"
+      
+      query = ""
+      @@params.each do |param|
+        val_set = instance_variable_get("@#{param}_set")
+        if val_set
+          val = instance_variable_get("@#{param}")
+          val = val.to_json unless ["startkey_docid", "endkey_docid"].include?(param)
+          query << "&#{param}=#{::CGI::escape(val)}" 
+        end
+      end
+    
+      uri << query.sub(/^&/, "?")
+    end
+    
+    def merge(paginate_params)
+      paginate_params.instance_variables.each do |pp|
+        val = paginate_params.instance_variable_get(pp)
+        method_name = pp[1, pp.length]
+        send(method_name, val) if methods.include? method_name
+      end
+    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

data/lib/relaxdb/relaxdb.rb

@@ -0,0 +1,157 @@
+module RelaxDB
+  
+  @@db = nil
+  
+  class <<self
+
+    def configure(config)
+      @@db = CouchDB.new(config)
+    end
+  
+    def db
+      @@db
+    end
+    
+    def logger
+      @@db.logger
+    end
+    
+    # Creates the named database if it doesn't already exist
+    def use_db(name)
+      db.use_db(name)
+    end
+    
+    def delete_db(name)
+      db.delete_db(name)
+    end
+    
+    def list_dbs
+      db.list_dbs
+    end
+    
+    def replicate_db(source, target)
+      db.replicate_db source, target
+    end
+    
+    def bulk_save(*objs)
+      docs = {}
+      objs.each { |o| docs[o._id] = o }
+    
+      resp = db.post("_bulk_docs", { "docs" => objs }.to_json )
+      data = JSON.parse(resp.body)
+    
+      data["new_revs"].each do |new_rev|
+        docs[ new_rev["id"] ]._rev = new_rev["rev"]
+      end
+    
+      data["ok"]
+    end
+  
+    def load(*ids)
+      if ids.size == 1
+        resp = db.get(ids[0])
+        data = JSON.parse(resp.body)
+        create_object(data)
+      else
+        resp = db.post("_all_docs?include_docs=true", {:keys => ids}.to_json)
+        data = JSON.parse(resp.body)
+        data["rows"].map { |row| create_object(row["doc"]) }
+      end
+    end
+    
+    # Used internally by RelaxDB
+    def retrieve(view_path, design_doc=nil, view_name=nil, map_function=nil)
+      begin
+        resp = db.get(view_path)
+      rescue => e
+        DesignDocument.get(design_doc).add_map_view(view_name, map_function).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?
+      
+      resp = q.keys ? db.post(q.view_path, q.keys) : db.get(q.view_path)
+      JSON.parse(resp.body)      
+    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)
+      merged = {}
+      data["rows"].each do |row|
+        value = row["value"]
+        merged[value[merge_key]] ||= {}
+        merged[value[merge_key]].merge!(value)
+      end
+      
+      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)      
+    end
+    
+    def paginate_view(page_params, design_doc, view_name, *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)
+                  
+      query = Query.new(design_doc, view_name)
+      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)
+      
+      docs
+    end
+        
+    def create_from_hash(data)
+      data["rows"].map { |row| create_object(row["value"]) }
+    end
+  
+    def create_object(data)
+      # revise use of string 'class' - it's a reserved word in JavaScript
+      klass = data.delete("class")
+      if klass
+        k = Module.const_get(klass)
+        k.new(data)
+      else 
+        # data is not of a known class
+        ViewObject.create(data)
+      end
+    end
+        
+    # Convenience methods - should be in a diffent module?
+    
+    def pp_get(uri=nil)
+      resp = db.get(uri)
+      pp(JSON.parse(resp.body))
+    end
+
+    def pp_post(uri=nil, json=nil)
+      resp = db.post(uri, json)
+      pp(JSON.parse(resp.body))
+    end
+  
+  end
+  
+end