nom-xml 0.0.3 → 0.0.4

data/lib/nom/xml.rb

@@ -3,7 +3,9 @@ require 'nokogiri'
 module Nom
   module XML
     require 'nom/xml/version'
+    require 'nom/xml/term'
     require 'nom/xml/terminology'
+    require 'nom/xml/template_registry'
     require 'nom/xml/decorators'
 
     require 'nom/xml/nokogiri_extension'

data/lib/nom/xml/decorators.rb

@@ -2,5 +2,6 @@ module Nom::XML
   module Decorators
     require 'nom/xml/decorators/terminology'
     require 'nom/xml/decorators/nodeset'
+    require 'nom/xml/decorators/template_registry'
   end
 end

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

@@ -0,0 +1,7 @@
+module Nom::XML::Decorators
+  module TemplateRegistry
+    def template(node_type, *args)
+      template_registry.instantiate(node_type, *args)
+    end
+  end
+end

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

@@ -4,44 +4,89 @@ module Nom::XML::Decorators::Terminology
     klass.add_terminology_methods!
   end
 
+  ##
+  # Add terminology accessors for querying child terms
   def add_terminology_methods!
-    document.add_terminology_methods(self)
+    self.term_accessors.each do |k, t|
+      (class << self; self; end).send(:define_method, k.to_sym) do |*args|
+        options = args.extract_options!
+
+        args += options.map { |key, value| %{#{key}="#{value.gsub(/"/, '\\\"') }"} }
+
+        xpath = t.local_xpath
+
+        xpath += "[#{args.join('][')}]" unless args.empty?
+
+        result = case self
+                   when Nokogiri::XML::Document
+                     self.root.xpath(xpath, self.document.terminology_namespaces)
+                   else
+                     self.xpath(xpath, self.document.terminology_namespaces)
+                 end
+
+        m = t.options[:accessor]
+        case
+          when m.nil?
+            result
+          when m.is_a?(Symbol)
+            result.collect { |r| r.send(m) }
+          when m.is_a?(Proc)
+            result.collect { |r| m.call(r) }
+          else
+            raise "Unknown accessor class: #{m.class}"
+        end
+      end
+    end
+
+    self
   end
 
+  ##
+  # Get the terminology terms associated with this node
   def terms
-    if self == self.document.root or self.is_a? Nokogiri::XML::Document
-      root_terms
-    elsif not self.parent.terms.empty?
-      child_terms
-    else
-      []
+    return {} unless self.respond_to? :parent and not self.parent.term_accessors.empty?
+
+    self.parent.term_accessors.select do |k,term|
+      self.parent.xpath(term.local_xpath, self.document.terminology_namespaces).include? self
+    end
+  end
+
+  protected
+  ##
+  # Collection of salient terminology accessors for this node
+  def term_accessors
+    case
+      when (self == self.document.root or self.is_a? Nokogiri::XML::Document)
+        root_terms
+      else
+        child_terms
     end
   end
 
   private
 
-  def root_terms 
+  ##
+  # Root terms for the document
+  def root_terms
     self.document.terminology.terms
   end
 
-  def child_terms 
+  ##
+  # Terms that are immediate children of this node, or are globally applicable
+  def child_terms
     h = {}
 
-    collect_terms_for_node.each do |k,v|
-      v.terms.each do |k1, v1|
+    terms.each do |k,term|
+
+      term.terms.each do |k1, v1|
         h[k1] = v1
       end
     end
 
-    h
-  end
-
-  ##
-  #find this self in the terminology
-  def collect_terms_for_node
-    self.parent.terms.select do |k,term|
-      self.parent.xpath(term.local_xpath, self.document.terminology_namespaces).include? self
+    self.ancestors.each do |a|
+      a.term_accessors.each { |k,t| h[k] ||= t if t.options[:global] }
     end
-  end
 
+    h
+  end
 end

data/lib/nom/xml/nokogiri_extension.rb

@@ -6,14 +6,17 @@ module Nom::XML
     def nom!
       unless decorators(Nokogiri::XML::Node).include? Nom::XML::Decorators::Terminology
         decorators(Nokogiri::XML::Node) << Nom::XML::Decorators::Terminology
-        decorate!
       end
 
       unless decorators(Nokogiri::XML::NodeSet).include? Nom::XML::Decorators::NodeSet
         decorators(Nokogiri::XML::NodeSet) << Nom::XML::Decorators::NodeSet
-        decorate!
       end
 
+      unless decorators(Nokogiri::XML::Document).include? Nom::XML::Decorators::TemplateRegistry
+        decorators(Nokogiri::XML::Document) << Nom::XML::Decorators::TemplateRegistry
+      end
+
+      decorate!
       self
     end
 
@@ -30,46 +33,18 @@ module Nom::XML
       @terminology ||= Nom::XML::Terminology.new
     end
 
-    ##
-    # Add terminology accessors for querying child terms
-    # @param [Nokogiri::XML::Node] node
-    def add_terminology_methods node
-      terms_to_add = node.terms
-      node.ancestors.each do |a|
-        a.terms.each { |k,t| terms_to_add[k] ||= t if t.options[:global] }
-      end
-
-      terms_to_add.each do |k, t|
-        (class << node; self; end).send(:define_method, k.to_sym) do |*args|
-          options = args.extract_options!
-
-          args += options.map { |key, value| %{#{key}="#{value.gsub(/"/, '\\\"') }"} }
-
-          xpath = t.local_xpath
-
+    def template_registry
+      @template_registry ||= Nom::XML::TemplateRegistry.new
+    end
 
-          xpath += "[#{args.join('][')}]" unless args.empty?
+    # Define a new node template with the Nom::XML::TemplateRegistry.
+    # * +name+ is a Symbol indicating the name of the new template.
+    # * The +block+ does the work of creating the new node, and will receive
+    #   a Nokogiri::XML::Builder and any other args passed to one of the node instantiation methods.
+    def define_template name, &block
+      self.template_registry.define name, &block
+    end
 
-          result = case self
-                     when Nokogiri::XML::Document
-                       self.root.xpath(xpath, node.document.terminology_namespaces)
-                     else
-                       self.xpath(xpath, node.document.terminology_namespaces)
-                   end
 
-          m = t.options[:accessor]
-          case
-          when m.nil?
-            result
-          when m.is_a?(Symbol)
-            result.collect { |r| r.send(m) }
-          when m.is_a?(Proc)
-            result.collect { |r| m.call(r) }
-          else
-            raise "Unknown accessor class: #{m.class}"
-          end
-        end
-      end
-    end
   end
 end

data/lib/nom/xml/template_registry.rb

@@ -0,0 +1,163 @@
+class Nom::XML::TemplateRegistry
+
+  def initialize
+    @templates = {}
+  end
+
+  # Define an XML template
+  # @param [Symbol] a node_type key to associate with this template
+  # @param [Block] a block that will receive a [Nokogiri::XML::Builder] object and any arbitrary parameters passed to +instantiate+
+  # @return the +node_type+ Symbol
+  def define(node_type, &block)
+    unless node_type.is_a?(Symbol)
+      raise TypeError, "Registered node type must be a Symbol (e.g., :person)"
+    end
+  
+    @templates[node_type] = block
+    node_type
+  end
+
+  # Undefine an XML template
+  # @param [Symbol] the node_type key of the template to undefine
+  # @return the +node_type+ Symbol
+  def undefine(node_type)
+    @templates.delete(node_type)
+    node_type
+  end
+
+  # Check whether a particular node_type is defined
+  # @param [Symbol] the node_type key to check
+  # @return [True] or [False]
+  def has_node_type?(node_type)
+    @templates.has_key?(node_type)
+  end
+
+  # List defined node_types
+  # @return [Array] of node_type symbols.
+  def node_types
+    @templates.keys
+  end
+
+  # Instantiate a detached, standalone node
+  # @param [Symbol] the node_type to instantiate
+  # @param additional arguments to pass to the template
+  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
+      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)
+      instantiate(sym,*args)
+    else
+      super(sym,*args)
+    end
+  end
+
+  private
+  
+  # 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.
+  # @param node_type a pointer to the template to use when creating the node
+  # @param [Array] args any additional args
+  def create_detached_node(builder_node, node_type, *args)
+    proc = @templates[node_type]
+    if proc.nil?
+      raise NameError, "Unknown node type: #{node_type.to_s}"
+    end
+    if builder_node.nil?
+      builder_node = empty_root_node
+    end
+    
+    builder = Nokogiri::XML::Builder.with(builder_node) do |xml|
+      proc.call(xml,*args)
+    end
+    builder_node.elements.last.remove
+  end
+
+  # Create a new XML node of type +node_type+ and attach it to +target_node+ using the specified +method+
+  #
+  # @param [Symbol] method name that should be called on +target_node+, usually a Nokogiri::XML::Node instance method
+  # @param [Nokogiri::XML::Node or Nokogiri::XML::NodeSet with only one Node in it] target_node
+  # @param [Symbol] builder_node_offset Indicates node to use as the starting point for _constructing_ the new node using {Nom::XML::TemplateRegistry#create_detached_node}. If this is set to :parent, target_node.parent will be used.  Otherwise, target_node will be used. 
+  # @param node_type
+  # @param [Array] args any additional arguments for creating the node
+  def attach_node(method, target_node, builder_node_offset, node_type, *args, &block)
+    if target_node.is_a?(Nokogiri::XML::NodeSet) and target_node.length == 1
+      target_node = target_node.first
+    end
+    builder_node = builder_node_offset == :parent ? target_node.parent : target_node
+    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
+    }
+    if block_given?
+      yield result
+    else
+      return result
+    end
+  end
+  
+  def empty_root_node
+    Nokogiri::XML('<root/>').root
+  end
+  
+end

data/lib/nom/xml/term.rb

@@ -0,0 +1,74 @@
+module Nom::XML
+  class Term
+    attr_reader :name
+    attr_reader :terms
+    attr_reader :parent
+    attr_writer :parent
+    attr_reader :options
+
+    def initialize parent, name, options = {}, *args, &block
+      @name = name
+      @terms = {}
+      @parent = parent
+      @options = options || {}
+
+      in_edit_context do
+        yield(self) if block_given?
+      end
+    end
+
+    def in_edit_context &block
+      @edit_context = true
+      yield
+      @edit_context = false
+    end
+
+    def in_edit_context?
+      @edit_context
+    end
+
+    def parent_xpath
+      @parent_xpath ||= self.parent.xpath
+    end
+
+    def clear_parent_cache!
+      @parent_xpath = nil
+    end
+
+    def xpath
+      [parent_xpath, local_xpath].flatten.compact.join("/")
+    end
+
+    def local_xpath
+      ("#{xmlns}:" unless xmlns.blank? ).to_s + (options[:path] || name).to_s
+    end
+
+    def xmlns
+      (options[:xmlns] if options) || (self.parent.xmlns if self.parent)
+    end
+
+    def method_missing method, *args, &block 
+      if in_edit_context?
+        add_term(method, *args, &block)
+      elsif key?(method)
+        term(method)
+      else
+        super
+      end
+    end
+
+    def key? term
+      terms.key? term
+    end
+
+    protected
+    def add_term method, options = {}, *args, &block
+      terms[method] = Term.new(self, method, options, *args, &block)
+    end
+
+    def term method, *args, &block
+      terms[method]
+    end
+  end
+
+end

data/lib/nom/xml/terminology.rb

@@ -1,94 +1,4 @@
 module Nom::XML
-  class Term
-    attr_reader :name
-    attr_reader :terms
-    attr_reader :parent
-    attr_writer :parent
-    attr_reader :options
-
-    def initialize parent, name, options = {}, *args, &block
-      @name = name
-      @terms = {}
-      @parent = parent
-      @options = options || {}
-
-      in_edit_context do
-        yield(self) if block_given?
-      end
-    end
-
-    def in_edit_context &block
-      @edit_context = true
-      yield
-      @edit_context = false
-    end
-
-    def terms_from_node node
-      terms.select do |k, term|
-        node.parent.xpath(term.xpath).include? node
-      end.flatten
-    end
-
-    def in_edit_context?
-      @edit_context
-    end
-
-    def parent_xpath
-      @parent_xpath ||= self.parent.xpath
-    end
-
-    def clear_parent_cache
-      @parent_xpath = nil
-    end
-
-    def xpath
-      [parent_xpath, local_xpath].flatten.compact.join("/")
-    end
-
-    def local_xpath
-      ("#{xmlns}:" unless xmlns.blank? ).to_s + (options[:path] || name).to_s
-    end
-
-    def xmlns
-      (options[:xmlns] if options) || (self.parent.xmlns if self.parent)
-    end
-    
-    def method_missing method, *args, &block 
-      if in_edit_context?
-        add_term(method, *args, &block)
-      elsif key?(method)
-        term(method)
-    #  else if options[:ref]
-    #    resolve_ref_and_return_term(method, *args, &block)
-      else
-        super
-      end
-      #terms[method]
-    end
-
-    def key? term
-      terms.key? term
-    end
-
-    def substitute_parent p
-      obj = self.dup
-
-      obj.parent = p
-      obj.clear_parent_cache
-
-      obj
-    end
-
-    protected
-    def add_term method, options = {}, *args, &block
-      terms[method] = Term.new(self, method, options, *args, &block)
-    end
-
-    def term method, *args, &block
-      terms[method]
-    end
-  end
-
   class Terminology < Term
     def initialize *args, &block
       @terms = {}
@@ -97,7 +7,6 @@ module Nom::XML
       end
     end
 
-
     def xpath
       nil
     end

data/lib/nom/xml/version.rb

@@ -1,5 +1,5 @@
 module Nom
   module XML
-    VERSION = '0.0.3'
+    VERSION = '0.0.4'
   end
 end

data/spec/examples/template_registry_example_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "Template Registry example" do
+  let(:file) {
+    <<-eoxml
+  <root>
+    <a>1234</a>
+
+    <b>asdf</b>
+
+    <c>
+      <nested>poiuyt</nested>
+    </c>
+  </root>
+   eoxml
+  }
+  let(:xml) { Nokogiri::XML(file) }
+
+  subject {
+    xml.define_template :a do |xml, value|
+      xml.a { xml.text value }
+    end
+
+    xml.set_terminology do |t|
+      t.a
+      t.b
+      t.b_ref :path => 'b'
+
+      t.c do |c|
+        c.nested
+      end
+    end
+
+    xml.nom!
+
+    xml
+  }
+
+  it "should work" do
+    subject.root.add_child(subject.template(:a, 'asdf'))
+    subject.a.should have(2).items
+  end
+end

data/spec/lib/nokogiri_extension_spec.rb

@@ -16,11 +16,14 @@ describe Nom::XML::NokogiriExtension do
       </item>
     eoxml
   }
-  describe "#add_terminology_methods" do
-    context "root node" do
-      it "should add terminology methods to the root node" do
 
-      end
+  describe "#nom!" do
+    it "should decorate Nodes and Nodesets with our decorators" do
+      doc.nom!
+
+      doc.root.should be_a_kind_of(Nom::XML::Decorators::Terminology)
+
+      doc.xpath('//*').should be_a_kind_of(Nom::XML::Decorators::NodeSet)
     end
   end
 end

data/spec/lib/terminology_decorator_spec.rb

@@ -1,6 +1,163 @@
-require "spec_helper"
+require 'spec_helper'
+
+describe "Nutrition" do
+  let(:file) {
+    <<-eoxml
+  <root>
+    <a>1234</a>
+
+    <b>asdf</b>
+
+    <c>
+      <nested>poiuyt</nested>
+    </c>
+  </root>
+   eoxml
+  }
+  let(:xml) { Nokogiri::XML(file) }
+
+  let(:document) {
+     xml.set_terminology do |t|
+       t.a
+       t.b
+       t.b_ref :path => 'b'
+
+       t.c do |c|
+         c.nested
+       end
+     end
+
+     xml.nom!
+
+     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
+      @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 }
+
+      m = mock()
+      subject.should_receive(:xpath).with('//asdf', anything).and_return([m])
+      m.should_receive(:zxcvb)
+
+      subject.asdf
+    end
+  end
+
+  describe "#terms" do
+
+    context "root element" do
+      subject { document.root }
+
+      it "should not have any associated terminology terms" do
+        subject.terms.should 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
+      end
+
+      it "should find the right term" do
+        subject.terms.keys.should include(:a)
+      end
+    end
+
+    context "node with multiple terms" do
+      subject { document.xpath('//b').first }
+
+      it "should have multiple terms" do
+        subject.terms.should have(2).items
+      end
+
+      it "should find the right terms" do
+        subject.terms.keys.should include(:b, :b_ref)
+      end
+    end
+  end
+
+  describe "#term_accessors" do
+
+    context "node" do
+      subject { document.xpath('//c').first }
+
+      it "should have a child accessor" do
+        subject.send(:term_accessors).keys.should include(:nested)
+      end
+    end
+
+    context "document" do
+      subject { document }
+
+      it "should have all the root terms" do
+        subject.send(:term_accessors).keys.should include(:a, :b, :c)
+      end
+    end
+
+   context "root node" do
+      subject { document.root }
+
+      it "should have all the root terms" do
+        subject.send(:term_accessors).keys.should include(:a, :b, :c)
+      end
+    end
+  end
 
-describe Nom::XML::Decorators::Terminology do
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nom-xml
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-13 00:00:00.000000000 Z
+date: 2012-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -139,13 +139,17 @@ files:
 - lib/nom/xml.rb
 - lib/nom/xml/decorators.rb
 - lib/nom/xml/decorators/nodeset.rb
+- lib/nom/xml/decorators/template_registry.rb
 - lib/nom/xml/decorators/terminology.rb
 - lib/nom/xml/nokogiri_extension.rb
+- lib/nom/xml/template_registry.rb
+- lib/nom/xml/term.rb
 - lib/nom/xml/terminology.rb
 - lib/nom/xml/version.rb
 - nom.gemspec
 - spec/examples/namespaced_example_spec.rb
 - spec/examples/nutrition_example_spec.rb
+- spec/examples/template_registry_example_spec.rb
 - spec/fixtures/nutrition.xml
 - spec/fixtures/xml_namespaces.xml
 - spec/lib/nodeset_decorator_spec.rb
@@ -168,7 +172,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3518149504485723530
+      hash: 1606554633515477206
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -177,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3518149504485723530
+      hash: 1606554633515477206
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -187,6 +191,7 @@ summary: asdf
 test_files:
 - spec/examples/namespaced_example_spec.rb
 - spec/examples/nutrition_example_spec.rb
+- spec/examples/template_registry_example_spec.rb
 - spec/fixtures/nutrition.xml
 - spec/fixtures/xml_namespaces.xml
 - spec/lib/nodeset_decorator_spec.rb