nom-xml 0.5.1 → 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e8abc2d0f36fabb997f6ff163e1670b7cafc87fe
+  data.tar.gz: daa5e3899254a527f80d0762825b201f77177d96
+SHA512:
+  metadata.gz: 75349d3a759439a1b24b1d4b10042e4bce8536e6cbb97b6383b2663914a6bd0acbf0f414bedd4b15a2b0539fc50fc195e1239dd3e11cf85178d0a1cf05f64f1f
+  data.tar.gz: 35099fbec920fc5ef8e47f688ee1a92925da789588666006ac0718c006fc153000f8852ecfd08d62573bb75a5da2fcaabd60ab61c1e04f52e0c901c5cfc98c93

data/.gitignore

@@ -0,0 +1,11 @@
+.DS_Store
+.bundle
+.idea
+.ruby-gemset
+.ruby-version
+.rvmrc
+.yardoc
+*.gem
+Gemfile.lock
+coverage
+coverage.data

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -1,6 +1,13 @@
+notifications:
+  email: false
+
+gemfile:
+  - gemfiles/rails3.gemfile
+  - gemfiles/rails4.gemfile
+
 rvm:
-  - "1.9.3"
+  - 1.9.3
   - jruby-19mode
   - rbx-19mode
-  - jruby-18mode
-  - "1.8.7"
+  - 2.0.0
+  - 2.1.2

data/Gemfile

@@ -1,4 +1,4 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
 
@@ -6,5 +6,3 @@ gem 'simplecov', :platform => :ruby_19
 gem 'rcov', :platform => :ruby_18
 gem 'debugger', :platform => :mri_19
 gem "redcarpet", :platform => :ruby_19
-
-gem 'nokogiri', '1.5.6.rc2'

data/gemfiles/rails3.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path=>"../"
+
+gem 'activesupport', '~> 3.2', '>= 3.2.18'
+

data/gemfiles/rails4.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec :path=>"../"
+
+gem 'activesupport', '~> 4.1'
+

data/lib/nom/xml/decorators/nodeset.rb

@@ -1,6 +1,6 @@
 module Nom::XML::Decorators::NodeSet
-	
-	def values_for_term term
+
+  def values_for_term term
       result = self
       result = result.select &(term.options[:if]) if term.options[:if].is_a? Proc
       result = result.reject &(term.options[:unless]) if term.options[:unless].is_a? Proc
@@ -22,30 +22,31 @@ module Nom::XML::Decorators::NodeSet
       end
 
       return return_value
-	end
+  end
 
-	##
-	# Add a #method_missing handler to NodeSets. If all of the elements in the Nodeset
-	# respond to a method (e.g. if it is a term accessor), call that method on all the
-	# elements in the node
-	def method_missing sym, *args, &block
-		if self.all? { |node| node.respond_to? sym }
-			result = self.collect { |node| node.send(sym, *args, &block) }.flatten
-			self.class.new(self.document, result) rescue result
-		else
+  ##
+  # Add a #method_missing handler to NodeSets. If all of the elements in the Nodeset
+  # respond to a method (e.g. if it is a term accessor), call that method on all the
+  # elements in the node
+  def method_missing sym, *args, &block
+    if self.all? { |node| node.respond_to? sym }
+      result = self.collect { |node| node.send(sym, *args, &block) }.flatten
+      self.class.new(self.document, result) rescue result
+    else
       begin
         self.document.template_registry.send(sym, self, *args, &block)
       rescue NameError
         super
       end
-		end
-	end
+    end
+  end
 
-	def respond_to? sym
+    # ruby 2.0 sends two arguments to respond_to?
+  def respond_to? sym, priv = false
       if self.all? { |node| node.respond_to? sym }
-      	true
+        true
       else
-      	super
+        super
       end
-	end
+  end
 end

data/lib/nom/xml/decorators/terminology.rb

@@ -30,7 +30,10 @@ module Nom::XML::Decorators::Terminology
 
   alias_method :respond_to_without_terms?, :respond_to?
 
-  def respond_to? method
+# As of ruby 2.0, respond_to includes an optional 2nd arg:
+#   a boolean controlling whether private methods are targeted.
+# We don't actually care for term accessors (none private).
+  def respond_to? method, private = false
     super || self.term_accessors[method.to_sym]
   end
 
@@ -39,7 +42,7 @@ module Nom::XML::Decorators::Terminology
   def terms
     @terms ||= self.ancestors.map { |p| p.term_accessors(self).map { |keys, values| values } }.flatten.compact.uniq
   end
-  
+
   protected
   ##
   # Collection of salient terminology accessors for this node

