om 3.1.1 → 3.2.0

data/om.gemspec

@@ -15,15 +15,18 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version     = '>= 1.9.3'
 
+  s.add_dependency 'activemodel', '>= 5.1', '< 7'
   s.add_dependency 'activesupport'
-  s.add_dependency 'activemodel'
-  s.add_dependency 'solrizer', '~> 3.3'
   s.add_dependency('nokogiri', ">= 1.4.2")
-  s.add_development_dependency "rspec", "~> 2.0"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "yard"
+  s.add_dependency 'solrizer', '~> 3.3'
   s.add_development_dependency "awesome_print"
+  s.add_development_dependency 'coveralls'
   s.add_development_dependency "equivalent-xml", ">= 0.2.4"
+  s.add_development_dependency "pry-byebug"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 3.8"
+  s.add_development_dependency "rspec_junit_formatter"
+  s.add_development_dependency "yard"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/integration/set_reentrant_terminology_spec.rb

@@ -1,106 +1,127 @@
 require 'spec_helper'
 
 describe "calling set_terminology more than once" do
+  context 'with a Class exposing the #foo accessor' do
+    before(:all) do
+      class ReentrantTerminology
+        include OM::XML::Document
 
-  before(:all) do
-    class ReentrantTerminology
-      include OM::XML::Document
-
-      set_terminology do |t|
-        t.root :path => 'root', :xmlns => "asdf"
-        t.foo
+        set_terminology do |t|
+          t.root :path => 'root', :xmlns => "asdf"
+          t.foo
+        end
       end
     end
-  end
 
-  describe "before" do
-
-    subject do
-      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
-      ReentrantTerminology.from_xml(xml)
+    after(:all) do
+      Object.send(:remove_const, :ReentrantTerminology)
     end
 
-    it "can get foo" do
-      expect(subject.foo).to eq ['fooval']
-    end
+    describe "before" do
+      subject do
+        xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+        ReentrantTerminology.from_xml(xml)
+      end
 
-    it "cannot get bar" do
-      expect { subject.bar }.to raise_error NoMethodError
-    end
+      it "can get foo" do
+        expect(subject.foo).to eq ['fooval']
+      end
 
+      it "cannot get bar" do
+        expect { subject.bar }.to raise_error NoMethodError
+      end
+    end
   end
 
   describe "after" do
-
-    before(:all) do
-      class ReentrantTerminology
-        set_terminology do |t|
-          t.root :path => 'root', :xmlns => "asdf"
-          t.bar
+    context 'with a Class exposing the #bar accessor' do
+      before(:all) do
+        class ReentrantTerminology
+          include OM::XML::Document
+          set_terminology do |t|
+            t.root :path => 'root', :xmlns => "asdf"
+            t.bar
+          end
         end
       end
-    end
 
-    subject do
-      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
-      ReentrantTerminology.from_xml(xml)
-    end
+      after(:all) do
+        Object.send(:remove_const, :ReentrantTerminology)
+      end
 
-    it "cannot get foo" do
-      expect { subject.foo }.to raise_error NoMethodError
-    end
+      subject do
+        xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+        ReentrantTerminology.from_xml(xml)
+      end
 
-    it "can now get bar" do
-      expect(subject.bar).to eq ['barval']
-    end
+      it "cannot get foo" do
+        expect { subject.foo }.to raise_error NoMethodError
+      end
 
+      it "can now get bar" do
+        expect(subject.bar).to eq ['barval']
+      end
+    end
   end
 
   describe "re-entrant modification" do
-
-
-    before(:all) do
-      class ReentrantTerminology
-        set_terminology do |t|
-          t.root :path => 'root', :xmlns => "asdf"
-          t.foo
+    let(:xml) { '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>' }
+
+    context 'with a Class exposing the #foo accessor' do
+      subject(:terminology) { FooReentrantTerminology.from_xml(xml) }
+
+      before(:all) do
+        class FooReentrantTerminology
+          include OM::XML::Document
+          set_terminology do |t|
+            t.root :path => 'root', :xmlns => "asdf"
+            t.foo
+          end
         end
       end
 
