om 3.1.0 → 3.1.1

data/spec/unit/om_spec.rb

@@ -4,8 +4,8 @@ describe "OM" do
   
   describe "#{}destringify" do
     it "should recursively change any strings beginning with : to symbols and any number strings to integers" do
-      OM.destringify( [{":person"=>"0"}, ":last_name"] ).should == [{:person=>0}, :last_name]
-      OM.destringify( [{"person"=>"3"}, "last_name"] ).should == [{:person=>3}, :last_name]
+      expect(OM.destringify( [{":person"=>"0"}, ":last_name"] )).to eq([{:person=>0}, :last_name])
+      expect(OM.destringify( [{"person"=>"3"}, "last_name"] )).to eq([{:person=>3}, :last_name])
     end
   end
   

data/spec/unit/template_registry_spec.rb

@@ -38,189 +38,189 @@ describe "OM::XML::TemplateRegistry" do
   
   describe "template definitions" do
     it "should contain predefined templates" do
-      RegistryTest.template_registry.node_types.should include(:person)
-      RegistryTest.template_registry.node_types.should_not include(:zombie)
+      expect(RegistryTest.template_registry.node_types).to include(:person)
+      expect(RegistryTest.template_registry.node_types).not_to include(:zombie)
     end
 
     it "should define new templates" do
-      RegistryTest.template_registry.node_types.should_not include(:zombie)
+      expect(RegistryTest.template_registry.node_types).not_to include(:zombie)
       RegistryTest.define_template :zombie do |xml,name|
         xml.monster(:wants => 'braaaaainz') do
           xml.text(name)
         end
       end
-      RegistryTest.template_registry.node_types.should include(:zombie)
+      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
-      node.should be_equivalent_to(expectation)
+      expect(node).to be_equivalent_to(expectation)
     end
     
     it "should raise an error when trying to instantiate an unknown node_type" do
-      lambda { RegistryTest.template_registry.instantiate(:demigod, 'Hercules') }.should raise_error(NameError)
+      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
-      lambda { RegistryTest.template_registry.demigod('Hercules') }.should raise_error(NameError)
+      expect { RegistryTest.template_registry.demigod('Hercules') }.to raise_error(NameError)
     end
     
     it "should undefine existing templates" do
-      RegistryTest.template_registry.node_types.should include(:zombie)
+      expect(RegistryTest.template_registry.node_types).to include(:zombie)
       RegistryTest.template_registry.undefine :zombie
-      RegistryTest.template_registry.node_types.should_not include(:zombie)
+      expect(RegistryTest.template_registry.node_types).not_to include(:zombie)
     end
     
     it "should complain if the template name isn't a symbol" do
-      lambda { RegistryTest.template_registry.define("die!") { |xml| xml.this_never_happened } }.should raise_error(TypeError)
+      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
-      RegistryTest.template_registry.has_node_type?(:person).should == true
-      RegistryTest.template_registry.has_node_type?(:zombie).should == false
+      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
-      RegistryTest.template_registry.methods.should include('person')
+      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')
-      @test_document.ng_xml.root.elements.length.should == 2
+      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')
-      @test_document.ng_xml.root.elements.length.should == 2
+      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
-      node.should be_equivalent_to(expectation)
+      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')
-      return_value.should == @test_document.find_by_terms(:person => 1).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:after]).respecting_element_order
+      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
     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')
-      return_value.should == @test_document.find_by_terms(:person => 1).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:after]).respecting_element_order
+      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
     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')
-      return_value.should == @test_document.find_by_terms(:person => 0).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:before]).respecting_element_order
+      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
     end
 
     it "should after" do
       return_value = @test_document.template_registry.after(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      return_value.should == @test_document.find_by_terms(:person => 0).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:after]).respecting_element_order
+      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
     end
 
     it "should before" do
       return_value = @test_document.template_registry.before(@test_document.find_by_terms(:person => 0), :person, 'Bob', 'Builder')
-      return_value.should == @test_document.find_by_terms(:person => 1).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:before]).respecting_element_order
+      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
     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')
-      return_value.should == @test_document.find_by_terms(:person => 0).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:instead]).respecting_element_order
+      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
     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')
