nom-xml 0.3.0 → 0.5.0

data/README.md

@@ -1,17 +1,17 @@
-# NOM
+# nom-xml
 
 [![Build Status](https://secure.travis-ci.org/cbeer/nom.png)](http://travis-ci.org/cbeer/nom)
 
 A library to help you tame sprawling XML schemas.
 
-NOM allows you to define a “terminology” to ease translation between XML and ruby objects – you can query the xml for Nodes or node values without ever writing a line of XPath. NOM is built on top of [nokogiri](http://nokogiri.org) decorators, which means you can mix-and-match NOM accessors with nokogiri xpaths, xml manipulation, and traversing and it will just work.
+nom-xml allows you to define a “terminology” to ease translation between XML and ruby objects – you can query the xml for Nodes or node values without ever writing a line of XPath. nom-xml is built on top of [nokogiri](http://nokogiri.org) decorators, which means you can mix-and-match NOM accessors with nokogiri xpaths, xml manipulation, and traversing and it will just work.
 
 
 Some Handy Links
 ----------------
 Here are some resources to help you learn more about nom-xml:
 
-- [API](http://rubydoc.info/github/cbeer/nom) - A reference to NOM's classes
+- [API](http://rubydoc.info/github/cbeer/nom-xml) - A reference to nom-xml's classes
 - [#projecthydra](http://webchat.freenode.net/?channels=#projecthydra) on irc.freenode.net
 - [Project Hydra Google Group](http://groups.google.com/group/hydra-tech) - community mailing list and forum
 

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

@@ -1,5 +1,29 @@
 module Nom::XML::Decorators::NodeSet
 	
+	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
+
+      m = term.options[:accessor]
+      return_value = case
+        when m.nil?
+          result
+        when m.is_a?(Symbol)
+           result.collect { |r| r.send(m) }.compact
+        when m.is_a?(Proc)
+          result.collect { |r| m.call(r) }.compact
+        else
+          raise "Unknown accessor class: #{m.class}"
+        end
+
+      if return_value and (term.options[:single] or (result.length == 1 and result.first.is_a? Nokogiri::XML::Attr))
+        return return_value.first
+      end
+
+      return return_value
+	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
@@ -9,7 +33,11 @@ module Nom::XML::Decorators::NodeSet
 			result = self.collect { |node| node.send(sym, *args, &block) }.flatten
 			self.class.new(self.document, result) rescue result
 		else
-			super
+      begin
+        self.document.template_registry.send(sym, self, *args, &block)
+      rescue NameError
+        super
+      end
 		end
 	end
 

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

@@ -20,7 +20,11 @@ module Nom::XML::Decorators::Terminology
 
       self.send(method, *args, &block)
     else
-      super
+      begin
+        self.document.template_registry.send(method, self, *args, &block)
+      rescue NameError
+        super
+      end
     end
   end
 
@@ -35,7 +39,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
@@ -94,9 +98,6 @@ module Nom::XML::Decorators::Terminology
 
     xpath = term.local_xpath
 
-    xpath += "[#{term.options[:if]}]" if term.options[:if] and term.options[:if].is_a? String
-    xpath += "[not(#{term.options[:unless]})]" if term.options[:unless] and term.options[:unless].is_a? String
-
     xpath += "[#{args.join('][')}]" unless args.empty?
 
     result = case self
@@ -106,26 +107,6 @@ module Nom::XML::Decorators::Terminology
                  self.xpath(xpath, self.document.terminology_namespaces)
                end
 
-    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
-
-    m = term.options[:accessor]
-   
-    return_value = case
-      when m.nil?
-        result
-      when m.is_a?(Symbol)
-        result.collect { |r| r.send(m) }.compact
-      when m.is_a?(Proc)
-        result.collect { |r| m.call(r) }.compact
-      else
-        raise "Unknown accessor class: #{m.class}"
-      end
-
-    if return_value and (term.options[:single] or (result.length == 1 and result.first.is_a? Nokogiri::XML::Attr))
-      return return_value.first
-    end
-
-    return return_value
+    result.values_for_term(term)
   end
 end

data/lib/nom/xml/nokogiri_extension.rb

@@ -9,6 +9,9 @@ module Nom::XML
       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

data/lib/nom/xml/template_registry.rb

@@ -44,71 +44,46 @@ class Nom::XML::TemplateRegistry
   def instantiate(node_type, *args)
     result = create_detached_node(nil, node_type, *args)
     # Strip namespaces from text and CDATA nodes. Stupid Nokogiri.
-    result.traverse { |node|
-      if node.is_a?(Nokogiri::XML::CharacterData)
-        node.namespace = nil
+      unless jruby?
+        result.traverse { |node|
+          if node.is_a?(Nokogiri::XML::CharacterData)
+            node.namespace = nil
+          end
+        }
       end
-    }
     return result
   end
 
-  # +instantiate+ a node and add it as a child of the [Nokogiri::XML::Node] specified by +target_node+
-  # @return the new [Nokogiri::XML::Node]
-  def add_child(target_node, node_type, *args, &block)
-    attach_node(:add_child, target_node, :self, node_type, *args, &block)
-  end
-
-  # +instantiate+ a node and add it as a following sibling of the [Nokogiri::XML::Node] specified by +target_node+
-  # @return the new [Nokogiri::XML::Node]
-  def add_next_sibling(target_node, node_type, *args, &block)
-    attach_node(:add_next_sibling, target_node, :parent, node_type, *args, &block)
-  end
-
-  # +instantiate+ a node and add it as a preceding sibling of the [Nokogiri::XML::Node] specified by +target_node+
-  # @return the new [Nokogiri::XML::Node]
-  def add_previous_sibling(target_node, node_type, *args, &block)
-    attach_node(:add_previous_sibling, target_node, :parent, node_type, *args, &block)
-  end
-
-  # +instantiate+ a node and add it as a following sibling of the [Nokogiri::XML::Node] specified by +target_node+
-  # @return +target_node+
-  def after(target_node, node_type, *args, &block)
-    attach_node(:after, target_node, :parent, node_type, *args, &block)
-  end
-
-  # +instantiate+ a node and add it as a preceding sibling of the [Nokogiri::XML::Node] specified by +target_node+
-  # @return +target_node+
-  def before(target_node, node_type, *args, &block)
-    attach_node(:before, target_node, :parent, node_type, *args, &block)
-  end
-
-  # +instantiate+ a node replace the [Nokogiri::XML::Node] specified by +target_node+ with it
-  # @return the new [Nokogiri::XML::Node]
-  def replace(target_node, node_type, *args, &block)
-    attach_node(:replace, target_node, :parent, node_type, *args, &block)
-  end
-
-  # +instantiate+ a node replace the [Nokogiri::XML::Node] specified by +target_node+ with it
-  # @return +target_node+
-  def swap(target_node, node_type, *args, &block)
-    attach_node(:swap, target_node, :parent, node_type, *args, &block)
-  end
-  
-  def methods
-    super + @templates.keys.collect { |k| k.to_s }
-  end
-
-  def method_missing(sym,*args)
-    sym = sym.to_s.sub(/_$/,'').to_sym
-    if @templates.has_key?(sym)
+  ACTIONS = {
+   :add_child => :self, :add_next_sibling => :parent, :add_previous_sibling => :parent, 
+   :after => :parent, :before => :parent, :replace => :parent, :swap  => :parent
+  }
+  def method_missing(sym,*args,&block)
+    method = sym.to_s.sub(/_+$/,'').to_sym
+    if @templates.has_key?(method)
       instantiate(sym,*args)
+    elsif ACTIONS.has_key?(method)
+      target_node = args.shift
+      attach_node(method, target_node, ACTIONS[method], *args, &block)
+    elsif method.to_s =~ /^(#{ACTIONS.keys.join('|')})_(.+)$/
+      method = $1.to_sym
+      template = $2.to_sym
+      if ACTIONS.has_key?(method) and @templates.has_key?(template)
+        target_node = args.shift
+        attach_node(method, target_node, ACTIONS[method], template, *args, &block)
+      end
     else
       super(sym,*args)
     end
+
   end
 
   private
   
+  def jruby?
+    defined?(RUBY_ENGINE) and (RUBY_ENGINE == 'jruby')
+  end
+
   # Create a new Nokogiri::XML::Node based on the template for +node_type+
   #
   # @param [Nokogiri::XML::Node] builder_node The node to use as starting point for building the node using Nokogiri::XML::Builder.with(builder_node).  This provides namespace info, etc for constructing the new Node object. If nil, defaults to {Nom::XML::TemplateRegistry#empty_root_node}.  This is just used to create the new node and will not be included in the response.
@@ -144,11 +119,13 @@ class Nom::XML::TemplateRegistry
     new_node = create_detached_node(builder_node, node_type, *args)
     result = target_node.send(method, new_node)
     # Strip namespaces from text and CDATA nodes. Stupid Nokogiri.
-    new_node.traverse { |node|
-      if node.is_a?(Nokogiri::XML::CharacterData)
-        node.namespace = nil
-      end
-    }
+    unless jruby?
+      new_node.traverse { |node|
+        if node.is_a?(Nokogiri::XML::CharacterData)
+          node.namespace = nil
+        end
+      }
+    end
     if block_given?
       yield result
     else

data/lib/nom/xml/term.rb

@@ -46,7 +46,12 @@ module Nom::XML
     # Get the relative xpath to this node from its immediate parent's term
     # @return [String]
     def local_xpath
-      ("#{xmlns}:" unless xmlns.blank? ).to_s + (options[:path] || name).to_s
+      xpath = ("#{xmlns}:" unless xmlns.blank? ).to_s + (options[:path] || name).to_s
+
+      xpath += "[#{options[:if]}]" if options[:if] and options[:if].is_a? String
+      xpath += "[not(#{options[:unless]})]" if options[:unless] and options[:unless].is_a? String
+
+      xpath
     end
 
     ##
@@ -56,6 +61,12 @@ module Nom::XML
       terminology.document.root.xpath(xpath, terminology.namespaces)
     end
 
+    ##
+    # Get the document values associated with the term (after e.g. accessors)
+    def values
+      terminology.document.root.xpath(xpath, terminology.namespaces).value_for_term(self)
+    end
+
     ##
     # Does this term have a sub-term called term_name
     # @attr [String] term_key

data/lib/nom/xml/version.rb

@@ -1,5 +1,5 @@
 module Nom
   module XML
-    VERSION = '0.3.0'
+    VERSION = '0.5.0'
   end
 end

data/{nom.gemspec → nom-xml.gemspec}

@@ -6,11 +6,11 @@ Gem::Specification.new do |s|
   s.name = "nom-xml"
   s.version = Nom::XML::VERSION
   s.platform = Gem::Platform::RUBY
-  s.authors = ["Chris Beer"]
-  s.email = %q{cabeer@stanford.edu}
-  s.homepage = %q{http://github.com/cbeer/nom}
-  s.summary = %q{ asdf }
-  s.description = %q{ asdfgh }
+  s.authors = ["Chris Beer", "Michael B. Klein"]
+  s.email = %q{cabeer@stanford.edu mbklein@gmail.com}
+  s.homepage = %q{http://github.com/cbeer/nom-xml}
+  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 'i18n'
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec"
   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/lib/nodeset_decorator_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Nom::XML::Decorators::NodeSet do
+  	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 }})
+
+      subject.xpath('//*').values_for_term(t).should be_empty
+      subject.xpath('//*').values_for_term(t1).should_not be_empty
+    end
+
+    it "should do unless" do
+      t = mock(:options => { :unless => lambda { |x| false }})
+
+      t1 = mock(:options => { :unless => lambda { |x| true }})
+
+      subject.xpath('//*').values_for_term(t).should_not be_empty
+      subject.xpath('//*').values_for_term(t1).should be_empty
+    end
+
+    it "should do a nil accessor" do
+      t = mock(:options => { :accessor => nil})
+
+      subject.xpath('//*').values_for_term(t).should == 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]
+    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]
+    end
+
+    it "should do single" do
+      t = mock(:options => { :single => true})
+      subject.xpath('//*').values_for_term(t).should == 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
+
+    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
+    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
+    end
+
+    it "should work" do
+      subject.xpath('//*').name.should include("a", "b", "c")
+    end
+  end
+end

data/spec/lib/template_registry_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe "NOM::XML::TemplateRegistry" do
+
+  let(:file) { '<people xmlns="urn:registry-test"><person title="Actor">Alice</person></people>' }
+  let(:xml) { Nokogiri::XML(file) }
+  let(: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>}
+    }
+  }
+  subject {
+    xml.set_terminology(:namespaces => { 'default' => 'urn:registry-test' }) do |t|
+      t.person(:xmlns => 'default') {
+        t.title(:path => "@title")
+      }
+    end
+
+    xml.define_template :person do |xml,name,title|
+      xml.person(:title => title) do
+        xml.text(name)
+      end
+    end
+
+    xml.nom!
+
+    xml
+  }
+  
+  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)
+    end
+
+    describe "ZOMG ZOMBIES!!11!!!1" do
+      before(:each) do
+        subject.define_template :zombie do |xml,name|
+          xml.monster(:wants => 'braaaaainz') do
+            xml.text(name)
+          end
+        end
+      end
+      it "should define new templates" do
+        subject.template_registry.node_types.should 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)
+      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)
+      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)
+      end
+      
+      it "should undefine existing templates" do
+        subject.template_registry.node_types.should include(:zombie)
+        subject.template_registry.undefine :zombie
+        subject.template_registry.node_types.should_not 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)
+      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
+      end
+
+    end    
+  end
+  
+  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
+    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
+    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)
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    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)
+        old_node
+      }.should 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
+    end
+
+    it "should accept a Nokogiri::XML::NodeSet as target" do
+      subject.person.after_person(:person, 'Bob', 'Builder')
+      subject.root.elements.length.should == 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)
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+    end
+  end
+  
+end