-      class ReentrantTerminology
-        extend_terminology do |t|
-          t.bar
-        end
+      after(:all) do
+        Object.send(:remove_const, :FooReentrantTerminology)
       end
-    end
-
-    subject do
-      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
-      ReentrantTerminology.from_xml(xml)
-    end
 
-    it "can get foo" do
-      expect(subject.foo).to eq ['fooval']
-    end
+      it "can get foo" do
+        expect(terminology.foo).to eq ['fooval']
+      end
 
-    it "can get bar" do
-      expect(subject.bar).to eq ['barval']
-    end
+      context 'with a Class exposing the #bar accessor' do
+        subject(:terminology) { BarReentrantTerminology.from_xml(xml) }
 
-  end
+        before do
+          class BarReentrantTerminology < FooReentrantTerminology
+            include OM::XML::Document
+            extend_terminology do |t|
+              t.bar
+            end
+          end
+        end
 
-  describe "subclass modification" do
+        after(:all) do
+          Object.send(:remove_const, :BarReentrantTerminology)
+        end
 
+        it "can get bar" do
+          expect(terminology.bar).to eq ['barval']
+        end
+      end
+    end
+  end
 
+  context 'with Classes exposing the #foo and #bar accessors' do
     before(:all) do
       class ReentrantTerminology
+        include OM::XML::Document
         set_terminology do |t|
           t.root :path => 'root', :xmlns => "asdf"
           t.foo
         end
       end
 
-      class LocalReentrantTerminology 
+      class LocalReentrantTerminology
         include OM::XML::Document
         use_terminology(ReentrantTerminology)
         extend_terminology do |t|
@@ -109,26 +130,32 @@ describe "calling set_terminology more than once" do
       end
     end
 
-    subject do
-      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
-      LocalReentrantTerminology.from_xml(xml)
+    after(:all) do
+      Object.send(:remove_const, :ReentrantTerminology)
+      Object.send(:remove_const, :LocalReentrantTerminology)
     end
 
-    it "shouldn't bleed up the inheritence stack" do
-      xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
-      t = ReentrantTerminology.from_xml(xml)
+    describe "subclass modification" do
 
-      expect { t.bar }.to raise_error NoMethodError
-    end
+      subject do
+        xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+        LocalReentrantTerminology.from_xml(xml)
+      end
 
-    it "can get foo" do
-      expect(subject.foo).to eq ['fooval']
-    end
+      it "shouldn't bleed up the inheritence stack" do
+        xml = '<root xmlns="asdf"><foo>fooval</foo><bar>barval</bar></root>'
+        t = ReentrantTerminology.from_xml(xml)
 
-    it "can get bar" do
-      expect(subject.bar).to eq ['barval']
-    end
+        expect { t.bar }.to raise_error NoMethodError
+      end
 
-  end
+      it "can get foo" do
+        expect(subject.foo).to eq ['fooval']
+      end
 
+      it "can get bar" do
+        expect(subject.bar).to eq ['barval']
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,20 +1,37 @@
-if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/
-  require 'simplecov'
-  require 'simplecov-rcov'
-
-  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
-  SimpleCov.start
-end
-
+require 'equivalent-xml/rspec_matchers'
+require 'logger'
 require 'om'
+require 'pry-byebug'
 require 'rspec'
-require 'equivalent-xml/rspec_matchers'
 require 'samples'
-require 'logger'
+
+def coverage_needed?
+  ENV['COVERAGE'] || ENV['TRAVIS']
+end
+
+if coverage_needed?
+  require 'simplecov'
+  require 'coveralls'
+  SimpleCov.root(File.expand_path('../..', __FILE__))
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+    [
+      SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter
+    ]
+  )
+  SimpleCov.start('rails') do
+    add_filter '/devel'
+    add_filter '/lib/om/version.rb'
+    add_filter '/lib/tasks'
+    add_filter '/spec'
+  end
+end
 
 OM.logger = Logger.new(STDERR)
 
 RSpec.configure do |config|
