Class: ActiveFedora::Indexing::FieldMapper

Inherits:
Object
  • Object
show all
Defined in:
lib/active_fedora/indexing/field_mapper.rb

Instance Method Summary collapse

Instance Method Details

#set_field(doc, name, value, *indexer_args) ⇒ Object 



15
16
17
18
19
20
 
# File 'lib/active_fedora/indexing/field_mapper.rb', line 15

def set_field(doc, name, value, *indexer_args)
  # adding defaults indexer
  indexer_args = [:stored_searchable] if indexer_args.empty?
  doc.merge! solr_names_and_values(name, value, indexer_args)
  doc
end

#solr_name(field_name, *opts) ⇒ String

Given a field name, index_type, etc., returns the corresponding Solr name. TODO field type is the input format, maybe we could just detect that? See github.com/samvera/active_fedora/issues/1338

Parameters:

  • field_name (String) —

    the ruby (term) name which will get a suffix appended to become a Solr field name

  • opts —

    • index_type is only needed if the FieldDescriptor requires it (e.g. :searcahble)

Returns:

  • (String) —

    name of the solr field, based on the params



29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/active_fedora/indexing/field_mapper.rb', line 29

def solr_name(field_name, *opts)
  index_type, args = if opts.first.is_a? Hash
                       [:stored_searchable, opts.first]
                     elsif opts.empty?
                       [:stored_searchable, { type: :text }]
                     else
                       [opts[0], opts[1] || { type: :string }]
                     end

  indexer(index_type).name_and_converter(field_name, args).first
end

#solr_names_and_values(field_name, field_value, index_types) ⇒ Object

Given a field name-value pair, a data type, and an array of index types, returns a hash of mapped names and values. The values in the hash are arrays, and may contain multiple values.



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/active_fedora/indexing/field_mapper.rb', line 43

def solr_names_and_values(field_name, field_value, index_types)
  return {} if field_value.nil?

  # Determine the set of index types
  index_types = Array(index_types)
  index_types.uniq!
  index_types.dup.each do |index_type|
    if index_type.to_s =~ /^not_(.*)/
      index_types.delete index_type # not_foo
      index_types.delete Regexp.last_match(1).to_sym # foo
    end
  end

  # Map names and values

  results = {}

  # Time seems to extend enumerable, so wrap it so we don't interate over each of its elements.
  field_value = [field_value] if field_value.is_a? Time

  index_types.each do |index_type|
    Array(field_value).each do |single_value|
      # Get mapping for field
      descriptor = indexer(index_type)
      data_type = extract_type(single_value)
      name, converter = descriptor.name_and_converter(field_name, type: data_type)
      next unless name

      # Is there a custom converter?
      # TODO instead of a custom converter, look for input data type and output data type. Create a few methods that can do that cast.
      # See https://github.com/samvera/active_fedora/issues/1339

      value = if converter
                if converter.arity == 1
                  converter.call(single_value)
                else
                  converter.call(single_value, field_name)
                end
              elsif data_type == :boolean
                single_value
              else
                single_value.to_s
              end

      # Add mapped name & value, unless it's a duplicate
      if descriptor.evaluate_suffix(data_type).multivalued?
        values = (results[name] ||= [])
        values << value unless value.nil? || values.include?(value)
      else
        Rails.logger.warn "Setting #{name} to `#{value}', but it already had `#{results[name]}'" if results[name]
        results[name] = value
      end
    end
  end

  results
end