data/spec/lib/terminology_decorator_spec.rb

@@ -26,7 +26,6 @@ describe "Nutrition" do
          c.nested
        end
 
-       t.d :if => 'my-custom-function()'
      end
 
      xml.nom!
@@ -34,102 +33,19 @@ describe "Nutrition" do
      xml
   }
 
-  describe "#add_terminology_methods!" do
-    subject do
-      m = mock()
-      m.stub(:document).and_return(mock(:terminology_namespaces => {}))
-      m.stub(:term_accessors).and_return(@term_accessors)
-      m.extend Nom::XML::Decorators::Terminology
-      m
-    end
-
-    it "should define terminology accessors" do
-      mock_term = mock(:options => {})
-      @term_accessors = { :asdf => mock_term }
-
-      subject.should respond_to(:asdf)
-    end
-
-    it "should perform basic xpath queries" do
-      mock_term = mock(:local_xpath => '//asdf', :options => {})
-      @term_accessors = { :asdf => mock_term }
-
-      subject.should_receive(:xpath).with('//asdf', anything)
-
-      subject.asdf
-    end
-
-    it "should perform xpath queries with constraints" do
-      mock_term = mock(:local_xpath => '//asdf', :options => {})
-      @term_accessors = { :asdf => mock_term }
-
-      subject.should_receive(:xpath).with('//asdf[predicate="value"]', anything)
-      subject.should_receive(:xpath).with('//asdf[predicate="\"value\""]', anything)
-      subject.should_receive(:xpath).with('//asdf[custom-xpath-predicate()]', anything)
-      subject.should_receive(:xpath).with('//asdf[custom-xpath-predicate()][predicate="value"]', anything)
-
-      subject.asdf(:predicate => 'value')
-      subject.asdf(:predicate => '"value"')
-      subject.asdf('custom-xpath-predicate()')
-      subject.asdf('custom-xpath-predicate()', :predicate => 'value')
-    end
-
-    it "should execute accessors" do
-      mock_term = mock(:local_xpath => '//asdf', :options => {:accessor => :text })
-      @term_accessors = { :asdf => mock_term }
-
-      m = mock()
-      subject.should_receive(:xpath).with('//asdf', anything).and_return([m])
-      m.should_receive(:text)
-
-      subject.asdf
-    end 
-
-    it "should execute proc-based accessors" do
-      mock_term = mock(:local_xpath => '//asdf', :options => {:accessor => lambda { |x| x.zxcvb } })
-      @term_accessors = { :asdf => mock_term }
+  describe "#add_terminology_method_overrides!" do
 
