opencdd 0.1.1

data/lib/opencdd/parcel/sheet.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Parcel
+    class Sheet
+      DEFAULT_REQUIREMENT_FOR_CODE = "KEY".freeze
+      DEFAULT_REQUIREMENT_OTHER   = "OPT".freeze
+      DEFAULT_SOURCE_LANGUAGE     = "en".freeze
+
+      attr_reader :name, :metadata, :schema, :rows, :raw_row_count
+
+      def self.scaffold(meta_class_irdi:, parcel_id:, source_language: DEFAULT_SOURCE_LANGUAGE,
+                        translation_languages: [], sheet_name: nil)
+        meta = Opencdd::MetaClasses.for(meta_class_irdi.to_s) or
+          raise ArgumentError, "unknown meta-class #{meta_class_irdi}"
+
+        code_property_id = Opencdd::MetaClasses.code_property_id_for(meta.irdi)
+        languages = ([source_language] + translation_languages).map(&:to_s).uniq
+
+        columns = meta.allowed_property_ids.each_with_index.map do |property_id, idx|
+          SheetSchema::Column.new(
+            index: idx + 1,
+            property_id: property_id,
+            name_by_lang: languages.to_h { |l| [l, display_name_for(property_id, l)] },
+            datatype: default_datatype_for(property_id),
+            value_format: nil,
+            pattern: nil,
+            requirement: property_id == code_property_id ? DEFAULT_REQUIREMENT_FOR_CODE : DEFAULT_REQUIREMENT_OTHER,
+          )
+        end
+
+        schema = SheetSchema.new
+        columns.each do |col|
+          schema.add_column(col)
+        end
+        schema.finalize_for_scaffold!
+
+        metadata = Metadata.new
+        metadata.add("#CLASS_ID := #{meta.irdi}")
+        metadata.add("#CLASS_NAME.#{source_language} := #{meta.name}")
+        metadata.add("#SOURCE_LANGUAGE := #{source_language}")
+        unless translation_languages.empty?
+          metadata.add("#TRANSLATION_LANGUAGE := #{translation_languages.join(',')}")
+        end
+
+        name = sheet_name || "#{parcel_id}_#{meta.name.upcase}"
+        new(name: name, metadata: metadata, schema: schema, raw_rows: [])
+      end
+
+      def self.display_name_for(property_id, _lang)
+        entry = Opencdd::PropertyIds::REGISTRY[property_id.to_s]
+        return property_id.to_s unless entry
+        entry.aliases.first || property_id.to_s
+      end
+
+      def self.default_datatype_for(property_id)
+        entry = Opencdd::PropertyIds::REGISTRY[property_id.to_s]
+        return nil unless entry
+        case entry.value_kind
+        when :identifier_ref, :class_ref then "ICID_STRING"
+        when :set_of_refs                 then "ICID_STRING"
+        when :date                        then "DATE_TYPE"
+        when :date_time                   then "DATE_TIME_TYPE"
+        when :condition                   then "STRING_TYPE"
+        else "STRING_TYPE"
+        end
+      end
+
+      def self.from_rows(rows, name: nil)
+        metadata = Opencdd::Parcel::Metadata.new
+        header_rows = []
+        data_rows = []
+
+        rows.each do |raw_row|
+          row = Array(raw_row)
+          first_cell = row.first&.to_s&.strip.to_s
+
+          if first_cell.start_with?("#") && first_cell.include?(":=")
+            metadata.add(first_cell)
+            next
+          end
+
+          if first_cell.start_with?("#")
+            header_rows << row
+            next
+          end
+
+          if row_has_data?(row)
+            data_rows << row
+          end
+        end
+
+        schema = Opencdd::Parcel::SheetSchema.from_header_rows(header_rows)
+        new(name: name, metadata: metadata, schema: schema, raw_rows: data_rows)
+      end
+
+      def self.row_has_data?(row)
+        row.each_with_index do |v, i|
+          next if i.zero?
+          next if v.nil?
+          s = v.to_s.strip
+          return true unless s.empty?
+        end
+        false
+      end
+
+      def initialize(name:, metadata:, schema:, raw_rows:)
+        @name = name
+        @metadata = metadata
+        @schema = schema
+        @raw_row_count = raw_rows.size
+        @rows = build_rows(raw_rows)
+        freeze
+      end
+
+      def meta_class_irdi
+        @metadata.meta_class_irdi
+      end
+
+      def meta_class_code
+        @metadata.meta_class_code
+      end
+
+      def type
+        @metadata.type
+      end
+
+      def each(&block)
+        @rows.each(&block)
+      end
+
+      include Enumerable
+
+      def size
+        @rows.size
+      end
+
+      alias_method :count, :size
+      alias_method :length, :size
+
+      def first
+        @rows.first
+      end
+
+      def last
+        @rows.last
+      end
+
+      def entities(database = nil)
+        EntitiesProxy.new(self, database)
+      end
+
+      def apply_default_values!(property_id:)
+        col = @schema.find_by_property_id(property_id.to_s)
+        return if col.nil? || col.default_value.nil?
+        storage_key = storage_key_for(col)
+        @rows.each do |row|
+          current = row[storage_key]
+          next if !current.nil? && !current.to_s.empty?
+          row[storage_key] = col.default_value
+        end
+        self
+      end
+
+      def apply_all_default_values!
+        @schema.columns.each do |col|
+          next if col.default_value.nil?
+          apply_default_values!(property_id: col.property_id)
+        end
+        self
+      end
+
+      def merge_rows_from(other)
+        unless meta_codes_match?(meta_class_irdi, other.meta_class_irdi)
+          raise ArgumentError,
+                "meta-class mismatch: #{meta_class_irdi} vs #{other.meta_class_irdi}"
+        end
+        other.rows.each do |src|
+          new_row = src.reject { |k, _| k == "__row_index__" }
+          next if new_row.empty?
+          new_row["__row_index__"] = @rows.size
+          @rows << new_row
+        end
+        self
+      end
+
+      def dup_with(name:)
+        raw_rows = @rows.map { |row| row_to_array(row) }
+        self.class.new(name: name, metadata: @metadata, schema: @schema, raw_rows: raw_rows)
+      end
+
+      private
+
+      def meta_codes_match?(a, b)
+        return false if a.nil? || b.nil?
+        a.to_s.split("#").last == b.to_s.split("#").last
+      end
+
+      def row_to_array(row)
+        array = Array.new(@schema.columns.map(&:index).max.to_i + 1)
+        @schema.columns.each do |col|
+          key = storage_key_for(col)
+          val = row[key]
+          array[col.index] = val if val
+        end
+        array
+      end
+
+      def build_rows(raw_rows)
+        seen = {}
+        result = []
+        raw_rows.each do |row|
+          instance = build_instance(row)
+          next unless instance
+          key = instance["__row_index__"] = result.size
+          result << instance
+          seen[key] = true
+        end
+        result
+      end
+
+      def build_instance(row)
+        h = {}
+        any_value = false
+        @schema.columns.each do |col|
+          v = row[col.index]
+          next if v.nil?
+          s = value_to_string(v)
+          next if s.empty?
+          key = storage_key_for(col)
+          h[key] = s
+          any_value = true
+        end
+
+        return nil unless any_value
+        h["__row_index__"] = nil
+        h
+      end
+
+      def storage_key_for(col)
+        pid = col.property_id
+        return pid if pid.include?(".")
+        entry = Opencdd::PropertyIds::REGISTRY[pid]
+        return pid unless entry&.multilingual
+        langs = (col.name_by_lang || {}).keys
+        return pid if langs.size != 1
+        "#{pid}.#{langs.first}"
+      end
+
+      def value_to_string(v)
+        return "" if v.nil?
+        case v
+        when String then v.strip
+        when Float
+          if v == v.to_i
+            v.to_i.to_s
+          else
+            v.to_s
+          end
+        when Integer then v.to_s
+        when Date, Time then v.iso8601
+        when Symbol then v.to_s
+        else v.to_s
+        end
+      end
+
+      class EntitiesProxy
+        attr_reader :sheet, :database
+
+        def initialize(sheet, database)
+          @sheet = sheet
+          @database = database
+        end
+
+        def each
+          return enum_for(:each) unless block_given?
+
+          sheet.each do |row|
+            yield row
+          end
+        end
+
+        include Enumerable
+      end
+    end
+  end
+end