data/lib/nom/xml/nokogiri_extension.rb

@@ -6,19 +6,14 @@ module Nom::XML
     ##
     # Apply NOM decorators to Nokogiri classes
     def nom!
-      unless decorators(Nokogiri::XML::Node).include? Nom::XML::Decorators::Terminology
-        decorators(Nokogiri::XML::Node) << Nom::XML::Decorators::Terminology
-      end
-      unless decorators(Nokogiri::XML::Attr).include? Nom::XML::Decorators::Terminology
-        decorators(Nokogiri::XML::Attr) << Nom::XML::Decorators::Terminology
-      end
-
-      unless decorators(Nokogiri::XML::NodeSet).include? Nom::XML::Decorators::NodeSet
-        decorators(Nokogiri::XML::NodeSet) << Nom::XML::Decorators::NodeSet
-      end
-
-      unless decorators(Nokogiri::XML::Document).include? Nom::XML::Decorators::TemplateRegistry
-        decorators(Nokogiri::XML::Document) << Nom::XML::Decorators::TemplateRegistry
+      decorations = {
+        Nokogiri::XML::Node => Nom::XML::Decorators::Terminology,
+        Nokogiri::XML::Attr => Nom::XML::Decorators::Terminology,
+        Nokogiri::XML::NodeSet => Nom::XML::Decorators::NodeSet,
+        Nokogiri::XML::Document => Nom::XML::Decorators::TemplateRegistry
+      }
+      decorations.each_pair do |host, decorator|
+        decorators(host) << decorator unless decorators(host).include? decorator
       end
 
       decorate!

data/lib/nom/xml/version.rb

@@ -1,5 +1,5 @@
 module Nom
   module XML
-    VERSION = '0.5.1'
+    VERSION = '0.5.2'
   end
 end

data/nom-xml.gemspec

@@ -12,14 +12,15 @@ Gem::Specification.new do |s|
   s.summary = %q{ A library to help you tame sprawling XML schemas. }
   s.description = %q{ NOM allows you to define a “terminology” to ease translation between XML and ruby objects }
 
-  s.add_dependency 'activesupport'
+  s.add_dependency 'activesupport', '>= 3.2.18'  # could be rails/AS 3 or 4+, but we don't support old insecure versions
   s.add_dependency 'i18n'
   s.add_dependency 'nokogiri'
 
-  s.add_development_dependency "rspec"
+  s.add_development_dependency 'equivalent-xml', '~> 0.5.1'
+  s.add_development_dependency 'rspec', '~> 3.1'
   s.add_development_dependency "rake"
   s.add_development_dependency "yard"
-  s.add_development_dependency "equivalent-xml"
+
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/spec/examples/mods_example_spec.rb

@@ -40,76 +40,76 @@ describe "Namespaces example" do
   }
 
   it "should work with existing reserved method names when override is present" do
-    subject.author.first.description.text.should include('asdf')
+    expect(subject.author.first.description.text).to include('asdf')
   end
 
   it "should return nodesets by default" do
-    subject.personal_authors.should be_a_kind_of(Nokogiri::XML::NodeSet)
+    expect(subject.personal_authors).to be_a_kind_of(Nokogiri::XML::NodeSet)
   end
 
   it "should return single elements on demand" do
-    subject.personal_authors.first.namePart.should be_a_kind_of(Nokogiri::XML::Element)
+    expect(subject.personal_authors.first.namePart).to be_a_kind_of(Nokogiri::XML::Element)
   end
 
   it "should return attributes as single-valued" do
-    subject.personal_authors.first.valueURI.should be_a_kind_of(Nokogiri::XML::Attr)
+    expect(subject.personal_authors.first.valueURI).to be_a_kind_of(Nokogiri::XML::Attr)
   end
 
 
   it "should treat attributes with an accessor as a single-able element" do
-    subject.author.first.authorityURI.should == 'http://id.loc.gov/authorities/names'
+    expect(subject.author.first.authorityURI).to eq('http://id.loc.gov/authorities/names')
   end
 
   it "should share terms over matched nodes" do
-    subject.personal_authors.first.namePart.text.should == "Alterman, Eric"
+    expect(subject.personal_authors.first.namePart.text).to eq("Alterman, Eric")
   end
 
   it "should return single elements out of nodesets correctly" do
-    subject.personal_authors.namePart.should be_a_kind_of(Nokogiri::XML::NodeSet)
+    expect(subject.personal_authors.namePart).to be_a_kind_of(Nokogiri::XML::NodeSet)
   end
 
   it "should create enumerable objects" do
