mattly-exegesis 0.0.10 → 0.2.0

data/lib/exegesis/document.rb

@@ -1,153 +1,93 @@
 module Exegesis
-  class Document < CouchRest::Document
+  module Document
     
-    def self.inherited subklass
-      Exegesis.document_classes[subklass.name] = subklass
+    def self.included base
+      base.send :include, Exegesis::Model
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+      base.send :attr_accessor, :database
     end
-    
-    def self.instantiate hash={}
-      Exegesis.document_classes[hash['.kind']].new(hash)
-    end
-    
-    def self.expose *attrs
-      opts = if attrs.last.is_a?(Hash)
-        attrs.pop
-      else
-        {}
-      end
-      
-      [attrs].flatten.each do |attrib|
-        attrib = "#{attrib}"
-        if opts.has_key?(:writer)
-          if opts[:writer]
-            define_method("#{attrib}=") {|val| self[attrib] = opts[:writer].call(val) }
-          end
-        else
-          define_method("#{attrib}=") {|val| self[attrib] = val }
+
+    module ClassMethods
+      def timestamps!
+        define_method :set_timestamps do
+          @attributes['updated_at'] = Time.now
+          @attributes['created_at'] ||= Time.now
         end
-        if opts[:as]
-          if opts[:as] == :reference
-            define_method(attrib) do |*reload|
-              reload = false if reload.empty?
-              instance_variable_set("@#{attrib}", nil) if reload
-              return instance_variable_get("@#{attrib}") if instance_variable_get("@#{attrib}")
-              instance_variable_set("@#{attrib}", load_reference(self[attrib]))
-            end
-          else
-            define_method(attrib) do
-              self[attrib] = if self[attrib].is_a?(Array)
-                self[attrib].map {|val| cast opts[:as], val }.compact
-              else
-                cast opts[:as], self[attrib]
-              end
-            end
-          end
+        expose 'updated_at', :as => Time, :writer => false
+        expose 'created_at', :as => Time, :writer => false
+      end
+    
+      def unique_id meth=nil, &block
+        if block
+          @unique_id_method = block
+        elsif meth
+          @unique_id_method = meth
         else
-          define_method(attrib) { self[attrib] }
+          @unique_id_method ||= nil
         end
       end
     end
     
-    def self.default hash=nil
-      if hash
-        @default = hash
-      else
-        @default ||= superclass.respond_to?(:default) ? superclass.default : {}
+    module InstanceMethods
+      def initialize hash={}, db=nil
+        super hash
+        @database = db
       end
-    end
-    
-    def self.timestamps!
-      define_method :set_timestamps do
-        self['updated_at'] = Time.now
-        self['created_at'] ||= Time.now
+      
+      def == other
+        self.id == other.id
       end
-      expose 'updated_at', :as => Time, :writer => false
-      expose 'created_at', :as => Time, :writer => false
-    end
-    
-    def self.unique_id meth
-      define_method :set_unique_id do
-        self['_id'] = self.send(meth)
+      
+      def id
+        @attributes['_id']
       end
-    end
-    
-    alias :_rev :rev
-    alias_method :document_save, :save
-    
-    attr_accessor :parent
-    
-    def save
-      raise ChildError, "cannot save if a parent is set" if parent
-      set_timestamps if respond_to?(:set_timestamps)
-      if respond_to?(:set_unique_id) && id.nil?
-        @unique_id_attempt = 0
-        begin
-          self['_id'] = set_unique_id
-          document_save
-        rescue RestClient::RequestFailed => e
-          @unique_id_attempt += 1
-          retry
+      
+      def rev
+        @attributes['_rev']
+      end
+      
+      def save
+        set_timestamps if respond_to?(:set_timestamps)
+        if self.class.unique_id && id.nil?
+          save_with_custom_unique_id
+        else
+          save_document
         end
-      else
-        document_save
       end
-    end
-    
-    def initialize keys={}
-      apply_default
-      super keys
-      self['.kind'] ||= self.class.to_s
-    end
-    
-    def update_attributes attrs={}
-      raise ArgumentError, 'must include a matching _rev attribute' unless rev == attrs.delete('_rev')
-      attrs.each_pair do |key, value| 
-        self.send("#{key}=", value) rescue nil
-        attrs.delete(key)
+      
+      def update_attributes attrs={}
+        raise ArgumentError, 'must include a matching _rev attribute' unless rev == attrs.delete('_rev')
+        super attrs
+        save
       end
