om 0.1.10 → 1.0.0

data/lib/om/xml/term_xpath_generator.rb

@@ -0,0 +1,224 @@
+module OM::XML::TermXpathGenerator
+  
+  def self.generate_relative_xpath(mapper)
+    template = ""
+    predicates = []
+    
+    if mapper.namespace_prefix.nil?
+      complete_prefix = ""
+    else
+      complete_prefix = mapper.namespace_prefix + ":"
+    end
+    
+    if mapper.path.kind_of?(Hash)
+      if mapper.path.has_key?(:attribute)
+        base_path = "@"+mapper.path[:attribute]
+      else
+        raise "#{mapper.path} is an invalid path for an OM::XML::Term.  You should provide either a string or {:attributes=>XXX}"
+      end
+    else
+      unless mapper.namespace_prefix.nil?
+        template << complete_prefix
+      end
+      base_path = mapper.path
+    end
+    template << base_path
+    
+    unless mapper.attributes.nil?
+      mapper.attributes.each_pair do |attr_name, attr_value|
+        predicates << "@#{attr_name}=\"#{attr_value}\""
+      end
+    end
+    
+    unless predicates.empty? 
+      template << "["+ delimited_list(predicates, " and ")+"]"
+    end
+    
+    return template
+  end
+  
+  def self.generate_absolute_xpath(mapper)
+    relative = generate_relative_xpath(mapper)
+    if mapper.parent.nil?
+      return "//#{relative}"
+    else
+      return mapper.parent.xpath_absolute + "/" + relative
+    end
+  end
+  
+  def self.generate_constrained_xpath(mapper)
+    if mapper.namespace_prefix.nil?
+      complete_prefix = ""
+    else
+      complete_prefix = mapper.namespace_prefix + ":"
+    end
+    
+    absolute = generate_absolute_xpath(mapper)
+    constraint_predicates = []
+    
+    arguments_for_contains_function = []
+
+    if !mapper.default_content_path.nil?
+      arguments_for_contains_function << "#{complete_prefix}#{mapper.default_content_path}"
+    end
+      
+    # If no subelements have been specified to search within, set contains function to search within the current node
+    if arguments_for_contains_function.empty?
+      arguments_for_contains_function << "."
+    end
+    
+    arguments_for_contains_function << "\":::constraint_value:::\""
+  
+    contains_function = "contains(#{delimited_list(arguments_for_contains_function)})"
+
+    template = add_predicate(absolute, contains_function)
+    return template.gsub( /:::(.*?):::/ ) { '#{'+$1+'}' }.gsub('"', '\"')
+  end
+  
+  def self.generate_xpath(mapper, type)
+    case type
+    when :relative
+      self.generate_relative_xpath(mapper)
+    when :absolute
+      self.generate_absolute_xpath(mapper)
+    when :constrained
+      self.generate_constrained_xpath(mapper)
+    end
+  end
+  
+  # Use the given +terminology+ to generate an xpath with (optional) node indexes for each of the term pointers.
+  # Ex.  OM::XML::TermXpathGenerator.xpath_with_indexes(my_terminology, {:conference=>0}, {:role=>1}, :text ) 
+  #      will yield an xpath similar to this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
+  def self.generate_xpath_with_indexes(terminology, *pointers)
+    if pointers.first.nil?
+      root_term = terminology.root_terms.first
+      if root_term.nil?
+        return "/"
+      else
+        return root_term.xpath
+      end
+    end
+    
+    query_constraints = nil
+    
+    if pointers.length > 1 && pointers.last.kind_of?(Hash)
+      query_constraints = pointers.pop
+    end
+
+    if pointers.length == 1 && pointers.first.instance_of?(String)
+      return xpath_query = pointers.first
+    end
+      
+    # if pointers.first.kind_of?(String)
+    #   return pointers.first
+    # end
+    
+    keys = []
+    xpath = "//"
+
+    pointers = OM.destringify(pointers)
+    pointers.each_with_index do |pointer, pointer_index|
+      
+      if pointer.kind_of?(Hash)
+        k = pointer.keys.first
+        index = pointer[k]
+      else
+        k = pointer
+        index = nil
+      end
+      
+      keys << k
+      
+      term = terminology.retrieve_term(*keys)  
+      # Return nil if there is no term to work with
+      if term.nil? then return nil end
+      
+      # If we've encountered a NamedTermProxy, insert path sections corresponding to 
+      # terms corresponding to each entry in its proxy_pointer rather than just the final term that it points to.
+      if term.kind_of? OM::XML::NamedTermProxy
+        current_location = term.parent
+        relative_path = ""
+        term.proxy_pointer.each_with_index do |proxy_pointer, proxy_pointer_index|
+          proxy_term = current_location.retrieve_term(proxy_pointer)
+          proxy_relative_path = proxy_term.xpath_relative
+          if proxy_pointer_index > 0
+            proxy_relative_path = "/"+proxy_relative_path
+          end
+          relative_path << proxy_relative_path
+          current_location = proxy_term
+        end
+      else  
+        relative_path = term.xpath_relative
+      
+        unless index.nil?
+          relative_path = add_node_index_predicate(relative_path, index)
+        end
+      end
+      
+      if pointer_index > 0
+        relative_path = "/"+relative_path
+      end
+      xpath << relative_path 
+    end
+      
+    final_term = terminology.retrieve_term(*keys) 
+    
+    if query_constraints.kind_of?(Hash)
+      contains_functions = []
+      query_constraints.each_pair do |k,v|
+        if k.instance_of?(Symbol)
+          constraint_path = final_term.children[k].xpath_relative
+        else
+          constraint_path = k
+        end
+        contains_functions << "contains(#{constraint_path}, \"#{v}\")"
+      end
+      
+      xpath = add_predicate(xpath, delimited_list(contains_functions, " and ") )
+    end
+    
+    return xpath
+  end
+  
+  
+  def self.delimited_list( values_array, delimiter=", ")
+    result = values_array.collect{|a| a + delimiter}.to_s.chomp(delimiter)
+  end
+  
+  # Adds xpath xpath node index predicate to the end of your xpath query
+  # Example: 
+  # add_node_index_predicate("//oxns:titleInfo",0)
+  #   => "//oxns:titleInfo[1]"
+  #
+  # add_node_index_predicate("//oxns:titleInfo[@lang=\"finnish\"]",0)
+  #   => "//oxns:titleInfo[@lang=\"finnish\"][1]"
+  def self.add_node_index_predicate(xpath_query, array_index_value)
+    modified_query = xpath_query.dup
+    modified_query << "[#{array_index_value + 1}]"
+  end
+  
+  # Adds xpath:position() method call to the end of your xpath query
+  # Examples: 
+  #
+  # add_position_predicate("//oxns:titleInfo",0)
+  # => "//oxns:titleInfo[position()=1]"
+  #
+  # add_position_predicate("//oxns:titleInfo[@lang=\"finnish\"]",0)
+  # => "//oxns:titleInfo[@lang=\"finnish\" and position()=1]"
+  def self.add_position_predicate(xpath_query, array_index_value)
+    position_function = "position()=#{array_index_value + 1}"
+    self.add_predicate(xpath_query, position_function)
+  end
+  
+  def self.add_predicate(xpath_query, predicate)
+    modified_query = xpath_query.dup
+    # if xpath_query.include?("]")
+    if xpath_query[xpath_query.length-1..xpath_query.length] == "]"
+      modified_query.insert(xpath_query.rindex("]"), " and #{predicate}")
+    else
+      modified_query << "[#{predicate}]"
+    end
+    return modified_query
+  end
+
+end

