class RecordDiff::Matcher

Handles matching results.

Attributes

after[R]
after_grouped[R]
before[R]
before_grouped[R]
options[R]
results[R]

@return [RecordDiff::ResultSet] - the results of the diff operation.

Public Class Methods

diff_hash(before:, after:) click to toggle source
# File lib/record_diff/matcher.rb, line 20
def self.diff_hash(before:, after:)
  new before: before, after: after,
      options: { before_id: :first, after_id: :first,
                 before_transform: :second, after_transform: :second }
end
new(before:, after:, options: {}) click to toggle source
# File lib/record_diff/matcher.rb, line 26
def initialize(before:, after:, options: {})
  @options = MatcherOptions.new(options)
  @before = before
  @after = after
  process
end

Public Instance Methods

generate_compares(before, after) click to toggle source
# File lib/record_diff/matcher.rb, line 104
def generate_compares(before, after) # rubocop:disable MethodLength
  begin
    before_compare = before ? before_transform.call(before) : nil
  rescue StandardError => e
    before_compare = e
  end
  begin
    after_compare = after ? after_transform.call(after) : nil
  rescue StandardError => e
    after_compare = e
  end
  [before_compare, after_compare]
end
generate_result(key, before_ary, after_ary) click to toggle source

@param [Array] before_ary @param [Array] after_ary @return [Array<RecordDiff::Results::AbstractResult>]

# File lib/record_diff/matcher.rb, line 60
def generate_result(key, before_ary, after_ary)
  raise "Multiple records to compare with same Key #{key}" if
    before_ary.count > 1 || after_ary.count > 1

  before_obj = before_ary[0]
  after_obj = after_ary[0]
  [generate_result_obj(key, before_obj, after_obj)]
end
generate_result_obj(key, before, after) click to toggle source

@return

# File lib/record_diff/matcher.rb, line 70
def generate_result_obj(key, before, after) # rubocop:disable MethodLength
  before_compare, after_compare = generate_compares before, after
  if before_compare.is_a?(StandardError) ||
     after_compare.is_a?(StandardError)
    return Results::ErroredResult.new id: key,
                                      before: before,
                                      before_compare: before_compare,
                                      after: after,
                                      after_compare: after_compare
  end
  if before_compare.nil?
    return Results::AddedResult.new id: key,
                                    after: after,
                                    after_compare: after_compare
  end
  if after_compare.nil?
    return Results::DroppedResult.new id: key, before: before,
                                      before_compare: before_compare
  end

  if before_compare == after_compare
    return Results::UnchangedResult.new(
      id: key,
      before: before, before_compare: before_compare,
      after: after, after_compare: after_compare
    )
  end

  Results::ChangedResult.new(
    id: key, before: before, before_compare: before_compare,
    after: after, after_compare: after_compare
  )
end
generate_results() click to toggle source
# File lib/record_diff/matcher.rb, line 48
def generate_results
  keys = (before_grouped.keys + after_grouped.keys).uniq
  result_ary = keys.map do |key|
    generate_result key, before_grouped[key] || [], after_grouped[key] || []
  end
  result_ary.flatten!
  @results = ResultSet.new(result_ary)
end
group_records() click to toggle source
# File lib/record_diff/matcher.rb, line 43
def group_records
  @before_grouped = before.group_by { |r| before_id.call r }
  @after_grouped = after.group_by { |r| after_id.call r }
end
key_for_record(record) click to toggle source
# File lib/record_diff/matcher.rb, line 39
def key_for_record(record)
  id_method.call(record)
end
process() click to toggle source
# File lib/record_diff/matcher.rb, line 33
def process
  group_records
  generate_results
  self
end