-      save
-    end
-    
-    private
-    
-    def apply_default
-      self.class.default.each do |key, value|
-        self[key] = value
+      
+      private
+      
+      def save_document
+        raise ArgumentError, "canont save without a database" unless database
+        database.save self.attributes
       end
-    end
-    
-    def cast as, value
-      return nil if value.nil?
-      klass = if as == :given
-        if value.is_a?(Hash)
-          Exegesis.document_classes[value['.kind']]
-        else
-          nil #nfi what do to in this case; maybe just have it be a doc hash?
+      
+      def save_with_custom_unique_id
+        attempt = 0
+        value = ''
+        begin
+          @attributes['_id'] = if self.class.unique_id.is_a?(Proc)
+            self.class.unique_id.call(self, attempt)
+          else
+            self.send(self.class.unique_id, attempt)
+          end
+          save_document
+        rescue RestClient::RequestFailed => e
+          oldvalue = value
+          value = @attributes['_id']
+          raise RestClient::RequestFailed if oldvalue == value || attempt > 100
+          attempt += 1
+          retry
         end
-      elsif as.is_a?(Class)
-        as
-      else
-        Exegesis.document_classes[nil] # whatever the default is? Hell idk.
-      end
-
-      with = klass == Time ? :parse : :new
-      casted = klass.send with, value
-      casted.parent = self if casted.respond_to?(:parent)
-      casted
-    end
-    
-    def load_reference ids
-      raise ArgumentError, "a database is required for loading a reference" unless database || (parent && parent.database)
-      if ids.is_a?(Array)
-        ids.map {|val| Exegesis::Document.instantiate((database || parent && parent.database).get(val)) }
-      else
-        Exegesis::Document.instantiate((database || parent && parent.database).get(ids))
       end
     end
     
   end
-end
-
-# $:.unshift File.dirname(__FILE__)
-# require 'document/annotated_reference'
-# require 'document/referencing'
+end

data/lib/exegesis/model.rb

@@ -0,0 +1,142 @@
+module Exegesis
+  module Model
+    
+    def self.included base
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+      Exegesis.model_classes[base.name] = base
+      base.send :attr_accessor, :attributes, :references, :parent
+    end
+    
+    module ClassMethods
+      def expose *attrs
+        opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
+        [attrs].flatten.each do |attrib|
+          attrib = attrib.to_s
+          if opts[:writer]
+            define_writer(attrib) {|val| @attributes[attrib] = opts[:writer].call(val) }
+          elsif !opts.has_key?(:writer)
+            define_writer(attrib) {|val| @attributes[attrib] = val }
+          end
+          if opts[:as] == :reference
+            define_reference attrib
+          elsif opts[:as]
+            define_caster attrib, opts[:as]
+          else
+            define_method(attrib) { @attributes[attrib] }
+          end
+        end
+      end
+      
+      # sets a default hash object for the attributes of the instances of the class if an argument given,
+      # else retrieves the default
+      def default hash=nil
+        if hash
+          @default = {}
+          hash.each {|key, value| @default[key.to_s] = value }
+        else
+          @default ||= {}
+        end
+      end
+      
+      private
+      def define_writer attrib, &block
+        define_method("#{attrib}=", block)
+      end
+      
+      def define_reference attrib
+        define_method(attrib) do |*reload|
+          reload = false if reload.empty?
+          @references ||= {}
+          @references[attrib] = nil if reload
+          @references[attrib] ||= load_reference(@attributes[attrib])
+        end
+      end
+      
+      def define_caster attrib, as
+        define_method(attrib) do
+          @attributes[attrib] = if @attributes[attrib].is_a?(Array)
+            @attributes[attrib].map {|val| cast as, val }.compact
+          else
+            cast as, @attributes[attrib]
+          end
+        end
+      end
+
+    end
+    
+    module InstanceMethods
+      def initialize hash={}
+        apply_default
+        hash.each {|key, value| @attributes[key.to_s] = value }
+        @attributes['class'] = self.class.name
+      end
+      
+      # works like Hash#update on the attributes hash, bypassing any writers
+      def update hash={}
+        hash.each {|key, value| @attributes[key.to_s] = value }
+      end
+      
+      # update the attributes in the model using writers. If no writer is defined for a given
+      # key it will raise NoMethodError
+      def update_attributes hash={}
+        hash.each do |key, value| 
+          self.send("#{key}=", value)
+        end
+      end
+      
+      # retrieves the attribte
+      def [] key
+        @attributes[key]
+      end
+      
+      # directly sets the attribute, avoiding any writers or lack thereof.
+      def []= key, value
+        @attributes[key] = value
+      end
+      
+      # returns the instance's database, or its parents database if it has a parent.
+      # If neither, returns false.
+      # This is overwritten in classes including Exegesis::Document by an attr_accessor.
+      def database
+        parent && parent.database
+      end
+      
+      private
+      def apply_default
+        @attributes = self.class.default.dup
+      end
+      
+      def cast as, value
+        return nil if value.nil?
+        klass = if as == :given && value.is_a?(Hash)
+          Exegesis.model_classes[value['class']]
+        elsif as.is_a?(Class)
+          as
+        else
+          nil
+        end
+        
+        casted = if klass.nil?
+          value # if no class, just return the value
+        elsif klass == Time # Time is a special case; the ONLY special case.
+          Time.parse value
+        else
+          klass.new value
+        end
+        casted.parent = self if casted.respond_to?(:parent)
+        casted
+      end
+      
+      def load_reference ids
+        raise ArgumentError, "a database is required for loading a reference" unless database
+        if ids.is_a?(Array)
+          ids.map {|val| database.get(val) }
+        else
+          database.get(ids)
+        end
+      end
+    end
+    
+  end
+end

