olfactory 0.2.0 → 0.2.1

data/lib/olfactory/template_definition.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 module Olfactory
   class TemplateDefinition
-    attr_accessor :t_items, :t_subtemplates, :t_sequences, :t_dictionaries, :t_macros, :t_presets, :t_before, :t_after
+    attr_accessor :t_items, :t_subtemplates, :t_sequences, :t_dictionaries, :t_macros, :t_presets, :t_befores, :t_afters, :t_instantiators
 
     def initialize
       self.t_items = {}
@@ -10,28 +10,29 @@ module Olfactory
       self.t_dictionaries = {}
       self.t_macros = {}
       self.t_presets = {}
-      self.t_before = {}
-      self.t_after = {}
+      self.t_befores = {}
+      self.t_afters = {}
+      self.t_instantiators = {}
     end
 
-    def build(block, options = {})
+    def construct(block, options = {})
       if options[:preset] || options[:quantity]
-        self.build_preset(options[:preset], (options[:quantity] || 1), options.reject { |k,v| [:preset, :quantity].include?(k) })
+        self.construct_preset(options[:preset], (options[:quantity] || 1), options.reject { |k,v| [:preset, :quantity].include?(k) })
       else
         new_template = Template.new(self, options)
-        new_template.build(block, options)
+        new_template.construct(block, options)
       end
       new_template
     end
-    def build_preset(preset_name, quantity, options = {})
+    def construct_preset(preset_name, quantity, options = {})
       raise "Quantity must be an integer!" if !(quantity.class <= Integer)
 
       if quantity > 1
         # Build multiple
         if preset_name
-          Array.new(quantity) { self.build_preset(preset_name, 1, options) }
+          Array.new(quantity) { self.construct_preset(preset_name, 1, options) }
         else
-          Array.new(quantity) { self.build(nil, options) }
+          Array.new(quantity) { self.construct(nil, options) }
         end
       elsif quantity == 1
         if preset_definition = self.find_preset_definition(preset_name)
@@ -39,12 +40,12 @@ module Olfactory
           new_template = Template.new(self, options)
           preset_block = preset_definition[:evaluator]
           if preset_definition[:regexp]
-            new_template.build(preset_block, options.merge(:value => preset_name))
+            new_template.construct(preset_block, options.merge(:value => preset_name))
           else
-            new_template.build(preset_block, options)
+            new_template.construct(preset_block, options)
           end
         elsif preset_name.nil?
-          self.build(nil, options)
+          self.construct(nil, options)
         else
           raise "Missing preset matching '#{preset_name}' for template!"
         end
@@ -157,17 +158,42 @@ module Olfactory
       self.t_presets[name] = self.t_presets[name].merge(:regexp => name) if name.class <= Regexp
     end
 
+    # Defines an instantiator
+    def instantiate(name, options = {}, &block)
+      self.t_instantiators[name] = {  :type => :instantiator,
+                                      :name => name,
+                                      :evaluator => block 
+                                    }.merge(options)
+    end
+
     # Defines defaults
-    def before(options = {}, &block)
-      self.t_before = { :type => :default,
-                        :evaluator => block
-                      }.merge(options)
-      self.t_before = self.t_before.merge(:preset => options[:preset]) if options[:preset]
-    end
-    def after(options = {}, &block)
-      self.t_after = {  :type => :default,
-                        :evaluator => block }.merge(options)
-      self.t_after = self.t_after.merge(:preset => options[:preset]) if options[:preset]
+    def before(context = nil, options = {}, &block)
+      if context.class == Hash
+        # Arguments need to be remapped...
+        options = context
+        context = nil
+      end
+      before_definition = { :type => :default,
+                            :evaluator => block
+                          }.merge(options)
+      before_definition.merge!(:preset => options[:preset]) if options[:preset]
+      context ||= :all
+      self.t_befores[context] ||= []
+      self.t_befores[context] << before_definition
+    end
+    def after(context = nil, options = {}, &block)
+      if context.class == Hash
+        # Arguments need to be remapped...
+        options = context
+        context = nil
+      end
+      after_definition = { :type => :default,
+                            :evaluator => block
+                          }.merge(options)
+      after_definition.merge!(:preset => options[:preset]) if options[:preset]
+      context ||= :all
+      self.t_afters[context] ||= []
+      self.t_afters[context] << after_definition
     end
   end
 end

