opencdd 0.1.1 → 0.2.0

data/lib/opencdd/database.rb

@@ -10,6 +10,23 @@ module Opencdd
     FORCED_META_CLASSES = %w[MDC_C002 MDC_C003].freeze
     PARCEL_ID_PATTERN = /\A[A-Z0-9-]+\z/.freeze
 
+    # Database is split into focused concern modules. Each module
+    # is mixed in below and lives in its own file under
+    # +lib/opencdd/database/+. The core class (this file) holds
+    # entity identity, indexing, and the type-partitioned accessors.
+    autoload :ParcelIntegration, "opencdd/database/parcel_integration"
+    autoload :Queries,           "opencdd/database/queries"
+    autoload :Finalization,      "opencdd/database/finalization"
+    autoload :Mutations,         "opencdd/database/mutations"
+    autoload :Persistence,       "opencdd/database/persistence"
+
+    include Enumerable
+    include Opencdd::Database::ParcelIntegration
+    include Opencdd::Database::Queries
+    include Opencdd::Database::Finalization
+    include Opencdd::Database::Mutations
+    include Opencdd::Database::Persistence
+
     attr_reader :workbooks, :unresolved_refs, :alias_table
 
     def self.load(path)
@@ -28,6 +45,14 @@ module Opencdd
       Opencdd::Parcel::ShardedDirReader.new(path).load_into(new)
     end
 
+    def self.from_yaml(yaml)
+      Opencdd::Model::YamlDatabase.from_yaml(yaml).to_database
+    end
+
+    def self.load_from_directory(path)
+      Opencdd::Model::EntityStore.new(path).load_database
+    end
+
     def initialize
       @entities_by_irdi = {}
       @entities_by_code = Hash.new { |h, k| h[k] = [] }
@@ -40,31 +65,6 @@ module Opencdd
       @entity_sources = {}
     end
 
-    def add_workbook(workbook)
-      @workbooks << workbook
-      parcel_id = workbook.parcel_id
-      workbook.each_sheet do |sheet|
-        next unless sheet.type && sheet.rows.any?
-        type = sheet.type
-        entity_class = Opencdd::MetaClasses.entity_class_for_type(type)
-        raise "Unknown entity type #{type.inspect} for sheet #{sheet.name.inspect}" unless entity_class
-
-        sheet.rows.each do |row|
-          entity = entity_class.from_row(
-            row,
-            schema: sheet.schema,
-            meta_class_irdi: sheet.meta_class_irdi,
-          )
-          add_entity(entity)
-          if parcel_id && entity.irdi
-            prev = @entity_sources[entity.irdi]
-            @entity_sources[entity.irdi] = prev.nil? ? parcel_id : prev
-          end
-        end
-      end
-      self
-    end
-
     def add_entity(entity)
       irdi = entity.irdi
       if irdi.nil?
@@ -102,111 +102,6 @@ module Opencdd
       self
     end
 
