mattly-exegesis 0.2.6 → 0.2.8

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 7
+:patch: 8

data/lib/exegesis.rb

@@ -22,10 +22,6 @@ module Exegesis
     
   extend self
   
-  def model_classes
-    @model_classes ||= {}
-  end
-  
   # extracted from Extlib
   #
   # Constantize tries to find a declared constant with the name specified
@@ -44,6 +40,11 @@ module Exegesis
     Object.module_eval("::#{$1}", __FILE__, __LINE__)
   end
   
+  # turns class/module names into valid database names
+  def nameify(name)
+    name.gsub(/([a-z])([A-Z])/) { "#{$1}_#{$2.downcase}"}.gsub(/[A-Z]/) {|m| m.downcase }.gsub(/::/,'/')
+  end
+  
   def instantiate(doc, database)
     doc = constantize(doc['class']).new(doc)
     doc.database = database if doc.respond_to?(:database=)

data/lib/exegesis/database.rb

@@ -1,66 +1,33 @@
 require 'pathname'
 module Exegesis
   module Database
+    autoload :Designs,    'exegesis/database/designs'
+    autoload :Documents,  'exegesis/database/documents'
+    autoload :Singleton,  'exegesis/database/singleton'
+    autoload :Rest,       'exegesis/database/rest'
     
     VALID_NAME_PATTERN = '[-a-z0-9_\$\(\)\+\/]+'