data/lib/olfactory/version.rb

@@ -1,3 +1,3 @@
 module Olfactory
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/olfactory.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
   s.required_ruby_version = Gem::Requirement.new(">= 1.9.2")
 
-  s.add_development_dependency("rspec", "~> 3.1")
+  s.add_development_dependency("rspec", "~> 3.2")
   s.add_development_dependency("pry", "~> 0.10")
   s.add_development_dependency("pry-nav", "~> 0.2")
   s.add_development_dependency("pry-stack_explorer", "~> 0.4.9")

data/spec/olfactory/sequence_spec.rb

@@ -4,7 +4,7 @@ describe Olfactory::Sequence do
   context "with no seed" do
     before(:example) do
       Olfactory.sequence :address do |n, options|
-        "#{(n + (n % 2)) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+        "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
       end
     end
     context "given nothing" do
@@ -22,7 +22,7 @@ describe Olfactory::Sequence do
     context "given a block" do
       subject do
         Olfactory.generate(:address) do |n|
-          "#{(n + (n % 2)) + 2} JOHN STREET"
+          "#{(2*n) + 2} JOHN STREET"
         end
       end
       it { expect(subject).to eq("2 JOHN STREET") }
@@ -30,7 +30,7 @@ describe Olfactory::Sequence do
     context "given options and a block" do
       subject do
         Olfactory.generate(:address, :suffix => "ROAD") do |n, options|
-          "#{(n + (n % 2)) + 2} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
+          "#{(2*n) + 2} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
         end
       end
       it { expect(subject).to eq("2 JOHN ROAD") }
@@ -39,42 +39,54 @@ describe Olfactory::Sequence do
   context "with a seed" do
     before(:example) do
       Olfactory.sequence :address, :seed => 10 do |n, options|
-        "#{(n + (n % 2))} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+        "#{(2*n)} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
       end
     end
     context "given nothing" do
       subject do
         Olfactory.generate(:address)
       end
-      it { expect(subject).to eq("10 BROADWAY") }
+      it { expect(subject).to eq("20 BROADWAY") }
     end
     context "given options" do
       subject do
         Olfactory.generate(:address, :prefix => "WEST")
       end
-      it { expect(subject).to eq("10 WEST BROADWAY") }
+      it { expect(subject).to eq("20 WEST BROADWAY") }
     end
     context "given a block" do
       subject do
         Olfactory.generate(:address) do |n|
-          "#{(n + (n % 2))} JOHN STREET"
+          "#{(2*n)} JOHN STREET"
         end
       end
-      it { expect(subject).to eq("10 JOHN STREET") }
+      it { expect(subject).to eq("20 JOHN STREET") }
     end
     context "given options and a block" do
       subject do
         Olfactory.generate(:address, :suffix => "ROAD") do |n, options|
-          "#{(n + (n % 2))} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
+          "#{(2*n)} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
         end
       end
-      it { expect(subject).to eq("10 JOHN ROAD") }
+      it { expect(subject).to eq("20 JOHN ROAD") }
     end
   end
+  context "given a dimension" do
+    before(:context) do
+      Olfactory.sequence :address do |n|
+        "#{(2*n)+2} BROADWAY"
+      end
+    end
+    let(:address_one) { Olfactory.generate(:address) }
+    let(:address_two) { Olfactory.generate(:address, :dimension => "LAS VEGAS") }
+    it { expect(address_one).to eq("2 BROADWAY") }
+    it { expect(address_two).to eq("2 BROADWAY") }
+    it { expect(address_one).to eq("4 BROADWAY") }
+  end
   context "given sequential invocations" do
     before(:context) do
       Olfactory.sequence :address do |n, options|
-        "#{(n + (n % 2)) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+        "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
       end
     end
     it { expect(Olfactory.generate(:address)).to eq("2 BROADWAY") }

data/spec/olfactory/template_spec.rb

@@ -395,6 +395,37 @@ describe Olfactory::Template do
         end
       end
     end