-    def resolve_reference(ref)
-      return nil if ref.nil?
-      return ref if ref.is_a?(Opencdd::Entity)
-
-      key = ref.to_s.strip
-      return nil if key.empty?
-
-      if key.include?("/") || key.include?("#")
-        irdi = Opencdd::IRDI.parse(key)
-        return find(irdi)
-      end
-
-      entity = @symbol_table[key]
-      return entity if entity
-
-      by_code = find_by_code(key)
-      return by_code if by_code
-
-      irdi = Opencdd::IRDI.parse(key)
-      irdi ? find(irdi) : nil
-    end
-
-    def finalize!
-      normalize_reference_collections!
-      link_class_hierarchy!
-      link_property_classes!
-      link_value_lists!
-      rebuild_symbol_table!
-      self
-    end
-
-    def normalize_reference_collections!
-      each_reference_collection do |entity, pid, _raw, elements|
-        entity.properties[pid] = Opencdd::StructuredValues.rejoin(elements)
-      end
-      self
-    end
-
-    # Single iteration shape for any method that walks every
-    # set_of_refs property across every entity. Yields
-    # (entity, property_id, raw_value, elements) where +elements+
-    # is the unwrapped Array<String> via StructuredValues.
-    # Returns an Enumerator when no block is given.
-    def each_reference_collection
-      return enum_for(:each_reference_collection) unless block_given?
-      set_property_ids = Opencdd::PropertyIds::REGISTRY
-                           .select { |_, e| e.value_kind == :set_of_refs }
-                           .keys
-      entities.each do |entity|
-        set_property_ids.each do |pid|
-          raw = entity.properties[pid]
-          next if raw.nil? || raw.to_s.strip.empty?
-          elements = Opencdd::StructuredValues.unwrap_and_split(raw)
-          next if elements.empty?
-          yield(entity, pid, raw, elements)
-        end
-      end
-    end
-
-    def find(irdi)
-      return nil if irdi.nil?
-      key = Opencdd::IRDI === irdi ? irdi : Opencdd::IRDI.parse(irdi)
-      return nil unless key
-      @entities_by_irdi[key]
-    end
-
-    # Coerce +value+ (Entity, IRDI, String, or nil) to an Entity.
-    # Returns nil if the value cannot be resolved. Single entry
-    # point for the "entity or irdi" pattern that used to be
-    # inlined at every call site.
-    def coerce_entity(value)
-      return nil if value.nil?
-      return value if value.is_a?(Opencdd::Entity)
-      find(value)
-    end
-
-    # Coerce +value+ to an IRDI. Accepts an Entity (returns its
-    # irdi), an IRDI (pass-through), or a String (parsed). Returns
-    # nil if the value cannot be parsed.
-    def coerce_irdi(value)
-      return nil if value.nil?
-      return value.irdi if value.is_a?(Opencdd::Entity)
-      return value if value.is_a?(Opencdd::IRDI)
-      Opencdd::IRDI.parse(value.to_s)
-    end
-
-    def find_by_code(code)
-      matches = @entities_by_code[code.to_s]
-      return nil if matches.empty?
-      matches.first
-    end
-
-    def find_all_by_code(code)
-      @entities_by_code[code.to_s].dup
-    end
-
-    def find_by_name(name, type: nil, lang: :en)
-      pools = type ? [@entities_by_type[type]].compact : @entities_by_type.values
-      pools.each do |pool|
-        hit = pool.find { |e| e.preferred_name(lang).to_s.casecmp(name.to_s).zero? }
-        return hit if hit
-      end
-      nil
-    end
-
     def classes        ; @entities_by_type[:class]        || [] ; end
     def properties     ; @entities_by_type[:property]     || [] ; end
     def units          ; @entities_by_type[:unit]         || [] ; end
@@ -227,315 +122,10 @@ module Opencdd
       type ? (@entities_by_type[type] || []).size : @entities_by_irdi.size
     end
 