+  config.full_backtrace = true if ENV['TRAVIS']
+  #config.fixture_path = File.expand_path("../fixtures", __FILE__)
 end
 
 def fixture(file)

data/spec/unit/nokogiri_sanity_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
 describe "OM::XML::TermValueOperators" do
-  
+
   describe "find_by_terms" do
     before(:each) do
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
     end
-  
+
     it "should do" do
       expect(@article.find_by_terms({:journal=>0}).length).to eq 1
     end
   end
-  
+
   describe "update_values" do
     before(:each) do
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
     end
-  
+
     it "should respond with a hash of updated values and their indexes" do
-      test_args = {[{"person"=>"0"},"description"]=>["mork", "york"]}      
+      test_args = {[{"person"=>"0"},"description"]=>["mork", "york"]}
       result = @article.update_values(test_args)
       expect(result).to eq({"person_0_description"=>["mork", "york"]})
     end
-    
+
     it "should update the xml in the specified datastream and know that changes have been made" do
       expect(@article.term_values({:person=>0}, :first_name)).to eq ["GIVEN NAMES"]
       test_args = {[{:person=>0}, :first_name]=>"Replacement FirstName"}
@@ -30,39 +30,39 @@ describe "OM::XML::TermValueOperators" do
       expect(@article.term_values({:person=>0}, :first_name)).to eq ["Replacement FirstName"]
       expect(@article).to be_changed
     end
-    
+
     it "should update the xml according to the find_by_terms_and_values in the given hash" do
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       result = @article.update_values(terms_attributes)
       expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
-      
+
       # Trying again with a more complex update hash
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
       result = @article.update_values(terms_attributes)
       expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"], "person_1_last_name"=>["Andronicus"],"person_1_first_name"=>["Titus"], "person_1_role"=>["otherrole1","otherrole2"]})
       expect(@article).to be_changed
     end
-    
+
     it "should work when you re-run the command" do
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       result = @article.update_values(terms_attributes)
 
       expect(@article.term_values( {":person"=>"0"}, "affiliation" )).to eq ["affiliation1", "affiliation2", "affiliation3"]
       expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
-      
+
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
       result = @article.update_values(terms_attributes)
       expect(@article.term_values( {":person"=>"0"}, "affiliation" )).to eq ["affiliation1", "affiliation2", "affiliation3"]
       expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
       result = @article.update_values(terms_attributes)
-      
+
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"]}
       @article = OM::Samples::ModsArticle.from_xml( fixture( File.join("mods_articles","hydrangea_article1.xml") ) )
       result = @article.update_values(terms_attributes)
       expect(@article.term_values( {":person"=>"0"}, "affiliation" )).to eq ["affiliation1", "affiliation2", "affiliation3"]
       expect(result).to eq({"person_0_affiliation"=>["affiliation1", "affiliation2", "affiliation3"]})