-      m = mock()
-      subject.should_receive(:xpath).with('//asdf', anything).and_return([m])
-      m.should_receive(:zxcvb)
-
-      subject.asdf
-    end
-
-    it "should raise an error on unknown accessors" do
-      mock_term = mock(:local_xpath => '//asdf', :options => {:accessor => 123 })
-      @term_accessors = { :asdf => mock_term }
-
-      subject.should_receive(:xpath).with('//asdf', anything)
-
-      expect { subject.asdf }.to raise_error
-    end
-
-    it "should convert single-valued objects to single values" do
-      mock_term = mock(:local_xpath => '//asdf', :options => {:single => true })
-      @term_accessors = { :asdf => mock_term }
-
-      subject.should_receive(:xpath).with('//asdf', anything).and_return([1])
-
-      subject.asdf.should == 1
-    end
-
-    it "should evaluate if" do
-       mock_term = mock(:local_xpath => '//asdf', :options => {:if => 'my-custom-function()' })
-       @term_accessors = { :asdf => mock_term }
-
-       subject.should_receive(:xpath).with('//asdf[my-custom-function()]', anything).and_return([1])
-
-       subject.asdf.should == [1]
+    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
+      expect { document.a.first.add_terminology_method_overrides! }.to raise_error /Trying to redefine/
     end