-    def root_classes
-      classes.select { |c| c.parent_irdi.nil? }
-    end
-
-    # ── Powertype accessors (4-layer ontology) ──────────────────
-    #
-    # Powertype semantics: a CATEGORICAL_CLASS at M1 has subclasses
-    # that are themselves classes but also act as its instances
-    # (used in CLASS_REFERENCE data types and sub_class_selection).
-    # See Opencdd module docstring + Klass#powertype?.
-
-    # All categorical classes registered in this database. Each is
-    # a candidate target for a CLASS_REFERENCE data type.
-    def categorical_classes
-      classes.select(&:powertype?)
-    end
-
-    # Powertype instances of +categorical_klass+ — its valid options
-    # for CLASS_REFERENCE values. Accepts a Klass, IRDI, or code
-    # String. Returns [] if +categorical_klass+ is not a powertype.
-    def instances_of(categorical_klass)
-      k = coerce_entity(categorical_klass)
-      return [] unless k.is_a?(Opencdd::Klass)
-      k.categorical_instances(self)
-    end
-
-    # Predicate: is +value+ a valid powertype instance of the given
-    # categorical class? Used by the validator's CLASS_REFERENCE
-    # check (R04/R08 extension).
-    def valid_class_reference?(categorical_klass, value)
-      target = coerce_entity(value)
-      return false unless target
-      instances_of(categorical_klass).any? { |c| c.irdi == target.irdi }
-    end
-
-    def class_tree(fields: Opencdd::ClassTree::DEFAULT_FIELDS)
-      Opencdd::ClassTree.new(self, fields: fields)
-    end
-
-    def effective_properties
-      @effective_properties ||= Opencdd::EffectiveProperties.new(self)
-    end
-
-    def composition_tree(klass, max_depth: 10)
-      Opencdd::CompositionTree.new(self).for(klass, max_depth: max_depth)
-    end
-
-    def relation_tree(root = nil, max_depth: 10)
-      Opencdd::RelationTree.new(self).for(root, max_depth: max_depth)
-    end
-
-    def add_dictionary(dict)
-      validate_parcel_id!(dict.parcel_id)
-      source_language = dict.source_language || "en"
-      translation_languages = Array(dict.translation_languages)
-      meta_irdis = normalize_meta_class_irdis(dict.meta_class_irdis)
-
-      sheets = meta_irdis.map do |meta_irdi|
-        Opencdd::Parcel::Sheet.scaffold(
-          meta_class_irdi: meta_irdi,
-          parcel_id: dict.parcel_id,
-          source_language: source_language,
-          translation_languages: translation_languages,
-        )
-      end
-
-      project = Opencdd::Parcel::Workbook::ProjectInfo.new(
-        project_id: dict.parcel_id,
-        parcel_id:  dict.parcel_id,
-        multi_language: translation_languages.join(","),
-        base_language: source_language,
-      )
-      sheetmap = build_sheetmap_for(dict.parcel_id, sheets)
-      workbook = Opencdd::Parcel::Workbook.new(
-        sheets: sheets, sheetmap: sheetmap, project: project,
-      )
-      @workbooks << workbook
-      workbook
-    end
-
-    def drop_dictionary(parcel_id)
-      matching = @workbooks.select { |wb| wb.parcel_id == parcel_id }
-      raise ArgumentError, "no dictionary with parcel_id #{parcel_id.inspect}" if matching.empty?
-
-      irdis_to_drop = @entity_sources.select { |_, pid| pid == parcel_id }.keys
-      irdis_to_drop.each do |irdi|
-        remove_entity_by_irdi!(irdi)
-        @entity_sources.delete(irdi)
-      end
-      @workbooks.reject! { |wb| wb.parcel_id == parcel_id }
-      self
-    end
-
-    def register_external_sheet(sheet, parcel_id:)
-      validate_parcel_id!(parcel_id)
-      wb = @workbooks.find { |w| w.parcel_id == parcel_id }
-      if wb.nil?
-        project = Opencdd::Parcel::Workbook::ProjectInfo.new(
-          project_id: parcel_id, parcel_id: parcel_id,
-          multi_language: "", base_language: "en",
-        )
-        wb = Opencdd::Parcel::Workbook.new(sheets: [], sheetmap: [], project: project)
-        @workbooks << wb
-      end
-      wb.register_sheet(sheet)
-      self
-    end
-
-    def dictionaries
-      @workbooks.map do |wb|
-        Dictionary.new(
-          parcel_id: wb.parcel_id,
-          source_language: wb.base_language,
-          translation_languages: parse_translation_languages(wb),
-          meta_class_irdis: wb.sheets.map(&:meta_class_irdi).compact.uniq,
-        )
-      end
-    end
-
-    def rename_entity(old_code, new_code)
-      old_code_s = old_code.to_s
-      new_code_s = new_code.to_s
-      return self if old_code_s == new_code_s
-
-      target = find_by_code(old_code_s)
-      return self unless target
-
-      clash = find_by_code(new_code_s)
-      if clash && clash.irdi != target.irdi
-        warn "Cannot rename #{old_code_s} → #{new_code_s}: target code already in use by #{clash.irdi}"
-        return self
-      end
-
-      old_irdi = target.irdi
-      new_irdi = old_irdi.with_code(new_code_s)
-
-      @entities_by_irdi.delete(old_irdi)
-      @entities_by_code[old_code_s].delete(target)
-
-      ref_property_ids = Opencdd::PropertyIds::REGISTRY.select do |_, e|
-        REFERENCE_VALUE_KINDS.include?(e.value_kind)
-      end.keys
-
-      entities.each do |entity|
-        rewrite_back_references!(entity, old_irdi, new_irdi, ref_property_ids)
-      end
-
-      code_pid = target.class.default_code_property_id(target.meta_class_irdi)
-      target.replace_code_value!(code_pid, new_code_s)
-      target.replace_irdi!(new_irdi)
-
-      @entities_by_irdi[new_irdi] = target
-      @entities_by_code[new_code_s] << target
-
-      rebuild_symbol_table!
-      self
-    end
-
-    def apply_view_control(klass, view_control)
-      properties = effective_properties.for(klass).to_a
-      return properties unless view_control.is_a?(Opencdd::ViewControl)
-
-      controlled = view_control.controlled_class_irdis
-      k = coerce_entity(klass)
-      return properties unless k.is_a?(Opencdd::Klass) && controlled.include?(k.irdi)
-
-      shown = view_control.shown_property_irdis
-      lookup = properties.each_with_object({}) { |p, h| h[p.irdi] = p }
-      shown.filter_map { |irdi| lookup[irdi] }
-    end
-
-    def properties_of(klass)
-      k = coerce_entity(klass)
-      return [] unless k.is_a?(Opencdd::Klass)
-      k.properties_on_class(self)
-    end
-
-    def classes_with_property(property)
-      irdi = coerce_irdi(property)
-      return [] unless irdi
-      @class_by_property_irdi&.fetch(irdi, []) || []
-    end
-
-    def value_list_of(property)
-      prop = coerce_entity(property)
-      return nil unless prop.is_a?(Opencdd::Property)
-
-      relations.each do |r|
-        next unless r.predication?
-        next unless r.domain_irdis.include?(prop.irdi)
-        vl = r.codomain_irdi && find(r.codomain_irdi)
-        return vl if vl.is_a?(Opencdd::ValueList)
-      end
-
-      return nil unless prop.enum?
-      identifier = value_list_identifier_of(prop)
-      return nil unless identifier
-      vl = resolve_reference(identifier)
-      vl if vl.is_a?(Opencdd::ValueList)
-    end
-
-    def value_list_identifier_of(property)
-      case property.parsed_data_type
-      when Opencdd::DataType::EnumStringType, Opencdd::DataType::EnumReferenceType
-        property.parsed_data_type.value_list_identifier
-      end
-    end
-
-    def terms_of(value_list)
-      return [] if value_list.nil?
-      value_list.term_irdis.map { |i| find(i) }.compact
-    end
-
-    def relations_for(domain: nil, codomain: nil)
-      dom = coerce_irdi(domain)
-      cod = coerce_irdi(codomain)
-      relations.select do |r|
-        (dom.nil?  || r.domain_irdis.include?(dom)) &&
-          (cod.nil? || r.codomain_irdi == cod)
-      end
-    end
-
-    def functions_involving(property)
-      irdi = coerce_irdi(property)
-      return [] unless irdi
-      relations.select do |r|
-        r.function? && (r.domain_irdis.include?(irdi) || r.codomain_irdi == irdi)
-      end
-    end
-
-    def merge(other)
-      raise TypeError, "merge expects a Opencdd::Database" unless other.is_a?(Opencdd::Database)
-      other.entities.each { |e| add_entity(e) }
-      finalize!
-      self
-    end
-
-    # Applies a Parcel change request (CR) to this database.
-    #
-    # +cr+ is a +Opencdd::Database+ whose entities represent the
-    # additions and updates to apply. +removals:+ is an Array of
-    # IRDIs (Strings or +Opencdd::IRDI+ instances) identifying entities
-    # to delete from this database.
-    #
-    # Unlike +#merge+, which is purely additive, +#apply_change_request+
-    # honors an explicit removal list. The CR's own entities are
-    # upserted first (so an update-then-remove ordering resolves to
-    # remove), then removals are applied.
-    #
-    # Returns +self+ for chaining.
-    def apply_change_request(cr, removals: [])
-      raise TypeError, "apply_change_request expects a Opencdd::Database" unless cr.is_a?(Opencdd::Database)
-      cr.entities.each { |e| add_entity(e) }
-      Array(removals).each { |r| remove_by_irdi(r) }
-      finalize!
-      self
-    end
-
-    def remove_by_irdi(ref)
-      irdi = ref.is_a?(Opencdd::IRDI) ? ref : Opencdd::IRDI.parse(ref.to_s)
-      return unless irdi
-      remove_entity_by_irdi!(irdi)
-      @entity_sources.delete(irdi)
-      self
-    end
-
     def each(&block)
       @entities_by_irdi.each_value(&block)
     end
 