data/lib/exegesis/server.rb

@@ -0,0 +1,28 @@
+module Exegesis
+  class Server
+    include Exegesis::Http
+    
+    attr_accessor :uri, :version
+
+    # Creates a new instance of Exegesis::Server. Defaults to http://localhost:5984 and
+    # verifies the existance of the database.
+    def initialize address='http://localhost:5984'
+      @uri = address
+      @version = get(@uri)['version']
+    end
+    
+    # returns an array of all the databases on the server
+    def databases
+      get "#{@uri}/_all_dbs"
+    end
+    
+    # creates a database with the given name on the server
+    def create_database name
+      put "#{@uri}/#{name}"
+    end
+    
+    def inspect
+      "#<Exegesis::Server #{@uri}>"
+    end
+  end
+end

data/lib/exegesis/utils/http.rb

@@ -0,0 +1,38 @@
+require 'cgi'
+module Exegesis
+  module Http
+    extend self
+    
+    def format_url url, params={}
+      if params && !params.empty?
+        query = params.map do |key, value|
+          value = value.to_json if [:key, :startkey, :endkey, :keys].include?(key)
+          "#{key}=#{CGI.escape(value.to_s)}"
+        end.join('&')
+        url = "#{url}?#{query}"
+      end
+      url
+    end
+    
+    def escape_id id
+      /^_design\/(.*)/ =~ id ? "_design/#{CGI.escape($1)}" : CGI.escape(id) 
+    end
+    
+    def get url
+      JSON.parse(RestClient.get(url), :max_nesting => false)
+    end
+    
+    def post url, body=''
+      JSON.parse(RestClient.post(url, (body || '').to_json))
+    end
+    
+    def put url, body=''
+      JSON.parse(RestClient.put(url, (body || '').to_json))
+    end
+    
+    def delete url
+      JSON.parse(RestClient.delete(url))
+    end
+    
+  end
+end

data/lib/monkeypatches/time.rb

@@ -0,0 +1,5 @@
+class Time
+  def to_json(options = nil)
+    %("#{self.dup.utc.strftime("%Y/%m/%d %H:%M:%S +0000")}")
+  end
+end

data/test/database_test.rb