-      
+
       # Trying again with a more complex update hash
       terms_attributes = {[{":person"=>"0"}, "affiliation"]=>["affiliation1", "affiliation2", "affiliation3"], [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
       result = @article.update_values(terms_attributes)

data/spec/unit/template_registry_spec.rb

@@ -1,10 +1,20 @@
 require 'spec_helper'
 
 describe "OM::XML::TemplateRegistry" do
+  let(:xml) { '<people xmlns="urn:registry-test"><person title="Actor">Alice</person></people>' }
+  let(:test_document) { RegistryTest.from_xml(xml) }
+  let(:expect_before) do
+     %{<people xmlns="urn:registry-test"><person title="Builder">Bob</person><person title="Actor">Alice</person></people>}
+  end
+  let(:expect_after) do
+    %{<people xmlns="urn:registry-test"><person title="Actor">Alice</person><person title="Builder">Bob</person></people>}
+  end
+  let(:expect_instead) do
+    %{<people xmlns="urn:registry-test"><person title="Builder">Bob</person></people>}
+  end
 
-  before(:all) do
+  before do
     class RegistryTest
-
       include OM::XML::Document
 
       set_terminology do |t|
@@ -19,23 +29,13 @@ describe "OM::XML::TemplateRegistry" do
           xml.text(name)
         end
       end
-
     end
   end
-  
-  after(:all) do
+
+  after do
     Object.send(:remove_const, :RegistryTest)
   end
 
-  before(:each) do
-    @test_document = RegistryTest.from_xml('<people xmlns="urn:registry-test"><person title="Actor">Alice</person></people>')
-    @expectations = {
-      :before  => %{<people xmlns="urn:registry-test"><person title="Builder">Bob</person><person title="Actor">Alice</person></people>},
-      :after   => %{<people xmlns="urn:registry-test"><person title="Actor">Alice</person><person title="Builder">Bob</person></people>},
-      :instead => %{<people xmlns="urn:registry-test"><person title="Builder">Bob</person></people>}
-    }
-  end
-  
   describe "template definitions" do
     it "should contain predefined templates" do
       expect(RegistryTest.template_registry.node_types).to include(:person)
@@ -52,176 +52,186 @@ describe "OM::XML::TemplateRegistry" do
       expect(RegistryTest.template_registry.node_types).to include(:zombie)
     end
 
-    it "should instantiate a detached node from a template" do
-      node = RegistryTest.template_registry.instantiate(:zombie, 'Zeke')
-      expectation = Nokogiri::XML('<monster wants="braaaaainz">Zeke</monster>').root
-      expect(node).to be_equivalent_to(expectation)
+    context 'when a zombie template has been defined' do
+      before do
+        RegistryTest.define_template :zombie do |xml,name|
+          xml.monster(:wants => 'braaaaainz') do
+            xml.text(name)
+          end
+        end
+      end
+
+      it "should instantiate a detached node from a template" do
+        node = RegistryTest.template_registry.instantiate(:zombie, 'Zeke')
+        expectation = Nokogiri::XML('<monster wants="braaaaainz">Zeke</monster>').root
+        expect(node).to be_equivalent_to(expectation)
+      end
+
+      it "should undefine existing templates" do
+        expect(RegistryTest.template_registry.node_types).to include(:zombie)
+        RegistryTest.template_registry.undefine :zombie
+        expect(RegistryTest.template_registry.node_types).not_to include(:zombie)
+      end
     end
-    
+
     it "should raise an error when trying to instantiate an unknown node_type" do
       expect { RegistryTest.template_registry.instantiate(:demigod, 'Hercules') }.to raise_error(NameError)
     end
-    
+
     it "should raise an exception if a missing method name doesn't match a node_type" do
       expect { RegistryTest.template_registry.demigod('Hercules') }.to raise_error(NameError)
     end
-    
-    it "should undefine existing templates" do
-      expect(RegistryTest.template_registry.node_types).to include(:zombie)
-      RegistryTest.template_registry.undefine :zombie
-      expect(RegistryTest.template_registry.node_types).not_to include(:zombie)
-    end
-    
+
     it "should complain if the template name isn't a symbol" do
       expect(lambda { RegistryTest.template_registry.define("die!") { |xml| xml.this_never_happened } }).to raise_error(TypeError)
     end
-    
+
     it "should report on whether a given template is defined" do
       expect(RegistryTest.template_registry.has_node_type?(:person)).to eq true
       expect(RegistryTest.template_registry.has_node_type?(:zombie)).to eq false
     end
-    
+
     it "should include defined node_types as method names for introspection" do
       expect(RegistryTest.template_registry.methods).to include('person')
     end
   end
-  
+
   describe "template-based document manipulations" do
     it "should accept a Nokogiri::XML::Node as target" do
-      @test_document.template_registry.after(@test_document.ng_xml.root.elements.first, :person, 'Bob', 'Builder')
-      expect(@test_document.ng_xml.root.elements.length).to eq 2
+      test_document.template_registry.after(test_document.ng_xml.root.elements.first, :person, 'Bob', 'Builder')
+      expect(test_document.ng_xml.root.elements.length).to eq 2
     end
 
     it "should accept a Nokogiri::XML::NodeSet as target" do
-      @test_document.template_registry.after(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      expect(@test_document.ng_xml.root.elements.length).to eq 2
+      test_document.template_registry.after(test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
+      expect(test_document.ng_xml.root.elements.length).to eq 2
     end
-    
+
     it "should instantiate a detached node from a template using the template name as a method" do
       node = RegistryTest.template_registry.person('Odin', 'All-Father')
       expectation = Nokogiri::XML('<person title="All-Father">Odin</person>').root
       expect(node).to be_equivalent_to(expectation)
     end
-    
+
     it "should add_child" do
-      return_value = @test_document.template_registry.add_child(@test_document.ng_xml.root, :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 1).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:after]).respecting_element_order
+      return_value = test_document.template_registry.add_child(test_document.ng_xml.root, :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 1).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_after).respecting_element_order
     end
-    
+
     it "should add_next_sibling" do
-      return_value = @test_document.template_registry.add_next_sibling(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 1).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:after]).respecting_element_order
+      return_value = test_document.template_registry.add_next_sibling(test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 1).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_after).respecting_element_order
     end
 
     it "should add_previous_sibling" do