data/lib/om/xml/terminology.rb

@@ -0,0 +1,216 @@
+class OM::XML::Terminology
+  
+  class BadPointerError < StandardError; end
+  class CircularReferenceError < StandardError; end
+  
+  class Builder
+    
+    attr_accessor :schema, :namespaces
+    attr_reader :term_builders
+    ###
+    # Create a new Terminology Builder object.  +options+ are sent to the top level
+    # Document that is being built.  
+    # (not yet supported:) +root+ can be a point in an existing Terminology that you want to add Mappers into
+    #
+    # Building a document with a particular encoding for example:
+    #
+    #   Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+    #     ...
+    #   end
+    def initialize(options = {}, root = nil, &block)
+      @schema = options.fetch(:schema,nil)
+      @namespaces = options.fetch(:namespaces,{})
+      @term_builders = {}
+      @cur_term_builder = nil
+      
+      yield self if block_given?
+    end
+    
+    # Set the root of the Terminology, along with namespace & schema info
+    def root opts, &block
+      @schema = opts.fetch(:schema,nil)
+      opts.select {|k,v| k.to_s.include?("xmlns")}.each do |ns_pair|
+        @namespaces[ns_pair.first.to_s] = ns_pair.last
+        if ns_pair.first.to_s == "xmlns"
+          @namespaces["oxns"] = ns_pair.last
+        end
+      end
+      root_term_builder = OM::XML::Term::Builder.new(opts.fetch(:path,:root).to_s.sub(/[_!]$/, '')).is_root_term(true)
+      @term_builders[root_term_builder.name] = root_term_builder
+      
+      return root_term_builder
+    end
+    
+    # Returns an array of Terms that have been marked as "root" terms
+    def root_term_builders
+      @term_builders.values.select {|term_builder| term_builder.settings[:is_root_term] == true }
+    end
+    
+    def method_missing method, *args, &block # :nodoc:
+      parent_builder = @cur_term_builder
+      @cur_term_builder = OM::XML::Term::Builder.new(method.to_s.sub(/[_!]$/, ''), self)
+      
+      # Attach to parent
+      if parent_builder
+        parent_builder.add_child @cur_term_builder
+      else
+        @term_builders [@cur_term_builder.name] = @cur_term_builder
+      end
+      
+      # Apply options
+      opts = args.shift
+      @cur_term_builder.settings.merge!(opts) if opts
+      
+      # Parse children
+      yield if block
+      
+      @cur_term_builder = parent_builder
+    end
+    
+    # Returns the TermBuilder corresponding to the given _pointer_.
+    def retrieve_term_builder(*args)
+      args_cp = args.dup
+      current_term = @term_builders[args_cp.delete_at(0)]
+      if current_term.nil?
+        raise OM::XML::Terminology::BadPointerError, "This TerminologyBuilder does not have a root TermBuilder defined that corresponds to \"#{args.first.inspect}\""
+      end
+      args_cp.each do |arg|
+        current_term = current_term.retrieve_child(arg)
+        if current_term.nil?
+          raise OM::XML::Terminology::BadPointerError, "You attempted to retrieve a TermBuilder using this pointer: #{args.inspect} but no TermBuilder exists at that location. Everything is fine until \"#{arg.inspect}\", which doesn't exist."
+        end
+      end
+      return current_term
+    end
+    
+    def build
+      terminology = OM::XML::Terminology.new(:schema=>@schema, :namespaces=>@namespaces)
+      root_term_builders.each do |root_term_builder| 
+        root_term_builder.children = self.term_builders.dup 
+        root_term_builder.children.delete(root_term_builder.name)
+      end 
+      @term_builders.each_value do |root_builder|
+        terminology.add_term root_builder.build
+      end
+      terminology
+    end
+  end
+  
+  # Terminology Class Definition
+  
+  attr_accessor :terms, :schema, :namespaces
+  
+  def initialize(options={})
+    @schema = options.fetch(:schema,nil)
+    @namespaces = options.fetch(:namespaces,{})
+    @terms = {}
+  end
+  
+  # Add a term to the root of the terminology
+  def add_term(term)
+    @terms[term.name.to_sym] = term
+  end
+  
+  # Returns true if the current terminology has a term defined at the location indicated by +pointers+ array
+  def has_term?(*pointers)
+    begin
+      retrieve_term(*OM.pointers_to_flat_array(pointers, false))
+      return true
+    rescue
+      return false
+    end
+  end
+  
+  # Returns the Term corresponding to the given _pointer_.
+  def retrieve_term(*args)
+    args_cp = args.dup
+    current_term = terms[args_cp.delete_at(0)]
+    if current_term.nil?
+      raise OM::XML::Terminology::BadPointerError, "This Terminology does not have a root term defined that corresponds to \"#{args.first.inspect}\""
+    else
+      args_cp.each do |arg|
+        current_term = current_term.retrieve_child(arg)
+        if current_term.nil?
+          raise OM::XML::Terminology::BadPointerError, "You attempted to retrieve a Term using this pointer: #{args.inspect} but no Term exists at that location. Everything is fine until \"#{arg.inspect}\", which doesn't exist."
+        end
+      end
+    end
+    return current_term
+  end
+  
+  # Return the appropriate xpath query for retrieving nodes corresponding to the term identified by +pointers+.
+  # If the last argument is a String or a Hash, it will be used to add +constraints+ to the resulting xpath query.
+  def xpath_for(*pointers)
+    if pointers.length == 1 && pointers.first.instance_of?(String)
+      xpath_query = pointers.first
+    else
+      query_constraints = nil
+      
+      if pointers.length > 1 && !pointers.last.kind_of?(Symbol)
+        query_constraints = pointers.pop
+      end
+
+      term = retrieve_term( *pointers )
+
+      if !term.nil?
+        if query_constraints.kind_of?(String)
+          constraint_value = query_constraints
+          xpath_template = term.xpath_constrained
+          xpath_query = eval( '"' + xpath_template + '"' )
+        elsif query_constraints.kind_of?(Hash) && !query_constraints.empty?       
+          key_value_pair = query_constraints.first 
+          constraint_value = key_value_pair.last
+          xpath_template = term.children[key_value_pair.first].xpath_constrained
+          xpath_query = eval( '"' + xpath_template + '"' )          
+        else 
+          xpath_query = term.xpath
+        end
+      else
+        xpath_query = nil
+      end
+    end
+    return xpath_query
+  end
+  
+  # Use the current terminology to generate an xpath with (optional) node indexes for each of the term pointers.
+  # Ex.  terminology.xpath_with_indexes({:conference=>0}, {:role=>1}, :text ) 
+  #      will yield an xpath like this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"]'
+  def xpath_with_indexes(*pointers)
+    OM::XML::TermXpathGenerator.generate_xpath_with_indexes(self, *pointers)
+  end
+  
+  # Retrieves a Term corresponding to +term_pointers+ and return the corresponding xml_builder_template for that term.
+  # The resulting xml_builder_template can be passed as a block into Nokogiri::XML::Builder.new
+  #
+  # +term_pointers+ point to the Term you want to generate a builder template for
+  # If the last term_pointer is a String or a Hash, it will be passed into the Term's xml_builder_template method as extra_opts
+  # see also: Term.xml_builder_template
+  def xml_builder_template(*term_pointers)    
+    extra_opts = {}
+    
+    if term_pointers.length > 1 && !term_pointers.last.kind_of?(Symbol)
+      extra_opts = term_pointers.pop
+    end
+    
+    term = retrieve_term(*term_pointers)
+    return term.xml_builder_template(extra_opts)
+  end
+  
+  # Returns an array of Terms that have been marked as "root" terms
+  def root_terms
+    terms.values.select {|term| term.is_root_term? }
+  end
+  
+  def self.term_generic_name(*pointers)
+    pointers_to_flat_array(pointers, false).join("_")
+  end
+  
+  def self.term_hierarchical_name(*pointers)
+    pointers_to_flat_array(pointers, true).join("_")
+  end
+  
+  def self.pointers_to_flat_array(pointers, include_indices=true)
+    OM.pointers_to_flat_array(pointers, include_indices)
+  end
+  
+end