-    include Enumerable
-
-    # ── YAML persistence (lutaml-model, CDD-native) ──────────
-    # Canonical YAML shape using semantic CDD attribute names
-    # (preferred_name, superclass, class_type) — not wire-format
-    # keys (MDC_P004, MDC_P010). See TODO.impl/33.
-
-    def to_yaml(*args)
-      Opencdd::Model::YamlDatabase.from_database(self).to_yaml(*args)
-    end
-
-    def self.from_yaml(yaml)
-      ydb = Opencdd::Model::YamlDatabase.from_yaml(yaml)
-      ydb.to_database
-    end
-
-    # ── Per-entity YAML persistence (lutaml-store) ───────────
-    # One .yaml file per entity in a directory layout. Diff-friendly
-    # at the entity level — one git diff shows exactly what changed.
-    # See TODO.impl/34.
-
-    def save_to_directory(path)
-      Opencdd::Model::EntityStore.new(path).save_database(self)
-      self
-    end
-
-    def self.load_from_directory(path)
-      Opencdd::Model::EntityStore.new(path).load_database
-    end
-
-    def semantically_equal?(other)
-      return false unless other.is_a?(Opencdd::Database)
-      return false unless entities.size == other.entities.size
-      entities.all? do |e|
-        oe = other.find(e.irdi)
-        oe && e.type == oe.type && e.properties == oe.properties
-      end
-    end
-
     def to_s
       "#<#{self.class.name} classes=#{classes.size} properties=#{properties.size} " \
         "units=#{units.size} value_lists=#{value_lists.size} value_terms=#{value_terms.size} " \
