om 3.0.3 → 3.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1de731732be29cdf0c460beebcb5b603deccb18c
+  data.tar.gz: 6fa913f9d7bcdd57e7d29555a266d265dd426ad0
+SHA512:
+  metadata.gz: e947f9c90119f8ac601105505d947a2ad78d4307ada79f3f7e609fd64ecb71c0330bbe668438e1d4ee71aac4dbcf112a9f5d2a0fe4a841d9a22125b81cd78e9d
+  data.tar.gz: 4db6a2f387c9630f6e9909966bc81e9939110ac92b6588745fb82766ec23d3249041ddbe70b5ddba6322b094622e51cdd09da26365bec6c6af7fcb12cc2a9f5a

data/CONTRIBUTING.md

@@ -0,0 +1,113 @@
+# How to Contribute
+
+We want your help to make Project Hydra great.
+There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.
+
+## Hydra Project Intellectual Property Licensing and Ownership
+
+All code contributors must have an Individual Contributor License Agreement (iCLA) on file with the Hydra Project Steering Group.
+If the contributor works for an institution, the institution must have a Corporate Contributor License Agreement (cCLA) on file.
+
+https://wiki.duraspace.org/display/hydra/Hydra+Project+Intellectual+Property+Licensing+and+Ownership
+
+You should also add yourself to the `CONTRIBUTORS.md` file in the root of the project.
+
+## Contribution Tasks
+
+* Reporting Issues
+* Making Changes
+* Submitting Changes
+* Merging Changes
+
+### Reporting Issues
+
+* Make sure you have a [GitHub account](https://github.com/signup/free)
+* Submit a [Github issue](./issues) by:
+  * Clearly describing the issue
+    * Provide a descriptive summary
+    * Explain the expected behavior
+    * Explain the actual behavior
+    * Provide steps to reproduce the actual behavior
+
+### Making Changes
+
+* Fork the repository on GitHub
+* Create a topic branch from where you want to base your work.
+  * This is usually the master branch.
+  * To quickly create a topic branch based on master; `git branch fix/master/my_contribution master`
+  * Then checkout the new branch with `git checkout fix/master/my_contribution`.
+  * Please avoid working directly on the `master` branch.
+  * You may find the [hub suite of commands](https://github.com/defunkt/hub) helpful
+* Make commits of logical units.
+  * Your commit should include a high level description of your work in HISTORY.textile 
+* Check for unnecessary whitespace with `git diff --check` before committing.
+* Make sure your commit messages are [well formed](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+* If you created an issue, you can close it by including "Closes #issue" in your commit message. See [Github's blog post for more details](https://github.com/blog/1386-closing-issues-via-commit-messages)
+
+```
+    Present tense short summary (50 characters or less)
+
+    More detailed description, if necessary. It should be wrapped to 72
+    characters. Try to be as descriptive as you can, even if you think that
+    the commit content is obvious, it may not be obvious to others. You
+    should add such description also if it's already present in bug tracker,
+    it should not be necessary to visit a webpage to check the history.
+
+    Include Closes #<issue-number> when relavent.
+
+    Description can have multiple paragraphs and you can use code examples
+    inside, just indent it with 4 spaces:
+
+        class PostsController
+          def index
+            respond_with Post.limit(10)
+          end
+        end
+
+    You can also add bullet points:
+
+    - you can use dashes or asterisks
+
+    - also, try to indent next line of a point for readability, if it's too
+      long to fit in 72 characters
+```
+
+* Make sure you have added the necessary tests for your changes.
+* Run _all_ the tests to assure nothing else was accidentally broken.
+* When you are ready to submit a pull request
+
+### Submitting Changes
+
+[Detailed Walkthrough of One Pull Request per Commit](http://ndlib.github.io/practices/one-commit-per-pull-request/)
+
+* Read the article ["Using Pull Requests"](https://help.github.com/articles/using-pull-requests) on GitHub.
+* Make sure your branch is up to date with its parent branch (i.e. master)
+  * `git checkout master`
+  * `git pull --rebase`
+  * `git checkout <your-branch>`
+  * `git rebase master`
+  * It is likely a good idea to run your tests again.
+* Squash the commits for your branch into one commit
+  * `git rebase --interactive HEAD~<number-of-commits>` ([See Github help](https://help.github.com/articles/interactive-rebase))
+  * To determine the number of commits on your branch: `git log master..<your-branch> --oneline | wc -l`
+  * Squashing your branch's changes into one commit is "good form" and helps the person merging your request to see everything that is going on.
+* Push your changes to a topic branch in your fork of the repository.
+* Submit a pull request from your fork to the project.
+
+### Merging Changes
+
+* It is considered "poor from" to merge your own request.
+* Please take the time to review the changes and get a sense of what is being changed. Things to consider:
+  * Does the commit message explain what is going on?
+  * Does the code changes have tests? _Not all changes need new tests, some changes are refactorings_
+  * Does the commit contain more than it should? Are two separate concerns being addressed in one commit?
+  * Did the Travis tests complete successfully?
+* If you are uncertain, bring other contributors into the conversation by creating a comment that includes their @username.
+* If you like the pull request, but want others to chime in, create a +1 comment and tag a user.
+
+# Additional Resources
+
+* [General GitHub documentation](http://help.github.com/)
+* [GitHub pull request documentation](http://help.github.com/send-pull-requests/)
+* [Pro Git](http://git-scm.com/book) is both a free and excellent book about Git.
+* [A Git Config for Contributing](http://ndlib.github.io/practices/my-typical-per-project-git-config/)

data/History.textile

@@ -1,9 +1,3 @@
-h3. 3.0.3 (19 Jul 2013)
-  Fix overly-aggressive template inheritance bug introduced in 3.0.2
-
-h3. 3.0.2 (15 Jul 2013)
-  Add terminology and template inheritance
-
 h3. 3.0.1 (25 Jun 2013)
   Fix bug where values that were the same as the existing values were 
     removed from the update list

data/README.md

@@ -0,0 +1,41 @@
+[![Build Status](https://travis-ci.org/projecthydra/om.png?branch=master)](https://travis-ci.org/projecthydra/om)
+[![Gem Version](https://badge.fury.io/rb/om.png)](http://badge.fury.io/rb/om)
+
+# om (Opinionated Metadata)
+
+A library to help you tame sprawling XML schemas like MODS.
+
+OM 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.
+
+OM "terms" are ruby symbols you define (in the terminology) that map specific XML content into ruby object attributes.
+
+## Tutorials & Reference
+
+* [Tame Your XML with OM](https://github.com/projecthydra/om/wiki/Tame-your-XML-with-OM)
+* [Common OM Patterns](https://github.com/projecthydra/om/blob/master/COMMON_OM_PATTERNS.textile)
+
+### Solrizing Documents
+
+The solrizer gem provides support for indexing XML documents into Solr based on OM Terminologies.  
+That process is documented in the [solrizer README](https://github.com/projecthydra/solrizer)
+
+## OM in the Wild
+
+We have a page on the Hydra wiki with a list of OM Terminologies in active use: 
+[OM Terminologies in the Wild](https://wiki.duraspace.org/display/hydra/OM+Terminologies+in+the+Wild)
+
+## Acknowledgments
+
+### Creator
+
+Matt Zumwalt ([MediaShelf](http://yourmediashelf.com)
+
+### Thanks To
+
+* Bess Sadler, who enabled us to take knowledge gleaned from developing Blacklight and apply it to OM metadata indexing
+* Ross Singer
+* Those who participated in the Opinionated MODS breakout session at Code4Lib 2010
+
+## Copyright
+
+Copyright (c) 2010 Matt Zumwalt. See LICENSE for details.

data/gemfiles/gemfile.rails4

@@ -2,7 +2,7 @@ source "http://rubygems.org"
 
 gemspec :path=>"../"
 
-gem 'activemodel', '4.0.0.rc1'
+gem 'activemodel', '~> 4.0.0'
 
 group :development, :test do
   gem 'simplecov', :platform => :mri_19

data/lib/om.rb

@@ -65,6 +65,8 @@ module OM
   def self.version
     Om::VERSION
   end
+
+  class TypeMismatch < StandardError; end
 end
 
 module OM::XML; end

data/lib/om/version.rb

@@ -1,3 +1,3 @@
 module Om
-  VERSION = "3.0.3"
+  VERSION = "3.0.5"
 end

data/lib/om/xml/document.rb

@@ -24,7 +24,12 @@ module OM::XML::Document
     end
 
     def terminology_builder
-      @terminology_builder ||= OM::XML::Terminology::Builder.new
+      return @terminology_builder if @terminology_builder
+      @terminology_builder = if superclass.respond_to? :terminology_builder
+        superclass.terminology_builder.dup
+      else
+        OM::XML::Terminology::Builder.new
+      end
     end
 
     def template_registry

data/lib/om/xml/dynamic_node.rb

@@ -44,7 +44,7 @@ module OM
         elsif args.length > 1
           new_update_node_with_index(name, args)
         else
-          child =  term_child_by_name(term.nil? ? parent.term : term, name)
+          child = term_child_by_name(term.nil? ? parent.term : term, name)
           if child
             OM::XML::DynamicNode.new(name, args.first, @document, child, self)
           else 
@@ -53,6 +53,10 @@ module OM
         end
       end
 
+      def respond_to?(method)
+        super || val.respond_to?(method)
+      end
+
       def new_update_node(name, args)
         modified_name = name.to_s.chop.to_sym
         child = term.retrieve_term(modified_name)
@@ -97,6 +101,8 @@ module OM
         end
       end
 
+      # This resolves the target of this dynamic node into a reified Array
+      # @return [Array]
       def val 
         query = xpath
         trim_text = !query.index("text()").nil?
@@ -119,7 +125,11 @@ module OM
       end
 
       def ==(other)
-        val == other
+        other == val
+      end
+
+      def !=(other)
+        val != other
       end
 
       def eql?(other)

data/lib/om/xml/term.rb

@@ -4,288 +4,291 @@ require 'om/xml/term_builder'
 # type, index_as, attributes,
 # is_root_term, required
 #
-class OM::XML::Term
+module OM
+  class XML::Term
 
-  include OM::TreeNode
-  include OM::XML::TermBuilder
+    include TreeNode
+    include XML::TermBuilder
 
-  attr_accessor :name, :xpath, :xpath_constrained, :xpath_relative, :path, :index_as, :required, :type, :variant_of, :path, :default_content_path, :is_root_term
-  attr_accessor :children, :internal_xml, :terminology
+    attr_accessor :name, :xpath, :xpath_constrained, :xpath_relative, :path, :index_as, :required, :type, :variant_of, :path, :default_content_path, :is_root_term
+    attr_accessor :children, :internal_xml, :terminology
 
-  # Any XML attributes that qualify the Term.
-  #
-  # @example Declare a Term that has a given attribute (ie. //title[@xml:lang='eng'])
-  #   t.english_title(:path=>"title", :attributes=>{"xml:lang"=>"eng"}
-  # @example Use nil to point to nodes that do not have a given attribute (ie. //title[not(@xml:lang)])
-  #   t.title_without_lang_attribute(:path=>"title", :attributes=>{"xml:lang"=>nil})
-  attr_accessor :attributes
+    # Any XML attributes that qualify the Term.
+    #
+    # @example Declare a Term that has a given attribute (ie. //title[@xml:lang='eng'])
+    #   t.english_title(:path=>"title", :attributes=>{"xml:lang"=>"eng"}
+    # @example Use nil to point to nodes that do not have a given attribute (ie. //title[not(@xml:lang)])
+    #   t.title_without_lang_attribute(:path=>"title", :attributes=>{"xml:lang"=>nil})
+    attr_accessor :attributes
 
-  # Namespace Prefix (xmlns) for the Term.
-  #
-  # By default, OM assumes that all terms in a Terminology have the namespace set in the root of the document.  If you want to set a different namespace for a Term, pass :namespace_prefix into its initializer (or call .namespace_prefix= on its builder)
-  # If a node has _no_ namespace, you must explicitly set namespace_prefix to nil.  Currently you have to do this on _each_ term, you can't set namespace_prefix to nil for an entire Terminology.
-  #
-  # @example
-  #   # For xml like this
-  #   <foo xmlns="http://foo.com/schemas/fooschema" xmlns:bar="http://bar.com/schemas/barschema">
-  #     <address>1400 Pennsylvania Avenue</address>
-  #     <bar:latitude>56</bar:latitude>
-  #   </foo>
-  #
-  #   # The Terminology would look like this
-  #   OM::XML::Terminology::Builder.new do |t|
-  #     t.root(:name=>:foo, :path=>"foo", :xmlns=>"http://foo.com/schemas/fooschema", "xmlns:bar"=>"http://bar.com/schemas/barschema")
-  #     t.address
-  #     t.latitude(:namespace_prefix=>"bar")
-  #   end
-  #
-  attr_accessor :namespace_prefix
+    # Namespace Prefix (xmlns) for the Term.
+    #
+    # By default, OM assumes that all terms in a Terminology have the namespace set in the root of the document.  If you want to set a different namespace for a Term, pass :namespace_prefix into its initializer (or call .namespace_prefix= on its builder)
+    # If a node has _no_ namespace, you must explicitly set namespace_prefix to nil.  Currently you have to do this on _each_ term, you can't set namespace_prefix to nil for an entire Terminology.
+    #
+    # @example
+    #   # For xml like this
+    #   <foo xmlns="http://foo.com/schemas/fooschema" xmlns:bar="http://bar.com/schemas/barschema">
+    #     <address>1400 Pennsylvania Avenue</address>
+    #     <bar:latitude>56</bar:latitude>
+    #   </foo>
+    #
+    #   # The Terminology would look like this
+    #   OM::XML::Terminology::Builder.new do |t|
+    #     t.root(:name=>:foo, :path=>"foo", :xmlns=>"http://foo.com/schemas/fooschema", "xmlns:bar"=>"http://bar.com/schemas/barschema")
+    #     t.address
+    #     t.latitude(:namespace_prefix=>"bar")
+    #   end
+    #
+    attr_accessor :namespace_prefix
 
 
-  # h2. Namespaces
-  # By default, OM assumes you have no namespace defined unless it is explicitly defined at the root of your document.
-  #
-  # @param [Symbol] name the name to refer to this term by
-  # @param [Hash] opts
-  # @option opts [Array]  :index_as a list of indexing hints provided to to_solr
-  # @option opts [String] :path partial xpath that points to the node.  
-  # @option opts [Hash]   :attributes xml attributes to match in the selector 
-  # @option opts [String] :namespace_prefix xml namespace for this node. If not provided, the default namespace set in the terminology will be used. 
-  # @option opts [Symbol] :type one of :string, :date, :time :integer. Defaults to :string
-  def initialize(name, opts={}, terminology=nil)
-    opts = {:ancestors=>[], :children=>{}}.merge(opts)
-    [:children, :ancestors,:path, :index_as, :required, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |accessor_name|
-      instance_variable_set("@#{accessor_name}", opts.fetch(accessor_name, nil) )
-    end
+    # h2. Namespaces
+    # By default, OM assumes you have no namespace defined unless it is explicitly defined at the root of your document.
+    #
+    # @param [Symbol] name the name to refer to this term by
+    # @param [Hash] opts
+    # @option opts [Array]  :index_as a list of indexing hints provided to to_solr
+    # @option opts [String] :path partial xpath that points to the node.
+    # @option opts [Hash]   :attributes xml attributes to match in the selector
+    # @option opts [String] :namespace_prefix xml namespace for this node. If not provided, the default namespace set in the terminology will be used. 
+    # @option opts [Symbol] :type one of :string, :date, :time :integer. Defaults to :string
+    def initialize(name, opts={}, terminology=nil)
+      opts = {:ancestors=>[], :children=>{}}.merge(opts)
+      [:children, :ancestors,:path, :index_as, :required, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |accessor_name|
+        instance_variable_set("@#{accessor_name}", opts.fetch(accessor_name, nil) )
+      end
 
-    self.type = opts[:type] || :string
+      self.type = opts[:type] || :string
 
-    unless terminology.nil?
-      if opts[:namespace_prefix].nil?
-        unless terminology.namespaces["xmlns"].nil?
-          @namespace_prefix = "oxns"
+      unless terminology.nil?
+        if opts[:namespace_prefix].nil?
+          unless terminology.namespaces["xmlns"].nil?
+            @namespace_prefix = "oxns"
+          end
         end
       end
+      @name = name
+      if @path.nil? || @path.empty?
+        @path = name.to_s
+      end
     end
-    @name = name
-    if @path.nil? || @path.empty?
-      @path = name.to_s
-    end
-  end
 
 
-  def sanitize_new_values(new_values)
-      # Sanitize new_values to always be a hash with indexes
-      case new_values
-      when Hash
-        sanitize_new_values(new_values.values)
-      when Array
-        new_values.map {|v| serialize(v)}
+    def sanitize_new_values(new_values)
+        # Sanitize new_values to always be a hash with indexes
+        case new_values
+        when Hash
+          sanitize_new_values(new_values.values)
+        when Array
+          new_values.map {|v| serialize(v)}
+        else
+          [serialize(new_values)]
+        end
+    end
+
+    # @param val [String,Date,Integer]
+    def serialize (val)
+      return if val.nil?
+      case type
+      when :date, :integer
+        val.to_s
+      when :time
+        time = val.to_time
+        raise TypeMismatch, "Can't convert `#{val}` to time" if time.nil?
+        time.utc.iso8601
+      when :boolean
+        val.to_s
       else
-        [serialize(new_values)]
+        val
       end
-  end
-  
-  # @param val [String,Date,Integer]
-  def serialize (val)
-    return if val.nil?
-    case type
-    when :date, :integer
-      val.to_s
-    when :time
-      val.to_time.utc.iso8601 
-    when :boolean
-      val.to_s
-    else 
-      val
     end
-  end
 
-  # @param [String] val the value (from xml) to deserialize into the correct object type.
-  # @return [String,Date,Integer]
-  def deserialize(val)
-    case type
-    when :date
-      #TODO use present?
-      val.map { |v| !v.empty? ? Date.parse(v) : nil}
-    when :time
-      #TODO use present?
-      val.map { |v| !v.empty? ? DateTime.parse(v) : nil}
-    when :integer
-      #TODO use blank?
-      val.map { |v| v.empty? ? nil : v.to_i}
-    when :boolean
-      val.map { |v| v == 'true' }
-    else 
-      val
+    # @param [String] val the value (from xml) to deserialize into the correct object type.
+    # @return [String,Date,Integer]
+    def deserialize(val)
+      case type
+      when :date
+        #TODO use present?
+        val.map { |v| !v.empty? ? Date.parse(v) : nil}
+      when :time
+        #TODO use present?
+        val.map { |v| !v.empty? ? DateTime.parse(v) : nil}
+      when :integer
+        #TODO use blank?
+        val.map { |v| v.empty? ? nil : v.to_i}
+      when :boolean
+        val.map { |v| v == 'true' }
+      else 
+        val
+      end
     end
-  end
 
-  def self.from_node(mapper_xml)
-    name = mapper_xml.attribute("name").text.to_sym
-    attributes = {}
-    mapper_xml.xpath("./attribute").each do |a|
-      attributes[a.attribute("name").text.to_sym] = a.attribute("value").text
-    end
-    new_mapper = self.new(name, :attributes=>attributes)
-    [:index_as, :required, :type, :variant_of, :path, :default_content_path, :namespace_prefix].each do |accessor_name|
-      attribute =  mapper_xml.attribute(accessor_name.to_s)
-      unless attribute.nil?
-        new_mapper.instance_variable_set("@#{accessor_name}", attribute.text )
+    def self.from_node(mapper_xml)
+      name = mapper_xml.attribute("name").text.to_sym
+      attributes = {}
+      mapper_xml.xpath("./attribute").each do |a|
+        attributes[a.attribute("name").text.to_sym] = a.attribute("value").text
       end
-    end
-    new_mapper.internal_xml = mapper_xml
+      new_mapper = self.new(name, :attributes=>attributes)
+      [:index_as, :required, :type, :variant_of, :path, :default_content_path, :namespace_prefix].each do |accessor_name|
+        attribute =  mapper_xml.attribute(accessor_name.to_s)
+        unless attribute.nil?
+          new_mapper.instance_variable_set("@#{accessor_name}", attribute.text )
+        end
+      end
+      new_mapper.internal_xml = mapper_xml
 
-    mapper_xml.xpath("./mapper").each do |child_node|
-      child = self.from_node(child_node)
-      new_mapper.add_child(child)
-    end
+      mapper_xml.xpath("./mapper").each do |child_node|
+        child = self.from_node(child_node)
+        new_mapper.add_child(child)
+      end
 
-    return new_mapper
-  end
+      return new_mapper
+    end
 
-  ##
-  # Always co-erce :index_as attributes into an Array
-  def index_as
-    Array(@index_as)
-  end
+    ##
+    # Always co-erce :index_as attributes into an Array
+    def index_as
+      Array(@index_as)
+    end
 
-  # crawl down into mapper's children hash to find the desired mapper
-  # ie. @test_mapper.retrieve_mapper(:conference, :role, :text)
-  def retrieve_term(*pointers)
-    children_hash = self.children
-    pointers.each do |p|
-      if children_hash.has_key?(p)
-        target = children_hash[p]
-        if pointers.index(p) == pointers.length-1
-          return target
+    # crawl down into mapper's children hash to find the desired mapper
+    # ie. @test_mapper.retrieve_mapper(:conference, :role, :text)
+    def retrieve_term(*pointers)
+      children_hash = self.children
+      pointers.each do |p|
+        if children_hash.has_key?(p)
+          target = children_hash[p]
+          if pointers.index(p) == pointers.length-1
+            return target
+          else
+            children_hash = target.children
+          end
         else
-          children_hash = target.children
+          return nil
         end
-      else
-        return nil
       end
+      return target
     end
-    return target
-  end
 
-  def is_root_term?
-    @is_root_term == true
-  end
+    def is_root_term?
+      @is_root_term == true
+    end
 
-  def xpath_absolute
-    @xpath
-  end
+    def xpath_absolute
+      @xpath
+    end
 
-  # +term_pointers+ reference to the property you want to generate a builder template for
-  # @param [Hash] extra_opts
-  # @option extra_opts [Hash] :attributes 
-  def xml_builder_template(extra_opts = {})
-    extra_attributes = extra_opts.fetch(:attributes, {})
+    # +term_pointers+ reference to the property you want to generate a builder template for
+    # @param [Hash] extra_opts
+    # @option extra_opts [Hash] :attributes
+    def xml_builder_template(extra_opts = {})
+      extra_attributes = extra_opts.fetch(:attributes, {})
 
-    node_options = []
-    node_child_template = ""
-    if !self.default_content_path.nil?
-      node_child_options = ["\':::builder_new_value:::\'"]
-      node_child_template = " { xml.#{self.default_content_path}( #{OM::XML.delimited_list(node_child_options)} ) }"
-    else
-      node_options = ["\':::builder_new_value:::\'"]
-    end
-    if !self.attributes.nil?
-      self.attributes.merge(extra_attributes).each_pair do |k,v|
-        node_options << "\'#{k}\'=>\'#{v}\'" unless v == :none
+      node_options = []
+      node_child_template = ""
+      if !self.default_content_path.nil?
+        node_child_options = ["\':::builder_new_value:::\'"]
+        node_child_template = " { xml.#{self.default_content_path}( #{OM::XML.delimited_list(node_child_options)} ) }"
+      else
+        node_options = ["\':::builder_new_value:::\'"]
+      end
+      if !self.attributes.nil?
+        self.attributes.merge(extra_attributes).each_pair do |k,v|
+          node_options << "\'#{k}\'=>\'#{v}\'" unless v == :none
+        end
       end
-    end
 
-    builder_ref = if self.path.include?(":")
-      "xml['#{self.path[0..path.index(":")-1]}']"
-    elsif !self.namespace_prefix.nil? and self.namespace_prefix != 'oxns'
-      "xml['#{self.namespace_prefix}']"
-    else
-      "xml"
-    end
+      builder_ref = if self.path.include?(":")
+        "xml['#{self.path[0..path.index(":")-1]}']"
+      elsif !self.namespace_prefix.nil? and self.namespace_prefix != 'oxns'
+        "xml['#{self.namespace_prefix}']"
+      else
+        "xml"
+      end
 
-    attribute = OM::XML.delimited_list(node_options)
+      attribute = OM::XML.delimited_list(node_options)
 
-    builder_method = if self.path.include?(":")
-      "#{self.path[path.index(":")+1..-1]}( #{attribute} )"
-    elsif self.path.include?(".")
-      "send(:\\\"#{self.path}\\\",  #{attribute} )"
-    elsif self.path.kind_of?(Hash) && self.path[:attribute]
-      "@#{self.path[:attribute]}( #{OM::XML.delimited_list(node_options)} )"
-    elsif Nokogiri::XML::Builder.method_defined? self.path.to_sym
-      "#{self.path}_( #{OM::XML.delimited_list(node_options)} )"
-    else
-      "#{self.path}( #{OM::XML.delimited_list(node_options)} )"
+      builder_method = if self.path.include?(":")
+        "#{self.path[path.index(":")+1..-1]}( #{attribute} )"
+      elsif self.path.include?(".")
+        "send(:\\\"#{self.path}\\\",  #{attribute} )"
+      elsif self.path.kind_of?(Hash) && self.path[:attribute]
+        "@#{self.path[:attribute]}( #{OM::XML.delimited_list(node_options)} )"
+      elsif Nokogiri::XML::Builder.method_defined? self.path.to_sym
+        "#{self.path}_( #{OM::XML.delimited_list(node_options)} )"
+      else
+        "#{self.path}( #{OM::XML.delimited_list(node_options)} )"
+      end
+      template = "#{builder_ref}.#{builder_method}#{node_child_template}"
+      return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
     end
-    template = "#{builder_ref}.#{builder_method}#{node_child_template}"
-    return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }
-  end
 
-  # Generates absolute, relative, and constrained xpaths for the term, setting xpath, xpath_relative, and xpath_constrained accordingly.
-  # Also triggers update_xpath_values! on all child nodes, as their absolute paths rely on those of their parent nodes.
-  def generate_xpath_queries!
-    self.xpath = OM::XML::TermXpathGenerator.generate_absolute_xpath(self)
-    self.xpath_constrained = OM::XML::TermXpathGenerator.generate_constrained_xpath(self)
-    self.xpath_relative = OM::XML::TermXpathGenerator.generate_relative_xpath(self)
-    self.children.each_value {|child| child.generate_xpath_queries! }
-    return self
-  end
+    # Generates absolute, relative, and constrained xpaths for the term, setting xpath, xpath_relative, and xpath_constrained accordingly.
+    # Also triggers update_xpath_values! on all child nodes, as their absolute paths rely on those of their parent nodes.
+    def generate_xpath_queries!
+      self.xpath = OM::XML::TermXpathGenerator.generate_absolute_xpath(self)
+      self.xpath_constrained = OM::XML::TermXpathGenerator.generate_constrained_xpath(self)
+      self.xpath_relative = OM::XML::TermXpathGenerator.generate_relative_xpath(self)
+      self.children.each_value {|child| child.generate_xpath_queries! }
+      return self
+    end
 
-  # Return an XML representation of the Term
-  # @param [Hash] options the term will be added to it. If :children=>false, skips rendering child Terms
-  # @param [Nokogiri::XML::Document] document (optional) document to insert the term xml into
-  # @return [Nokogiri::XML::Document]
-  # @example If :children=>false, skips rendering child Terms
-  #   term.to_xml(:children=>false)
-  # @example You can provide your own Nokogiri document to insert the xml into
-  #   doc = Nokogiri::XML::Document.new
-  #   term.to_xml({}, document=doc)
-  def to_xml(options={}, document=Nokogiri::XML::Document.new)
-    builder = Nokogiri::XML::Builder.with(document) do |xml|
-      xml.term(:name=>name) {
-        if is_root_term?
-          xml.is_root_term("true")
-        end
-        xml.path path
-        xml.namespace_prefix namespace_prefix
-        unless attributes.nil? || attributes.empty?
-          xml.attributes {
-            attributes.each_pair do |attribute_name, attribute_value|
-              xml.send("#{attribute_name}_".to_sym, attribute_value)
+    # Return an XML representation of the Term
+    # @param [Hash] options the term will be added to it. If :children=>false, skips rendering child Terms
+    # @param [Nokogiri::XML::Document] document (optional) document to insert the term xml into
+    # @return [Nokogiri::XML::Document]
+    # @example If :children=>false, skips rendering child Terms
+    #   term.to_xml(:children=>false)
+    # @example You can provide your own Nokogiri document to insert the xml into
+    #   doc = Nokogiri::XML::Document.new
+    #   term.to_xml({}, document=doc)
+    def to_xml(options={}, document=Nokogiri::XML::Document.new)
+      builder = Nokogiri::XML::Builder.with(document) do |xml|
+        xml.term(:name=>name) {
+          if is_root_term?
+            xml.is_root_term("true")
+          end
+          xml.path path
+          xml.namespace_prefix namespace_prefix
+          unless attributes.nil? || attributes.empty?
+            xml.attributes {
+              attributes.each_pair do |attribute_name, attribute_value|
+                xml.send("#{attribute_name}_".to_sym, attribute_value)
+              end
+            }
+          end
+          xml.index_as {
+            unless index_as.nil?
+              index_as.each  { |index_type| xml.index_type }
             end
           }
-        end
-        xml.index_as {
-          unless index_as.nil?
-            index_as.each  { |index_type| xml.index_type }
+          xml.required required
+          xml.data_type type
+          unless variant_of.nil?
+            xml.variant_of variant_of
+          end
+          unless default_content_path.nil?
+            xml.default_content_path default_content_path
+          end
+          xml.xpath {
+            xml.relative xpath_relative
+            xml.absolute xpath
+            xml.constrained xpath_constrained
+          }
+          if options.fetch(:children, true)
+            xml.children
           end
         }
-        xml.required required
-        xml.data_type type
-        unless variant_of.nil?
-          xml.variant_of variant_of
-        end
-        unless default_content_path.nil?
-          xml.default_content_path default_content_path
-        end
-        xml.xpath {
-          xml.relative xpath_relative
-          xml.absolute xpath
-          xml.constrained xpath_constrained
-        }
-        if options.fetch(:children, true)
-          xml.children
-        end
-      }
-    end
-    doc = builder.doc
-    if options.fetch(:children, true)
-      children.values.each {|child| child.to_xml(options, doc.xpath("//term[@name=\"#{name}\"]/children").first)}
+      end
+      doc = builder.doc
+      if options.fetch(:children, true)
+        children.values.each {|child| child.to_xml(options, doc.xpath("//term[@name=\"#{name}\"]/children").first)}
+      end
+      return doc
     end
-    return doc
-  end
-
-  # private :update_xpath_values
 
+    # private :update_xpath_values
+  end
 end