mattly-exegesis 0.0.10 → 0.2.0

data/test/model_test.rb

@@ -0,0 +1,230 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class FooTestModel
+  include Exegesis::Model
+  expose :ref, :as => :reference
+end
+class BarTestModel
+  include Exegesis::Model
+end
+
+class WithDefaultTestModel
+  include Exegesis::Model
+  default :foo => 'bar'
+end
+
+class ModelTestDocument
+  include Exegesis::Model
+  attr_accessor :database
+end
+
+class ExposeTestModel
+  include Exegesis::Model
+  expose :foo, :bar
+  expose :read_only, :writer => false
+  expose :custom_writer, :writer => lambda {|val| {'value' => val} }
+  expose :castee, :castees, :as => :given
+  expose :time, :times, :as => Time
+  expose :regex, :regexen, :as => Regexp
+  expose :other_doc, :other_docs, :as => :reference
+end
+
+class ExegesisModelTest < Test::Unit::TestCase
+  
+  context "class definitions" do
+    context "default objects" do
+      expect { WithDefaultTestModel.new['foo'].will == 'bar' }
+      expect { WithDefaultTestModel.new({'foo' => 'baz'})['foo'].will == 'baz' }
+    end
+  
+    context "exposing keys" do
+      context "regular declarations" do
+        before do 
+          @obj = ExposeTestModel.new(:foo => 'bar', :bar => 'foo')
+        end
+        context "reading" do
+          expect { @obj.foo.will == 'bar' }
+          expect { @obj.bar.will == 'foo' }
+        end
+      
+        context "writing" do
+          before do
+            @obj.bar = "bee"
+          end
+          expect { @obj.bar.will == "bee" }
+        end
+      end
+    
+      context "with a custom writer" do
+        context "when false" do
+          before { @obj = ExposeTestModel.new(:read_only => 'value') }
+          expect { @obj.read_only.will == 'value' }
+          expect { lambda{@obj.read_only = "other value"}.will raise_error(NoMethodError) }
+        end
+      
+        context "when lambda" do
+          before do
+            @obj = ExposeTestModel.new(:custom_writer => 'value')
+            @obj.custom_writer = 'other value'
+            @expected = {'value' => 'other value'}
+          end
+          expect { @obj.custom_writer.will == @expected }
+        end
+      end
+    
+      context "when casting a value" do
+        context "when as given" do
+          before do
+            @obj = ExposeTestModel.new({
+              :castee => {'foo' => 'foo', 'class' => 'FooTestModel'},
+              :castees => [
+                {'foo' => 'foo', 'class' => 'FooTestModel'}, 
+                {'foo' => 'bar', 'class' => 'BarTestModel'}
+              ]
+            })
+          end
+        
+          expect { @obj.castee.class.will == FooTestModel }
+          expect { @obj.castee['foo'].will == 'foo' }
+          expect { @obj.castee.parent.will == @obj }
+        
+          expect { @obj.castees.class.will == Array }
+          expect { @obj.castees[0].class.will == FooTestModel }
+          expect { @obj.castees[0]['foo'].will == 'foo' }
+          expect { @obj.castees[0].parent.will == @obj }
+          expect { @obj.castees[1].class.will == BarTestModel }
+          expect { @obj.castees[1]['foo'].will == 'bar' }
+          expect { @obj.castees[1].parent.will == @obj }
+        end
+      
+        context "when as time" do
+          before do
+            @obj = ExposeTestModel.new({:time => Time.now.to_json, :times => [Time.local(2009,3,1).to_json, Time.local(2009,2,1).to_json]})
+          end
+        
+          expect { @obj.time.class.will == Time }
+          expect { @obj.time.to_f.will be_close(Time.now.to_f, 1) }
+        
+          expect { @obj.times.class.will == Array }
+          expect { @obj.times[0].class.will == Time }
+          expect { @obj.times[0].will == Time.local(2009,3,1) }
+          expect { @obj.times[1].class.will == Time }
+          expect { @obj.times[1].will == Time.local(2009,2,1) }
+        end
+      
+        context "when as non document class" do
+          before do
+            @obj = ExposeTestModel.new({
+              :regex => 'foo',
+              :regexen => ['foo', 'bar']
+            })
+          end
+        
+          expect { @obj.regex.will == /foo/ }
+        
+          expect { @obj.regexen.class.will == Array }
+          expect { @obj.regexen[0].will == /foo/ }
+          expect { @obj.regexen[1].will == /bar/ }
+        end
+      
+        context "when as reference" do
+          context "with a database present" do
+            before do
+              reset_db
+              @obj = ExposeTestModel.new(:other_doc => "other_doc", 
+                                         :other_docs => ["other_docs_1", "other_docs_2"])
+              @doc = ModelTestDocument.new
+              @doc.database = @db
+              @obj.parent = @doc
+            end
+          
+            context "when the referenced document exists" do
+              before do
+                [ {'class' => 'ModelTestDocument', '_id' => 'other_doc'},
+                  {'class' => 'ModelTestDocument', '_id' => 'other_docs_1'}, 
+                  {'class' => 'ModelTestDocument', '_id' => 'other_docs_2'}
+                ].each {|doc| @db.put(doc.delete('_id'), doc) }
+              end
+            
+              expect { @obj.other_doc['_rev'].will == @db.get('other_doc')['_rev'] }
+              expect { @obj.other_doc.class.will == ModelTestDocument }
+              expect { @obj.other_docs.class.will == Array }
+              expect { @obj.other_docs[0]['_rev'].will == @db.get('other_docs_1')['_rev'] }
+              expect { @obj.other_docs[0].class.will == ModelTestDocument }
+              expect { @obj.other_docs[1]['_rev'].will == @db.get('other_docs_2')['_rev'] }
+              expect { @obj.other_docs[1].class.will == ModelTestDocument }
+            
+              context "caching" do
+                before do
+                  @obj.other_doc # load it
+                  doc = @db.get('other_doc')
+                  doc.update('foo' => 'updated')
+                  @db.put(doc['_id'], doc.attributes)
+                end
+              
+                expect { @obj.other_doc['foo'].will be(nil) }
+                expect { @obj.other_doc(true)['foo'].will == 'updated' }
+              end
+            end
+          
+            context "when the document is missing" do
+              expect { lambda{@obj.other_doc}.will raise_error(RestClient::ResourceNotFound) }
+              expect { lambda{@obj.other_docs}.will raise_error(RestClient::ResourceNotFound) }
+            end
+          
+            context "when the model has a parent" do
+              before do
+                @obj.castee = {'class' => 'FooTestModel', 'ref' => 'other_doc'}
+                @db.put('other_doc', {'class' => 'ModelTestDocument', '_id' => 'other_doc'})
+              end
+            
+              expect { @obj.castee.ref['_rev'].will == @db.get('other_doc')['_rev'] }
+            end
+          end
+        
+          context "without any database present" do
+            before { @obj = ExposeTestModel.new(:other_doc => "some_doc_id") }
+            expect { lambda{@obj.other_doc}.will raise_error(ArgumentError) }
+          end
+        end
+      
+        context "when the value is nil" do
+          before do
+            @obj =  ExposeTestModel.new({:castee => nil, :castees => nil, :regexen => ['foo', nil]})
+          end
+          expect { @obj.castee.will be(nil) }
+          expect { @obj.castees.will be(nil) }
+          expect { @obj.regexen.will == [/foo/] }
+        end
+      end
+    end
+  end
+  
+  context "instance methods" do
+    before do
+      @obj = ExposeTestModel.new({:read_only => 'bar'})
+    end
+    context "update" do
+      before do
+        @obj.update({:read_only => 'bee'})
+      end
+      
+      expect { @obj.read_only.will == 'bee' } 
+    end
+    
+    context "update" do
+      context "with a writer" do
+        before do
+          @obj.update_attributes(:foo => 'foo')
+        end
+        
+        expect { @obj.foo.will == "foo" }
+      end
+      
+      context "without a writer" do
+        expect { lambda{@obj.update_attributes({:read_only => 'bee'})}.will raise_error(NoMethodError) }
+      end
+    end
+  end
+  
+end