+    # context "with a before block" do
+    #   before do
+    #     Olfactory.template :widget do |t|
+    #       t.embeds_one :doodad do |w|
+    #         w.quality :dull
+    #       end
+    #       t.macro :quality do |m, type|
+    #         m.transient :attribute, type.to_s
+    #       end
+    #     end
+    #     Olfactory.template :doodad do |t|
+    #       t.has_one :gizmo
+    #       t.after do |d|
+    #         d.gizmo "#{d.transients[:attribute]} #{value}"
+    #       end
+    #     end
+    #   end
+    #   let(:shiny) do
+    #     Olfactory.build :widget do |w|
+    #       w.quality :shiny
+    #       w.doodad
+    #     end
+    #   end
+    #   let(:dull) do
+    #     Olfactory.build :widget do |w|
+    #       w.doodad
+    #     end
+    #   end
+    #   it { expect(shiny[:doodad][:gizmo]).to eq("shiny #{value}")}
+    #   it { expect(dull[:doodad][:gizmo]).to eq("dull #{value}")}
+    # end
   end
   context "embeds_many" do
     before(:context) do
@@ -744,7 +775,7 @@ describe Olfactory::Template do
             Olfactory.template :building do |t|
               t.has_one :address
               t.sequence :address, :scope => :template do |n, options|
-                "#{(n + (n % 2)) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+                "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
               end
             end
           end
@@ -769,7 +800,7 @@ describe Olfactory::Template do
               Olfactory.build :building do |building|
                 building.address do
                   building.generate(:address) do |n|
-                    "#{(n + (n % 2)) + 2} JOHN STREET"
+                    "#{(2*n) + 2} JOHN STREET"
                   end
                 end
               end
@@ -781,20 +812,40 @@ describe Olfactory::Template do
               Olfactory.build :building do |building|
                 building.address do
                   building.generate(:address, :suffix => "ROAD") do |n, options|
-                    "#{(n + (n % 2)) + 2} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
+                    "#{(2*n) + 2} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
                   end
                 end
               end
             end
             it { expect(subject[:address]).to eq("2 JOHN ROAD") }
           end
+          context "given a dimension" do
+            let!(:building_one) do
+              Olfactory.build :building do |building|
+                building.address building.generate(:address)
+              end
+            end
+            let!(:building_two) do
+              Olfactory.build :building do |building|
+                building.address building.generate(:address, :dimension => "LAS VEGAS")
+              end
+            end
+            let!(:building_three) do
+              Olfactory.build :building do |building|
+                building.address building.generate(:address)
+              end
+            end
+            it { expect(building_one[:address]).to eq("2 BROADWAY") }
+            it { expect(building_two[:address]).to eq("2 BROADWAY") }
+            it { expect(building_three[:address]).to eq("4 BROADWAY") }
+          end
         end
         context "given sequential invocations" do
           before(:context) do
             Olfactory.template :building do |t|
               t.has_one :address
               t.sequence :address, :scope => :template do |n, options|
-                "#{(n + (n % 2)) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+                "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
               end
             end
           end
@@ -818,7 +869,7 @@ describe Olfactory::Template do
             Olfactory.template :building do |t|
               t.has_one :address
               t.sequence :address, :scope => :instance do |n, options|
-                "#{(n + (n % 2)) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+                "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
               end
             end
           end
@@ -843,7 +894,7 @@ describe Olfactory::Template do
               Olfactory.build :building do |building|
                 building.address do
                   building.generate(:address) do |n|
-                    "#{(n + (n % 2)) + 2} JOHN STREET"
+                    "#{(2*n) + 2} JOHN STREET"
                   end
                 end
               end
@@ -855,13 +906,45 @@ describe Olfactory::Template do
               Olfactory.build :building do |building|
                 building.address do
                   building.generate(:address, :suffix => "ROAD") do |n, options|
-                    "#{(n + (n % 2)) + 2} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
+                    "#{(2*n) + 2} JOHN#{options[:suffix] ? " #{options[:suffix]}" : " STREET"}"
                   end
                 end
               end
             end
             it { expect(subject[:address]).to eq("2 JOHN ROAD") }
           end
