cohitre-relaxdb 0.2.2

data/lib/relaxdb/server.rb

@@ -0,0 +1,132 @@
+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)
+      create_db_if_non_existant(name)
+      @db = name
+    end
+    
+    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      
+      data = { "source" => source, "target" => target}
+      @server.post("/_replicate", data.to_json)
+    end
+
+    def delete(path=nil)
+      @logger.info("DELETE /#{@db}/#{unesc(path)}")
+      @server.delete("/#{@db}/#{path}")
+    end
+    
+    # *ignored allows methods to invoke get or post indifferently
+    def get(path=nil, *ignored)
+      @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
+      path ? ::CGI::unescape(path) : ""
+    end
+    
+    def uri
+      "#@server" / @db
+    end
+    
+    def name
+      @db
+    end
+    
+    def logger
+      @logger
+    end
+    
+    private
+    
+    def create_db_if_non_existant(name)
+      begin
+        @server.get("/#{name}")
+      rescue
+        @server.put("/#{name}", "")
+      end
+    end
+    
+  end
+        
+end

data/lib/relaxdb/sorted_by_view.rb

@@ -0,0 +1,62 @@
+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 map_function
+      key = @atts.map { |a| "doc.#{a}" }.join(", ")
+      key = @atts.size > 1 ? key.sub(/^/, "[").sub(/$/, "]") : key
+    
+      <<-QUERY
+      function(doc) {
+        if(doc.class == "#{@class_name}") {
+          emit(#{key}, doc);
+        }
+      }
+      QUERY
+    end
+    
+    def reduce_function
+      <<-QUERY
+      function(keys, values, rereduce) {
+        return values.length;
+      }
+      QUERY
+    end
+    
+    def view_name
+      "all_sorted_by_" << @atts.join("_and_")
+    end
+        
+    def query(query)
+      # If a view contains both a map and reduce function, CouchDB will by default return 
+      # the result of the reduce function when queried. 
+      # This class automatically creates both map and reduce functions so it can be used by the paginator.
+      # In normal usage, this class will be used with map functions, hence reduce is explicitly set 
+      # to false if it hasn't already been set.
+      query.reduce(false) if query.reduce.nil?
+      
+      # I hope the query.group(true) should be temporary only (given that reduce has been set to false)
+      method = query.keys ? (query.group(true) && :post) : :get
+      
+      begin
+        resp = RelaxDB.db.send(method, query.view_path, query.keys)
+      rescue => e
+        design_doc = DesignDocument.get(@class_name) 
+        design_doc.add_map_view(view_name, map_function).add_reduce_view(view_name, reduce_function).save
+        resp = RelaxDB.db.send(method, query.view_path, query.keys)        
+      end
+
+      data = JSON.parse(resp.body)
+      ViewResult.new(data)            
+    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_result.rb

@@ -0,0 +1,18 @@
+module RelaxDB
+
+  class ViewResult < DelegateClass(Array)
+    
+    attr_reader :offset, :total_rows
+  
+    def initialize(result_hash)
+      objs = RelaxDB.create_from_hash(result_hash)
+      
+      @offset = result_hash["offset"]
+      @total_rows = result_hash["total_rows"]
+      
+      super(objs)
+    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/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/callbacks_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# A little naiive, needs quite a bit more thought and work
+
+describe RelaxDB::Document, "callbacks" 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 "before_save" do
+  
+    it "should be run before the object is saved" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { |s| s.gem += 1 if s.unsaved? }
+        property :gem
+      end
+      p = c.new(:gem => 5).save
+      p.gem.should == 6
+    end
+    
+    it "should prevent the object from being saved if it returns false" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      c.new.save.should == false
+    end
+    
+    it "may be a proc" do
+      c = Class.new(RelaxDB::Document) do
+        before_save lambda { false }
+      end
+      c.new.save.should == false      
+    end
+    
+    it "may be a method" do
+      c = Class.new(RelaxDB::Document) do
+        before_save :never
+        def never; false; end
+      end
+      c.new.save.should == false
+    end
+    
+  end
+  
+  describe "after_save" do
+    
+    it "should be run after the object is saved" do
+      c = Class.new(RelaxDB::Document) do
+        after_save lambda { |s| s.gem +=1 unless s.unsaved? }
+        property :gem
+      end
+      p = c.new(:gem => 5).save
+      p.gem.should == 6
+    end
+    
+  end
+
+end