data/lib/om/xml/vocabulary.rb

@@ -0,0 +1,17 @@
+class OM::XML::Vocabulary
+  
+  attr_accessor :builder
+  # Vocabularies are not editable once they've been created because inserting/removing/rearranging mappers in a vocabulary 
+  # will invalidate the xpath queries for an entire branch of the Vocabulary's tree of mappers.
+  # If you want to change a vocabulary's structure, retrieve it's +builder+, make your changes, and re-generate the vocabulary.
+  # 
+  # Ex:
+  #   builder = vocabulary.builder
+  #   builder.insert_mapper(:name_, :namePart)
+  #   vocabulary = builder.build
+  
+  # Mappers can be retrieved by their mapper name
+  # Ex.
+  # vocabulary.retrieve_mapper(:name_, :namePart)
+
+end

data/lib/om/xml.rb

@@ -5,10 +5,26 @@ require "om/xml/properties"
 require "om/xml/property_value_operators"
 require "om/xml/generator"
 
+require "om/xml/terminology"
+require "om/xml/term"
+require "om/xml/term_xpath_generator"
+require "om/xml/node_generator"
+require "om/xml/term_value_operators"
+require "om/xml/named_term_proxy"
+require "om/xml/document"
+
+
 module OM::XML
   
   attr_accessor :ng_xml
   