-    subject.personal_authors.should respond_to(:each)
-    subject.personal_authors.should have(1).node
+    expect(subject.personal_authors).to respond_to(:each)
+    expect(subject.personal_authors.size).to eq(1)
   end
 
   it "should provide accessors" do
     eric =subject.personal_authors.first
  
-    eric.namePart.text.should == "Alterman, Eric"
-    eric.roleTerm.text.should == "creator"
+    expect(eric.namePart.text).to eq("Alterman, Eric")
+    expect(eric.roleTerm.text).to eq("creator")
 
-    eric.roleTerm._type.text.should == "text"
+    expect(eric.roleTerm._type.text).to eq("text")
   end
 
   it "should let you mix and match xpaths and nom accessors" do
-    subject.language.value.should include('eng')
-    subject.xpath('//mods:language', 'mods' => 'http://www.loc.gov/mods/v3').value.should include('eng')
+    expect(subject.language.value).to include('eng')
+    expect(subject.xpath('//mods:language', 'mods' => 'http://www.loc.gov/mods/v3').value).to include('eng')
   end
 
   it "should work with attributes" do
     eric =subject.personal_authors.first
-    eric.valueURI.to_s.should == 'http://id.loc.gov/authorities/names/n92101908'
+    expect(eric.valueURI.to_s).to eq('http://id.loc.gov/authorities/names/n92101908')
   end
 
   it "should allow you to access a term from the node" do
-    subject.personal_authors.namePart.terms.map { |term|term.options[:index_as] }.flatten.should include(:type_1)
+    expect(subject.personal_authors.namePart.terms.map { |term|term.options[:index_as] }.flatten).to include(:type_1)
   end
 
   it "should allow you to use multiple terms to address the same node" do
     t = subject.xpath('//mods:name', subject.terminology.namespaces).first.terms
-    t.map { |x| x.name }.should include(:author, :personal_authors)
+    expect(t.map { |x| x.name }).to include(:author, :personal_authors)
   end
 
   it "should let you go from a terminology to nodes" do
-    subject.terminology.flatten.length.should == 14
+    expect(subject.terminology.flatten.length).to eq(14)
 
-    subject.terminology.flatten.select { |x| x.options[:index_as] }.should have(2).terms 
-    subject.terminology.flatten.select { |x| x.options[:index_as] }.map { |x| x.nodes }.flatten.should have(2).nodes
+    expect(subject.terminology.flatten.select { |x| x.options[:index_as] }.size).to eq(2) 
+    expect(subject.terminology.flatten.select { |x| x.options[:index_as] }.map { |x| x.nodes }.flatten.size).to eq(2)
   end
 
   it "should let you go from a term to a terminology" do
-    subject.personal_authors.terms.first.terminology.should == subject.terminology
+    expect(subject.personal_authors.terms.first.terminology).to eq(subject.terminology)
   end
 
 end

data/spec/examples/namespaced_example_spec.rb

@@ -25,10 +25,10 @@ describe "Namespaces example" do
   }
 
   it "should get nodes" do
-    subject.table.tr.td.map { |x| x.text }.should include("Apples", "Bananas")
+    expect(subject.table.tr.td.map { |x| x.text }).to include("Apples", "Bananas")
   end
 
   it "should get nodes from the other namespace" do
-    subject.furniture_table._name.text.should include("African Coffee Table")
+    expect(subject.furniture_table._name.text).to include("African Coffee Table")
   end
 end

data/spec/examples/nutrition_example_spec.rb

@@ -33,33 +33,33 @@ describe "Nutrition" do
   }
 
   it "should be able to access things via xpath, and then continue with terminology selectors" do
-    subject.xpath('//food').first._name.text.should == "Avocado Dip"
+    expect(subject.xpath('//food').first._name.text).to eq("Avocado Dip")
   end
 
   it "should have total fat information" do
-    subject.daily_values.total_fat.text.should == "65"
-    subject.daily_values.total_fat.value.should include(65)
-    subject.daily_values.total_fat.units.text.should =='g'
+    expect(subject.daily_values.total_fat.text).to eq("65")
+    expect(subject.daily_values.total_fat.value).to include(65)
+    expect(subject.daily_values.total_fat.units.text).to eq('g')
 
-    subject.foods.total_fat.value.inject(:+).should == 117
+    expect(subject.foods.total_fat.value.inject(:+)).to eq(117)
   end
 
   it "should have food names" do
-    subject.foods._name.text.should include("Avocado Dip")
+    expect(subject.foods._name.text).to include("Avocado Dip")
   end
 
   it "should have xpath selectors" do