-      return_value = @test_document.template_registry.add_previous_sibling(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      expect(return_value).to eq(@test_document.find_by_terms(:person => 0).first)
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:before]).respecting_element_order
+      return_value = test_document.template_registry.add_previous_sibling(test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
+      expect(return_value).to eq(test_document.find_by_terms(:person => 0).first)
+      expect(test_document.ng_xml).to be_equivalent_to(expect_before).respecting_element_order
     end
 
     it "should after" do
-      return_value = @test_document.template_registry.after(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      expect(return_value).to eq(@test_document.find_by_terms(:person => 0).first)
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:after]).respecting_element_order
+      return_value = test_document.template_registry.after(test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
+      expect(return_value).to eq(test_document.find_by_terms(:person => 0).first)
+      expect(test_document.ng_xml).to be_equivalent_to(expect_after).respecting_element_order
     end
 
     it "should before" do
-      return_value = @test_document.template_registry.before(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      expect(return_value).to eq(@test_document.find_by_terms(:person => 1).first)
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:before]).respecting_element_order
+      return_value = test_document.template_registry.before(test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
+      expect(return_value).to eq(test_document.find_by_terms(:person => 1).first)
+      expect(test_document.ng_xml).to be_equivalent_to(expect_before).respecting_element_order
     end
 
     it "should replace" do
-      target_node = @test_document.find_by_terms(:person => 0).first
-      return_value = @test_document.template_registry.replace(target_node, :person, 'Bob', 'Builder')
-      expect(return_value).to eq(@test_document.find_by_terms(:person => 0).first)
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:instead]).respecting_element_order
+      target_node = test_document.find_by_terms(:person => 0).first
+      return_value = test_document.template_registry.replace(target_node, :person, 'Bob', 'Builder')
+      expect(return_value).to eq(test_document.find_by_terms(:person => 0).first)
+      expect(test_document.ng_xml).to be_equivalent_to(expect_instead).respecting_element_order
     end
 
     it "should swap" do
-      target_node = @test_document.find_by_terms(:person => 0).first
-      return_value = @test_document.template_registry.swap(target_node, :person, 'Bob', 'Builder')
+      target_node = test_document.find_by_terms(:person => 0).first
+      return_value = test_document.template_registry.swap(target_node, :person, 'Bob', 'Builder')
       expect(return_value).to eq target_node
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:instead]).respecting_element_order
+      expect(test_document.ng_xml).to be_equivalent_to(expect_instead).respecting_element_order
     end
-    
+
     it "should yield the result if a block is given" do
-      target_node = @test_document.find_by_terms(:person => 0).first
+      target_node = test_document.find_by_terms(:person => 0).first
       expectation = Nokogiri::XML('<person xmlns="urn:registry-test" title="Actor">Alice</person>').root