+  # Module Methods -- These methods can be called directly on the Module itself
+  
+  # Transforms an array of values into a string delimited by +delimiter+
+  def self.delimited_list( values_array, delimiter=", ")
+    result = values_array.collect{|a| a + delimiter}.to_s.chomp(delimiter)
+  end
+  
   # Class Methods -- These methods will be available on classes that include this Module 
   
   module ClassMethods
@@ -42,4 +58,5 @@ module OM::XML
     klass.send(:include, OM::XML::Generator)
   end
   
+  
 end

data/lib/om.rb

@@ -59,6 +59,8 @@ end
 
 module OM::XML; end
 
+require "om/tree_node"
 require "om/xml"
+require "om/samples"
 
 

data/om.gemspec

@@ -5,16 +5,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{om}
-  s.version = "0.1.10"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Zumwalt"]
-  s.date = %q{2010-07-06}
+  s.date = %q{2010-09-15}
   s.description = %q{OM (Opinionated Metadata): A library to help you tame sprawling XML schemas like MODS.  Wraps Nokogiri documents in objects with miscellaneous helper methods for doing things like retrieve generated xpath queries or look up properties based on a simplified DSL}
   s.email = %q{matt.zumwalt@yourmediashelf.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.rdoc",
+     "README.textile"
   ]
   s.files = [
     ".document",
@@ -22,17 +23,29 @@ Gem::Specification.new do |s|
      "History.textile",
      "LICENSE",
      "README.rdoc",
+     "README.textile",
      "Rakefile",
      "VERSION",
      "container_spec.rb",
      "lib/om.rb",
+     "lib/om/samples.rb",
+     "lib/om/samples/mods_article.rb",
+     "lib/om/tree_node.rb",
      "lib/om/xml.rb",
      "lib/om/xml/accessors.rb",
      "lib/om/xml/container.rb",
+     "lib/om/xml/document.rb",
      "lib/om/xml/generator.rb",
+     "lib/om/xml/named_term_proxy.rb",
+     "lib/om/xml/node_generator.rb",
      "lib/om/xml/properties.rb",
      "lib/om/xml/property_value_operators.rb",
+     "lib/om/xml/term.rb",
+     "lib/om/xml/term_value_operators.rb",
+     "lib/om/xml/term_xpath_generator.rb",
+     "lib/om/xml/terminology.rb",
      "lib/om/xml/validation.rb",
+     "lib/om/xml/vocabulary.rb",
      "om.gemspec",
      "spec/fixtures/CBF_MODS/ARS0025_016.xml",
      "spec/fixtures/RUBRIC_mods_article_template.xml",
@@ -44,10 +57,19 @@ Gem::Specification.new do |s|
      "spec/spec_helper.rb",
      "spec/unit/accessors_spec.rb",
      "spec/unit/container_spec.rb",
+     "spec/unit/document_spec.rb",
      "spec/unit/generator_spec.rb",
+     "spec/unit/named_term_proxy_spec.rb",
+     "spec/unit/node_generator_spec.rb",
      "spec/unit/om_spec.rb",
      "spec/unit/properties_spec.rb",
      "spec/unit/property_value_operators_spec.rb",
+     "spec/unit/term_builder_spec.rb",
+     "spec/unit/term_spec.rb",
+     "spec/unit/term_value_operators_spec.rb",
+     "spec/unit/term_xpath_generator_spec.rb",
+     "spec/unit/terminology_builder_spec.rb",
+     "spec/unit/terminology_spec.rb",
      "spec/unit/validation_spec.rb",
      "spec/unit/xml_spec.rb"
   ]