@@ -546,36 +136,6 @@ module Opencdd
 
     private
 
-    REFERENCE_VALUE_KINDS = %i[identifier_ref set_of_refs class_ref].freeze
-
-    def rewrite_back_references!(entity, old_irdi, new_irdi, ref_property_ids)
-      ref_property_ids.each do |pid|
-        raw = entity.properties[pid]
-        next if raw.nil?
-        entry = Opencdd::PropertyIds::REGISTRY[pid]
-        case entry.value_kind
-        when :identifier_ref
-          parsed = Opencdd::IRDI.parse(raw.to_s)
-          next unless parsed == old_irdi
-          entity.properties[pid] = new_irdi.to_s
-        when :set_of_refs
-          # SSOT: split + rejoin via StructuredValues.
-          elements = Opencdd::StructuredValues.unwrap_and_split(raw)
-          next if elements.empty?
-          mapped = elements.map { |e| e == old_irdi.to_s ? new_irdi.to_s : e }
-          entity.properties[pid] = Opencdd::StructuredValues.rejoin(mapped)
-        when :class_ref
-          entity.properties[pid] = substitute_class_ref_value(raw.to_s, old_irdi, new_irdi)
-        end
-      end
-    end
-
-    def substitute_class_ref_value(raw, old_irdi, new_irdi)
-      out = raw.sub(old_irdi.to_s, new_irdi.to_s)
-      return out if old_irdi.code.nil? || old_irdi.code == new_irdi.code
-      out.sub(old_irdi.code, new_irdi.code)
-    end
-
     def bind_symbol(name, entity)
       key = name.to_s
       existing = @symbol_table[key]
@@ -586,134 +146,5 @@ module Opencdd
       @symbol_table[key] = entity
       self
     end