-    subject.foods(:name => 'Avocado Dip').total_fat.value.first.should == 11
-    subject.foods('total-fat/text() = 11')._name.text.should == "Avocado Dip"
+    expect(subject.foods(:name => 'Avocado Dip').total_fat.value.first).to eq(11)
+    expect(subject.foods('total-fat/text() = 11')._name.text).to eq("Avocado Dip")
   end
 
   it "should have global terms" do
-    subject.daily_values.total_fat.unit_value.should include('65g')
-    subject.foods.first.at('serving').unit_value.should include('29g')
+    expect(subject.daily_values.total_fat.unit_value).to include('65g')
+    expect(subject.foods.first.at('serving').unit_value).to include('29g')
   end
 
   it "should accept if in proc-form" do
     subject.daily_values.total_fat.units_if == subject.daily_values.total_fat.units
-    subject.daily_values.total_fat.units_if_false.should be_empty
+    expect(subject.daily_values.total_fat.units_if_false).to be_empty
   end
 end

data/spec/examples/template_registry_example_spec.rb

@@ -37,8 +37,7 @@ describe "Template Registry example" do
   }
 
   it "should work" do
-    pending if defined? JRUBY_VERSION
     subject.root.add_child(subject.template(:a, 'asdf'))
-    subject.a.should have(2).items
+    expect(subject.a.size).to eq(2)
   end
 end

data/spec/lib/nodeset_decorator_spec.rb

@@ -1,73 +1,69 @@
 require 'spec_helper'
 
 describe Nom::XML::Decorators::NodeSet do
-  	subject { 
-      doc = Nokogiri::XML '<root><a n="1"/><b /><c /></root>'
-      doc.nom!
-      doc
-  	}
+  subject {
+    doc = Nokogiri::XML '<root><a n="1"/><b /><c /></root>'
+    doc.nom!
+    doc
+  }
   describe "#values_for_term" do
 
-
     it "should do if" do
-      t = mock(:options => { :if => lambda { |x| false }})
-
-      t1 = mock(:options => { :if => lambda { |x| true }})
+      t  = double(:options => { :if => lambda { |x| false }})
+      t1 = double(:options => { :if => lambda { |x| true }})
 
-      subject.xpath('//*').values_for_term(t).should be_empty
-      subject.xpath('//*').values_for_term(t1).should_not be_empty
+      expect(subject.xpath('//*').values_for_term(t)).to be_empty
+      expect(subject.xpath('//*').values_for_term(t1)).not_to be_empty
     end
 
     it "should do unless" do
-      t = mock(:options => { :unless => lambda { |x| false }})
-
-      t1 = mock(:options => { :unless => lambda { |x| true }})
+      t  = double(:options => { :unless => lambda { |x| false }})
+      t1 = double(:options => { :unless => lambda { |x| true }})
 
-      subject.xpath('//*').values_for_term(t).should_not be_empty
-      subject.xpath('//*').values_for_term(t1).should be_empty
+      expect(subject.xpath('//*').values_for_term(t)).not_to be_empty
+      expect(subject.xpath('//*').values_for_term(t1)).to be_empty
     end
 
     it "should do a nil accessor" do
-      t = mock(:options => { :accessor => nil})
-
-      subject.xpath('//*').values_for_term(t).should == subject.xpath('//*')
+      t = double(:options => { :accessor => nil})
+      expect(subject.xpath('//*').values_for_term(t)).to eq(subject.xpath('//*'))
     end
 
     it "should do a Proc accessor" do
-      t = mock(:options => { :accessor => lambda { |x| 1 }})
-      subject.xpath('//a').values_for_term(t).should == [1]
+      t = double(:options => { :accessor => lambda { |x| 1 }})
+      expect(subject.xpath('//a').values_for_term(t)).to eq([1])
     end
 
     it "should do a symbol accessor" do
-      t = mock(:options => { :accessor => :z})
-      subject.xpath('//a').first.should_receive(:z).and_return(1)
-      subject.xpath('//a').values_for_term(t).should == [1]
+      t = double(:options => { :accessor => :z })
+      allow(subject.xpath('//a').first).to receive(:z).and_return(1)
+      expect(subject.xpath('//a').values_for_term(t)).to eq([1])
     end
 
     it "should do single" do
-      t = mock(:options => { :single => true})
-      subject.xpath('//*').values_for_term(t).should == subject.xpath('//*').first
-
+      t = double(:options => { :single => true})
+      expect(subject.xpath('//*').values_for_term(t)).to eq(subject.xpath('//*').first)
     end
 
     it "should treat an attribute as a single" do