+    URI_PATTERN   = /\A(https?:\/\/[-0-9a-z\.]+(?::\d+))\/(#{Exegesis::Database::VALID_NAME_PATTERN})\Z/
+    NAME_PATTERN  = /\A#{Exegesis::Database::VALID_NAME_PATTERN}\Z/
     
     def self.included base
       base.send :attr_accessor, :server, :uri
       base.send :include, InstanceMethods
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-      def designs_directory dir=nil
-        if dir
-          @designs_directory = Pathname.new(dir)
-        else
-          @designs_directory ||= Pathname.new('designs')
-        end
-      end
-      
-      # declare a design document for this database. Creates a new class and yields a given block to the class to
-      # configure the design document and declare views; See Class methods for Exegesis::Design
-      def design design_name, opts={}, &block
-        klass_name = "#{design_name.to_s.capitalize}Design"
-        klass = const_set(klass_name, Class.new(Exegesis::Design))
-        klass.design_directory = opts[:directory] || self.designs_directory + design_name.to_s
-        klass.design_name = opts[:name] || design_name.to_s
-        klass.compose_canonical
-        klass.class_eval &block
-        define_method design_name do
-          @exegesis_designs ||= {}
-          @exegesis_designs[design_name] ||= klass.new(self)
-        end
-      end
-      
-      def named_document document_name, opts={}, &block
-        klass_name = document_name.to_s.capitalize.gsub(/_(\w)/) { $1.capitalize }
-        klass = const_set(klass_name, Class.new(Exegesis::GenericDocument))
-        klass.unique_id { document_name.to_s }
-        klass.class_eval &block if block
-        define_method document_name do
-          @exegesis_named_documents ||= {}
-          @exegesis_named_documents[document_name] ||= begin
-            get(document_name.to_s)
-          rescue RestClient::ResourceNotFound
-            doc = klass.new({}, self)
-            doc.save
-            doc
-          end
-        end
-      end
+      base.extend Exegesis::Database::Designs
+      base.extend Exegesis::Database::Documents
     end
     
     module InstanceMethods
+      include Exegesis::Database::Rest
+      
       # Create a Database adapter for the given server and database name. Will raise 
       # RestClient::ResourceNotFound if the database does not exist.
       def initialize server, database_name=nil
         if database_name.nil?
-          if server.match(/\A(https?:\/\/[-0-9a-z\.]+(?::\d+))\/(#{Exegesis::Database::VALID_NAME_PATTERN})\Z/)
+          if server.match(URI_PATTERN)
             @server = Exegesis::Server.new($1)
             database_name = $2
-          elsif server.match(/\A#{Exegesis::Database::VALID_NAME_PATTERN}\Z/)
+          elsif server.match(NAME_PATTERN)
             @server = Exegesis::Server.new #localhost
             database_name = server
           else
@@ -78,56 +45,6 @@ module Exegesis
       end
       alias :inspect :to_s
       
-      # performs a raw GET request against the database
-      def raw_get id, options={}
-        keys = options.delete(:keys)
-        id = Exegesis::Http.escape_id id
-        url = Exegesis::Http.format_url "#{@uri}/#{id}", options
-        if id.match(%r{^_design/.*/_view/.*$}) && keys
-          Exegesis::Http.post url, {:keys => keys}.to_json
-        else
-          Exegesis::Http.get url
-        end
-      end
-      
-      # GETs a document with the given id from the database
-      def get id, opts={}
-        if id.kind_of?(Array)
-          collection = opts.delete(:collection) # nil or true for yes, false for no
-          r = post '_all_docs?include_docs=true', {"keys"=>id}
-          r['rows'].map {|d| Exegesis.instantiate d['doc'], self }
-        else
-          Exegesis.instantiate raw_get(id), self
-        end
-      end
-      
-      # saves a document or collection thereof
-      def save docs
-        if docs.is_a?(Array)
-          post "_bulk_docs", { 'docs' => docs }
-        else
-          result = docs['_id'].nil? ? post(docs) : put(docs['_id'], docs)
-          if result['ok']
-            docs['_id'] = result['id']
-            docs['_rev'] = result['rev']
-          end
-          docs
-        end
-      end
-      
-      # PUTs the body to the given id in the database
-      def put id, body, headers={}
-        Exegesis::Http.put "#{@uri}/#{id}", (body || '').to_json, headers
-      end
-      
-      # POSTs the body to the database
-      def post url, body={}, headers={}
-        if body.is_a?(Hash) && body.empty?
-          body = url
-          url = ''
-        end
-        Exegesis::Http.post "#{@uri}/#{url}", (body || '').to_json, headers
-      end
     end
   end
 end

data/lib/exegesis/database/designs.rb

@@ -0,0 +1,31 @@
+# tests for this module are in test/design_test.rb
+module Exegesis
+  module Database
+    module Designs
+      
+      # set the directory where the designs will be, relative to ENV['PWD']
+      def designs_directory dir=nil
+        if dir
+          @designs_directory = Pathname.new(dir)
+        else
+          @designs_directory ||= Pathname.new('designs')
+        end
+      end
+      
+      # declare a design document for this database. Creates a new class and yields a given block to the class to
+      # configure the design document and declare views; See Class methods for Exegesis::Design
+      def design design_name, opts={}, &block
+        klass_name = "#{design_name.to_s.capitalize}Design"
+        klass = const_set(klass_name, Class.new(Exegesis::Design))
+        klass.design_directory = opts[:directory] || self.designs_directory + design_name.to_s
+        klass.design_name = opts[:name] || design_name.to_s
+        klass.compose_canonical
+        klass.class_eval &block if block_given?
+        define_method design_name do
+          @exegesis_designs ||= {}
+          @exegesis_designs[design_name] ||= klass.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/exegesis/database/documents.rb

@@ -0,0 +1,25 @@
+module Exegesis
+  module Database
+    module Documents
+      
+      # creates a one-off document
+      def document document_name, opts={}, &block
+        klass_name = document_name.to_s.capitalize.gsub(/_(\w)/) { $1.capitalize }
+        klass = const_set(klass_name, Class.new(Exegesis::GenericDocument))
+        klass.unique_id { document_name.to_s }
+        klass.class_eval &block if block_given?
+        define_method document_name do
+          @exegesis_named_documents ||= {}
+          @exegesis_named_documents[document_name] ||= begin
+            get(document_name.to_s)
+          rescue RestClient::ResourceNotFound
+            doc = klass.new({}, self)
+            doc.save
+            doc
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/exegesis/database/rest.rb

@@ -0,0 +1,62 @@
+module Exegesis
+  module Database
+    module Rest
+      # performs a raw GET request against the database
+      def raw_get(id, options={})
+        keys = options.delete(:keys)
+        id = Exegesis::Http.escape_id id
+        url = Exegesis::Http.format_url "#{@uri}/#{id}", options
+        if id.match(%r{^_design/.*/_view/.*$}) && keys
+          Exegesis::Http.post url, {:keys => keys}.to_json
+        else
+          Exegesis::Http.get url
+        end
+      end
+      
+      # GETs a document with the given id from the database
+      def get(id, opts={})
+        if id.kind_of?(Array)
+          collection = opts.delete(:collection) # nil or true for yes, false for no
+          r = post '_all_docs?include_docs=true', {"keys"=>id}
+          r['rows'].map {|d| Exegesis.instantiate d['doc'], self }
+        else
+          Exegesis.instantiate raw_get(id), self
+        end
+      end
+      
+      # saves a document or collection thereof
+      def save(docs)
+        if docs.is_a?(Array)
+          post "_bulk_docs", { 'docs' => docs }
+        else
+          result = docs['_id'] ? put(docs['_id'], docs) : post(docs)
+          if result['ok']
+            docs['_id'] = result['id']
+            docs['_rev'] = result['rev']
+          end
+          docs
+        end
+      end
+      
+      # PUTs the body to the given id in the database
+      def put(id, body, headers={})
+        Exegesis::Http.put "#{@uri}/#{id}", (body || '').to_json, headers
+      end
+      
+      # POSTs the body to the database
+      def post(url, body={}, headers={})
+        if body.is_a?(Hash) && body.empty?
+          body = url
+          url = ''
+        end
+        Exegesis::Http.post "#{@uri}/#{url}", (body || '').to_json, headers
+      end
+      
+      # DELETE the doc from the database. requires a hash with _id and _rev keys
+      def delete(doc={})
+        raise ArgumentError, "doc must have both '_id' and '_rev' keys" unless doc['_id'] && doc['_rev']
+        Exegesis::Http.delete "#{@uri}/#{doc['_id']}?rev=#{doc['_rev']}"
+      end
+    end
+  end
+end

data/lib/exegesis/database/singleton.rb

@@ -0,0 +1,36 @@
+module Exegesis
+  module Database
+    module Singleton
+      
+      include Exegesis::Database::InstanceMethods
+      include Exegesis::Database::Designs
+      include Exegesis::Database::Documents
+      
+      def uri(addr=nil)
+        if addr
+          if addr.match(Exegesis::Database::URI_PATTERN)
+            @server   = Exegesis::Server.new($1)
+            @uri      = "#{@server.uri}/#{$2}"
+          elsif addr.match(Exegesis::Database::NAME_PATTERN)
+            @server   = Exegesis::Server.new
+            @uri      = "#{@server.uri}/#{addr}"
+          else
+            raise ArgumentError, "does not match a valid database name/uri pattern"
+          end
+          begin
+            @server.get @uri
+          rescue RestClient::ResourceNotFound
+            @server.put @uri
+          end
+          @uri
+        else
+          @uri || uri(Exegesis.nameify(name))
+        end
+      end
+    
+      def server
+        @server
+      end
+    end
+  end
+end

data/lib/exegesis/document.rb

@@ -14,6 +14,18 @@ module Exegesis
     end
 
     module ClassMethods
+      def database(db=nil)
+        if db 
+          if db.is_a?(Exegesis::Database::Singleton) || db.is_a?(Exegesis::Database)
+            @database = db
+          else
+            raise ArgumentError, "please supply either an Exegesis::Database or Exegesis::Database::Singleton"
+          end
+        else
+          @database
+        end
+      end
+      
       def timestamps!
         define_method :set_timestamps do
           @attributes['updated_at'] = Time.now
@@ -37,7 +49,7 @@ module Exegesis
     module InstanceMethods
       def initialize hash={}, db=nil
         super hash
-        @database = db
+        @database = db || self.class.database
       end
       
       def uri

data/test/database/documents_test.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+class DatabaseDocumentsTest
+  include Exegesis::Database
+  
+  document :settings do
+    expose :things
+  end
+  document :no_block
+end
+
+describe Exegesis::Database::Documents do
+  
+  before do
+    reset_db
+    @db = DatabaseDocumentsTest.new('exegesis-test')
+  end
+  
+  describe "with named documents" do
+    describe "that doesn't exist yet" do
+      before do
+        @db.settings
+      end
+      
+      expect { @db.settings.must_be_kind_of DatabaseDocumentsTest::Settings }
+      expect { @db.settings.rev.must_match /1-\d{7,12}/ }
+      expect { @db.settings.must_respond_to :things }
+      expect { @db.get('settings').must_be_kind_of DatabaseDocumentsTest::Settings }
+    end
+    
+    describe "that does exist" do
+      before do
+        @doc = @db.save({'_id' => 'settings', 'things' => %w(foo bar baz), 'class' => 'DatabaseDocumentsTest::Settings'})
+      end
+      
+      expect { @db.settings.rev.must_equal @doc['_rev'] }
+      expect { @db.settings.rev.must_match /1-\d{7,12}/ }
+      expect { @db.settings.things.must_equal %w(foo bar baz) }
+    end
+    
+    describe "when the declaration does not have a block" do
+      expect { @db.no_block.must_be_kind_of DatabaseDocumentsTest::NoBlock }
+    end
+  end
+  
+end

data/test/database/singleton_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper.rb')
+
+Exegesis::Http.delete("#{@server.uri}/exegesis-singleton-test") rescue nil
+
+module SingletonDbTest
+  extend self
+  
+  COUCH = 'http://localhost:5984'
+  DB    = 'exegesis-singleton-test'
+  URI   = "#{COUCH}/#{DB}"
+  
+  extend Exegesis::Database::Singleton
+  uri DB
+  
+  design :design_doc
+  document :named_doc
+end
+
+module SingletonDbDefaultUriTest
+  extend self
+  extend Exegesis::Database::Singleton
+end
+
+describe Exegesis::Database::Singleton do
+  
+  describe "database setup" do
+    expect { SingletonDbTest.uri.must_equal SingletonDbTest::URI }
+    expect { Exegesis::Http.get(SingletonDbTest::URI)["db_name"].must_equal SingletonDbTest::DB }
+    expect { lambda{SingletonDbTest.uri('foo.db')}.must_raise ArgumentError }
+    
+    expect { SingletonDbDefaultUriTest.uri.must_equal "http://localhost:5984/singleton_db_default_uri_test" }
+  end
+  
+  describe "database REST methods" do
+    before do
+      Exegesis::Http.delete(SingletonDbTest::URI) rescue nil
+      Exegesis::Http.put(SingletonDbTest::URI)
+      @test_doc = {"_id" => "test", "foo" => "bar"}
+      response = Exegesis::Http.put("#{SingletonDbTest::URI}/test", @test_doc.to_json)
+      @test_doc['_rev'] = response['rev']
+    end
+    expect { SingletonDbTest.get("test")['foo'].must_equal @test_doc['foo'] }
+    expect { SingletonDbTest.post({"foo" => "bar"})["id"].must_match /[0-9a-f]{32}/ }
+    expect { SingletonDbTest.put("foo", {"_id" => "foo"})["id"].must_equal "foo" }
+    expect { SingletonDbTest.delete(@test_doc)["ok"].must_equal true }
+  end
+  
+  describe "database class methods" do
+    expect { SingletonDbTest.design_doc.must_be_kind_of Exegesis::Design }
+    expect { SingletonDbTest.named_doc.must_be_kind_of Exegesis::GenericDocument }
+  end
+end

data/test/database_test.rb

@@ -3,20 +3,12 @@ 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 NamedDocumentDatabaseTest
-  include Exegesis::Database
-  named_document :settings do
-    expose :things
-  end
-end
-class NamedDocumentWithoutBlockDatabaseTest
-  include Exegesis::Database
-  named_document :blah
-end
+
 class DatabaseTestDocument
   include Exegesis::Document
 end
@@ -179,40 +171,4 @@ describe Exegesis::Database do
     expect { CustomDesignDirDatabaseTest.designs_directory.must_equal Pathname.new('app/designs') }
   end
   
-  describe "with a named document" do
-    describe "that doesn't exist yet" do
-      before do
-        reset_db
-        @db = NamedDocumentDatabaseTest.new('exegesis-test')
-        @db.settings
-      end
-      
-      expect { @db.settings.must_be_kind_of NamedDocumentDatabaseTest::Settings }
-      expect { @db.settings.rev.must_match /1-\d{7,12}/ }
-      expect { @db.settings.must_respond_to :things }
-      expect { @db.get('settings').must_be_kind_of NamedDocumentDatabaseTest::Settings }
-    end
-    
-    describe "that does exist" do
-      before do
-        reset_db
-        @db = NamedDocumentDatabaseTest.new('exegesis-test')
-        @doc = @db.save({'_id' => 'settings', 'things' => %w(foo bar baz), 'class' => 'NamedDocumentDatabaseTest::Settings'})
-      end
-      
-      expect { @db.settings.rev.must_equal @doc['_rev'] }
-      expect { @db.settings.rev.must_match /1-\d{7,12}/ }
-      expect { @db.settings.things.must_equal %w(foo bar baz) }
-    end
-    
-    describe "when the declaration does not have a block" do
-      before do
-        reset_db
-        @db = NamedDocumentWithoutBlockDatabaseTest.new('exegesis-test')
-      end
-      
-      expect { @db.blah.must_be_kind_of NamedDocumentWithoutBlockDatabaseTest::Blah }
-    end
-  end
-  
-end
+end

data/test/document_test.rb

@@ -23,9 +23,29 @@ class UniqueIdBlockTestDocument
   unique_id {|doc, attempt| attempt.zero? ? doc['pk'] : "#{doc['pk']}-#{attempt}" }
 end
 
+module DocumentSingletonDatabaseTest
+  extend self
+  extend Exegesis::Database::Singleton
+end
+class SingletonDatabaseDocument
+  include Exegesis::Document
+  database DocumentSingletonDatabaseTest
+end
+
 describe Exegesis::Document do
   
   describe "class definitions" do
+    describe "with database declarations" do
+      before do
+        @doc = SingletonDatabaseDocument.new
+      end
+      
+      expect { SingletonDatabaseDocument.database.must_equal DocumentSingletonDatabaseTest }
+      expect { @doc.database.must_equal DocumentSingletonDatabaseTest }
+      
+      expect { lambda{SingletonDatabaseDocument.database("foo")}.must_raise(ArgumentError) }
+    end
+    
     describe "with timestamps" do
       before do
         reset_db

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mattly-exegesis
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  version: 0.2.8
 platform: ruby
 authors: 
 - Matt Lyon
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-12 00:00:00 -07:00
+date: 2009-06-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,6 +38,10 @@ files:
 - VERSION.yml
 - lib/exegesis.rb
 - lib/exegesis/database.rb
+- lib/exegesis/database/designs.rb
+- lib/exegesis/database/documents.rb
+- lib/exegesis/database/rest.rb
+- lib/exegesis/database/singleton.rb
 - lib/exegesis/design.rb
 - lib/exegesis/document.rb
 - lib/exegesis/document/attachment.rb
@@ -49,6 +53,8 @@ files:
 - lib/exegesis/utils/http.rb
 - lib/monkeypatches/time.rb
 - test/attachments_test.rb
+- test/database/documents_test.rb
+- test/database/singleton_test.rb
 - test/database_test.rb
 - test/design_test.rb
 - test/document_collection_test.rb
@@ -91,6 +97,8 @@ specification_version: 3
 summary: A Document <> Object Mapper for CouchDB Documents
 test_files: 
 - test/attachments_test.rb
+- test/database/documents_test.rb
+- test/database/singleton_test.rb
 - test/database_test.rb
 - test/design_test.rb
 - test/document_collection_test.rb