mattly-exegesis 0.0.6

data/README.rdoc

@@ -0,0 +1,23 @@
+= exegesis
+
+* http://github.com/mattly/exegesis
+
+== DESCRIPTION:
+
+An ODM (Object/Document Mapper) for Couchdb. Still very much a work in progress
+
+== FEATURES/PROBLEMS:
+
+* Encourages Per-"Account" databases. This is both a feature and a problem, since classes cannot know which database to pull from you cannot do f.e. "Article.find('foo')" as Article doesn't know what database to use.
+* Does not provide it's own validators or callbacks. I have a solution in mind for this involving state machines.
+
+== REQUIREMENTS:
+
+* Johnson (and Spidermonkey, if you have CouchDB you have Spidermonkey)
+
+For running the tests:
+
+* Test::Unit (you got it)
+* Context (http://github.com/jeremymcanally/context, can install from github gems)
+* Matchy (http://github.com/jeremymcanally/matchy, github gem version out of date; clone, build & install for now)
+* Zebra (http://github.com/giraffesoft/zerba, depends on jeremymcanally-matchy, which is out of date; clone, build & install for now)

data/VERSION.yml

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

data/lib/exegesis.rb

@@ -0,0 +1,44 @@
+require 'time'
+require 'pathname'
+
+require 'couchrest'
+require 'active_support/inflector'
+
+$:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Exegesis
+  autoload :Document,   'exegesis/document'
+  autoload :Design,     'exegesis/design'
+  
+  extend self
+  
+  def designs_directory= dir
+    @designs_directory = Pathname.new(dir)
+  end
+  
+  def designs_directory
+    @designs_directory ||= Pathname.new(ENV["PWD"])
+    @designs_directory
+  end
+  
+  def design_file name
+    File.read(designs_directory + name)
+  end
+  
+  def database_template= template
+    @db_template = template
+  end
+  
+  def database_template
+    @db_template ||= "http://localhost:5984/%s"
+  end
+  
+  def database_for name
+    database_template % name
+  end
+  
+  def document_classes
+    @document_classes ||= Hash.new(Exegesis::Document)
+  end
+  
+end

data/lib/exegesis/design.rb

@@ -0,0 +1,84 @@
+$:.unshift File.dirname(__FILE__)
+require 'design/design_docs'
+
+module Exegesis
+  class Design
+    include Exegesis::Design::DesignDocs
+    
+    attr_accessor :database
+    
+    def initialize(db)
+      @database = db
+    end
+    
+    def self.use_design_doc_name name
+      @design_doc_name = name.to_s
+    end
+    
+    def self.design_doc_name
+      @design_doc_name ||= name.to_s.sub(/(Design)$/,'').downcase
+    end
+    
+    def design_doc_name
+      self.class.design_doc_name
+    end
+    
+    def get(id)
+      doc = Exegesis::Document.instantiate database.get(id)
+      doc.database = self.database
+      doc
+    end
+    
+    def parse_opts(opts={})
+      if opts[:key]
+        case opts[:key]
+        when Range
+          range = opts.delete(:key)
+          opts.update({:startkey => range.first, :endkey => range.last})
+        when Array
+          if opts[:key].any?{|v| v.kind_of?(Range) }
+            key = opts.delete(:key)
+            opts[:startkey] = key.map {|v| v.kind_of?(Range) ? v.first : v }
+            opts[:endkey]   = key.map {|v| v.kind_of?(Range) ? v.last : v }
+          end
+        end
+      elsif opts[:keys] && opts[:keys].empty?
+        opts.delete(:keys)
+      end
+
+      opts
+    end
+    
+    def view view_name, opts={}
+      opts = parse_opts opts
+      return [] unless opts[:key] || opts[:startkey] || opts[:keys] || opts[:all]
+      opts.delete(:all)
+      database.view("#{design_doc_name}/#{view_name}", opts)['rows']
+    end
+    
+    def docs_for view_name, opts={}
+      response = view view_name, opts.update({:include_docs => true})
+      response.map do |doc| 
+        model = Exegesis::Document.instantiate doc['doc']
+        model.database = database
+        model
+      end
+    end
+    
+    def values_for view_name, opts={}
+      response = view view_name, opts
+      response.map {|row| row['value'] }
+    end
+    
+    def keys_for view_name, opts={}
+      response = view view_name, opts
+      response.map {|row| row['key'] }
+    end
+    
+    def ids_for view_name, opts={}
+      response = view view_name, opts
+      response.map {|row| row['id'] }
+    end
+    
+  end
+end

data/lib/exegesis/design/design_docs.rb

@@ -0,0 +1,92 @@
+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

data/lib/exegesis/document.rb

@@ -0,0 +1,149 @@
+module Exegesis
+  class Document < CouchRest::Document
+    
+    def self.inherited subklass
+      Exegesis.document_classes[subklass.name] = subklass
+    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 }
+        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
+        else
+          define_method(attrib) { self[attrib] }
+        end
+      end
+    end
+    
+    def self.default hash=nil
+      if hash
+        @default = hash
+      else
+        @default ||= superclass.respond_to?(:default) ? superclass.default : {}
+      end
+    end
+    
+    def self.timestamps!
+      define_method :set_timestamps do
+        self['updated_at'] = Time.now
+        self['created_at'] ||= Time.now
+      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)
+      end
+    end
+    
+    alias :_rev :rev
+    alias_method :document_save, :save
+    
+    def save
+      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
+        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)
+      end
+      save
+    end
+    
+    private
+    
+    def apply_default
+      self.class.default.each do |key, value|
+        self[key] = value
+      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?
+        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
+    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| Exegesis::Document.instantiate(database.get(val)) }
+      else
+        Exegesis::Document.instantiate(database.get(ids))
+      end
+    end
+    
+  end
+end
+
+# $:.unshift File.dirname(__FILE__)
+# require 'document/annotated_reference'
+# require 'document/referencing'