data/test/server_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class ExegesisServerTest < Test::Unit::TestCase
+
+  before(:all) do
+    @db = 'http://localhost:5984/exegesis-test'
+    RestClient.delete @db rescue nil
+    RestClient.delete "#{@db}-2" rescue nil
+    RestClient.put @db, ''
+    
+    @server = Exegesis::Server.new('http://localhost:5984')
+  end
+  
+  context "listing databases" do
+    expect { @server.databases.include?('exegesis-test').will == true }
+  end
+  
+  context "creating a database" do
+    before do
+      @response = @server.create_database('exegesis-test-2')
+    end
+    
+    expect { @response['ok'].will == true }
+  end
+  
+end

data/test/test_helper.rb

@@ -15,25 +15,29 @@ end
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'lib/exegesis'
 
+class TestingDatabase
+  include Exegesis::Database
+end
+
 class Test::Unit::TestCase
   
   def fixtures_path fixtures
     File.join(File.dirname(__FILE__), 'fixtures', fixtures)
   end
   
-  # todo: extract to some helper methods to include ala RR, etc
-  def reset_db(name=nil)
-    @db = CouchRest.database db(name) rescue nil
-    @db.delete! rescue nil
-    @db = CouchRest.database! db(name)
+  def db_server
+    @db_server ||= Exegesis::Server.new('http://localhost:5984')
   end
   
-  def teardown_db
-    @db.delete! rescue nil
+  # todo: extract to some helper methods to include ala RR, etc
+  def reset_db(name=nil)
+    RestClient.delete "http://localhost:5984/#{db(name)}" rescue nil
+    db_server.create_database(db(name))
+    @db = TestingDatabase.new(db_server, db(name))
   end
   
   def db(name)
