relaxdb 0.3.5

data/lib/relaxdb/taf2_curb_server.rb

@@ -0,0 +1,63 @@
+module RelaxDB
+
+  class Server
+    class Response
+      attr_reader :body
+      def initialize body
+        @body = body
+      end
+    end
+
+    def initialize(host, port)
+      @host, @port = host, port
+    end
+
+    def delete(uri)
+      request(uri, 'delete'){ |c| c.http_delete}
+    end
+
+    def get(uri)
+      request(uri, 'get'){ |c| c.http_get}
+    end
+
+    def put(uri, json)
+      request(uri, 'put') do |c|
+        c.headers['content-type'] = 'application/json'
+        c.headers['X-Couch-Full-Commit'] = "true"
+        c.http_put json
+      end
+    end
+
+    def post(uri, json)
+      request(uri, 'post') do |c|
+        c.headers['content-type'] = 'application/json'
+        c.http_post json
+      end
+    end
+
+    def request(uri, method)
+      c = Curl::Easy.new "http://#{@host}:#{@port}#{uri}"
+      yield c
+
+      if c.response_code < 200 || c.response_code >= 300
+        status_line = c.header_str.split('\r\n').first
+        msg = "#{c.response_code}:#{status_line}\nMETHOD:#{method}\nURI:#{uri}\n#{c.body_str}"
+        begin
+          klass = RelaxDB.const_get("HTTP_#{c.response_code}")
+          e = klass.new(msg)
+        rescue
+          e = RuntimeError.new(msg)
+        end
+
+        raise e
+      end
+      Response.new c.body_str
+    end
+
+    def to_s
+      "http://#{@host}:#{@port}/"
+    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/validators.rb

@@ -0,0 +1,11 @@
+module RelaxDB
+  
+  module Validators
+   
+    def validator_required(att, o)
+      !att.blank?
+    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,49 @@
+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, the view name may not contain '-'
+      # Exepcted function declaration form is 
+      #   function funcname-functype(doc) {
+      # For example 
+      #   function Users_followers-map(doc) {
+      #
+      def upload(filename)
+        lines = File.readlines(filename)
+        dd = RelaxDB::DesignDocument.get(RelaxDB.dd)
+        extract(lines) do |vn, t, f|
+          dd.add_view(vn, t, f)
+        end
+        dd.save
+      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)+/
+          declr.sub!($&, '')
+          view_name, type = $&.split('-')
+          func = lines[m[i]...m[i+1]].join
+          yield view_name, type, func
+        end
+      end
+
+    end
+    
+  end
+  
+end

data/lib/relaxdb/views.rb

