paulcarey-relaxdb 0.1.0

data/lib/relaxdb/relaxdb.rb

@@ -0,0 +1,106 @@
+module RelaxDB
+  
+  @@db = nil
+  
+  class <<self
+
+    def configure(config)
+      @@db = CouchDB.new(config)
+    end
+  
+    def db
+      @@db
+    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 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(id)
+      resp = db.get("#{id}")
+      data = JSON.parse(resp.body)
+      create_object(data)
+    end
+    
+    def retrieve(view_path, design_doc, view_name, map_function)
+      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)
+      create_from_hash(data)      
+    end
+      
+    def view(design_doc, view_name, default_ret_val=[])
+      q = Query.new(design_doc, view_name)
+      yield q if block_given?
+      
+      resp = db.get(q.view_path)
+      data = JSON.parse(resp.body)
+
+      # presence of total_rows tells us a map function was invoked
+      # if it's absent a map reduce invocation occured
+      if data["total_rows"]
+        create_from_hash(data)
+      else
+        obj = data["rows"][0] && data["rows"][0]["value"]
+        obj ? ViewObject.create(obj) : default_ret_val
+      end
+    end
+        
+    def create_from_hash(data)
+      @objects = []
+      data["rows"].each do |row|
+        @objects << create_object(row["value"])
+      end
+      @objects      
+    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
+  
+  end
+  
+end

data/lib/relaxdb/server.rb

@@ -0,0 +1,112 @@
+module RelaxDB
+
+  class Server
+        
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+
+    def delete(uri)
+      request(Net::HTTP::Delete.new(uri))
+    end
+
+    def get(uri)
+      request(Net::HTTP::Get.new(uri))
+    end
+
+    def put(uri, json)
+      req = Net::HTTP::Put.new(uri)
+      req["content-type"] = "application/json"
+      req.body = json
+      request(req)
+    end
+
+    def post(uri, json)
+      req = Net::HTTP::Post.new(uri)
+      req["content-type"] = "application/json"
+      req.body = json
+      request(req)
+    end
+
+    def request(req)
+      res = Net::HTTP.start(@host, @port) {|http|
+        http.request(req)
+      }
+      if (not res.kind_of?(Net::HTTPSuccess))
+        handle_error(req, res)
+      end
+      res
+    end
+    
+    def to_s
+      "http://#{@host}:#{@port}/"
+    end
+    
+    private
+
+    def handle_error(req, res)
+      e = RuntimeError.new("#{res.code}:#{res.message}\nMETHOD:#{req.method}\nURI:#{req.path}\n#{res.body}")
+      raise e
+    end
+  end
+      
+  class CouchDB
+        
+    def initialize(config)
+      @server = RelaxDB::Server.new(config[:host], config[:port])
+      @logger = config[:logger] ? config[:logger] : Logger.new(Tempfile.new('couchdb.log'))
+    end
+    
+    def use_db(name)
+      begin
+        @server.get("/#{name}")
+      rescue
+        @server.put("/#{name}", "")
+      end
+      @db = name
+    end
+    
+    def delete_db(name)
+      @server.delete("/#{name}")
+    end
+    
+    def list_dbs
+      JSON.parse(@server.get("/_all_dbs").body)
+    end
+    
+    def delete(path=nil)
+      @logger.info("DELETE /#{@db}/#{unesc(path)}")
+      @server.delete("/#{@db}/#{path}")
+    end
+    
+    def get(path=nil)
+      @logger.info("GET /#{@db}/#{unesc(path)}")
+      @server.get("/#{@db}/#{path}")
+    end
+        
+    def post(path=nil, json=nil)
+      @logger.info("POST /#{@db}/#{unesc(path)} #{json}")
+      @server.post("/#{@db}/#{path}", json)
+    end
+    
+    def put(path=nil, json=nil)
+      @logger.info("PUT /#{@db}/#{unesc(path)} #{json}")
+      @server.put("/#{@db}/#{path}", json)
+    end
+    
+    def unesc(path)
+       path ? ::CGI::unescape(path) : ""
+    end
+    
+    def uri
+      "#@server" / @db
+    end
+    
+    def name
+      @db
+    end
+    
+  end
+        
+end