data/test/design_doc_test.rb

@@ -0,0 +1,120 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class FoosDesign < Exegesis::Design
+  view_by :foo
+  view_by :foo, :bar
+end
+class CustomDesignDirDesign < Exegesis::Design
+  designs_directory File.join(File.dirname(__FILE__), 'fixtures')
+end
+
+
+class ComposingDesignDocTest < Test::Unit::TestCase
+  before(:all) { Exegesis.designs_directory = fixtures_path('designs') }
+  
+  context "setting a custom designs directory" do
+    before do
+      @custom_design_dir = File.join(File.dirname(__FILE__), 'fixtures')
+    end
+    
+    expect { CustomDesignDirDesign.designs_directory.to_s.will == @custom_design_dir }
+    
+  end
+  
+  context "composing design docs from local sources" do
+    before do
+      @design = FoosDesign.design_doc
+      @file = File.read(fixtures_path('designs/foos.js'))
+      @jsdoc = Johnson.evaluate("v=#{@file}")
+    end
+  
+    expect { @design.has_key?('_id').will be(true) }
+    expect { @design['_id'].will == '_design/foos' }
+    expect { @design['views']['by_bar']['map'].will == @jsdoc['views']['by_bar']['map'].toString }
+  end
+  
+  context "composing a design doc from view_by declarations" do
+    before do
+      @design = FoosDesign.design_doc
+      @by_foo = @design['views']['by_foo']['map']
+      @by_foo_and_bar = @design['views']['by_foo_and_bar']['map']
+    end
+    
+    expect { @by_foo.will include("if (doc['.kind'] == 'Foos' && doc['foo'])") }
+    expect { @by_foo.will include("emit(doc['foo'], null);") }
+    
+    expect { @by_foo_and_bar.will include("if (doc['.kind'] == 'Foos' && doc['foo'] && doc['bar'])") }
+    expect { @by_foo_and_bar.will include("emit([doc['foo'], doc['bar']], null)") }
+  end
+  
+  context "building a hash a design doc" do
+    before do
+      @design = {
+        'views' => {
+          'a' => {'map' => 'some value', 'reduce' => 'some value'},
+          'b' => {'map' => 'some value'}
+        }
+      }
+      funcs = @design['views'].map{|name, view| "//view/#{name}/#{view['map']}/#{view['reduce']}" }.sort
+      @hashed = Digest::MD5.hexdigest(funcs.join)
+    end
+    expect { FoosDesign.hash_for_design(@design).will == @hashed }
+  end
+
+  context "syncronising with a databae" do
+    before do
+      reset_db
+    end
+    
+    context "pushing design doc when it doesn't exist yet" do
+      before do
+        foo = FoosDesign.new(@db)
+        foo.push_design!
+        @get_design = lambda { @db.get('_design/foos') }
+        @design = @get_design.call rescue nil
+      end
+
+      expect { @get_design.wont raise_error }
+      expect { @design['_rev'].will =~ /^[0-9]+$/ }
+      expect { @design['language'].will == 'javascript' }
+      expect { @design['views'].has_key?('by_bar').will be(true) }
+    end
+
+    context "reading the existing design document" do
+      before do
+        @db.save_doc(FoosDesign.design_doc)
+        @foo = FoosDesign.new(@db)
+      end
+
+      expect { lambda {@foo.design_doc}.wont raise_error }
+      expect { @foo.design_doc['_rev'].will =~ /^[0-9]+$/ }
+      expect { @foo.design_doc['views'].keys.will == FoosDesign.design_doc['views'].keys }
+    end
+
+    context "updating an existing doc" do
+
+      context "when it hasn't changed" do
+        before do
+          @db.save_doc(FoosDesign.design_doc)
+          @foo = FoosDesign.new(@db)
+        end
+        
+        expect { lambda { @foo.push_design! }.wont change { @db.get('_design/foos')['_rev'] } }
+      end
+
+      context "when it has chagned" do
+        before do
+          @db.save_doc({'_id' => '_design/foos', 
+            'views' => {'a' => {'map' => 'function(doc) { emit(true, null)}'}}
+          })
+          @foo = FoosDesign.new(@db)
+          @pushing = lambda{ @foo.push_design! }
+        end
+
+        expect { @pushing.will change { @db.get('_design/foos')['_rev'] } }
+        expect { @pushing.call; @foo.design_doc_hash.will == FoosDesign.design_doc_hash }
+      end
+    end
+    
+  end
+end