@@ -0,0 +1,114 @@
+module RelaxDB
+
+  class ViewCreator
+    
+    def self.all(kls)
+      class_name = kls[0]
+      map = <<-QUERY
+      function(doc) {        
+        var class_match = #{kls_check kls}
+        if (class_match) {
+          emit(doc._id, doc);
+        }
+      }
+      QUERY
+            
+      View.new "#{class_name}_all", map, sum_reduce_func      
+    end
+    
+    def self.by_att_list(kls, *atts)
+      class_name = kls[0]
+      key = atts.map { |a| "doc.#{a}" }.join(", ")
+      key = atts.size > 1 ? key.sub(/^/, "[").sub(/$/, "]") : key
+      prop_check = atts.map { |a| "doc.#{a} !== undefined" }.join(" && ")
+    
+      map = <<-QUERY
+      function(doc) {
+        var class_match = #{kls_check kls}
+        if (class_match && #{prop_check}) {
+          emit(#{key}, doc);
+        }
+      }
+      QUERY
+      
+      view_name = "#{class_name}_by_" << atts.join("_and_")
+      View.new view_name, map, sum_reduce_func
+    end
+    
+  
+    def self.has_n(client_class, relationship, target_class, relationship_to_client)
+      map = <<-QUERY
+        function(doc) {
+          if (doc.relaxdb_class == "#{target_class}" && doc.#{relationship_to_client}_id)
+            emit(doc.#{relationship_to_client}_id, doc);
+        }
+      QUERY
+      
+      view_name = "#{client_class}_#{relationship}"
+      View.new view_name, map
+    end
+  
+    def self.references_many(client_class, relationship, target_class, peers)
+      map = <<-QUERY
+        function(doc) {
+          if (doc.relaxdb_class == "#{target_class}" && doc.#{peers}) {
+            var i;
+            for(i = 0; i < doc.#{peers}.length; i++) {
+              emit(doc.#{peers}[i], doc);
+            }
+          }
+        }
+      QUERY
+      
+      view_name = "#{client_class}_#{relationship}"
+      View.new view_name, map
+    end
+    
+    def self.kls_check kls
+      kls_names = kls.map{ |k| %Q("#{k}") }.join(",")
+      "[#{kls_names}].indexOf(doc.relaxdb_class) >= 0;"
+    end
+    
+    def self.sum_reduce_func
+      <<-QUERY
+      function(keys, values, rereduce) {
+        if (rereduce) {
+          return sum(values);
+        } else {
+          return values.length;
+        }
+      }
+      QUERY
+    end    
+    
+  end
+  
+  class View
+    
+    attr_reader :view_name
+        
+    def initialize view_name, map_func, reduce_func = nil
+      @view_name = view_name
+      @map_func = map_func
+      @reduce_func = reduce_func
+    end
+    
+    def design_doc
+      @design_doc ||= DesignDocument.get(RelaxDB.dd) 
+    end
+    
+    def save
+      dd = design_doc
+      dd.add_map_view(@view_name, @map_func)
+      dd.add_reduce_view(@view_name, @reduce_func) if @reduce_func
+      dd.save
+    end
+    
+    def exists?
+      dd = design_doc
+      dd.data["views"] && dd.data["views"][@view_name]
+    end
+    
+  end
+
+end

data/readme.rb

@@ -0,0 +1,80 @@
+# README code is extracted from this file (pagination code excepted).
+
+require 'rubygems'
+require 'lib/relaxdb'
+
+RelaxDB.configure :host => "localhost", :port => 5984, :design_doc => "app" #, :logger => Logger.new(STDOUT)
+RelaxDB.delete_db "relaxdb_scratch" rescue :ok
+RelaxDB.use_db "relaxdb_scratch"
+RelaxDB.enable_view_creation # creates views when class definition is executed
+
+class User < RelaxDB::Document
+  property :name
+end
+
+class Invite < RelaxDB::Document
+  
+  property :created_at
+  
+  property :event_name
+  
+  property :state, :default => "awaiting_response",
+    :validator => lambda { |s| %w(accepted rejected awaiting_response).include? s }
+  
+  references :sender, :validator => :required
+  
+  references :recipient, :validator => :required
+  
+  property :sender_name,
+   :derived => [:sender, lambda { |p, o| o.sender.name } ]
+  
+  view_by :sender_name
+  view_by :sender_id
+  view_by :recipient_id, :created_at, :descending => true
+  
+  def on_update_conflict
+    puts "conflict!"
+  end
+  
+end
+
+# Saving objects
+
+sofa = User.new(:name => "sofa").save!
+futon = User.new(:name => "futon").save!
+
+i = Invite.new :sender => sofa, :recipient => futon, :event_name => "CouchCamp"
+i.save!
+
+# Loading and querying
+
+il = RelaxDB.load i._id
+puts i == il # true
+
+ir = Invite.by_sender_name "sofa"
+puts i == ir # true
+
+ix = Invite.by_sender_name(:key => "sofa").first
+puts i == ix # true
+
+# Denormalization
+
+puts ix.sender_name # prints sofa, no requests to CouchDB made
+puts ix.sender.name # prints sofa, a single CouchDB request made
+
+# Saving with conflicts
+
+idup = i.dup
+i.save!
+idup.save     # conflict printed
+
+# Saving with and without validations
+
+i = Invite.new :sender => sofa, :event_name => "CouchCamp"
+
+i.save! rescue :ok        # save! throws an exception on validation failure or conflict
+i.save                    # returns false rather than throwing an exception
+puts i.errors.inspect     # prints {:recipient=>"invalid:"}
+
+i.validation_skip_list << :recipient  # Any and all validations may be skipped
+i.save                                # succeeds

data/spec/belongs_to_spec.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_models.rb'
+
+describe RelaxDB::BelongsToProxy do
+  
+  before(:all) do
+    setup_test_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    
+    
+    it "may be used reciprocally" do
+      C1 = Class.new(RelaxDB::Document) do
+        belongs_to :c2
+      end
+      C2 = Class.new(RelaxDB::Document) do
+        belongs_to :c1
+      end
+      i1, i2 = C1.new, C2.new
+
+      i1.c2 = i2
+      i1.save!
+      i2.c1 = i1
+      i2.save!
+      
+      i1 = RelaxDB.load i1._id
+      i1.c2.should == i2
+      
+      i2 = RelaxDB.load i2._id
+      i2.c1.should == i1
+    end
+    
+    describe "validator" do
+      
+      it "should be passed the _id and object" do
+        a = Atom.new(:_id => "atom").save!
+        c = Class.new(RelaxDB::Document) do
+          belongs_to :foo, :validator => lambda { |foo_id, obj| foo_id.reverse == obj._id }
+        end
+        c.new(:_id => "mota", :foo => a).save!
+      end
+      
+      it "may be used with a predefined validator" do
+        c = Class.new(RelaxDB::Document) do
+          belongs_to :foo, :validator => :required
+        end
+        c.new.save.should be_false
+      end
+
+      it "should be provided with a default error message when validation fails" do
+        c = Class.new(RelaxDB::Document) do
+          belongs_to :foo, :validator => :required
+        end
+        x = c.new
+        x.save
+        x.errors[:foo].should_not be_blank
+      end
+          
+    end
+    
+  end
+
+end