class OM::XML::Terminology

When you're defining a Terminology, you will usually use a “Terminology Builder”:OM/XML/Terminology/Builder.html to create it Each line you put into a “Terminology Builder”:OM/XML/Terminology/Builder.html is passed to the constructor for a “Term Builder”:OM/XML/Term/Builder.html. See the “OM::XML::Term::Builder”:OM/XML/Term/Builder.html API docs for complete description of your options for defining each Term.

The most important thing to define in a Terminology is the root term. This is the place where you set namespaces and schemas for the Terminology @example Define a Terminology with a root term “mods”, a default namespace of “www.loc.gov/mods/v3” and a schema of “www.loc.gov/standards/mods/v3/mods-3-2.xsd” (schema is optional)

terminology_builder = OM::XML::Terminology::Builder.new do |t|
  t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
end
terminology = terminology_builder.build

If you do not set a namespace, the terminology will assume there is no namespace on the xml document.

Attributes

namespaces[RW]

Terminology Class Definition

schema[RW]

Terminology Class Definition

terms[RW]

Terminology Class Definition

Public Class Methods

new(options={}) click to toggle source
# File lib/om/xml/terminology.rb, line 130
def initialize(options={})
  @schema = options.fetch(:schema,nil)
  @namespaces = options.fetch(:namespaces,{})
  @terms = {}
end
pointers_to_flat_array(pointers, include_indices=true) click to toggle source
# File lib/om/xml/terminology.rb, line 293
def self.pointers_to_flat_array(pointers, include_indices=true)
  OM.pointers_to_flat_array(pointers, include_indices)
end
term_generic_name(*pointers) click to toggle source
# File lib/om/xml/terminology.rb, line 285
def self.term_generic_name(*pointers)
  pointers_to_flat_array(pointers, false).join("_")
end
term_hierarchical_name(*pointers) click to toggle source
# File lib/om/xml/terminology.rb, line 289
def self.term_hierarchical_name(*pointers)
  pointers_to_flat_array(pointers, true).join("_")
end

Public Instance Methods

add_term(term) click to toggle source

Add a term to the root of the terminology

# File lib/om/xml/terminology.rb, line 137
def add_term(term)
  @terms[term.name.to_sym] = term
end
has_term?(*pointers) click to toggle source

Returns true if the current terminology has a term defined at the location indicated by pointers array

# File lib/om/xml/terminology.rb, line 142
def has_term?(*pointers)
  begin
    retrieve_term(*OM.pointers_to_flat_array(pointers, false))
    return true
  rescue
    return false
  end
end
retrieve_node(*args) click to toggle source

This is very similar to retrieve_term, however it expands proxy paths out into their cannonical paths

# File lib/om/xml/terminology.rb, line 181
def retrieve_node(*args)
  current_term = terms[args.shift]
  if current_term.kind_of? OM::XML::NamedTermProxy
    args = (current_term.proxy_pointer + args).flatten
    current_term = terms[args.shift]
  end
  args.empty? ? current_term : retrieve_node_subsequent(args, current_term)
end
retrieve_node_subsequent(args, context) click to toggle source
# File lib/om/xml/terminology.rb, line 169
def retrieve_node_subsequent(args, context)
  current_term = context.children[args.shift]
  if current_term.kind_of? OM::XML::NamedTermProxy
    args = (current_term.proxy_pointer + args).flatten
    current_term = context.children[args.shift]
  end
  args.empty? ? current_term : retrieve_node_subsequent(args, current_term)
end
retrieve_term(*args) click to toggle source

Returns the Term corresponding to the given pointer. Proxies are not expanded

# File lib/om/xml/terminology.rb, line 153
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
root_terms() click to toggle source

Returns an array of Terms that have been marked as “root” terms

# File lib/om/xml/terminology.rb, line 252
def root_terms
  terms.values.select {|term| term.is_root_term? }
end
to_xml(options={}, document=Nokogiri::XML::Document.new) click to toggle source

Return an XML representation of the Terminology and its terms @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

terminology.to_xml(:children=>false)

@example You can provide your own Nokogiri document to insert the xml into

doc = Nokogiri::XML::Document.new
terminology.to_xml({}, document=doc)
# File lib/om/xml/terminology.rb, line 265
def to_xml(options={}, document=Nokogiri::XML::Document.new)
  builder = Nokogiri::XML::Builder.with(document) do |xml|
    xml.terminology {
      xml.schema schema
      xml.namespaces {
        namespaces.each_pair do |ns_name, ns_value|
          xml.namespace {
            xml.name ns_name
            xml.identifier ns_value
          }
        end
      }
      xml.terms
    }
  end
  document = builder.doc
  terms.values.each {|term| term.to_xml(options,document.xpath("//terms").first)}
  return document
end
xml_builder_template(*term_pointers) click to toggle source

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

# File lib/om/xml/terminology.rb, line 240
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
xpath_for(*pointers) click to toggle source

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. If you provide an xpath query as the argument, it will be returne untouched.

# File lib/om/xml/terminology.rb, line 194
def xpath_for(*pointers)
  if pointers.length == 1 && pointers.first.instance_of?(String)
    return pointers.first
  end
  query_constraints = nil

  if pointers.length > 1 && !pointers.last.kind_of?(Symbol)
    query_constraints = pointers.pop
  end

  term = retrieve_node( *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
  xpath_query
end
xpath_with_indexes(*pointers) click to toggle source

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"]'

Ex. terminology.xpath_with_indexes({:conference=>0}, {:role=>1}, {:text => 0} )

will yield an xpath like this: '//oxns:name[@type="conference"][1]/oxns:role[2]/oxns:roleTerm[@type="text"][1]'
# File lib/om/xml/terminology.rb, line 230
def xpath_with_indexes(*pointers)
  OM::XML::TermXpathGenerator.generate_xpath_with_indexes(self, *pointers)
end