-    def rebuild_symbol_table!
-      entities.each { |e| register_entity_symbols(e) }
-    end
-
-    def link_class_hierarchy!
-      classes.each do |klass|
-        next if klass.parent_irdi
-        parent_id = klass.parent_property_id || Opencdd::PropertyIds::MDC_P010
-        parent_raw = klass.properties[parent_id]
-        next if parent_raw.nil? || parent_raw.to_s.strip.empty?
-        target = resolve_reference(parent_raw)
-        next unless target
-        klass.attach_parent_irdi(target.irdi)
-        target.add_child(klass)
-      end
-    end
-
-    def link_property_classes!
-      @class_by_property_irdi = Hash.new { |h, k| h[k] = [] }
-      link_property_classes_via_relations!
-      link_property_classes_via_definition_class!
-    end
-
-      # Strategy 1: walk Relation entities. Parcel files are
-      # relation-centric — each Relation row says "this domain
-      # entity is linked to this codomain entity via this relation
-      # type." Predication and function relations imply
-      # "Klass declares Property" (or vice versa).
-      def link_property_classes_via_relations!
-        relations.each do |r|
-          next unless r.predication? || r.function?
-          next if r.domain_irdis.empty?
-          next unless r.codomain_irdi
-          r.domain_irdis.each do |d|
-            next unless d
-            src = find(d)
-            dst = find(r.codomain_irdi)
-            next unless src && dst
-
-            if src.is_a?(Opencdd::Klass) && dst.is_a?(Opencdd::Property)
-              src.declare_property(dst.irdi)
-              @class_by_property_irdi[dst.irdi] << src unless @class_by_property_irdi[dst.irdi].include?(src)
-            elsif src.is_a?(Opencdd::Property) && dst.is_a?(Opencdd::Klass)
-              dst.declare_property(src.irdi)
-              @class_by_property_irdi[src.irdi] << dst unless @class_by_property_irdi[src.irdi].include?(dst)
-            end
-          end
-        end
-      end
-
-      # Strategy 2: walk Property entities' definition_class
-      # (MDC_P021). CDDAL files are often property-centric and
-      # don't carry explicit Relation rows — the link is implied
-      # by each property's definition_class field. declare_property
-      # deduplicates, so running both strategies is safe.
-      def link_property_classes_via_definition_class!
-        properties.each do |prop|
-          dc_raw = prop.properties[Opencdd::PropertyIds::MDC_P021]
-          next unless dc_raw
-          target = resolve_reference(dc_raw)
-          next unless target.is_a?(Opencdd::Klass)
-          target.declare_property(prop.irdi)
-          @class_by_property_irdi[prop.irdi] << target unless @class_by_property_irdi[prop.irdi].include?(target)
-        end
-      end
-
-    def link_value_lists!
-      properties.each do |prop|
-        next unless prop.enum?
-        identifier = value_list_identifier_of(prop)
-        vl_irdi = identifier && resolve_reference(identifier)&.irdi
-        next unless vl_irdi
-        vl = find(vl_irdi)
-        next unless vl.is_a?(Opencdd::ValueList)
-        @class_by_property_irdi[prop.irdi] << vl unless @class_by_property_irdi[prop.irdi].include?(vl)
-      end
-    end
-
-    def validate_parcel_id!(parcel_id)
-      unless parcel_id.is_a?(String) && parcel_id.match?(PARCEL_ID_PATTERN)
-        raise ArgumentError, "invalid parcel_id: #{parcel_id.inspect}"
-      end
-    end
-
-    def normalize_meta_class_irdis(raw)
-      codes = Array(raw).map { |v| v.to_s.split("#").last }
-      FORCED_META_CLASSES.each { |c| codes << c unless codes.include?(c) }
-      codes.uniq
-    end
-
-    def build_sheetmap_for(parcel_id, sheets)
-      entries = [
-        Opencdd::Parcel::Workbook::SheetMapEntry.new(
-          project_id: parcel_id, parcel_id: parcel_id, class_irdi: nil,
-          content_no: 0, sheet_no: 2, sheet_name: "pcls_LOCAL",
-          type: "PARCEL_LIST", target: "",
-        ),
-      ]
-      sheets.each_with_index do |sheet, idx|
-        entries << Opencdd::Parcel::Workbook::SheetMapEntry.new(
-          project_id: parcel_id, parcel_id: parcel_id,
-          class_irdi: sheet.meta_class_irdi,
-          content_no: 0, sheet_no: idx + 3,
-          sheet_name: sheet.name,
-          type: Opencdd::MetaClasses.sheet_type_for_type(Opencdd::MetaClasses.type_for(sheet.meta_class_code)),
-          target: "",
-        )
-      end
-      entries
-    end
-
-    def parse_translation_languages(workbook)
-      multi = workbook.project&.multi_language.to_s
-      multi.split(",").map(&:strip).reject(&:empty?)
-    end
-
-    def remove_entity_by_irdi!(irdi)
-      entity = @entities_by_irdi.delete(irdi)
-      return unless entity
-      if entity.code
-        list = @entities_by_code[entity.code]
-        list.delete(entity)
-        @entities_by_code.delete(entity.code) if list.empty?
-      end
-      if entity.type
-        @entities_by_type[entity.type].delete(entity)
-      end
-      @symbol_table.delete_if { |_, e| e.equal?(entity) }
-    end
   end
 end