-
-    it "should evaluate unless" do
-       mock_term = mock(:local_xpath => '//asdf', :options => {:unless => 'my-custom-function()' })
-       @term_accessors = { :asdf => mock_term }
-
-       subject.should_receive(:xpath).with('//asdf[not(my-custom-function())]', anything).and_return([1])
-
-       subject.asdf.should == [1]
+  
+    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/
     end
   end
 

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ end
 
 require 'rspec/autorun'
 require 'nom'
+require 'equivalent-xml/rspec_matchers'
 
 RSpec.configure do |config|
 

data/spec/test_spec.rb

@@ -2,6 +2,21 @@ require 'spec_helper'
 
 describe Nom::XML do
 
+  it "shouldn't break under jruby" do
+    doc = Nokogiri::XML <<-eoxml
+      <root>
+        <a b="1">123</a>
+      </root>
+    eoxml
+
+    doc.set_terminology do |t|
+      t.b :path => '//@b', :accessor => lambda { |x| x.text }
+    end
+
+    doc.nom!
+
+    doc.b.should == "1"
+  end
   it "should do stuff with terminologies" do
     doc = Nokogiri::XML <<-eos
   <root>

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: nom-xml
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
 - Chris Beer
+- Michael B. Klein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-07 00:00:00.000000000 Z
+date: 2012-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -107,8 +108,25 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! ' asdfgh '
-email: cabeer@stanford.edu
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  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 '
+email: cabeer@stanford.edu mbklein@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -131,7 +149,7 @@ files:
 - lib/nom/xml/term.rb
 - lib/nom/xml/terminology.rb
 - lib/nom/xml/version.rb