-    "http://localhost:5984/exegesis-test#{name.nil? ? '' : "-#{name}"}"
+    "exegesis-test#{name.nil? ? '' : "-#{name}"}"
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mattly-exegesis
 version: !ruby/object:Gem::Version 
-  version: 0.0.10
+  version: 0.2.0
 platform: ruby
 authors: 
 - Matt Lyon
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-08 00:00:00 -08:00
+date: 2009-04-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: jchris-couchrest
+  name: rest-client
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -22,32 +22,45 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.12.6
     version: 
-description: TODO
+description: A Document <> Object Mapper for CouchDB Documents
 email: matt@flowerpowered.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
 files: 
 - README.rdoc
 - VERSION.yml
 - lib/exegesis
-- lib/exegesis/design
-- lib/exegesis/design/design_docs.rb
+- lib/exegesis/database.rb
 - lib/exegesis/design.rb
 - lib/exegesis/document.rb
+- lib/exegesis/model.rb
+- lib/exegesis/server.rb
+- lib/exegesis/utils
+- lib/exegesis/utils/http.rb
 - lib/exegesis.rb
-- test/design_doc_test.rb
+- lib/monkeypatches
+- lib/monkeypatches/time.rb
+- test/database_test.rb
 - test/design_test.rb
-- test/document_class_definitions_test.rb
-- test/document_instance_methods_test.rb
-- test/exegesis_test.rb
+- test/document_test.rb
 - test/fixtures
 - test/fixtures/designs
 - test/fixtures/designs/foos.js
+- test/fixtures/designs/tags
+- test/fixtures/designs/tags/views
+- test/fixtures/designs/tags/views/by_tag
+- test/fixtures/designs/tags/views/by_tag/map.js
+- test/fixtures/designs/tags/views/by_tag/reduce.js
+- test/http_test.rb
+- test/model_test.rb
+- test/server_test.rb
 - test/test_helper.rb
+- LICENSE
 has_rdoc: true
 homepage: http://github.com/mattly/exegesis
 post_install_message: 

data/lib/exegesis/design/design_docs.rb

@@ -1,92 +0,0 @@
-require 'johnson'
-require 'digest/md5'
-
-module Exegesis
-  class Design
-    module DesignDocs
-      
-      def self.included(base)
-        base.extend ClassMethods
-      end
-      
-      module ClassMethods
-        def designs_directory dir=nil
-          if dir
-            @designs_directory = Pathname.new(dir)
-          else
-            @designs_directory || Exegesis.designs_directory
-          end
-        end
-        
-        def design_doc_path
-          designs_directory + "#{design_doc_name}.js"
-        end
-        
-        def design_doc
-          js_doc = Johnson.evaluate("v = #{File.read(design_doc_path)}");
-          views = js_doc['views'].entries.inject({}) do |memo, (name, mapreduce)|
-            memo[name] = mapreduce.entries.inject({}) do |view, (role, func)|
-              view.update role => func.toString
-            end
-            memo
-          end
-          composite_views = declared_views.dup.update(views)
-          { '_id' => "_design/#{design_doc_name}",
-            'language' => 'javascript',
-            'views' => composite_views
-          }
-        end
-        
-        def declared_views
-          @declared_views ||= {}
-        end
-        
-        def view_by *keys
-          view_name = "by_#{keys.join('_and_')}"
-          doc_keys = keys.map {|k| "doc['#{k}']" }
-          declared_views[view_name] = {
-            'map' => %|function(doc) {
-              if (doc['.kind'] == '#{name.sub(/Design$/,'')}' && #{doc_keys.join(' && ')}) {
-                emit(#{keys.length == 1 ? doc_keys.first : "[#{doc_keys.join(', ')}]" }, null);
-              }
-            }|
-          }
-          define_method view_name do |*args|
-            docs_for view_name, *args
-          end
-        end
-        
-        def design_doc_hash
-          hash_for_design design_doc
-        end
-        
-        def hash_for_design design
-          funcs = design['views'].map do |name, view|
-            "//view/#{name}/#{view['map']}/#{view['reduce']}"
-          end
-          Digest::MD5.hexdigest(funcs.sort.join)
-        end
-        
-      end
-      
-      def design_doc_hash
-        design_doc.nil? ? '' : self.class.hash_for_design(design_doc)
-      end
-      
-      def design_doc reload=false
-        @design_doc = nil if reload
-        @design_doc ||= database.get "_design/#{design_doc_name}" rescue nil
-      end
-      
-      def push_design!
-        return if design_doc_hash == self.class.design_doc_hash
-        if design_doc
-          design_doc.update(self.class.design_doc)
-          design_doc.save
-        else
-          database.save_doc(self.class.design_doc)
-        end
-      end
-    end
-  end
-end