class Burner::Library::Collection::Coalesce

This is generally used right after the Group job has been executed on a separate dataset in a separate register. This job can match up specified values in its dataset with lookup values in another. If it finds a match then it will (shallow) copy over the values into the respective dataset.

Expected Payload input: array of objects. Payload output: array of objects.

Attributes

grouped_register[R]
insensitive[R]
key_mappings[R]
keys[R]
resolver[R]

Public Class Methods

new( grouped_register:, insensitive: false, key_mappings: [], keys: [], name: '', register: DEFAULT_REGISTER, separator: '' ) click to toggle source
Calls superclass method Burner::JobWithRegister::new
# File lib/burner/library/collection/coalesce.rb, line 29
def initialize(
  grouped_register:,
  insensitive: false,
  key_mappings: [],
  keys: [],
  name: '',
  register: DEFAULT_REGISTER,
  separator: ''
)
  super(name: name, register: register)

  @grouped_register = grouped_register.to_s
  @insensitive      = insensitive || false
  @key_mappings     = Modeling::KeyMapping.array(key_mappings)
  @keys             = Array(keys)
  @resolver         = Objectable.resolver(separator: separator.to_s)

  raise ArgumentError, 'at least one key is required' if @keys.empty?

  freeze
end

Public Instance Methods

perform(output, payload) click to toggle source
# File lib/burner/library/collection/coalesce.rb, line 51
def perform(output, payload)
  ensure_array(payload)

  count = payload[register].length

  output.detail("Coalescing based on key(s): #{keys} for #{count} records(s)")

  payload[register].each do |record|
    key    = make_key(record, keys, resolver, insensitive)
    lookup = find_lookup(payload, key)

    key_mappings.each do |key_mapping|
      value = resolver.get(lookup, key_mapping.from)

      resolver.set(record, key_mapping.to, value)
    end
  end
end

Private Instance Methods

find_lookup(payload, key) click to toggle source
# File lib/burner/library/collection/coalesce.rb, line 72
def find_lookup(payload, key)
  (payload[grouped_register] || {})[key] || {}
end