-      return_value.should == target_node
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:instead]).respecting_element_order
+      expect(return_value).to eq target_node
+      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[: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
       expectation = Nokogiri::XML('<person xmlns="urn:registry-test" title="Actor">Alice</person>').root
-      @test_document.template_registry.swap(target_node, :person, 'Bob', 'Builder') { |old_node|
-        old_node.should be_equivalent_to(expectation)
+      expect(@test_document.template_registry.swap(target_node, :person, 'Bob', 'Builder') { |old_node|
+        expect(old_node).to be_equivalent_to(expectation)
         old_node
-      }.should be_equivalent_to(expectation)
+      }).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')
-      @test_document.ng_xml.root.elements.length.should == 2
+      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')
-      @test_document.ng_xml.root.elements.length.should == 2
+      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')
-      @test_document.ng_xml.root.elements.length.should == 2
+      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')
       expectation = Nokogiri::XML('<person title="All-Father">Odin</person>').root
-      node.should be_equivalent_to(expectation)
+      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')
-      return_value.should == @test_document.find_by_terms(:person => 1).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:after]).respecting_element_order
+      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
     end
     
     it "should add_next_sibling_node" do
       return_value = @test_document.add_next_sibling_node([:person => 0], :person, 'Bob', 'Builder')
-      return_value.should == @test_document.find_by_terms(:person => 1).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:after]).respecting_element_order
+      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
     end
 
     it "should add_previous_sibling_node" do
       return_value = @test_document.add_previous_sibling_node([:person => 0], :person, 'Bob', 'Builder')
-      return_value.should == @test_document.find_by_terms(:person => 0).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:before]).respecting_element_order
+      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
     end
 
     it "should after_node" do
       return_value = @test_document.after_node([:person => 0], :person, 'Bob', 'Builder')
-      return_value.should == @test_document.find_by_terms(:person => 0).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:after]).respecting_element_order
+      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
     end
 
     it "should before_node" do
       return_value = @test_document.before_node([:person => 0], :person, 'Bob', 'Builder')
-      return_value.should == @test_document.find_by_terms(:person => 1).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:before]).respecting_element_order
+      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
     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')
-      return_value.should == @test_document.find_by_terms(:person => 0).first
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:instead]).respecting_element_order
+      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
     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')
-      return_value.should == target_node
-      @test_document.ng_xml.should be_equivalent_to(@expectations[:instead]).respecting_element_order
+      expect(return_value).to eq target_node
+      expect(@test_document.ng_xml).to be_equivalent_to(@expectations[:instead]).respecting_element_order
     end
   end
   

data/spec/unit/term_builder_spec.rb

@@ -34,7 +34,7 @@ describe "OM::XML::Term::Builder" do
   describe '#new' do
    it "should set terminology_builder attribute if provided" do
      mock_terminology_builder = double("TerminologyBuilder")
-     OM::XML::Term::Builder.new("term1", mock_terminology_builder).terminology_builder.should == mock_terminology_builder
+     expect(OM::XML::Term::Builder.new("term1", mock_terminology_builder).terminology_builder).to eq mock_terminology_builder
    end
   end
   
@@ -42,7 +42,7 @@ describe "OM::XML::Term::Builder" do
     it "should set the corresponding .settings value return the mapping object" do
       [:path, :index_as, :required, :type, :variant_of, :path, :attributes, :default_content_path].each do |method_name|
         @test_builder.send("#{method_name}=".to_sym, "#{method_name.to_s}foo")
-        @test_builder.settings[method_name].should == "#{method_name.to_s}foo"
+        expect(@test_builder.settings[method_name]).to eq "#{method_name.to_s}foo"
       end
     end
     # it "should be chainable" do
@@ -59,11 +59,11 @@ describe "OM::XML::Term::Builder" do
   describe "settings" do
     describe "defaults" do
       it "should be set" do
-        @test_builder.settings[:required].should == false
-        @test_builder.settings[:type].should == :string
-        @test_builder.settings[:variant_of].should be_nil
-        @test_builder.settings[:attributes].should be_nil
-        @test_builder.settings[:default_content_path].should be_nil
+        expect(@test_builder.settings[:required]).to eq false
+        expect(@test_builder.settings[:type]).to eq :string
+        expect(@test_builder.settings[:variant_of]).to be_nil
+        expect(@test_builder.settings[:attributes]).to be_nil
+        expect(@test_builder.settings[:default_content_path]).to be_nil
       end
     end
   end
@@ -71,19 +71,19 @@ describe "OM::XML::Term::Builder" do
   describe ".add_child" do
     it "should insert the given Term Builder into the current Term Builder's children" do
       @test_builder.add_child(@test_builder_2)