data/lib/opencdd/parcel/sheet_emitter.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Parcel
+    class SheetEmitter
+      DEFAULT_SOURCE_LANGUAGE = "en".freeze
+
+      META_DIRECTIVE_ORDER = %w[
+        CLASS_ID ALTERNATE_CLASSID SUPER_ALT_CLASSID SUB_ALT_CLASSID
+        CLASS_NAME CLASS_DEFINITION CLASS_NOTE
+        SOURCE_LANGUAGE PARCEL_MODE PARCEL_ID PARCEL_CC
+        DEFAULT_SUPPLIER DEFAULT_VERSION
+        ID_ENCODE DELIMITER DECIMAL OBJECT_ID_NAME
+        TRANSLATION_LANGUAGE
+      ].freeze
+
+      HEADER_DIRECTIVE_ORDER = %w[
+        PROPERTY_ID ALTERNATE_ID SUPER_ALTERNATE_ID SUB_ALTERNATE_ID EQUIVALENT_ID
+        SUPER_PROPERTY
+        DATATYPE UNIT VARIABLE_PREFIX_UNIT UNIT_ID ALTERNATIVE_UNITS
+        VALUE_FORMAT PATTERN RELATION DEFAULT_VALUE
+        DEFAULT_DATA_SUPPLIER DEFAULT_DATA_VERSION REQUIREMENT
+      ].freeze
+
+      MULTILINGUAL_DIRECTIVES = %w[PROPERTY_NAME DEFINITION NOTE].freeze
+
+      attr_reader :source_language
+
+      def initialize(source_language: "en")
+        @source_language = source_language.to_s
+      end
+
+      def emit(sheet, entities)
+        rows = []
+        emit_metadata_rows(sheet, rows)
+        emit_header_rows(sheet, rows)
+        entities.each { |e| emit_data_row(sheet, e, rows) }
+        rows
+      end
+
+      def emit_data_rows(sheet, entities)
+        rows = []
+        entities.each { |e| emit_data_row(sheet, e, rows) }
+        rows
+      end
+
+      private
+
+      def emit_metadata_rows(sheet, rows)
+        present = sheet.metadata.directives.transform_keys(&:to_s)
+        META_DIRECTIVE_ORDER.each do |base|
+          emit_meta_base(present, base, rows)
+        end
+      end
+
+      def emit_meta_base(present, base, rows)
+        matched = present.select { |k, _| k == base || k.start_with?("#{base}.") }
+        if matched.empty?
+          rows << ["##{base}:="]
+          return
+        end
+        matched.each do |key, val|
+          rows << ["##{key}:=#{val}"]
+        end
+      end
+
+      def emit_header_rows(sheet, rows)
+        present = column_directives_from(sheet)
+        HEADER_DIRECTIVE_ORDER.each do |name|
+          emit_directive_row(present, name, rows)
+        end
+        MULTILINGUAL_DIRECTIVES.each do |base|
+          present.keys.select { |k| k == base || k.start_with?("#{base}.") }.sort.each do |key|
+            emit_directive_row(present, key, rows)
+          end
+        end
+      end
+
+      def column_directives_from(sheet)
+        cols = sheet.schema.columns
+        {}.tap do |h|
+          HEADER_DIRECTIVE_ORDER.each do |name|
+            vals = cols.map { |col| column_scalar_value(col, name) }
+            h[name] = vals
+          end
+          MULTILINGUAL_DIRECTIVES.each do |base|
+            langs = cols.flat_map { |col| langs_for(col, base) }.uniq
+            langs.each do |lang|
+              h["#{base}.#{lang}"] = cols.map { |col| localized_value(col, base, lang) }
+            end
+          end
+        end
+      end
+
+      def emit_directive_row(present, name, rows)
+        values = present[name]
+        rows << ["##{name}", *(values || [])]
+      end
+
+      def column_scalar_value(col, name)
+        case name
+        when "PROPERTY_ID"           then col.raw_property_id || col.property_id
+        when "ALTERNATE_ID"          then col.alternate_id
+        when "SUPER_ALTERNATE_ID"    then col.super_alternate_id
+        when "SUB_ALTERNATE_ID"      then col.sub_alternate_id
+        when "EQUIVALENT_ID"         then col.equivalent_id
+        when "SUPER_PROPERTY"        then col.super_property
+        when "DATATYPE"              then col.datatype
+        when "UNIT"                  then col.unit
+        when "VARIABLE_PREFIX_UNIT"  then col.variable_prefix_unit
+        when "UNIT_ID"               then col.unit_id
+        when "ALTERNATIVE_UNITS"     then col.alternative_units
+        when "VALUE_FORMAT"          then col.value_format
+        when "PATTERN"               then col.pattern
+        when "RELATION"              then col.relation
+        when "DEFAULT_VALUE"         then col.default_value
+        when "DEFAULT_DATA_SUPPLIER" then col.default_data_supplier
+        when "DEFAULT_DATA_VERSION"  then col.default_data_version
+        when "REQUIREMENT"           then col.requirement
+        end
+      end
+
+      def langs_for(col, base)
+        case base
+        when "PROPERTY_NAME" then (col.name_by_lang || {}).keys
+        when "DEFINITION"    then (col.definition_by_lang || {}).keys
+        when "NOTE"          then (col.note_by_lang || {}).keys
+        else []
+        end
+      end
+
+      def localized_value(col, base, lang)
+        case base
+        when "PROPERTY_NAME" then (col.name_by_lang || {})[lang]
+        when "DEFINITION"    then (col.definition_by_lang || {})[lang]
+        when "NOTE"          then (col.note_by_lang || {})[lang]
+        end
+      end
+
+      def emit_data_row(sheet, entity, rows)
+        values = sheet.schema.columns.map { |col| entity_value_for(entity, col) }
+        rows << [nil, *values]
+      end
+
+      def entity_value_for(entity, col)
+        pid = col.property_id
+        val = entity.properties[pid]
+        return val unless val.nil?
+        multilingual_lookup(entity, pid)
+      end
+
+      # Multilingual fallback. The raw properties hash is the
+      # canonical store; the lookup here mirrors FieldReader's
+      # raw_multilingual resolution (single source of truth for
+      # "where do I find the language-tagged variant of this field").
+      # Routed through Entity#read_field when the column maps to a
+      # declared field, so any future field-DTL changes apply here
+      # too — see TODO.impl/26.
+      def multilingual_lookup(entity, pid)
+        entry = Opencdd::PropertyIds::REGISTRY[pid]
+        return entity.properties["#{pid}.#{@source_language}"] if entry && entry.multilingual
+        if pid.include?(".")
+          base, = pid.split(".", 2)
+          return entity.properties[pid] if entity.properties.key?(pid)
+          return entity.properties[base]
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/opencdd/parcel/sheet_schema.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Parcel
+    class SheetSchema
+      # Parcel-specific column-ID canonicalization. Maps the
+      # ParcelMaker variant headers (MDC_P004_1, MDC_P005, ...)
+      # to the canonical IEC 61360 IDs (MDC_P004, MDC_P006, ...).
+      #
+      # Owned by SheetSchema because this mapping only exists for
+      # the Parcel sheet layout — the PropertyIds registry is
+      # ontology-only and shouldn't carry format-specific details.
+      VARIANT_TO_CANONICAL = {
+        "MDC_P004_1" => "MDC_P004",
+        "MDC_P004_2" => "MDC_P007",
+        "MDC_P004_3" => "MDC_P005",
+        "MDC_P005"   => "MDC_P006",
+        "MDC_P007_1" => "MDC_P008",
+        "MDC_P007_2" => "MDC_P009",
+      }.freeze
+
+      # Canonicalize a Parcel column ID. Splits language tags
+      # (<id>.<lang>) so they round-trip cleanly. Returns the
+      # canonical ID (or the input unchanged if no mapping exists).
+      def self.canonical_id(raw_id)
+        return nil if raw_id.nil?
+        s = raw_id.to_s.strip
+        return nil if s.empty?
+        match = s.match(/\.(?<lang>[A-Za-z0-9-]+)\z/)
+        base = match ? match.pre_match : s
+        lang = match && match[:lang]
+        canonical = VARIANT_TO_CANONICAL[base] || base
+        lang ? "#{canonical}.#{lang}" : canonical
+      end
+
+      DIRECTIVE_ROWS = %w[
+        PROPERTY_ID
+        ALTERNATE_ID
+        SUPER_ALTERNATE_ID
+        SUB_ALTERNATE_ID
+        EQUIVALENT_ID
+        SUPER_PROPERTY
+        PROPERTY_NAME
+        DEFINITION
+        NOTE
+        DATATYPE
+        UNIT
+        VARIABLE_PREFIX_UNIT
+        UNIT_ID
+        ALTERNATIVE_UNITS
+        VALUE_FORMAT
+        PATTERN
+        RELATION
+        DEFAULT_VALUE
+        DEFAULT_DATA_SUPPLIER
+        DEFAULT_DATA_VERSION
+        REQUIREMENT
+      ].freeze
+
+      class Column < Struct.new(
+        :index,
+        :property_id,
+        :raw_property_id,
+        :alternate_id,
+        :super_alternate_id,
+        :sub_alternate_id,
+        :equivalent_id,
+        :super_property,
+        :name_by_lang,
+        :definition_by_lang,
+        :note_by_lang,
+        :datatype,
+        :unit,
+        :variable_prefix_unit,
+        :unit_id,
+        :alternative_units,
+        :value_format,
+        :pattern,
+        :relation,
+        :default_value,
+        :default_data_supplier,
+        :default_data_version,
+        :requirement,
+        keyword_init: true,
+      )
+        def name(lang = :en)
+          name_by_lang[lang.to_s]
+        end
+
+        def definition(lang = :en)
+          definition_by_lang[lang.to_s]
+        end
+
+        def note(lang = :en)
+          note_by_lang[lang.to_s]
+        end
+
+        def required?
+          requirement == "MAND"
+        end
+
+        def key?
+          requirement == "KEY"
+        end
+
+        def obsolete?
+          requirement == "OBS"
+        end
+      end
+
+      DIRECTIVE_ROW_PREFIX = "#".freeze
+
+      attr_reader :columns, :columns_by_id, :column_directives
+
+      def initialize
+        @columns = []
+        @columns_by_id = {}
+        @column_directives = {}
+      end
+
+      def self.from_header_rows(rows)
+        schema = new
+        rows.each do |row|
+          schema.add_directive_row(row)
+        end
+        schema.finalize!
+        schema
+      end
+
+      def add_directive_row(row)
+        return self if row.nil? || row.empty?
+
+        label_cell = row[0].to_s
+        directive = parse_directive(label_cell)
+        return self unless directive
+
+        values = row[1..].to_a
+
+        unless @column_directives.key?(directive)
+          @column_directives[directive] = []
+        end
+
+        values.each_with_index do |val, idx|
+          @column_directives[directive][idx] = val
+        end
+
+        self
+      end
+
+      def add_column(column)
+        @columns << column
+        @columns_by_id[column.property_id] = column
+        self
+      end
+
+      def finalize_for_scaffold!
+        freeze
+      end
+
+      def finalize!
+        ids = @column_directives["PROPERTY_ID"] || []
+        ids.each_with_index do |id, idx|
+          next if id.nil? || id.to_s.strip.empty?
+
+          col = Column.new(
+            index: idx + 1,
+            property_id: Opencdd::Parcel::SheetSchema.canonical_id(id.to_s.strip),
+            raw_property_id: id.to_s.strip,
+            alternate_id: lookup("ALTERNATE_ID", idx),
+            super_alternate_id: lookup("SUPER_ALTERNATE_ID", idx),
+            sub_alternate_id: lookup("SUB_ALTERNATE_ID", idx),
+            equivalent_id: lookup("EQUIVALENT_ID", idx),
+            super_property: lookup("SUPER_PROPERTY", idx),
+            name_by_lang: lang_hash_for("PROPERTY_NAME", idx),
+            definition_by_lang: lang_hash_for("DEFINITION", idx),
+            note_by_lang: lang_hash_for("NOTE", idx),
+            datatype: lookup("DATATYPE", idx),
+            unit: lookup("UNIT", idx),
+            variable_prefix_unit: lookup("VARIABLE_PREFIX_UNIT", idx),
+            unit_id: lookup("UNIT_ID", idx),
+            alternative_units: lookup("ALTERNATIVE_UNITS", idx),
+            value_format: lookup("VALUE_FORMAT", idx),
+            pattern: lookup("PATTERN", idx),
+            relation: lookup("RELATION", idx),
+            default_value: lookup("DEFAULT_VALUE", idx),
+            default_data_supplier: lookup("DEFAULT_DATA_SUPPLIER", idx),
+            default_data_version: lookup("DEFAULT_DATA_VERSION", idx),
+            requirement: lookup("REQUIREMENT", idx),
+          )
+          @columns << col
+          @columns_by_id[col.property_id] = col
+        end
+
+        freeze
+      end
+
+      def [](property_id_or_name)
+        find_by_property_id(property_id_or_name) || find_by_name(property_id_or_name)
+      end
+
+      def find_by_property_id(id)
+        @columns_by_id[id.to_s]
+      end
+
+      def find_by_name(name, lang = :en)
+        @columns.find { |c| c.name(lang).to_s.casecmp(name.to_s).zero? }
+      end
+
+      def size
+        @columns.size
+      end
+
+      def each(&block)
+        @columns.each(&block)
+      end
+
+      include Enumerable
+
+      private
+
+      def parse_directive(cell)
+        return nil if cell.nil?
+        s = cell.to_s.strip
+        return nil unless s.start_with?("#")
+        s[1..]
+      end
+
+      def lookup(directive, col_idx)
+        vals = @column_directives[directive]
+        return nil unless vals
+        v = vals[col_idx]
+        return nil if v.nil?
+        s = v.to_s.strip
+        s.empty? ? nil : s
+      end
+
+      def lang_hash_for(directive, col_idx)
+        h = {}
+        @column_directives.each do |key, vals|
+          base, lang = key.split(".", 2)
+          next unless base == directive
+          v = vals[col_idx]
+          next if v.nil?
+          s = v.to_s.strip
+          next if s.empty?
+          lang = "en" if lang.nil? || lang.empty?
+          h[lang] = s
+        end
+        h
+      end
+    end
+  end
+end