data/test/design_test.rb

@@ -0,0 +1,113 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class FoosDesign < Exegesis::Design; end
+class BarsDesign < Exegesis::Design
+  use_design_doc_name :something_else
+end
+
+class TestForDesign < Exegesis::Document; end
+
+class ExegesisDesignTest < Test::Unit::TestCase
+  
+  before do
+    reset_db
+    @doc = FoosDesign.new(@db)
+  end
+  
+  expect { @doc.database.will == @db }
+  expect { @doc.design_doc_name.will == "foos" }
+
+  expect { FoosDesign.design_doc_name.will == "foos" }
+  expect { BarsDesign.design_doc_name.will == "something_else" }
+  
+  context "retrieving documents with #get" do
+    before do
+      @db.save_doc '_id' => 'foo', 'foo' => 'bar', '.kind' => 'TestForDesign'
+      @obj = @doc.get('foo')
+    end
+    
+    expect { @obj.will be_kind_of(TestForDesign) }
+    expect { @obj['foo'].will == 'bar' }
+  end
+  
+  context "retreiving views" do
+    before do
+      @raw_docs = [
+        {'_id' => 'bar', 'foo' => 'bar', 'bar' => 'bar', '.kind' => 'TestForDesign'},
+        {'_id' => 'baz', 'foo' => 'baz', 'bar' => 'baz', '.kind' => 'TestForDesign'},
+        {'_id' => 'foo', 'foo' => 'foo', 'bar' => 'foo', '.kind' => 'TestForDesign'}
+      ]
+      @db.bulk_save @raw_docs
+      @db.save_doc({
+        '_id' => '_design/foos',
+        'views' => {
+          'test' => { 'map'=>'function(doc) {emit(doc.foo, doc.bar);}' },
+        }
+      })
+    end
+    
+    context "parsing options" do
+      context "when the key is a range" do
+        before { @opts = @doc.parse_opts(:key => 'bar'..'baz') }
+        
+        expect { @opts[:key].will == nil }
+        expect { @opts[:startkey].will == 'bar' }
+        expect { @opts[:endkey].will == 'baz' }
+      end
+      
+      context "when the key is an array with a range in it" do
+        before { @opts = @doc.parse_opts(:key => ['published', '2008'..'2008/13']) }
+        
+        expect { @opts[:key].will be(nil) }
+        expect { @opts[:startkey].will == ['published', '2008'] }
+        expect { @opts[:endkey].will == ['published', '2008/13'] }
+      end
+      
+      context "when a keys option is empty" do
+        before { @opts = @doc.parse_opts(:keys => []) }
+        
+        expect { @opts[:keys].will be(nil) }
+      end
+    end
+    
+    context "when no key, keys, startkey or all option is present" do
+      before { @response = @doc.view :test }
+      
+      expect { @response.will == [] }
+    end
+
+    context "with an all key" do
+      before { @response = @doc.view :test, :all => true }
+      
+      expect { @response.will == @raw_docs.map{|d| {'id' => d['_id'], 'key' => d['foo'], 'value' => d['bar']} } }
+    end
+
+    context "with docs" do
+      before { @response = @doc.docs_for :test, :key => 'foo' }
+    
+      expect { @response.will be_kind_of(Array) }
+      expect { @response.size.will == 1 }
+      expect { @response.first.will be_kind_of(TestForDesign) }
+      expect { @response.first['foo'].will == 'foo' }
+    end
+    
+    context "for the view's data" do
+      before { @response = @doc.values_for :test, :all => true }
+      
+      expect { @response.will == %w(bar baz foo) }
+    end
+    
+    context "for the view's matching keys" do
+      before { @response = @doc.keys_for :test, :key => 'bar'..'baz' }
+      
+      expect { @response.will == %w(bar baz) }
+    end
+    
+    context "for the view's matching ids" do
+      before { @response = @doc.ids_for :test, :key => 'bar'..'foo'}
+      
+      expect { @response.will == %w(bar baz foo) }
+    end
+  end
+  
+end

