Module: Upkeep::Dependencies

Defined in:

lib/upkeep/dependencies.rb

Defined Under Namespace

Classes: ActiveRecordAttribute, ActiveRecordCollection, ActiveRecordQuery, Base, CookieValue, CurrentAttribute, Identity, RequestValue, Restored, SessionValue, Unknown, WardenUser

Class Method Summary

• .canonical_identity(value) ⇒ Object
• .from_h(snapshot) ⇒ Object
• .model_identity(value) ⇒ Object
• .model_metadata(value) ⇒ Object
• .private_fingerprint(value) ⇒ Object
• .private_fingerprint_payload(value) ⇒ Object
• .symbolize_keys(value) ⇒ Object

Class Method Details

.canonical_identity(value) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 420

def canonical_identity(value)
  case value
  when nil, true, false, Numeric, String, Symbol
    value
  else
    model_identity(value) || private_fingerprint(value)
  end
end

.from_h(snapshot) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 359

def from_h(snapshot)
  snapshot = symbolize_keys(snapshot)
  source = snapshot.fetch(:source)
  key = symbolize_keys(snapshot.fetch(:key))
  metadata = symbolize_keys(snapshot.fetch(:metadata))

  case source.to_sym
  when :active_record_attribute
    ActiveRecordAttribute.new(
      table: key.fetch(:table),
      id: key.fetch(:id),
      attribute: key.fetch(:attribute),
      model: metadata[:model]
    )
  when :active_record_collection, :active_record_query
    dependency_class = source.to_sym == :active_record_query ? ActiveRecordQuery : ActiveRecordCollection
    dependency_class.new(
      primary_table: metadata.fetch(:primary_table),
      table_columns: metadata.fetch(:table_columns),
      coverage: metadata.fetch(:coverage),
      sql: metadata.fetch(:sql),
      predicates: metadata.fetch(:predicates)
    )
  else
    if snapshot.fetch(:visibility).to_sym == :identity_bound
      Identity.new(
        source: source,
        key: key.fetch(:key),
        value: key.fetch(:value),
        metadata: metadata
      )
    else
      Restored.new(
        source: source,
        key: key,
        metadata: metadata,
        visibility: snapshot.fetch(:visibility),
        precision: snapshot.fetch(:precision)
      )
    end
  end
end

.model_identity(value) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 402

def model_identity(value)
  return nil unless value

  if value.respond_to?(:id) && value.class.respond_to?(:name)
    { model: value.class.name, id: value.id }
  end
end

.model_metadata(value) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 410

def model_metadata(value)
  return {} unless value

  {
    model: value.class.name,
    table: value.class.respond_to?(:table_name) ? value.class.table_name : nil,
    id: value.respond_to?(:id) ? value.id : nil
  }.compact
end

.private_fingerprint(value) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 429

def private_fingerprint(value)
  Digest::SHA256.hexdigest(JSON.generate(private_fingerprint_payload(value)))[0, 16]
end

.private_fingerprint_payload(value) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 433

def private_fingerprint_payload(value)
  case value
  when nil, true, false, Numeric, String
    [value.class.name, value]
  when Symbol
    ["Symbol", value.to_s]
  when Array
    ["Array", value.map { |item| private_fingerprint_payload(item) }]
  when Hash
    entries = value.keys.sort_by { |key| JSON.generate(private_fingerprint_payload(key)) }.map do |key|
      [private_fingerprint_payload(key), private_fingerprint_payload(value.fetch(key))]
    end
    ["Hash", entries]
  else
    identity = model_identity(value)
    identity ? ["Model", identity] : ["Object", value.class.name, value.inspect]
  end
end

.symbolize_keys(value) ⇒ Object

# File 'lib/upkeep/dependencies.rb', line 452

def symbolize_keys(value)
  case value
  when Hash
    value.each_with_object({}) do |(key, nested_value), result|
      normalized_key = key.respond_to?(:to_sym) ? key.to_sym : key
      result[normalized_key] = symbolize_keys(nested_value)
    end
  when Array
    value.map { |nested_value| symbolize_keys(nested_value) }
  else
    value
  end
end