ceritium-relaxdb 0.2.8

data/lib/relaxdb/extlib.rb

@@ -0,0 +1,15 @@
+class Errors < Hash
+  alias_method :on, :[]
+end
+
+class Time
+  
+  # Ensure that all Times are stored as UTC
+  # Times in the following format may be passed directly to 
+  # Date.new in a JavaScript runtime
+  def to_json
+    utc
+    %Q("#{strftime "%Y/%m/%d %H:%M:%S +0000"}")
+  end
+  
+end

data/lib/relaxdb/has_many_proxy.rb

@@ -0,0 +1,104 @@
+module RelaxDB
+
+  class HasManyProxy
+
+    include Enumerable
+    
+    attr_reader :children
+  
+    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 if @children.include?(obj)
+
+      obj.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+      if obj.save
+        @children << obj
+        self
+      else
+        false
+      end
+    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 first
+      @children[0]
+    end
+    
+    def last
+      @children[size-1]
+    end
+  
+    def each(&blk)
+      @children.each(&blk)
+    end
+  
+    def reload
+      @children = load_children
+    end
+  
+    def load_children
+      view_path = "_design/#{@client.class}/_view/#{@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 children=(children)
+      children.each do |obj|
+        obj.send("#{@relationship_as_viewed_by_target}=".to_sym, @client)
+      end
+      @children = children
+    end
+  
+    def inspect
+      @children.inspect
+    end
+    
+    # Play nice with Merb partials - [ obj ].flatten invokes
+    # obj.to_ary if it responds to to_ary
+    alias_method :to_ary, :to_a
+  
+  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 = "_design/#{design_doc}/_view/#{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 limit 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.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).limit(1)
+      RelaxDB.retrieve(query.view_path).offset
+    end
+    
+  end
+  
+end

data/lib/relaxdb/query.rb

@@ -0,0 +1,75 @@
+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").limit(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 limit 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
+        self
+      end
+    end
+    
+    def view_path
+      uri = "_design/#{@design_doc}/_view/#{@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,101 @@
+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
+      
+      @peers = resolve
+    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
+        # TODO: Should this be bulk_save! ? Probably.
+        RelaxDB.bulk_save(@client, obj)
+      end
+    
+      self
+    end
+  
+    def clear
+      @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)
+      peer_ids.delete(obj._id)
+    end
+        
+    def empty?
+      peer_ids.empty?
+    end
+
+    def size
+      peer_ids.size
+    end
+  
+    def [](*args)
+      @peers[*args]
+    end
+  
+    def each(&blk)
+      @peers.each(&blk)    
+    end
+      
+    def inspect
+      @client.instance_variable_get("@#{@relationship}".to_sym).inspect
+    end
+      
+    def peer_ids
+      @client.instance_variable_get("@#{@relationship}".to_sym)
+    end
+  
+    alias to_id_a peer_ids
+  
+    private
+    
+    # Resolves the actual ids into real objects via a single GET to CouchDB
+    def resolve
+      design_doc = @client.class
+      view_name = @relationship
+      view_path = "_design/#{design_doc}/_view/#{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