data/test/document_class_definitions_test.rb

@@ -0,0 +1,267 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Foo < Exegesis::Document; end
+class Bar < Exegesis::Document; end
+
+class WithDefault < Exegesis::Document
+  default :foo => 'bar'
+end
+
+class Exposer < Exegesis::Document
+  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 Timestamper < Exegesis::Document
+  timestamps!
+end
+
+class UniqueSnowflake < Exegesis::Document
+  unique_id :set_id
+  def set_id
+    @unique_id_attempt.zero? ? "snowflake" : "snowflake-#{@unique_id_attempt}"
+  end
+end
+
+class ExegesisDocumentClassDefinitionsTest < Test::Unit::TestCase
+  
+  context "a bare Exegesis::Document" do
+    before do
+      reset_db
+      @obj = Foo.new
+      @obj.database = @db
+      @obj.save
+    end
+    
+    expect { @obj['.kind'].will == "Foo" }
+    expect { @obj['foo'].will == nil }
+    expect { @obj.will_not respond_to(:foo) }
+    expect { @obj['created_at'].will == nil }
+    expect { @obj['updated_at'].will == nil }
+  end
+  
+  context "instantiating" do
+    expect { Exegesis::Document.instantiate({'.kind' => 'Foo'}).will be_kind_of(Foo) }
+
+    context "transitions" do
+      before do
+        @foo = Foo.new
+        @foo['.kind'] = 'Bar'
+        @bar = Exegesis::Document.instantiate(@foo)
+      end
+      
+      expect { @bar.will be_kind_of(Bar) }
+    end
+  end
+  
+  context "default objects" do
+    expect { WithDefault.new['foo'].will == 'bar' }
+    expect { WithDefault.new({'foo' => 'baz'})['foo'].will == 'baz' }
+  end
+  
+  context "exposing keys" do
+    context "regular declarations" do
+      before do 
+        @obj = Exposer.new(:foo => 'bar', :bar => 'foo')
+        @writing = lambda { @obj.bar = "bee" }
+      end
+      expect { @obj.foo.will == 'bar' }
+      expect { @obj.bar.will == 'foo' }
+      expect { @writing.wont raise_error }
+      expect { @writing.call; @obj.bar.will == "bee" }
+    end
+    
+    context "with a custom writer" do
+      context "when false" do
+        before { @obj = Exposer.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 = Exposer.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 = Exposer.new({
+            :castee => {'foo' => 'foo', '.kind' => 'Foo'},
+            :castees => [{'foo' => 'foo', '.kind' => 'Foo'}, {'foo' => 'bar', '.kind' => 'Bar'}]
+          })
+        end
+        
+        expect { @obj.castee.class.will == Foo }
+        expect { @obj.castee['foo'].will == 'foo' }
+        
+        expect { @obj.castees.class.will == Array }
+        expect { @obj.castees[0].class.will == Foo }
+        expect { @obj.castees[0]['foo'].will == 'foo' }
+        expect { @obj.castees[1].class.will == Bar }
+        expect { @obj.castees[1]['foo'].will == 'bar' }
+      end
+      
+      context "when as time" do
+        before do
+          @obj = Exposer.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 = Exposer.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 = Exposer.new(:other_doc => "other_doc", :other_docs => ["other_docs_1", "other_docs_2"])
+            @obj.database = @db
+          end
+          context "when the document exists" do
+            before do
+              @db.bulk_save([
+                {'.kind' => 'Foo', '_id' => 'other_doc'},
+                {'.kind' => 'Foo', '_id' => 'other_docs_1'}, 
+                {'.kind' => 'Foo', '_id' => 'other_docs_2'}
+              ])
+            end
+            
+            expect { @obj.other_doc.rev.will == @db.get('other_doc')['_rev'] }
+            expect { @obj.other_doc.class.will == Foo }
+            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 == Foo }
+            expect { @obj.other_docs[1].rev.will == @db.get('other_docs_2')['_rev'] }
+            expect { @obj.other_docs[1].class.will == Foo }
+            
+            context "caching" do
+              before do
+                @obj.other_doc
+                doc = @db.get('other_doc')
+                doc['foo'] = "updated"
+                doc.save
+              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
+        end
+        
+        context "without a database present" do
+          before { @obj = Exposer.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 = Exposer.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
+  
+  context "with timestamps" do
+    before do
+      reset_db
+      @obj = Timestamper.new
+      @obj.database = @db
+      @obj.save
+      @obj = Timestamper.new(@db.get(@obj.id))
+    end
+    
+    context "initial save" do
+      expect { @obj.created_at.to_f.will be_close(Time.now.to_f, 1) }
+      expect { @obj.updated_at.to_f.will be_close(Time.now.to_f, 1) }
+    end
+    
+    context "when created_at already exists" do
+      before do
+        @obj.database = @db
+        @obj['created_at'] = Time.now
+        @obj.save
+        @obj = Timestamper.new(@db.get(@obj.id))
+      end
+      
+      expect { @obj.created_at.to_f.will be_close(Time.now.to_f, 1) }
+      expect { @obj.updated_at.to_f.will be_close(Time.now.to_f, 1) }
+    end
+    
+  end
+  
+  context "with a custom unique_id setter" do
+    before do
+      reset_db
+      @obj = UniqueSnowflake.new
+      @obj.database = @db
+    end
+    
+    context "when the id isn't in use yet" do
+      before do
+        @obj.save
+      end
+      
+      expect { @obj.id.will == "snowflake" }
+    end
+    
+    context "when there is an id in place already" do
+      before do
+        @obj['_id'] = 'foo'
+        @obj.save
+      end
+      
+      expect { @obj.id.will == "foo" }
+    end
+    
+    context "when the desired id is already in use" do
+      before do
+        @db.save_doc({'_id' => 'snowflake', 'foo' => 'bar'})
+        @obj.save
+      end
+      
+      expect { @obj.id.will == 'snowflake-1' }
+    end
+  end
+  
+end

data/test/document_instance_methods_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class DocInstance < Exegesis::Document
+  expose :foo
+end
+
+class ExegesisDocumentInstanceMethodsTest < Test::Unit::TestCase
+  
+  context "update_attributes" do
+    before do
+      reset_db
+    end
+    
+    context "an existing doc" do
+      before do
+        @doc = DocInstance.new({'foo' => 'bar'})
+        @doc.database = @db
+        @doc.save
+        @old_rev = @doc.rev
+      end
+      
+      context "without a matching rev" do
+        expect { lambda {@doc.update_attributes({'foo' => 'bee'})}.will raise_error(ArgumentError) }
+        expect { lambda {@doc.update_attributes({'foo' => 'bee', '_rev' => 'z'})}.will raise_error(ArgumentError) }
+      end
+      
+      context "with a matching rev" do
+        before do
+          @doc.update_attributes({'_rev' => @doc.rev, 'foo' => 'bee', 'bar' => 'boo'})
+        end
+        
+        expect { @doc['foo'].will == 'bee' }
+        expect { @doc['bar'].will be(nil) }
+        expect { @doc.rev.wont == @old_rev }
+      end
+    end
+    
+  end
+  
+end

data/test/exegesis_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class ExegesisTest < Test::Unit::TestCase
+  
+  context "designs directory" do
+    context "setting custom" do
+      before do
+        @custom_design_dir = File.join(File.dirname(__FILE__), 'fixtures', 'designs')
+        Exegesis.designs_directory = @custom_design_dir
+      end
+      
+      expect { Exegesis.designs_directory.to_s.will == @custom_design_dir }
+    end
+    
+    
+  end
+  
+  context "database template" do
+    before do
+      @template_string = "http://localhost:5984/appname-%s"
+      @account = "foo"
+      Exegesis.database_template = @template_string
+    end
+    
+    expect { Exegesis.database_for(@account).will == @template_string % @account }
+  end
+  
+end

data/test/fixtures/designs/foos.js

@@ -0,0 +1,12 @@
+{
+  views: {
+    by_bar: {
+      map: function(doc) {
+        emit(doc.bar, null)
+      },
+      reduce: function(keys, values, rereduce) {
+        return(sum(values))
+      }
+    },
+  }
+}

data/test/test_helper.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'test/unit'
+
+require 'context'   # with github: gem install jeremymcanally-context
+require 'matchy'    # best bet for now: clone from github and build yourself; when jeremy fixes matchy, jeremymcanally-matchy
+require 'zebra'     # until jeremy updates matchy, download and build yourself, after that, with github: gem install giraffesoft-zebra
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue
+  puts "no ruby-debug installed? REAlLY? ok, if that's how you roll..."
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'lib/exegesis'
+
+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)
+  end
+  
+  def teardown_db
+    @db.delete! rescue nil
+  end
+  
+  def db(name)
+    "http://localhost:5984/exegesis-test#{name.nil? ? '' : "-#{name}"}"
+  end
+  
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: mattly-exegesis
+version: !ruby/object:Gem::Version 
+  version: 0.0.6
+platform: ruby
+authors: 
+- Matt Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-01 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jchris-couchrest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.12.6
+    version: 
+description: TODO
+email: matt@flowerpowered.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/exegesis
+- lib/exegesis/design
+- lib/exegesis/design/design_docs.rb
+- lib/exegesis/design.rb
+- lib/exegesis/document.rb
+- lib/exegesis.rb
+- test/design_doc_test.rb
+- test/design_test.rb
+- test/document_class_definitions_test.rb
+- test/document_instance_methods_test.rb
+- test/exegesis_test.rb
+- test/fixtures
+- test/fixtures/designs
+- test/fixtures/designs/foos.js
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/mattly/exegesis
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: []
+