opencdd 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1ea74c1b474208d733e1aedb3174ae3c088b6899f78e65a88b87cff180932b3
-  data.tar.gz: ea3d59ec075cd72cb7182955936dc577fb6be2b53bacd45045a5409cd002df8a
+  metadata.gz: 74a134259cf9d336b0e401139d10fcda58d1df883ec52312e04eadd2c6016bb9
+  data.tar.gz: b2c6cd320d420f7258c4116c218e0de50850d9ebb1745f81e4b06c33113196ef
 SHA512:
-  metadata.gz: f9efe7bf576ed24dc6f124a234ea12c3a2a8a70872e38e6e274550b3b77c78847434992f47250b18718cd3f5719103b2182afcacb517a2e5568ccce0588bcc12
-  data.tar.gz: 32499575fc889ae2b278ed5d767b0ad75e91cdd339ccecea4cc02b008edab66b87c123963132e307ed932553cbfdded8c0e047773cbcbb113963b03585ce89eb
+  metadata.gz: 5147138e2581efbaf28bf224de9c56ed541040cdedec3569436c786419df35fc190a144982d78d53ca7d1ce4d4b7f73b7cd21847d5c3597e1987b0ade886db85
+  data.tar.gz: 9bd7ee2d030cfb9792177763875b02114aca94534754986fe17ba6c7b24dcf5cd47ad9361fd9f9533c8d3fcbdc4bcc296d4610b335809358d5a6d3ae9844f0f0

data/lib/opencdd/database/finalization.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Database
+    # Finalization: link class hierarchy, property↔class links,
+    # value-list links, normalize reference collections, rebuild
+    # the symbol table.
+    module Finalization
+      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.write_property!(pid, Opencdd::StructuredValues.rejoin(elements))
+        end
+        self
+      end
+
+      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 rebuild_symbol_table!
+        entities.each { |e| register_entity_symbols(e) }
+      end
+
+      private
+
+      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
+          next unless target.is_a?(Opencdd::Klass)
+          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
+
+      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
+
+      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
+    end
+  end
+end

data/lib/opencdd/database/mutations.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Database
+    # Mutations: rename, merge, apply_change_request, remove,
+    # apply_view_control, and back-reference rewriting.
+    module Mutations
+      REFERENCE_VALUE_KINDS = %i[identifier_ref set_of_refs class_ref].freeze
+
+      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 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
+
+      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 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
+
+      private
+
+      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.write_property!(pid, new_irdi.to_s)
+          when :set_of_refs
+            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.write_property!(pid, Opencdd::StructuredValues.rejoin(mapped))
+          when :class_ref
+            entity.write_property!(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 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
+end

data/lib/opencdd/database/parcel_integration.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Database
+    # Parcel workbook ingestion and dictionary lifecycle (add/drop/
+    # register_external). Sheetmap construction and translation-
+    # language parsing.
+    module ParcelIntegration
+      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_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
+
+      private
+
+      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
+    end
+  end
+end

data/lib/opencdd/database/persistence.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Database
+    # YAML persistence: whole-database YAML (to_yaml via
+    # Model::YamlDatabase) and per-entity directory persistence
+    # (save_to_directory via Model::EntityStore). Class-method
+    # counterparts (from_yaml, load_from_directory) are defined
+    # on Database directly in database.rb.
+    module Persistence
+      def to_yaml(*args)
+        Opencdd::Model::YamlDatabase.from_database(self).to_yaml(*args)
+      end
+
+      def save_to_directory(path)
+        Opencdd::Model::EntityStore.new(path).save_database(self)
+        self
+      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
+    end
+  end
+end

data/lib/opencdd/database/queries.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Database
+    # Graph queries: find, coerce, powertype API, tree walkers,
+    # property/class/value-list lookups, relation queries.
+    module Queries
+      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 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
+
+      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 coerce_entity(value)
+        return nil if value.nil?
+        return value if value.is_a?(Opencdd::Entity)
+        find(value)
+      end
+
+      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 root_classes
+        classes.select { |c| c.parent_irdi.nil? }
+      end
+
+      # ── Powertype accessors (4-layer ontology) ──────────────
+
+      def categorical_classes
+        classes.select(&:powertype?)
+      end
+
+      def instances_of(categorical_klass)
+        k = coerce_entity(categorical_klass)
+        return [] unless k.is_a?(Opencdd::Klass)
+        k.categorical_instances(self)
+      end
+
+      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
+
+      # ── Tree walkers ─────────────────────────────────────────
+
+      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
+
+      # ── Property / class / value-list lookups ────────────────
+
+      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
+    end
+  end
+end