+          context "given a dimension" do
+            before(:example) do
+              Olfactory.template :building do |t|
+                t.has_one :address
+                t.has_one :other_address
+                t.has_one :another_address
+                t.sequence :address, :scope => :instance do |n, options|
+                  "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+                end
+              end
+            end
+            let!(:building_one) do
+              Olfactory.build :building do |building|
+                building.address building.generate(:address)
+                building.other_address building.generate(:address, :dimension => "LAS VEGAS")
+                building.another_address building.generate(:address)
+              end
+            end
+            let!(:building_two) do
+              Olfactory.build :building do |building|
+                building.address building.generate(:address)
+                building.other_address building.generate(:address, :dimension => "LAS VEGAS")
+                building.another_address building.generate(:address)
+              end
+            end
+            it { expect(building_one[:address]).to eq("2 BROADWAY") }
+            it { expect(building_one[:other_address]).to eq("2 BROADWAY") }
+            it { expect(building_one[:another_address]).to eq("4 BROADWAY") }
+            it { expect(building_two[:address]).to eq("2 BROADWAY") }
+            it { expect(building_two[:other_address]).to eq("2 BROADWAY") }
+            it { expect(building_two[:another_address]).to eq("4 BROADWAY") }
+          end
         end
         context "given sequential invocations" do
           before(:context) do
@@ -869,7 +952,7 @@ describe Olfactory::Template do
               t.has_one :address
               t.has_one :other_address
               t.sequence :address, :scope => :instance do |n, options|
-                "#{(n + (n % 2)) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
+                "#{(2*n) + 2} #{"#{options[:prefix]} " if options[:prefix]}BROADWAY"
               end
             end
           end
@@ -898,10 +981,10 @@ describe Olfactory::Template do
           t.has_one :even_count
           t.has_one :odd_count
           t.sequence :even, :scope => :template do |n|
-            (n + (n % 2)) + 2
+            (2*n) + 2
           end
           t.sequence :odd, :scope => :template do |n|
-            (n + (n % 2)) + 1
+            (2*n) + 1
           end
         end
       end
@@ -1185,13 +1268,27 @@ describe Olfactory::Template do
     end
     let(:value) { "temporary value"}
     context "when set" do
-      subject do
-        Olfactory.build :widget do |t|
-          t.transient :foo, value
+      context "given a basic value" do
+        subject do
+          Olfactory.build :widget do |t|
+            t.transient :foo, value
+          end
+        end
+        it do
+          expect(subject.transients[:foo]).to eq(value)
         end
       end
-      it do
-        expect(subject.transients[:foo]).to eq(value)
+      context "given a block" do
+        subject do
+          Olfactory.build :widget do |t|
+            t.transient :foo do
+              value
+            end
+          end
+        end
+        it do
+          expect(subject.transients[:foo]).to eq(value)
+        end
       end
     end
     context "when read" do
@@ -1228,50 +1325,322 @@ describe Olfactory::Template do
   context "defaults" do
     let(:value) { "doodad" }
     let(:default_value) { "default doodad" }
+    let(:default_after_value) { "default after doodad" }
     context "before" do
-      before(:context) do
-        Olfactory.template :widget do |t|
-          t.has_one :doodad
-          t.has_one :other_doodad
-          t.before do |d|
-            d.doodad default_value
-            d.other_doodad default_value
+      context "all" do
+        before(:context) do
+          Olfactory.template :widget do |t|
+            t.has_one :doodad
+            t.has_one :other_doodad
+            t.before do |d|
+              d.doodad default_value
+              d.other_doodad default_value
+            end
           end
         end
+        subject do
+          Olfactory.build :widget do |t|
+            t.doodad value
+          end
+        end
+        it "values can be overriden" do
+          expect(subject[:doodad]).to eq(value)
+        end
+        it "values can be set"do
+          expect(subject[:other_doodad]).to eq(default_value)
+        end
       end