@@ -61,10 +83,19 @@ Gem::Specification.new do |s|
      "spec/spec_helper.rb",
      "spec/unit/accessors_spec.rb",
      "spec/unit/container_spec.rb",
+     "spec/unit/document_spec.rb",
      "spec/unit/generator_spec.rb",
+     "spec/unit/named_term_proxy_spec.rb",
+     "spec/unit/node_generator_spec.rb",
      "spec/unit/om_spec.rb",
      "spec/unit/properties_spec.rb",
      "spec/unit/property_value_operators_spec.rb",
+     "spec/unit/term_builder_spec.rb",
+     "spec/unit/term_spec.rb",
+     "spec/unit/term_value_operators_spec.rb",
+     "spec/unit/term_xpath_generator_spec.rb",
+     "spec/unit/terminology_builder_spec.rb",
+     "spec/unit/terminology_spec.rb",
      "spec/unit/validation_spec.rb",
      "spec/unit/xml_spec.rb"
   ]
@@ -74,20 +105,20 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.4.2"])
       s.add_runtime_dependency(%q<facets>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_development_dependency(%q<mocha>, [">= 0.9.8"])
       s.add_development_dependency(%q<ruby-debug>, [">= 0"])
     else
-      s.add_dependency(%q<nokogiri>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, [">= 1.4.2"])
       s.add_dependency(%q<facets>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_dependency(%q<mocha>, [">= 0.9.8"])
       s.add_dependency(%q<ruby-debug>, [">= 0"])
     end
   else
-    s.add_dependency(%q<nokogiri>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, [">= 1.4.2"])
     s.add_dependency(%q<facets>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
     s.add_dependency(%q<mocha>, [">= 0.9.8"])

data/spec/fixtures/mods_articles/hydrangea_article1.xml

@@ -73,7 +73,6 @@
             </detail>
             <extent unit="pages">
                 <start>195</start>
-                <end>230</end>
             </extent>
             <date>FEB. 2007</date>
         </part>            

data/spec/integration/rights_metadata_integration_example_spec.rb

@@ -7,22 +7,34 @@ describe "OM::XML::Accessors" do
   before(:all) do
     class RightsMDTest
       
-      include OM::XML
-      
-      root_property :rightsMetadata, "rightsMetadata", "http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd"          
-      
-      property :access, :path=>"access",
-                  :subelements=>[:machine],
-                  :convenience_methods => {
-                    :human_readable => {:path=>"human"}
-                  }
-                  
-      property :edit_access, :variant_of=>:access, :attributes=>{:type=>"edit"}
-      
-      property :machine, :path=>"machine",
-                  :subelements=>["group","person"]
+      include OM::XML::Document
+          
+      terminology = OM::XML::Terminology::Builder.new do |t|
+        t.rightsMetadata(:xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") {
+          t.access {
+            t.human_readable(:path=>"human")
+            t.machine {
+              t.group
+              t.person
+            }
+          }
+          t.edit_access(:variant_of=>:access, :attributes=>{:type=>"personal"})
+        }
+      end
+      # root_property :rightsMetadata, "rightsMetadata", "http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd"          
+      # 
+      # property :access, :path=>"access",
+      #             :subelements=>[:machine],
+      #             :convenience_methods => {
+      #               :human_readable => {:path=>"human"}
+      #             }
+      #             
+      # property :edit_access, :variant_of=>:access, :attributes=>{:type=>"edit"}
+      # 
+      # property :machine, :path=>"machine",
+      #             :subelements=>["group","person"]
       
-      generate_accessors_from_properties
+      # generate_accessors_from_properties
       # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
       def self.xml_template
         builder = Nokogiri::XML::Builder.new do |xml|