Class: OM::XML::Terminology
- Inherits:
-
Object
- Object
- OM::XML::Terminology
- Defined in:
- lib/om/xml/terminology.rb
Overview
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 If you do not set a namespace, the terminology will assume there is no namespace on the xml document.
Defined Under Namespace
Classes: BadPointerError, Builder, CircularReferenceError
Instance Attribute Summary collapse
-
#namespaces ⇒ Object
Terminology Class Definition.
-
#schema ⇒ Object
Terminology Class Definition.
-
#terms ⇒ Object
Terminology Class Definition.
Class Method Summary collapse
- .pointers_to_flat_array(pointers, include_indices = true) ⇒ Object
- .term_generic_name(*pointers) ⇒ Object
- .term_hierarchical_name(*pointers) ⇒ Object
Instance Method Summary collapse
-
#add_term(term) ⇒ Object
Add a term to the root of the terminology.
-
#has_term?(*pointers) ⇒ Boolean
Returns true if the current terminology has a term defined at the location indicated by
pointers
array. -
#initialize(options = {}) ⇒ Terminology
constructor
A new instance of Terminology.
-
#retrieve_node(*args) ⇒ Object
This is very similar to retrieve_term, however it expands proxy paths out into their cannonical paths.
- #retrieve_node_subsequent(args, context) ⇒ Object
-
#retrieve_term(*args) ⇒ Object
Returns the Term corresponding to the given pointer.
-
#root_terms ⇒ Object
Returns an array of Terms that have been marked as “root” terms.
-
#to_xml(options = {}, document = Nokogiri::XML::Document.new) ⇒ Nokogiri::XML::Document
Return an XML representation of the Terminology and its terms.
-
#xml_builder_template(*term_pointers) ⇒ Object
Retrieves a Term corresponding to
term_pointers
and return the corresponding xml_builder_template for that term. -
#xpath_for(*pointers) ⇒ Object
Return the appropriate xpath query for retrieving nodes corresponding to the term identified by
pointers
. -
#xpath_with_indexes(*pointers) ⇒ Object
Use the current terminology to generate an xpath with (optional) node indexes for each of the term pointers.
Constructor Details
#initialize(options = {}) ⇒ Terminology
Returns a new instance of Terminology.
122 123 124 125 126 |
# File 'lib/om/xml/terminology.rb', line 122 def initialize(={}) @schema = .fetch(:schema,nil) @namespaces = .fetch(:namespaces,{}) @terms = {} end |
Instance Attribute Details
#namespaces ⇒ Object
Terminology Class Definition
120 121 122 |
# File 'lib/om/xml/terminology.rb', line 120 def namespaces @namespaces end |
#schema ⇒ Object
Terminology Class Definition
120 121 122 |
# File 'lib/om/xml/terminology.rb', line 120 def schema @schema end |
#terms ⇒ Object
Terminology Class Definition
120 121 122 |
# File 'lib/om/xml/terminology.rb', line 120 def terms @terms end |
Class Method Details
.pointers_to_flat_array(pointers, include_indices = true) ⇒ Object
283 284 285 |
# File 'lib/om/xml/terminology.rb', line 283 def self.pointers_to_flat_array(pointers, include_indices=true) OM.pointers_to_flat_array(pointers, include_indices) end |
.term_generic_name(*pointers) ⇒ Object
275 276 277 |
# File 'lib/om/xml/terminology.rb', line 275 def self.term_generic_name(*pointers) pointers_to_flat_array(pointers, false).join("_") end |
.term_hierarchical_name(*pointers) ⇒ Object
279 280 281 |
# File 'lib/om/xml/terminology.rb', line 279 def self.term_hierarchical_name(*pointers) pointers_to_flat_array(pointers, true).join("_") end |
Instance Method Details
#add_term(term) ⇒ Object
Add a term to the root of the terminology
129 130 131 |
# File 'lib/om/xml/terminology.rb', line 129 def add_term(term) @terms[term.name.to_sym] = term end |
#has_term?(*pointers) ⇒ Boolean
Returns true if the current terminology has a term defined at the location indicated by pointers
array
134 135 136 137 138 139 140 141 |
# File 'lib/om/xml/terminology.rb', line 134 def has_term?(*pointers) begin retrieve_term(*OM.pointers_to_flat_array(pointers, false)) return true rescue return false end end |
#retrieve_node(*args) ⇒ Object
This is very similar to retrieve_term, however it expands proxy paths out into their cannonical paths
173 174 175 176 177 178 179 180 |
# File 'lib/om/xml/terminology.rb', line 173 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) ⇒ Object
161 162 163 164 165 166 167 168 |
# File 'lib/om/xml/terminology.rb', line 161 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) ⇒ Object
Returns the Term corresponding to the given pointer. Proxies are not expanded
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 |
# File 'lib/om/xml/terminology.rb', line 145 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 ⇒ Object
Returns an array of Terms that have been marked as “root” terms
242 243 244 |
# File 'lib/om/xml/terminology.rb', line 242 def root_terms terms.values.select {|term| term.is_root_term? } end |
#to_xml(options = {}, document = Nokogiri::XML::Document.new) ⇒ Nokogiri::XML::Document
Return an XML representation of the Terminology and its terms
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 |
# File 'lib/om/xml/terminology.rb', line 255 def to_xml(={}, 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(,document.xpath("//terms").first)} return document end |
#xml_builder_template(*term_pointers) ⇒ Object
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
230 231 232 233 234 235 236 237 238 239 |
# File 'lib/om/xml/terminology.rb', line 230 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) ⇒ Object
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.
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 |
# File 'lib/om/xml/terminology.rb', line 186 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) ⇒ Object
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"]'
220 221 222 |
# File 'lib/om/xml/terminology.rb', line 220 def xpath_with_indexes(*pointers) OM::XML::TermXpathGenerator.generate_xpath_with_indexes(self, *pointers) end |