labimotion 2.3.4 → 2.4.0.rc1

data/lib/labimotion/libs/klass_version.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object/blank'
-
-module Labimotion
-  # Resolves which release of a template a saved element, segment or dataset follows, as
-  # the pair [klass_uuid, properties_release]. The submitted properties carry the klass_uuid
-  # they were built on; it counts when it is the klass's current release or one of its
-  # revisions, so a copy of an older record keeps that release instead of being relabelled.
-  module KlassVersion
-    # A new record without a known release, such as a new empty one, follows the current release.
-    # A copy of a record from an instance with releases of its own names a klass_uuid this one
-    # cannot resolve; it keeps the release the client sent only when that release names the same uuid.
-    def self.for_create(klass, revisions, submitted_uuid, client_release: nil)
-      uuid = string_uuid(submitted_uuid)
-      release = release_of(klass, revisions, uuid)
-      return [uuid, release] if release
-      return [uuid, client_release] if uuid.present? && release_uuid(client_release) == uuid
-
-      [klass.uuid, klass.properties_release]
-    end
-
-    # An existing record keeps its stored klass_uuid when none is submitted, then the uuid its
-    # stored release names, and follows the current release only when it has neither. A klass_uuid
-    # this instance cannot resolve (a record imported from elsewhere) keeps the release stored with it.
-    def self.for_update(klass, revisions, submitted_uuid, record)
-      uuid = string_uuid(submitted_uuid).presence || record.klass_uuid.presence
-      if uuid.nil?
-        stored_uuid = release_uuid(record.properties_release)
-        return [stored_uuid, record.properties_release] if stored_uuid
-
-        return [klass.uuid, klass.properties_release]
-      end
-
-      release = release_of(klass, revisions, uuid) || record.properties_release.presence
-      [uuid, release || klass.properties_release]
-    end
-
-    # for_update when the record exists, for_create when it is nil.
-    def self.for_record(klass, revisions, submitted_uuid, record, client_release: nil)
-      return for_create(klass, revisions, submitted_uuid, client_release: client_release) if record.nil?
-
-      for_update(klass, revisions, submitted_uuid, record)
-    end
-
-    # Revisions are soft-deleted, and deleting one does not change which release the records
-    # built on it follow, so a deleted revision still answers here.
-    def self.release_of(klass, revisions, uuid)
-      return if uuid.blank?
-      return klass.properties_release if uuid == klass.uuid
-
-      revisions.with_deleted.where(uuid: uuid).order(id: :desc).pick(:properties_release)
-    end
-
-    # Every release hash carries the uuid of the release it describes; nil when it names none.
-    def self.release_uuid(release)
-      release.is_a?(Hash) ? string_uuid(release['uuid']).presence : nil
-    end
-
-    # properties is a free-form hash, so klass_uuid can arrive as an array or a number; either
-    # would turn the revision lookup into a query matching more than the record's own release.
-    def self.string_uuid(submitted_uuid)
-      submitted_uuid.is_a?(String) ? submitted_uuid : nil
-    end
-  end
-end

data/lib/labimotion/libs/release_metadata.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# `underscore`, `constantize` and `index_by` are ActiveSupport core extensions, not plain
-# Ruby. A booted host always has them; declaring them here keeps this file from depending on
-# load order.
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/string/inflections'
-
-module Labimotion
-  ## ReleaseMetadata
-  # Each klass's metadata as of its active release, for the `metadata_releases:` option the
-  # klass entities read and for records the gem builds itself. The klass row's own `metadata`
-  # follows every save, drafts included, so a record built from `properties_release` needs the
-  # copy kept on the revision.
-  # The active revision is the one whose uuid equals the klass's, which changes only on release.
-  class ReleaseMetadata
-    # A klass with no revision matching its uuid (never released, or imported without one)
-    # is left out of the map, and the entity reads it as nil.
-    def self.map_for(klasses)
-      Array(klasses).compact.group_by(&:class).each_with_object({}) do |(model, group), map|
-        map.merge!(map_for_family(model, group))
-      end
-    end
-
-    # The metadata a record built from the klass's `properties_release` stores: the active
-    # release's, or the klass's own when no revision matches its uuid. A failed lookup also
-    # falls back to the klass's own, so building the record never fails on it.
-    def self.for_klass(klass)
-      map_for([klass])[key_of(klass)] || klass.metadata || {}
-    end
-
-    # Family as well as id: a segment klass payload nests its element klass, and ids repeat
-    # across the klass tables.
-    def self.key_of(klass)
-      "#{klass.class.name.split('::').last}:#{klass.id}"
-    end
-
-    def self.map_for_family(model, klasses)
-      by_pair = klasses.reject { |klass| klass.uuid.nil? }.index_by { |klass| [klass.id, klass.uuid] }
-      return {} if by_pair.empty?
-
-      revisions_for(model, by_pair.keys).each_with_object({}) do |(klass_id, uuid, metadata), map|
-        # The IN lists cross-match: a revision of one listed klass can carry the uuid of
-        # another. Only the exact pair is that klass's active release.
-        klass = by_pair[[klass_id, uuid]]
-        map[key_of(klass)] = metadata unless klass.nil?
-      end
-    rescue StandardError => e
-      # The release metadata is an addition to a list that must still render, and a failing
-      # family must not blank the families that resolved. A record builder falls back too.
-      Labimotion.log_exception(e)
-      {}
-    end
-
-    # The revision model and its foreign key are named after the klass model.
-    def self.revisions_for(model, pairs)
-      foreign_key = "#{model.name.underscore.split('/').last}_id"
-      "#{model.name}esRevision".constantize
-                               .where(foreign_key => pairs.map(&:first), uuid: pairs.map(&:last))
-                               .pluck(foreign_key, :uuid, :metadata)
-    end
-    private_class_method :map_for_family, :revisions_for
-  end
-end