-      expect(@test_document.template_registry.swap(target_node, :person, 'Bob', 'Builder') { |old_node|
+      expect(test_document.template_registry.swap(target_node, :person, 'Bob', 'Builder') { |old_node|
         expect(old_node).to be_equivalent_to(expectation)
         old_node
       }).to be_equivalent_to(expectation)
     end
   end
-    
+
   describe "document-based document manipulations" do
     it "should accept a Nokogiri::XML::Node as target" do
-      @test_document.after_node(@test_document.ng_xml.root.elements.first, :person, 'Bob', 'Builder')
-      expect(@test_document.ng_xml.root.elements.length).to eq 2
+      test_document.after_node(test_document.ng_xml.root.elements.first, :person, 'Bob', 'Builder')
+      expect(test_document.ng_xml.root.elements.length).to eq 2
     end
 
     it "should accept a Nokogiri::XML::NodeSet as target" do
-      @test_document.after_node(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      expect(@test_document.ng_xml.root.elements.length).to eq 2
+      test_document.after_node(test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
+      expect(test_document.ng_xml.root.elements.length).to eq 2
     end
-    
+
     it "should accept a term-pointer array as target" do
-      @test_document.after_node([:person => 0], :person, 'Bob', 'Builder')
-      expect(@test_document.ng_xml.root.elements.length).to eq 2
+      test_document.after_node([:person => 0], :person, 'Bob', 'Builder')
+      expect(test_document.ng_xml.root.elements.length).to eq 2
     end
-    
+
     it "should instantiate a detached node from a template" do
-      node = @test_document.template(:person, 'Odin', 'All-Father')
+      node = test_document.template(:person, 'Odin', 'All-Father')
       expectation = Nokogiri::XML('<person title="All-Father">Odin</person>').root
       expect(node).to be_equivalent_to(expectation)
     end
 
     it "should add_child_node" do
-      return_value = @test_document.add_child_node(@test_document.ng_xml.root, :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 1).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:after]).respecting_element_order
+      return_value = test_document.add_child_node(test_document.ng_xml.root, :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 1).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_after).respecting_element_order
     end
-    
+
     it "should add_next_sibling_node" do
-      return_value = @test_document.add_next_sibling_node([:person => 0], :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 1).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:after]).respecting_element_order
+      return_value = test_document.add_next_sibling_node([:person => 0], :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 1).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_after).respecting_element_order
     end
 
     it "should add_previous_sibling_node" do
-      return_value = @test_document.add_previous_sibling_node([:person => 0], :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 0).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:before]).respecting_element_order
+      return_value = test_document.add_previous_sibling_node([:person => 0], :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 0).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_before).respecting_element_order
     end
 
     it "should after_node" do
-      return_value = @test_document.after_node([:person => 0], :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 0).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:after]).respecting_element_order
+      return_value = test_document.after_node([:person => 0], :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 0).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_after).respecting_element_order
     end
 
     it "should before_node" do
-      return_value = @test_document.before_node([:person => 0], :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 1).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:before]).respecting_element_order
+      return_value = test_document.before_node([:person => 0], :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 1).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_before).respecting_element_order
     end
 
     it "should replace_node" do
-      target_node = @test_document.find_by_terms(:person => 0).first
-      return_value = @test_document.replace_node(target_node, :person, 'Bob', 'Builder')
-      expect(return_value).to eq @test_document.find_by_terms(:person => 0).first
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:instead]).respecting_element_order
+      target_node = test_document.find_by_terms(:person => 0).first
+      return_value = test_document.replace_node(target_node, :person, 'Bob', 'Builder')
+      expect(return_value).to eq test_document.find_by_terms(:person => 0).first
+      expect(test_document.ng_xml).to be_equivalent_to(expect_instead).respecting_element_order
     end
 
     it "should swap_node" do
-      target_node = @test_document.find_by_terms(:person => 0).first
-      return_value = @test_document.swap_node(target_node, :person, 'Bob', 'Builder')
+      target_node = test_document.find_by_terms(:person => 0).first
+      return_value = test_document.swap_node(target_node, :person, 'Bob', 'Builder')
       expect(return_value).to eq target_node
-      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:instead]).respecting_element_order
+      expect(test_document.ng_xml).to be_equivalent_to(expect_instead).respecting_element_order
     end
   end
-  
+
 end