-      t = mock(:options => { })
-      subject.xpath('//@n').values_for_term(t).should be_a_kind_of Nokogiri::XML::Attr
-
+      t = double(:options => { })
+      expect(subject.xpath('//@n').values_for_term(t)).to be_a_kind_of Nokogiri::XML::Attr
     end
   end
 
   describe "method missing and respond to" do
     it "should respond to methods on nodes if all nodes in the nodeset respond to the method" do
-      subject.xpath('//*').should respond_to :text
+      expect(subject.xpath('//*')).to respond_to :text
+      expect(subject.xpath('//*').respond_to?(:text, true)).to be_truthy
+      expect(subject.xpath('//*').respond_to?(:text, false)).to be_truthy
     end
 
     it "should respond to methods on nodes if all nodes in the nodeset respond to the method" do
-      subject.xpath('//*').should_not respond_to :text_123
+      expect(subject.xpath('//*')).not_to respond_to :text_123
     end
 
     it "should work" do
-      subject.xpath('//*').name.should include("a", "b", "c")
+      expect(subject.xpath('//*').name).to include("a", "b", "c")
     end
   end
-end
+end

data/spec/lib/nokogiri_extension_spec.rb

@@ -21,9 +21,9 @@ describe Nom::XML::NokogiriExtension do
     it "should decorate Nodes and Nodesets with our decorators" do
       doc.nom!
 
-      doc.root.should be_a_kind_of(Nom::XML::Decorators::Terminology)
+      expect(doc.root).to be_a_kind_of(Nom::XML::Decorators::Terminology)
 
-      doc.xpath('//*').should be_a_kind_of(Nom::XML::Decorators::NodeSet)
+      expect(doc.xpath('//*')).to be_a_kind_of(Nom::XML::Decorators::NodeSet)
     end
   end
 end

data/spec/lib/template_registry_spec.rb

@@ -31,8 +31,8 @@ describe "NOM::XML::TemplateRegistry" do
   
   describe "template definitions" do
     it "should contain predefined templates" do
-      subject.template_registry.node_types.should include(:person)
-      subject.template_registry.node_types.should_not include(:zombie)
+      expect(subject.template_registry.node_types).to include(:person)
+      expect(subject.template_registry.node_types).not_to include(:zombie)
     end
 
     describe "ZOMG ZOMBIES!!11!!!1" do
@@ -44,36 +44,36 @@ describe "NOM::XML::TemplateRegistry" do
         end
       end
       it "should define new templates" do
-        subject.template_registry.node_types.should include(:zombie)
+        expect(subject.template_registry.node_types).to include(:zombie)
       end
 
       it "should instantiate a detached node from a template" do
         node = subject.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 { subject.template_registry.instantiate(:demigod, 'Hercules') }.should raise_error(NameError)
