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
• .deployment_stable_request?(dependency) ⇒ Boolean
• .from_h(snapshot) ⇒ Object
• .identity_absent_for?(dependency, name) ⇒ Boolean
• .metadata_value(dependency, key) ⇒ Object
• .model_identity(value) ⇒ Object
• .model_metadata(value) ⇒ Object
• .nil_identity?(dependency) ⇒ Boolean
• .partitioning_identity?(dependency) ⇒ Boolean
• .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 516

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

.deployment_stable_request?(dependency) ⇒ Boolean

Returns:

• (Boolean)

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

def deployment_stable_request?(dependency)
  return false unless dependency.identity?
  return false unless dependency.source.to_s == "request"

  RequestValue::DEPLOYMENT_STABLE_KEYS.include?(dependency.key.fetch(:key).to_s)
end

.from_h(snapshot) ⇒ Object

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

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],
      scope: key[:scope]
    )
  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

.identity_absent_for?(dependency, name) ⇒ Boolean

Returns:

• (Boolean)

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

def identity_absent_for?(dependency, name)
  absent_by_name = metadata_value(dependency, :identity_absent_by_name) || {}
  absent_by_name = absent_by_name.transform_keys(&:to_s) if absent_by_name.respond_to?(:transform_keys)
  return absent_by_name.fetch(name.to_s) if absent_by_name.key?(name.to_s)

  !partitioning_identity?(dependency)
end

.metadata_value(dependency, key) ⇒ Object

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

def metadata_value(dependency, key)
  return unless dependency.respond_to?(:metadata)

  if dependency.metadata.key?(key)
    dependency.metadata.fetch(key)
  elsif dependency.metadata.key?(key.to_s)
    dependency.metadata.fetch(key.to_s)
  end
end

.model_identity(value) ⇒ Object

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

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 506

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

.nil_identity?(dependency) ⇒ Boolean

Returns:

• (Boolean)

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

def nil_identity?(dependency)
  dependency.respond_to?(:nil_identity?) && dependency.nil_identity?
end

.partitioning_identity?(dependency) ⇒ Boolean

Returns:

• (Boolean)

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

def partitioning_identity?(dependency)
  return false unless dependency.identity?

  flag = metadata_value(dependency, :partitioning_identity)
  return flag if [true, false].include?(flag)

  !nil_identity?(dependency)
end

.private_fingerprint(value) ⇒ Object

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

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 567

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 586

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