-      subject do
-        Olfactory.build :widget do |t|
-          t.doodad value
+      context "embedded" do
+        before(:context) do
+          Olfactory.template :widget do |t|
+            t.embeds_one :doodad
+            t.macro :quality do |m, type|
+              m.transient :attribute, type.to_s
+            end
+            t.before(:embedded) do |d|
+              d.quality :dull
+            end
+            t.before do |d|
+              d.quality :scratched
+            end
+          end
+          Olfactory.template :doodad do |t|
+            t.has_one :gizmo
+            t.after do |d|
+              d.gizmo "#{d.transients[:attribute]} #{value}"
+            end
+          end
+        end
+        let(:shiny) do
+          Olfactory.build :widget do |w|
+            w.quality :shiny
+            w.doodad
+          end
+        end
+        let(:dull) do
+          Olfactory.build :widget do |w|
+            w.doodad
+          end
+        end
+        it { expect(shiny[:doodad][:gizmo]).to eq("shiny #{value}")}
+        it { expect(dull[:doodad][:gizmo]).to eq("dull #{value}")}
+        context "(run once)" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.embeds_many :doodads, :singular => :doodad
+              t.has_one :thingamabob
+              t.macro :quality do |m, type|
+                m.transient :attribute, type.to_s
+              end
+              t.before(:embedded, :run => :once) do |d|
+                d.quality :dull
+                d.thingamabob "thingamabob" if d[:doodads] && d[:doodads].count > 0
+              end
+            end
+            Olfactory.template :doodad do |t|
+              t.has_one :gizmo
+              t.after do |d|
+                d.gizmo "#{d.transients[:attribute]} #{value}"
+              end
+            end
+          end
+          subject do
+            Olfactory.build :widget do |w|
+              w.doodad
+              w.quality :shiny
+              w.doodad
+            end
+          end
+          it do
+            expect(subject[:doodads]).to eq([{ :gizmo => "dull #{value}" }, { :gizmo => "shiny #{value}" }])
+            expect(subject[:thingamabob]).to be_nil
+          end
         end
       end
-      it "values can be overriden" do
-        expect(subject[:doodad]).to eq(value)
+    end
+    context "after" do
+      context "values" do
+        context "given a has_one" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.has_one :doodad
+              t.has_one :other_doodad
+              t.after do |d|
+                d.doodad default_value
+                d.other_doodad default_value
+              end
+            end
+          end
+          subject do
+            Olfactory.build :widget do |t|
+              t.doodad value
+            end
+          end
+          it "will not override existing ones" do
+            expect(subject[:doodad]).to eq(value)
+          end
+          it "will fill in missing ones"do
+            expect(subject[:other_doodad]).to eq(default_value)
+          end
+        end
+        context "given a has_many" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.has_many :doodads, :singular => :doodad
+              t.has_many :other_doodads, :singular => :other_doodad
+              t.after do |d|
+                d.doodad default_value
+                d.doodads default_value
+                d.other_doodad default_value
+                d.other_doodads default_value, default_value
+              end
+            end
+          end
+          subject do
+            Olfactory.build :widget do |t|
+              t.doodad value
+            end
+          end
+          it "will not override existing ones" do
+            expect(subject[:doodads]).to eq([value])
+          end
+          it "will fill in missing ones"do
+            expect(subject[:other_doodads]).to eq([default_value, default_value, default_value])
+          end
+        end
+        context "given a embeds_one" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.embeds_one :doodad
+              t.embeds_one :other_doodad
+              t.after do |d|
+                d.doodad { |doodad| doodad.gizmo default_value }
+                d.other_doodad { |doodad| doodad.gizmo default_value }
+              end
+            end
+            Olfactory.template :doodad do |t|
+              t.has_one :gizmo
+            end
+            Olfactory.template :other_doodad do |t|
+              t.has_one :gizmo
+            end
+          end
+          subject do
+            Olfactory.build :widget do |t|
+              t.doodad { |doodad| doodad.gizmo value }
+            end
+          end
+          it "will not override existing ones" do
+            expect(subject[:doodad]).to eq({ :gizmo => value })
+          end
+          it "will fill in missing ones" do
+            expect(subject[:other_doodad]).to eq({ :gizmo => default_value })
+          end
+        end
+        context "given a embeds_many" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.embeds_many :doodads, :singular => :doodad
+              t.embeds_many :other_doodads, :singular => :other_doodad
+              t.after do |d|
+                d.doodad { |doodad| doodad.gizmo default_value }
+                d.doodads 2 do |doodad| doodad.gizmo default_value end
+                d.other_doodad { |doodad| doodad.gizmo default_value }
+                d.other_doodads 2 do |doodad| doodad.gizmo default_value end
+              end
+            end
+            Olfactory.template :doodad do |t|
+              t.has_one :gizmo
+            end
+            Olfactory.template :other_doodad do |t|
+              t.has_one :gizmo
+            end
+          end
+          subject do
+            Olfactory.build :widget do |t|
+              t.doodad { |doodad| doodad.gizmo value }
+            end
+          end
+          it "will not override existing ones" do
+            expect(subject[:doodads]).to eq([{ :gizmo => value }])
+          end
+          it "will fill in missing ones"do
+            expect(subject[:other_doodads]).to eq([{ :gizmo => default_value }, { :gizmo => default_value }, { :gizmo => default_value }])
+          end
+        end
+      end
+    end
+    context "both before and after" do
+      context "given no value" do
+        before(:context) do
+          Olfactory.template :widget do |t|
+            t.has_one :doodad
+            t.before do |d|
+              d.doodad default_value
+            end
+            t.after do |d|
+              d.doodad default_after_value
+            end
+          end
+        end
+        subject do
+          Olfactory.build :widget
+        end
+        it "will override with a default the second time" do
+          expect(subject[:doodad]).to eq(default_after_value)
+        end
       end