data/lib/relaxdb/sorted_by_view.rb

@@ -0,0 +1,42 @@
+module RelaxDB
+
+  # Represents a CouchDB view, which is implicitly sorted by key
+  # The view name is determined by sort attributes  
+  class SortedByView
+
+    def initialize(class_name, *atts)
+      @class_name = class_name
+      @atts = atts
+    end
+
+    def view_name
+      name = "all_sorted_by"
+
+      @atts.each do |att|
+        name += "_#{att}_and"
+      end
+      name[0, name.size-4]
+    end
+    
+    def map_function
+      # To guard against non existing attributes in older documents, an OR with an object literal 
+      # is inserted for each emitted key
+      # The object literal is the lowest sorting JSON category
+        
+      # Create the key from the attributes, wrapping it in [] if the key is composite
+      raw = @atts.inject("") { |m,v| m << "(doc.#{v}||{}), " }
+      refined = raw[0, raw.size-2]
+      pure = @atts.size > 1 ? refined.sub(/^/, "[").sub(/$/, "]") : refined
+    
+      <<-QUERY
+      function(doc) {
+        if(doc.class == "#{@class_name}") {
+          emit(#{pure}, doc);
+        }
+      }
+      QUERY
+    end
+  
+  end
+  
+end

data/lib/relaxdb/uuid_generator.rb

@@ -0,0 +1,21 @@
+module RelaxDB
+
+  class UuidGenerator
+  
+    def self.uuid
+      unless @length
+        @uuid ||= UUID.new 
+        @uuid.generate
+      else
+        rand.to_s[2, @length]
+      end
+    end
+  
+    # Convenience that helps relationship debuggging and model exploration
+    def self.id_length=(length)
+      @length = length
+    end
+  
+  end
+
+end

data/lib/relaxdb/view_object.rb

@@ -0,0 +1,34 @@
+module RelaxDB
+
+  # An immuntable object typically used to display the results of a view
+  class ViewObject
+  
+    def initialize(hash)
+      hash.each do |k, v|
+
+        if k.to_s =~ /_at$/
+          v = Time.local(*ParseDate.parsedate(v)) rescue v
+        end
+
+        instance_variable_set("@#{k}", v)
+        meta_class.instance_eval do
+          define_method(k.to_sym) do
+            instance_variable_get("@#{k}".to_sym)
+          end
+        end      
+      end
+    end
+  
+    def self.create(obj)
+      if obj.instance_of? Array
+        obj.inject([]) { |arr, o| arr << ViewObject.new(o) }
+      elsif obj.instance_of? Hash
+        ViewObject.new(obj)
+      else
+        obj
+      end
+    end
+  
+  end
+
+end

data/lib/relaxdb/view_uploader.rb

@@ -0,0 +1,47 @@
+module RelaxDB
+  
+  class ViewUploader
+
+    class << self
+      
+      # Methods must start and finish on different lines
+      # The function declaration must start at the beginning of a line
+      # As '-' is used as a delimiter, neither design doc nor view name may contain '-'
+      # Exepcted function declaration form is 
+      #   function DesignDoc-funcname-functype(doc) {
+      # For example 
+      #   function Users-followers-map(doc) {
+      #
+      def upload(filename)
+        lines = File.readlines(filename)
+        extract(lines) do |dd, vn, t, f|
+          RelaxDB::DesignDocument.get(dd).add_view(vn, t, f).save
+        end
+      end
+      
+      def extract(lines)
+        # Index of function declaration matches
+        m = []
+
+        0.upto(lines.size-1) do |p|
+          line = lines[p]
+          m << p if line =~ /^function[^\{]+\{/
+        end
+        # Add one beyond the last line number as the final terminator
+        m << lines.size
+
+        0.upto(m.size-2) do |i|
+          declr = lines[m[i]]
+          declr =~ /(\w)+-(\w)+-(\w)+/
+          declr.sub!($&, '')
+          design_doc, view_name, type = $&.split('-')
+          func = lines[m[i]...m[i+1]].join
+          yield design_doc, view_name, type, func
+        end
+      end
+
+    end
+    
+  end
+  
+end

data/lib/relaxdb/views.rb

@@ -0,0 +1,42 @@
+module RelaxDB
+
+  class ViewCreator
+    
+    def self.all(target_class)
+      template = <<-QUERY
+      function(doc) {
+        if(doc.class == "${target_class}")
+          emit(null, doc);
+      }
+      QUERY
+      template.sub!("${target_class}", target_class.to_s)
+    end
+  
+    def self.has_n(target_class, relationship_to_client)
+      template = <<-MAP_FUNC
+      function(doc) {
+        if(doc.class == "${target_class}")
+          emit(doc.${relationship_to_client}_id, doc);
+      }
+      MAP_FUNC
+      template.sub!("${target_class}", target_class)
+      template.sub("${relationship_to_client}", relationship_to_client)
+    end
+  
+    def self.has_many_through(target_class, peers)
+      template = <<-MAP_FUNC
+        function(doc) {
+          if(doc.class == "${target_class}" && doc.${peers}) {
+            var i;
+            for(i = 0; i < doc.${peers}.length; i++) {
+              emit(doc.${peers}[i], doc);
+            }
+          }
+        }
+      MAP_FUNC
+      template.sub!("${target_class}", target_class).gsub!("${peers}", peers)
+    end
+    
+  end
+
+end

data/lib/relaxdb.rb

@@ -0,0 +1,33 @@
+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/has_many_proxy'
+require 'relaxdb/has_one_proxy'
+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_uploader'
+require 'relaxdb/views'
+
+module RelaxDB
+end

data/spec/belongs_to_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::BelongsToProxy do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+
+  describe "belongs_to" do
+    
+    it "should return nil when accessed before assignment" do
+      r = Rating.new
+      r.photo.should == nil
+    end
+
+    it "should be establishable via constructor attribute" do
+      p = Photo.new
+      r = Rating.new :photo => p
+      r.photo.should == p
+    end
+    
+    it "should be establishable via constructor id" do
+      p = Photo.new.save
+      r = Rating.new(:photo_id => p._id).save
+      r.photo.should == p
+    end        
+      
+    it "should establish the parent relationship when supplied a parent and saved" do
+      p = Photo.new.save
+      r = Rating.new
+      r.photo = p
+      # I'm not saying the following is correct or desired - merely codifying how things stand 
+      p.rating.should be_nil 
+      r.save
+      p.rating.should == r
+    end    
+  
+    it "should establish the parent relationship when supplied a parent id and saved" do
+      p = Photo.new.save
+      r = Rating.new(:photo_id => p._id).save
+      p.rating.should == r
+    end        
+
+    it "should return the same object on repeated invocations" do
+      p = Photo.new.save
+      r = Rating.new(:photo => p).save
+      r = RelaxDB.load(r._id)
+      r.photo.object_id.should == r.photo.object_id
+    end    
+
+    it "should be nullified when the parent is destroyed" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      p.destroy!
+      RelaxDB.load(r._id).photo.should be_nil
+    end
+  
+    it "should be preserved across save / load boundary" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      r = RelaxDB.load r._id
+      r.photo.should == p
+    end    
+
+    it "should be able to reference itself via its parent" do
+      r = Rating.new
+      p = Photo.new(:rating => r).save
+      r = RelaxDB.load r._id
+      r.photo.rating.should == r
+    end    
+
+  end
+
+end

data/spec/design_doc_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::DesignDocument do
+  
+  before(:all) do
+    RelaxDB.configure(:host => "localhost", :port => 5984)  
+  end
+
+  before(:each) do
+    RelaxDB.delete_db "relaxdb_spec_db" rescue "ok"
+    RelaxDB.use_db "relaxdb_spec_db"
+  end
+
+  describe "#save" do
+    
+    it "should create a corresponding document in CouchDB" do
+      RelaxDB::DesignDocument.get("foo").save      
+      RelaxDB.load("_design/foo").should_not be_nil
+    end
+    
+  end
+
+  describe "#destroy" do
+    
+    it "should delete the corresponding document from CouchDB" do
+      dd = RelaxDB::DesignDocument.get("foo").save
+      dd.destroy!
+      lambda { RelaxDB.load("_design/foo") }.should raise_error
+    end
+    
+  end
+
+end