relaxdb 0.3.5

data/lib/relaxdb/references_many_proxy.rb

@@ -0,0 +1,97 @@
+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
+        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
+      view_name = "#{@client.class}_#{@relationship}"
+      @peers = RelaxDB.view(view_name, :key => @client._id)      
+    end
+    
+  end
+  
+end

data/lib/relaxdb/relaxdb.rb

@@ -0,0 +1,250 @@
+module RelaxDB
+
+  class NotFound < StandardError; end
+  class DocumentNotSaved < StandardError; end
+  class UpdateConflict < DocumentNotSaved; end
+  class ValidationFailure < DocumentNotSaved; end
+  
+  @@db = nil
+  
+  class <<self
+
+    def configure(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
+      @@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 db_exists?(name)
+      db.db_exists? name
+    end
+    
+    def db_info
+      data = JSON.parse db.get.body
+      create_object data
+    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)
+      if objs[0].equal? :all_or_nothing
+        objs.shift
+        all_or_nothing = true
+      end
+      
+      pre_save_success = objs.inject(true) { |s, o| s &= o.pre_save }
+      raise ValidationFailure, objs.inspect unless pre_save_success
+      
+      docs = {}
+      objs.each { |o| docs[o._id] = o }
+      
+      data = { "docs" => objs }
+      data[:all_or_nothing] = true if all_or_nothing
+      resp = db.post("_bulk_docs", data.to_json )
+      data = JSON.parse(resp.body)
+  
+      conflicted = []
+      data.each do |new_rev|
+        obj = docs[ new_rev["id"] ]
+        if new_rev["rev"]
+          obj._rev = new_rev["rev"]
+          obj.post_save
+        else
+          conflicted << obj._id
+          obj.conflicted
+        end
+      end
+  
+      raise UpdateConflict, conflicted.inspect unless conflicted.empty?
+      objs
+    end
+    
+    def bulk_save(*objs)
+      begin
+        bulk_save!(*objs)
+      rescue ValidationFailure, UpdateConflict
+        false
+      end
+    end
+    
+    def reload(obj)
+      load(obj._id)
+    end
+  
+    #
+    # Examples:
+    #   RelaxDB.load "foo", :conflicts => true
+    #   RelaxDB.load "foo", :revs => true
+    #   RelaxDB.load ["foo", "bar"]
+    #
+    def load(ids, atts={})
+      # RelaxDB.logger.debug(caller.inject("#{db.name}/#{ids}\n") { |a, i| a += "#{i}\n" })
+      
+      if ids.is_a? Array
+        resp = db.post("_all_docs?include_docs=true", {:keys => ids}.to_json)
+        data = JSON.parse(resp.body)
+        data["rows"].map { |row| row["doc"] ? create_object(row["doc"]) : nil }
+      else
+        begin
+          qs = atts.map{ |k, v| "#{k}=#{v}" }.join("&")
+          qs = atts.empty? ? ids : "#{ids}?#{qs}"
+          resp = db.get qs
+          data = JSON.parse resp.body
+          create_object data
+        rescue HTTP_404
+          nil
+        end
+      end
+    end
+    
+    def load!(ids)
+      res = load(ids)
+      
+      raise NotFound, ids if res == nil
+      raise NotFound, ids if res.respond_to?(:include?) && res.include?(nil)
+      
+      res
+    end
+    
+    #
+    # CouchDB defaults reduce to true when a reduce func is present.
+    # RelaxDB used to indiscriminately set reduce=false, allowing clients to override
+    # if desired. However, as of CouchDB 0.10, such behaviour results in 
+    #   {"error":"query_parse_error","reason":"Invalid URL parameter `reduce` for map view."} 
+    # View https://issues.apache.org/jira/browse/COUCHDB-383#action_12722350
+    # 
+    # This method is an internal workaround for this change to CouchDB and may
+    # be removed if a future change allows for a better solution e.g. map=true 
+    # or a _map endpoint
+    #
+    def rf_view view_name, params
+      params[:reduce] = false
+      view view_name, params
+    end
+          
+    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)
+      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)
+      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
+        
+    def reduce_result(data)
+      res = create_from_hash data
+      res.size == 0 ? nil :
+        res.size == 1 ? res[0] : res
+    end
+    
+    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)
+
+      atts[:reduce] = false
+      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, view_name, view_keys)
+      
+      docs
+    end
+        
+    def create_from_hash(data)
+      data["rows"].map { |row| create_object(row["value"]) }
+    end
+  
+    def create_object(data)
+      klass = data.is_a?(Hash) && data.delete("relaxdb_class")
+      if klass
+        k = klass.split("::").inject(Object) { |x, y| x.const_get y }
+        k.new data
+      else 
+        # data is a scalar or not of a known class
+        ViewObject.create data
+      end
+    end
+        
+    # Convenience methods - should be in a diffent module?
+    
+    def get(uri=nil)
+      JSON.parse(db.get(uri).body)
+    end
+    
+    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

data/lib/relaxdb/server.rb

@@ -0,0 +1,109 @@
+module RelaxDB
+  
+  class HTTP_404 < StandardError; end
+  class HTTP_409 < StandardError; end
+  class HTTP_412 < StandardError; end
+      
+  class CouchDB
+
+    attr_reader :logger
+        
+    # Used for test instrumentation only i.e. to assert that 
+    # an expected number of requests have been issued
+    attr_accessor :get_count, :put_count, :post_count
+        
+    def initialize(config)
+      @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('relaxdb.log'))
+    end
+    
+    def use_db(name)
+      create_db_if_non_existant(name)
+      @db = name
+    end
+    
+    def db_exists?(name)
+      @server.get("/#{name}") rescue false
+    end
+    
+    # URL encode slashes e.g. RelaxDB.delete_db "foo%2Fbar"
+    def delete_db(name)
+      @logger.info("Deleting database #{name}")
+      @server.delete("/#{name}")
+    end
+    
+    def list_dbs
+      JSON.parse(@server.get("/_all_dbs").body)
+    end
+    
+    def replicate_db(source, target)
+      @logger.info("Replicating from #{source} to #{target}")
+      create_db_if_non_existant target      
+      # Manual JSON encoding to allow for dbs containing a '/'
+      data = %Q({"source":"#{source}","target":"#{target}"})       
+      @server.post("/_replicate", data)
+    end
+
+    def delete(path=nil)
+      @logger.info("DELETE /#{@db}/#{unesc(path)}")
+      @server.delete("/#{@db}/#{path}")
+    end
+    
+    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
+    
+    def put(path=nil, json=nil)
+      @put_count += 1
+      @logger.info("PUT /#{@db}/#{unesc(path)} #{json}")
+      @server.put("/#{@db}/#{path}", json)
+      # @server.put("/#{@db}/#{path}?batch=ok", json)
+    end
+    
+    def unesc(path)
+      # path
+      path ? ::CGI::unescape(path) : ""
+    end
+    
+    def uri
+      "#@server" / @db
+    end
+    
+    def name
+      @db
+    end
+    
+    def name=(name)
+      @db = name
+    end
+    
+    def req_count
+      get_count + put_count + post_count
+    end
+    
+    def reset_req_count
+      @get_count = @put_count = @post_count = 0
+    end
+        
+    private
+    
+    def create_db_if_non_existant(name)
+      begin
+        @server.get("/#{name}")
+      rescue
+        @server.put("/#{name}", "")
+      end
+    end
+    
+  end
+        
+end