+        expect { subject.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 { subject.template_registry.demigod('Hercules') }.should raise_error(NameError)
+        expect { subject.template_registry.demigod('Hercules') }.to raise_error(NameError)
       end
       
       it "should undefine existing templates" do
-        subject.template_registry.node_types.should include(:zombie)
+        expect(subject.template_registry.node_types).to include(:zombie)
         subject.template_registry.undefine :zombie
-        subject.template_registry.node_types.should_not include(:zombie)
+        expect(subject.template_registry.node_types).not_to include(:zombie)
       end
       
       it "should complain if the template name isn't a symbol" do
-        lambda { subject.template_registry.define("die!") { |xml| subject.this_never_happened } }.should raise_error(TypeError)
+        expect { subject.template_registry.define("die!") { |xml| subject.this_never_happened } }.to raise_error(TypeError)
       end
       
       it "should report on whether a given template is defined" do
-        subject.template_registry.has_node_type?(:zombie).should == true
-        subject.template_registry.has_node_type?(:demigod).should == false
+        expect(subject.template_registry.has_node_type?(:zombie)).to eq(true)
+        expect(subject.template_registry.has_node_type?(:demigod)).to eq(false)
       end
 
     end    
@@ -82,133 +82,133 @@ describe "NOM::XML::TemplateRegistry" do
   describe "template-based document manipulations" do
     it "should accept a Nokogiri::XML::Node as target" do
       subject.template_registry.after(subject.root.elements.first, :person, 'Bob', 'Builder')
-      subject.root.elements.length.should == 2
+      expect(subject.root.elements.length).to eq(2)
     end
 
     it "should accept a Nokogiri::XML::NodeSet as target" do
       subject.template_registry.after(subject.root.elements, :person, 'Bob', 'Builder')
-      subject.root.elements.length.should == 2
+      expect(subject.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 = subject.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 = subject.template_registry.add_child(subject.root, :person, 'Bob', 'Builder')
-      return_value.should == subject.person[1]
-      subject.should be_equivalent_to(expectations[:after]).respecting_element_order
+      expect(return_value).to eq(subject.person[1])
+      expect(subject).to be_equivalent_to(expectations[:after]).respecting_element_order
     end
     
     it "should add_next_sibling" do
       return_value = subject.template_registry.add_next_sibling(subject.person.first, :person, 'Bob', 'Builder')
-      return_value.should == subject.person[1]
-      subject.should be_equivalent_to(expectations[:after]).respecting_element_order
+      expect(return_value).to eq(subject.person[1])
+      expect(subject).to be_equivalent_to(expectations[:after]).respecting_element_order
     end
 
     it "should add_previous_sibling" do
       return_value = subject.template_registry.add_previous_sibling(subject.person.first, :person, 'Bob', 'Builder')
-      return_value.should == subject.person.first
-      subject.should be_equivalent_to(expectations[:before]).respecting_element_order
+      expect(return_value).to eq(subject.person.first)
+      expect(subject).to be_equivalent_to(expectations[:before]).respecting_element_order
     end
 
     it "should after" do
       return_value = subject.template_registry.after(subject.person.first, :person, 'Bob', 'Builder')
-      return_value.should == subject.person.first
-      subject.should be_equivalent_to(expectations[:after]).respecting_element_order
+      expect(return_value).to eq(subject.person.first)
+      expect(subject).to be_equivalent_to(expectations[:after]).respecting_element_order
     end
 
     it "should before" do
       return_value = subject.template_registry.before(subject.person.first, :person, 'Bob', 'Builder')
-      return_value.should == subject.person[1]
-      subject.should be_equivalent_to(expectations[:before]).respecting_element_order
+      expect(return_value).to eq(subject.person[1])
+      expect(subject).to be_equivalent_to(expectations[:before]).respecting_element_order
     end
 
     it "should replace" do
       target_node = subject.person.first
       return_value = subject.template_registry.replace(target_node, :person, 'Bob', 'Builder')
-      return_value.should == subject.person.first
-      subject.should be_equivalent_to(expectations[:instead]).respecting_element_order
+      expect(return_value).to eq(subject.person.first)
+      expect(subject).to be_equivalent_to(expectations[:instead]).respecting_element_order
     end
 
     it "should swap" do
       target_node = subject.person.first
       return_value = subject.template_registry.swap(target_node, :person, 'Bob', 'Builder')
-      return_value.should == target_node
-      subject.should be_equivalent_to(expectations[:instead]).respecting_element_order
+      expect(return_value).to eq(target_node)
+      expect(subject).to be_equivalent_to(expectations[:instead]).respecting_element_order
     end
     
     it "should yield the result if a block is given" do
       target_node = subject.person.first
       expectation = Nokogiri::XML('<person xmlns="urn:registry-test" title="Actor">Alice</person>').root
-      subject.template_registry.swap(target_node, :person, 'Bob', 'Builder') { |old_node|
-        old_node.should be_equivalent_to(expectation)
+      expect(subject.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
       subject.root.elements.first.after_person('Bob', 'Builder')
-      subject.root.elements.length.should == 2
+      expect(subject.root.elements.length).to eq(2)
     end
 
     it "should accept a Nokogiri::XML::NodeSet as target" do
       subject.person.after_person(:person, 'Bob', 'Builder')
-      subject.root.elements.length.should == 2
+      expect(subject.root.elements.length).to eq(2)
     end
     
     it "should instantiate a detached node from a template" do
       node = subject.template_registry.instantiate(: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 = subject.root.add_child_person('Bob', 'Builder')
-      return_value.should == subject.person[1]
-      subject.should be_equivalent_to(expectations[:after]).respecting_element_order
+      expect(return_value).to eq(subject.person[1])
+      expect(subject).to be_equivalent_to(expectations[:after]).respecting_element_order
     end
     
     it "should add_next_sibling_node" do
       return_value = subject.person[0].add_next_sibling_person('Bob', 'Builder')
-      return_value.should == subject.person[1]
-      subject.should be_equivalent_to(expectations[:after]).respecting_element_order
+      expect(return_value).to eq(subject.person[1])
+      expect(subject).to be_equivalent_to(expectations[:after]).respecting_element_order
     end
 
     it "should add_previous_sibling_node" do
       return_value = subject.person[0].add_previous_sibling_person('Bob', 'Builder')
-      return_value.should == subject.person.first
-      subject.should be_equivalent_to(expectations[:before]).respecting_element_order
+      expect(return_value).to eq(subject.person.first)
+      expect(subject).to be_equivalent_to(expectations[:before]).respecting_element_order
     end
 
     it "should after_node" do
       return_value = subject.person[0].after_person('Bob', 'Builder')
-      return_value.should == subject.person.first
-      subject.should be_equivalent_to(expectations[:after]).respecting_element_order
+      expect(return_value).to eq(subject.person.first)
+      expect(subject).to be_equivalent_to(expectations[:after]).respecting_element_order
     end
 
     it "should before_node" do
       return_value = subject.person[0].before_person('Bob', 'Builder')
-      return_value.should == subject.person[1]
-      subject.should be_equivalent_to(expectations[:before]).respecting_element_order
+      expect(return_value).to eq(subject.person[1])
+      expect(subject).to be_equivalent_to(expectations[:before]).respecting_element_order
     end
 
     it "should replace_node" do
       target_node = subject.person.first
       return_value = target_node.replace_person('Bob', 'Builder')
-      return_value.should == subject.person.first
-      subject.should be_equivalent_to(expectations[:instead]).respecting_element_order
+      expect(return_value).to eq(subject.person.first)
+      expect(subject).to be_equivalent_to(expectations[:instead]).respecting_element_order
     end
 
     it "should swap_node" do
       target_node = subject.person.first
       return_value = target_node.swap_person('Bob', 'Builder')
-      return_value.should == target_node
-      subject.should be_equivalent_to(expectations[:instead]).respecting_element_order
+      expect(return_value).to eq(target_node)
+      expect(subject).to be_equivalent_to(expectations[:instead]).respecting_element_order
     end
   end
   

data/spec/lib/terminology_decorator_spec.rb

@@ -29,7 +29,6 @@ describe "Nutrition" do
      end
 
      xml.nom!
-
      xml
   }
 
@@ -37,15 +36,16 @@ describe "Nutrition" do
 
     it "should warn you if you try to override already existing methods" do
       pending if defined? JRUBY_VERSION
-      mock_term = {:text => mock(:options => {})}
-      document.a.first.stub(:term_accessors).and_return mock_term
+      mock_term = {:text => double(:options => {})}
+      allow(document.a.first).to receive(:term_accessors).and_return mock_term
       expect { document.a.first.add_terminology_method_overrides! }.to raise_error /Trying to redefine/
     end
   
     it "should let you override the warning" do
-      mock_term = {:text => mock(:options => { :override => true } )}
-      document.a.first.stub(:term_accessors).and_return mock_term
-      expect { document.a.first.add_terminology_method_overrides! }.to_not raise_error /Trying to redefine/
+      pending if defined? JRUBY_VERSION
+      mock_term = {:text => double(:options => { :override => true } )}
+      allow(document.a.first).to receive(:term_accessors).and_return mock_term
+      expect { document.a.first.add_terminology_method_overrides! }.to_not raise_error
     end
   end
 
@@ -55,20 +55,19 @@ describe "Nutrition" do
       subject { document.root }
 
       it "should not have any associated terminology terms" do
-        subject.terms.should be_empty
+        expect(subject.terms).to be_empty
       end
-
     end
 
     context "node with a single term" do
       subject { document.xpath('//a').first }
 
       it "should have a single term" do
-        subject.terms.should have(1).item
+        expect(subject.terms.size).to eq(1)
       end
 
       it "should find the right term" do
-        subject.terms.map { |x| x.name }.should include(:a)
+        expect(subject.terms.map { |x| x.name }).to include(:a)
       end
     end
 
@@ -76,11 +75,11 @@ describe "Nutrition" do
       subject { document.xpath('//b').first }
 
       it "should have multiple terms" do
-        subject.terms.should have(2).items
+        expect(subject.terms.size).to eq(2)
       end
 
       it "should find the right terms" do
-        subject.terms.map { |x| x.name }.should include(:b, :b_ref)
+        expect(subject.terms.map { |x| x.name }).to include(:b, :b_ref)
       end
     end
   end
@@ -91,7 +90,7 @@ describe "Nutrition" do
       subject { document.xpath('//c').first }
 
       it "should have a child accessor" do
-        subject.send(:term_accessors).keys.should include(:nested)
+        expect(subject.send(:term_accessors).keys).to include(:nested)
       end
     end
 
@@ -99,7 +98,7 @@ describe "Nutrition" do
       subject { document }
 
       it "should have all the root terms" do
-        subject.send(:term_accessors).keys.should include(:a, :b, :c)
+        expect(subject.send(:term_accessors).keys).to include(:a, :b, :c)
       end
     end
 
@@ -107,11 +106,10 @@ describe "Nutrition" do
       subject { document.root }
 
       it "should have all the root terms" do
-        subject.send(:term_accessors).keys.should include(:a, :b, :c)
+        expect(subject.send(:term_accessors).keys).to include(:a, :b, :c)
       end
     end
   end
 
-
 end
 

data/spec/lib/terminology_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe Nom::XML::Terminology do
   describe "#namespaces" do
     it "should pull the namespaces out of the terminology options" do
-      Nom::XML::Terminology.new(nil, :namespaces => { 'asd' => '123'}).namespaces.should == { 'asd' => '123'}
+      expect(Nom::XML::Terminology.new(nil, :namespaces => { 'asd' => '123'}).namespaces).to eq({ 'asd' => '123'})
     end
 
     it "should return an empty hash if no namespace is provided" do
-      Nom::XML::Terminology.new.namespaces.should == {}
+      expect(Nom::XML::Terminology.new.namespaces).to eq({})
     end
   end
 
@@ -15,7 +15,7 @@ describe Nom::XML::Terminology do
     it "should be an identity function" do
       a = Nom::XML::Terminology.new
 
-      a.terminology.should == a
+      expect(a.terminology).to eq(a)
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ if ENV['COVERAGE'] and RUBY_VERSION =~ /^1.9/
   SimpleCov.start
 end
 
-require 'rspec/autorun'
+require 'rspec'
 require 'nom'
 require 'equivalent-xml/rspec_matchers'
 

data/spec/test_spec.rb

@@ -15,7 +15,7 @@ describe Nom::XML do
 
     doc.nom!
 
-    doc.b.should == "1"
+    expect(doc.b).to eq("1")
   end
   it "should do stuff with terminologies" do
     doc = Nokogiri::XML <<-eos
@@ -59,14 +59,14 @@ describe Nom::XML do
 
     doc.nom!
 
-    doc.root.element_a.text.should == 'a value'
-    doc.root.element_b.element_c.text.should == 'c value'
-    doc.root.element_d.element_e.element_f.text.strip.should == 'f value'
-    doc.root.element_d.element_e.foo.collect(&:text).should == ['bar']
-    doc.root.element_d.element_e.foo_text.should == ['bar']
-    doc.root.element_g.first.element_h.should == ['h value 1','h value 2']
-    doc.root.element_g.element_h.should == ['h value 1','h value 2','h value 3']
-    doc.root.element_g.whatever.should == ['element_h:h value 1','element_h:h value 2','element_h:h value 3']
+    expect(doc.root.element_a.text).to eq('a value')
+    expect(doc.root.element_b.element_c.text).to eq('c value')
+    expect(doc.root.element_d.element_e.element_f.text.strip).to eq('f value')
+    expect(doc.root.element_d.element_e.foo.collect(&:text)).to eq(['bar'])
+    expect(doc.root.element_d.element_e.foo_text).to eq(['bar'])
+    expect(doc.root.element_g.first.element_h).to eq(['h value 1','h value 2'])
+    expect(doc.root.element_g.element_h).to eq(['h value 1','h value 2','h value 3'])
+    expect(doc.root.element_g.whatever).to eq(['element_h:h value 1','element_h:h value 2','element_h:h value 3'])
   end
 end
 

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nom-xml
 version: !ruby/object:Gem::Version
-  version: 0.5.1
-  prerelease: 
+  version: 0.5.2
 platform: ruby
 authors:
 - Chris Beer
@@ -10,122 +9,108 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-11 00:00:00.000000000 Z
+date: 2015-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.2.18
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.2.18
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: equivalent-xml
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.1
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: equivalent-xml
+  name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! ' NOM allows you to define a “terminology” to ease translation between
-  XML and ruby objects '
+description: " NOM allows you to define a “terminology” to ease translation between
+  XML and ruby objects "
 email: cabeer@stanford.edu mbklein@gmail.com
 executables: []
 extensions: []
@@ -133,11 +118,15 @@ extra_rdoc_files:
 - LICENSE
 - README.md
 files:
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- gemfiles/rails3.gemfile
+- gemfiles/rails4.gemfile
 - lib/nom.rb
 - lib/nom/xml.rb
 - lib/nom/xml/decorators.rb
@@ -166,33 +155,26 @@ files:
 - spec/test_spec.rb
 homepage: http://github.com/cbeer/nom-xml
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 623172737244635261
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 623172737244635261
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A library to help you tame sprawling XML schemas.
 test_files:
 - spec/examples/mods_example_spec.rb