Module: Solrizer::XML::TerminologyBasedSolrizer

Defined in:
lib/solrizer/xml/terminology_based_solrizer.rb

Overview

This module is only suitable to mix into Classes that use the OM::XML::Document Module

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#field_mapper ⇒ Object

Instance Methods



96
97
98
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 96

def field_mapper
  @field_mapper
end

Class Method Details

.default_field_mapper ⇒ Object 



4
5
6
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 4

def self.default_field_mapper
  @@default_field_mapper ||= Solrizer::FieldMapper::Default.new
end

.format_node_value(values) ⇒ Object

Strips the majority of whitespace from the values array and then joins them with a single blank delimitter



90
91
92
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 90

def self.format_node_value values
  values.map{|val| val.gsub(/\s+/,' ').strip}.join(" ")
end

.solrize(doc, solr_doc = Solr::Document.new, field_mapper = nil) ⇒ Object

Build a solr document from doc based on its terminology



13
14
15
16
17
18
19
20
21
22
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 13

def self.solrize(doc, solr_doc=Solr::Document.new, field_mapper = nil)
  unless doc.class.terminology.nil?
    doc.class.terminology.terms.each_pair do |term_name,term|
      doc.solrize_term(term, solr_doc, field_mapper)
      # self.solrize_by_term(accessor_name, accessor_info, :solr_doc=>solr_doc)
    end
  end

  return solr_doc
end

.solrize_node(node, doc, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = nil, opts = {}) ⇒ Object

Populate a solr document with solr fields corresponding to the given xml node Field names are generated using settings from the term in the doc‘s terminology corresponding to term_pointer



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 58

def self.solrize_node(node, doc, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = nil, opts = {})
  field_mapper ||= self.default_field_mapper
  terminology = doc.class.terminology
  # term = terminology.retrieve_term(*term_pointer)
  
  if term.path.kind_of?(Hash) && term.path.has_key?(:attribute)
    node_value = node.value
  else
    node_value = node.text
  end
  
  generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
  
  field_mapper.solr_names_and_values(generic_field_name_base, node_value, term.data_type, term.index_as).each do |field_name, field_value|
    unless field_value.join("").strip.blank?
      solr_doc << Solr::Field.new(field_name => self.format_node_value(field_value)) 
    end
  end
  
  if term_pointer.length > 1
    hierarchical_field_name_base = OM::XML::Terminology.term_hierarchical_name(*term_pointer)
    field_mapper.solr_names_and_values(hierarchical_field_name_base, node_value, term.data_type, term.index_as).each do |field_name, field_value|
      unless field_value.join("").strip.blank?
        solr_doc << Solr::Field.new(field_name => self.format_node_value(field_value))
      end
    end
  end
  solr_doc
end

.solrize_term(doc, term, solr_doc = Solr::Document.new, field_mapper = nil, opts = {}) ⇒ Object

Populate a solr document with fields based on nodes in xml corresponding to the term identified by term_pointer within terminology



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 28

def self.solrize_term(doc, term, solr_doc = Solr::Document.new, field_mapper = nil, opts={})
  terminology = doc.class.terminology
  parents = opts.fetch(:parents, [])

  term_pointer = parents+[term.name]

  # term = terminology.retrieve_term(term_pointer)

  # prep children hash
  # child_accessors = accessor_info.fetch(:children, {})
  # xpath = term.xpath_for(*term_pointer)
  nodeset = doc.find_by_terms(*term_pointer)
  
  nodeset.each do |node|
    # create solr fields
    
    self.solrize_node(node, doc, term_pointer, term, solr_doc, field_mapper)
    term.children.each_pair do |child_term_name, child_term|
      doc.solrize_term(child_term, solr_doc, field_mapper, opts={:parents=>parents+[{term.name=>nodeset.index(node)}]})
      # self.solrize_term(doc, child_term_name, child_term, opts={:solr_doc=>solr_doc, :parents=>parents+[{accessor_name=>nodeset.index(node)}] })
    end
  end
  solr_doc
end

Instance Method Details

#solrize_node(node, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts = {}) ⇒ Object 



106
107
108
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 106

def solrize_node(node, term_pointer, term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts={})
  Solrizer::XML::TerminologyBasedSolrizer.solrize_node(node, self, term_pointer, solr_doc, field_mapper, opts)
end

#solrize_term(term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts = {}) ⇒ Object 



102
103
104
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 102

def solrize_term(term, solr_doc = Solr::Document.new, field_mapper = self.field_mapper, opts={})
  Solrizer::XML::TerminologyBasedSolrizer.solrize_term(self, term, solr_doc, field_mapper, opts)    
end

#to_solr(solr_doc = Solr::Document.new, field_mapper = self.field_mapper) ⇒ Object

:nodoc:



98
99
100
 
# File 'lib/solrizer/xml/terminology_based_solrizer.rb', line 98

def to_solr(solr_doc = Solr::Document.new, field_mapper = self.field_mapper) # :nodoc:
  Solrizer::XML::TerminologyBasedSolrizer.solrize(self, solr_doc, field_mapper)
end