@@ -0,0 +1,161 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class DatabaseTest
+  include Exegesis::Database
+end
+class CustomDesignDirDatabaseTest
+  include Exegesis::Database
+  designs_directory 'app/designs'
+end
+class DatabaseTestDocument
+  include Exegesis::Document
+end
+
+class ExegesisDatabaseTest < Test::Unit::TestCase
+  before(:all) do
+    @server = Exegesis::Server.new('http://localhost:5984')
+    RestClient.delete("#{@server.uri}/exegesis-test") rescue nil
+    RestClient.delete("#{@server.uri}/exegesis-test-nonexistent") rescue nil
+    RestClient.put("#{@server.uri}/exegesis-test", '')
+  end
+  
+  context "initializing" do
+    context "with server and name arguments" do
+      before do
+        @db =DatabaseTest.new(@server, 'exegesis-test')
+      end
+
+      expect { @db.is_a?(DatabaseTest).will == true }
+      expect { @db.uri.will == "#{@server.uri}/exegesis-test"}
+
+      context "when the database does not exist" do
+        before do
+          @action = lambda { DatabaseTest.new(@server, 'exegesis-test-nonexistent') }
+        end
+      
+        expect { @action.will raise_error(RestClient::ResourceNotFound) }
+      end
+    end
+    
+    context "with a url argument" do
+      before do
+        @db = DatabaseTest.new('http://localhost:5984/exegesis-test')
+      end
+      
+      expect { @db.is_a?(DatabaseTest).will == true }
+      expect { @db.uri.will == 'http://localhost:5984/exegesis-test' }
+    end
+    
+    context "with a name argument" do
+      before do
+        @db = DatabaseTest.new('exegesis-test')
+      end
+      
+      expect { @db.is_a?(DatabaseTest).will == true }
+      expect { @db.uri.will == "http://localhost:5984/exegesis-test" }
+    end
+  end
+  
+  context "retrieving documents by id" do
+    before do
+      @db = DatabaseTest.new @server, 'exegesis-test'
+      RestClient.put "#{@db.uri}/test-document", {'key'=>'value', 'class'=>'DatabaseTestDocument'}.to_json rescue nil
+      @doc = @db.get('test-document')
+    end
+    
+    after do
+      RestClient.delete("#{@db.uri}/test-document?rev=#{@doc['_rev']}") rescue nil
+    end
+    
+    expect { @doc.is_a?(DatabaseTestDocument).will == true }
+    expect { @doc.id.will == 'test-document' }
+    expect { @doc['key'].will == 'value' }
+    
+    context "retrieving the raw document" do
+      before do
+        @doc = @db.raw_get('test-document')
+      end
+      
+      expect { @doc.is_a?(Hash).will == true }
+      expect { @doc['_id'].will == 'test-document' }
+      expect { @doc['key'].will == 'value' }
+      expect { @doc['class'].will == 'DatabaseTestDocument' }
+    end
+  end
+  
+  context "saving docs" do
+    before do
+      reset_db
+      @db = DatabaseTest.new('exegesis-test')
+    end
+    
+    context "a single doc" do
+      before { @doc = {'foo' => 'bar'} }
+
+      context "without an id" do
+        before do
+          @db.save(@doc)
+          @rdoc = @db.get(@doc['_id'])
+        end
+        expect { @doc['_rev'].will == @rdoc['_rev'] }
+        expect { @rdoc['foo'].will == @doc['foo'] }
+      end
+      
+      context "with an id" do
+        before { @doc['_id'] = 'test-document' }
+        
+        context "when the document doesn't exist yet" do
+          before do
+            @db.save(@doc)
+            @rdoc = @db.get('test-document')
+          end
+          expect { @doc['_rev'].will == @rdoc['_rev'] }
+          expect { @rdoc['foo'].will == @doc['foo'] }
+        end
+        
+        context "when the document exists already" do
+          before do 
+            response = @db.post(@doc)
+            @doc['_id'] = response['id']
+            @doc['_rev'] = response['rev']
+            @doc['foo'] = 'bee'
+          end
+
+          expect { lambda { @db.save(@doc) }.wont raise_error }
+          
+          context "without a valid rev" do
+            before { @doc.delete('_rev') }
+            expect { lambda { @db.save(@doc) }.will raise_error }
+          end
+        end
+      end
+    end
+    
+    context "multiple docs" do
+      before do
+        @updated = @db.post({'_id' => 'updated', 'key' => 'original'})
+        @deleted = @db.post({'_id' => 'deleted', 'key' => 'original'})
+        @saving = lambda {
+          @db.save([
+            {'_id' => 'new', 'key' => 'new'},
+            {'_id' => 'updated', 'key' => 'new', '_rev' => @updated['rev']},
+            {'_id' => 'deleted', '_rev' => @deleted['rev'], '_deleted' => true }
+          ])
+        }
+      end
+        
+      context "without conflicts" do
+        before { @saving.call }
+        expect { @db.get('new')['key'].will == 'new' }
+        expect { @db.get('updated')['key'].will == 'new' }
+        expect { lambda {@db.get('deleted')}.will raise_error(RestClient::ResourceNotFound) }
+      end
+    end
+  end
+  
+  context "setting the designs directory" do
+    expect { DatabaseTest.designs_directory.will == Pathname.new('designs') }
+    expect { CustomDesignDirDatabaseTest.designs_directory.will == Pathname.new('app/designs') }
+  end
+  
+end