-- nom.gemspec
+- nom-xml.gemspec
 - spec/examples/mods_example_spec.rb
 - spec/examples/namespaced_example_spec.rb
 - spec/examples/nutrition_example_spec.rb
@@ -141,11 +159,12 @@ files:
 - spec/fixtures/xml_namespaces.xml
 - spec/lib/nodeset_decorator_spec.rb
 - spec/lib/nokogiri_extension_spec.rb
+- spec/lib/template_registry_spec.rb
 - spec/lib/terminology_decorator_spec.rb
 - spec/lib/terminology_spec.rb
 - spec/spec_helper.rb
 - spec/test_spec.rb
-homepage: http://github.com/cbeer/nom
+homepage: http://github.com/cbeer/nom-xml
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -159,7 +178,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2552568584722504681
+      hash: -2880685956354160513
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -168,13 +187,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2552568584722504681
+      hash: -2880685956354160513
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: asdf
+summary: A library to help you tame sprawling XML schemas.
 test_files:
 - spec/examples/mods_example_spec.rb
 - spec/examples/namespaced_example_spec.rb
@@ -185,6 +204,7 @@ test_files:
 - spec/fixtures/xml_namespaces.xml
 - spec/lib/nodeset_decorator_spec.rb
 - spec/lib/nokogiri_extension_spec.rb
+- spec/lib/template_registry_spec.rb
 - spec/lib/terminology_decorator_spec.rb
 - spec/lib/terminology_spec.rb
 - spec/spec_helper.rb