-      @test_builder.children[@test_builder_2.name].should == @test_builder_2
+      expect(@test_builder.children[@test_builder_2.name]).to eq @test_builder_2
     end
   end
   describe ".retrieve_child" do
     it "should fetch the child identified by the given name" do
       @test_builder.add_child(@test_builder_2)
-      @test_builder.retrieve_child(@test_builder_2.name).should == @test_builder.children[@test_builder_2.name]
+      expect(@test_builder.retrieve_child(@test_builder_2.name)).to eq @test_builder.children[@test_builder_2.name]
     end
   end
   describe ".children" do
     it "should return a hash of Term Builders that are the children of the current object, indexed by name" do
       @test_builder.add_child(@test_builder_2)
-      @test_builder.children[@test_builder_2.name].should == @test_builder_2
+      expect(@test_builder.children[@test_builder_2.name]).to eq @test_builder_2
     end
   end
   
@@ -95,70 +95,71 @@ describe "OM::XML::Term::Builder" do
         t.type = :text
       end
       result = test_builder.build
-      result.should be_instance_of OM::XML::Term
-      result.index_as.should == [:facetable, :searchable, :sortable, :displayable]
-      result.required.should == true 
-      result.type.should == :text
+      expect(result).to be_instance_of OM::XML::Term
+      expect(result.index_as).to eq [:facetable, :searchable, :sortable, :displayable]
+      expect(result.required).to eq true 
+      expect(result.type).to eq :text
       
-      result.xpath.should == OM::XML::TermXpathGenerator.generate_absolute_xpath(result)
-      result.xpath_constrained.should == OM::XML::TermXpathGenerator.generate_constrained_xpath(result)
-      result.xpath_relative.should == OM::XML::TermXpathGenerator.generate_relative_xpath(result)
+      expect(result.xpath).to eq   OM::XML::TermXpathGenerator.generate_absolute_xpath(result)
+      expect(result.xpath_constrained).to eq   OM::XML::TermXpathGenerator.generate_constrained_xpath(result)
+      expect(result.xpath_relative).to eq  OM::XML::TermXpathGenerator.generate_relative_xpath(result)
     end
     it "should create proxy terms if :proxy is set" do
       test_builder = OM::XML::Term::Builder.new("my_proxy").tap do |t|
         t.proxy = [:foo, :bar]
       end
       result = test_builder.build
-      result.should be_kind_of OM::XML::NamedTermProxy
+      expect(result).to be_kind_of OM::XML::NamedTermProxy
     end
     it "should set path to match name if it is empty" do
-      @test_builder.settings[:path].should be_nil
-      @test_builder.build.path.should == @test_builder.name.to_s
+      expect(@test_builder.settings[:path]).to be_nil
+      expect(@test_builder.build.path).to eq @test_builder.name.to_s
     end
     it "should work recursively, calling .build on any of its children" do
-      OM::XML::Term.any_instance.stub(:generate_xpath_queries!)
+      allow_any_instance_of(OM::XML::Term).to receive(:generate_xpath_queries!)
       built_child1 = OM::XML::Term.new("child1")
       built_child2 = OM::XML::Term.new("child2")
 
       mock1 = double("Builder1", :build => built_child1 )
       mock2 = double("Builder2", :build => built_child2 )
-      mock1.stub(:name).and_return("child1")
-      mock2.stub(:name).and_return("child2")
+      allow(mock1).to receive(:name).and_return("child1")
+      allow(mock2).to receive(:name).and_return("child2")
 
       @test_builder.children = {:mock1=>mock1, :mock2=>mock2}
       result = @test_builder.build
-      result.children[:child1].should == built_child1
-      result.children[:child2].should == built_child2
-      result.children.length.should == 2
+      expect(result.children[:child1]).to eq built_child1
+      expect(result.children[:child2]).to eq built_child2
+      expect(result.children.length).to eq 2
     end
   end
   
   describe ".lookup_refs" do
     it "should return an empty array if no refs are declared" do
-      @test_builder.lookup_refs.should == []
+      expect(@test_builder.lookup_refs).to eq []
     end
     it "should should look up the referenced TermBuilder from the terminology_builder" do
-       @peach.lookup_refs.should == [@stone_fruit]
+       expect(@peach.lookup_refs).to eq [@stone_fruit]
     end
     it "should support recursive refs" do
-	    @almond.lookup_refs.should == [@peach, @stone_fruit]
+	    expect(@almond.lookup_refs).to eq [@peach, @stone_fruit]
 	  end
   	it "should raise an error if the TermBuilder does not have a reference to a terminology builder" do