-      it "values can be set"do
-        expect(subject[:other_doodad]).to eq(default_value)
+      context "given a value" do
+        before(:context) do
+          Olfactory.template :widget do |t|
+            t.has_one :doodad
+            t.before do |d|
+              d.doodad default_value
+            end
+            t.after do |d|
+              d.doodad default_value
+            end
+          end
+        end
+        subject do
+          Olfactory.build :widget do |t|
+            t.doodad value
+          end
+        end
+        it "will not set override with a default the second time" do
+          expect(subject[:doodad]).to eq(value)
+        end
       end
     end
-    context "after" do
+  end
+  context "instantiators" do
+    context "given a symbol and block" do
       before(:context) do
         Olfactory.template :widget do |t|
           t.has_one :doodad
-          t.has_one :other_doodad
-          t.after do |d|
-            d.doodad default_value
-            d.other_doodad default_value
+          t.instantiate :doodad do |i|
+            SaveableString.new("#{i[:doodad]}-instance")
           end
         end
       end
-      subject do
-        Olfactory.build :widget do |t|
-          t.doodad value
+      let(:value) { "doodad" }
+      let(:template) { Olfactory.build :widget do |w| w.doodad "doodad" end }
+
+      context "invoked with #build" do
+        subject do
+          template.build(:doodad)
+        end
+        it do
+          expect(subject).to eq("#{value}-instance")
+          expect(subject.saved?).to be false
         end
       end
-      it "values will not override existing ones" do
-        expect(subject[:doodad]).to eq(value)
-      end
-      it "values will fill in missing ones"do
-        expect(subject[:other_doodad]).to eq(default_value)
+      context "invoked with #create" do
+        subject do
+          template.create(:doodad)
+        end
+        context "that returns a saveable object" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.has_one :doodad
+              t.instantiate :doodad do |i|
+                SaveableString.new("#{i[:doodad]}-instance")
+              end
+            end
+          end
+          it do
+            expect(subject).to eq("#{value}-instance")
+            expect(subject.saved?).to be true
+          end
+        end
+        context "that returns an array of saveable objects" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.has_one :doodad
+              t.instantiate :doodad do |i|
+                [SaveableString.new("#{i[:doodad]}-instance-1"), SaveableString.new("#{i[:doodad]}-instance-2")]
+              end
+            end
+          end
+          it do
+            expect(subject).to eq(["#{value}-instance-1", "#{value}-instance-2"])
+            expect(subject.all? { |d| d.saved? }).to be true
+          end
+        end
+        context "that returns a hash of saveable objects" do
+          before(:context) do
+            Olfactory.template :widget do |t|
+              t.has_one :doodad
+              t.instantiate :doodad do |i|
+                { 1 => SaveableString.new("#{i[:doodad]}-instance"), 2 => SaveableString.new("#{i[:doodad]}-instance") }
+              end
+            end
+          end
+          it do
+            expect(subject).to eq({ 1 => "#{value}-instance", 2 => "#{value}-instance" })
+            expect(subject.values.all? { |d| d.saved? }).to be true
+          end
+        end
       end
     end
   end