-  	  lambda { 
+  	  expect(lambda { 
         OM::XML::Term::Builder.new("referrer").tap do |t|
           t.ref="bongos"
           t.lookup_refs 
         end
-      }.should raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
+      }).to raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
 	  end
+
     it "should raise an error if the referece points to a nonexistent term builder" do
       tb = OM::XML::Term::Builder.new("mork",@test_terminology_builder).tap do |t|
         t.ref = [:characters, :aliens]
       end
-      lambda { tb.lookup_refs }.should raise_error(OM::XML::Terminology::BadPointerError,"This TerminologyBuilder does not have a root TermBuilder defined that corresponds to \":characters\"")
+      expect { tb.lookup_refs }.to raise_error(OM::XML::Terminology::BadPointerError,"This TerminologyBuilder does not have a root TermBuilder defined that corresponds to \":characters\"")
     end
     it "should raise an error with informative error when given circular references" do
-      lambda { @pineapple.lookup_refs }.should raise_error(OM::XML::Terminology::CircularReferenceError,"Circular reference in Terminology: :pineapple => :banana => :coconut => :pineapple")
+      expect { @pineapple.lookup_refs }.to raise_error(OM::XML::Terminology::CircularReferenceError,"Circular reference in Terminology: :pineapple => :banana => :coconut => :pineapple")
     end
   end
   
@@ -168,8 +169,8 @@ describe "OM::XML::Term::Builder" do
       children_pre = @test_builder.children
 
       @test_builder.resolve_refs!
-      @test_builder.settings.should == settings_pre
-      @test_builder.children.should == children_pre
+      expect(@test_builder.settings).to eq settings_pre
+      expect(@test_builder.children).to eq children_pre
     end
     it "should should look up the referenced TermBuilder, use its settings and duplicate its children without changing the name" do
       term_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).tap do |b|
@@ -177,24 +178,24 @@ describe "OM::XML::Term::Builder" do
       end
       term_builder.resolve_refs!
       # Make sure children and settings were copied
-      term_builder.settings.should == @citrus.settings.merge(:path=>"citrus")
-  	  term_builder.children.should == @citrus.children
+      expect(term_builder.settings).to eq @citrus.settings.merge(:path=>"citrus")
+  	  expect(term_builder.children).to eq @citrus.children
   	  
   	  # Make sure name and parent of both the term_builder and its target were left alone
-  	  term_builder.name.should == :orange
-  	  @citrus.name.should == :citrus
+  	  expect(term_builder.name).to eq :orange
+  	  expect(@citrus.name).to eq :citrus
     end
     it "should set path based on the ref's path if set" do
       [@peach,@almond].each { |x| x.resolve_refs! }
-      @peach.settings[:path].should == "prunus"
-      @almond.settings[:path].should == "prunus"
+      expect(@peach.settings[:path]).to eq "prunus"
+      expect(@almond.settings[:path]).to eq "prunus"
     end
     it "should set path based on the first ref's name if no path is set" do
       orange_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).tap do |b|
         b.ref= [:fruit_trees, :citrus]
       end
       orange_builder.resolve_refs!
-      orange_builder.settings[:path].should == "citrus"
+      expect(orange_builder.settings[:path]).to eq "citrus"
     end
     # It should not be a problem if multiple TermBuilders refer to the same child TermBuilder since the parent-child relationship is set up after calling TermBuilder.build 
     it "should result in clean trees of Terms after building" 
@@ -206,11 +207,11 @@ describe "OM::XML::Term::Builder" do
         b.required =true
       end
   	  tb.resolve_refs!
-  	  tb.settings.should == {:path=>"citrus", :attributes=>{"citric_acid"=>"true", :color=>"orange"}, :required=>true, :type=>:string, :index_as=>[:facetable]}
+  	  expect(tb.settings).to eq({:path=>"citrus", :attributes=>{"citric_acid"=>"true", :color=>"orange"}, :required=>true, :type=>:string, :index_as=>[:facetable]})
 	  end
 	  it "should aggregate all settings from refs, combining them with a cascading approach" do
 	    @almond.resolve_refs!
-	    @almond.settings[:attributes].should == {:genus=>"Prunus",:subgenus=>"Amygdalus", :species=>"Prunus dulcis"}
+	    expect(@almond.settings[:attributes]).to eq({:genus=>"Prunus",:subgenus=>"Amygdalus", :species=>"Prunus dulcis"})
     end
   end
 end