opencdd 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0782b45aeee8bad692974cd0480dd8430f13c92f405760188a13df3e3b2c77ed'
-  data.tar.gz: a4e26b1842e838b8e9464d0ff782ec745d59b96e9f5637e8630de9343218805d
+  metadata.gz: c582aa6a0bf79bedf583a586f97c1c308852b53d4efc9972b3bb883a2be425fc
+  data.tar.gz: 1195b6615ee045c3c1ac63f237ccdb930d80838db9dbe33677216e271748accc
 SHA512:
-  metadata.gz: 12267bf271cabfeedb613766a6f679843d3be7fe542a96b097c9804ae7014c2a6fa5d96c2bafeeeefdaf7bbd9878ccde9aeca85423bbc40ad07ef3b7fb1428b7
-  data.tar.gz: 23a8abce3684e130d3e7bff46973b579c3a71d9212153aea4f216314e6ab9ff7747b3a0030ecb1a0cd9134a3dab6dc83b782132d83a4feea8c2c36052994bfb0
+  metadata.gz: 1cbdf2e8832ccd86b95fcfc6789d8d9dfe4be656a27f7b4cac4cb854ea6f224153f5aa8cca521362f364954e123e0c50d3424da3daf031cd73f1974823794cb9
+  data.tar.gz: 072c326fba5a5807249b7ea79eda95c31fc42384c80de750dba20c741de0601c8c67afe61e9b58a27e594797c68b12cbb38b4166c0f56ce547130e610625c80c

data/bin/lint-no-raw-mdc

@@ -1,3 +1,4 @@
+#!/usr/bin/env bash
 # lint-no-raw-mdc — fail if any raw MDC_P### / MDC_C### / EXT_P### /
 # EXT_C### / CIM_P### string literal appears in lib/opencdd/ outside
 # the designated SSOT files.

data/lib/opencdd/cddal/builder.rb

@@ -24,7 +24,7 @@ module Opencdd
                   :source_file, :loaded_modules
 
       def initialize(database = nil, resolver: nil, source_file: nil,
-                     loaded_modules: nil, loading_stack: nil)
+                     loaded_modules: nil, loading_stack: nil, qualified_table: nil)
         @database = database || Opencdd::Database.new
         @resolver = resolver || Opencdd::Cddal.default_resolver
         @source_file = source_file
@@ -32,7 +32,7 @@ module Opencdd
         @loading_stack = loading_stack || []
         @alias_table = Opencdd::AliasTable.new(defaults: true)
         @symbol_table = {}
-        @qualified_table = {} # "qualifier.name" => entity (qualified imports)
+        @qualified_table = qualified_table || {}
         @instance_decls = []
         @meta_class_overrides = {}
       end
@@ -108,84 +108,14 @@ module Opencdd
       # names are accessible without qualification.
 
       def apply_import_declarations(document)
-        document.import_declarations.each { |decl| process_import(decl) }
-      end
-
-      def process_import(decl)
-        canonical, source = resolve_specifier(decl.specifier)
-        # Resolution may return [nil, nil] in non-strict mode when
-        # the specifier points at an unreachable URL or a missing
-        # file. Skip the import with a warning — preserves the
-        # graceful-degradation behavior CDDAL authors expect for
-        # cross-dictionary URLs.
-        return if canonical.nil?
-        return if @loaded_modules.key?(canonical)
-        check_cycle!(canonical, decl.specifier)
-
-        @loading_stack.push(canonical)
-        sub_doc = Opencdd::Cddal::Parser.parse(source)
-        Builder.new(@database, resolver: @resolver, source_file: canonical,
-                                loaded_modules: @loaded_modules,
-                                loading_stack: @loading_stack)
-          .build(sub_doc)
-        @loading_stack.pop
-        @loaded_modules[canonical] = true
-
-        # Symbol scoping is applied AFTER the sub-document is built,
-        # so the named entities exist in @database by the time we
-        # look them up.
-        apply_import_scope(decl, canonical)
-      end
-
-      def resolve_specifier(specifier)
-        @resolver.resolve(specifier, importing_file: @source_file)
-      end
-
-      def check_cycle!(canonical, specifier)
-        return unless @loading_stack.include?(canonical)
-        cycle = @loading_stack.dup
-        cycle << canonical
-        raise Opencdd::Cddal::ImportError,
-              "circular CDDAL import detected: #{cycle.join(' → ')} " \
-              "(originally imported as #{specifier.inspect})"
-      end
-
-      def apply_import_scope(decl, _canonical)
-        case decl.kind
-        when :bare
-          # Nothing to do — bare imports leave the sub-document's
-          # names in the shared @database symbol table.
-        when :qualified
-          register_qualified_symbols(decl.qualifier)
-        when :selective
-          register_selective_symbols(decl.imported_names)
-        end
-      end
-
-      def register_qualified_symbols(qualifier)
-        @database.entities.each do |entity|
-          name = entity_alias_name(entity)
-          next unless name
-          qualified = "#{qualifier}.#{name}"
-          @qualified_table[qualified] = entity
-          @database.register_symbol(qualified, entity)
-        end
-      end
-
-      def register_selective_symbols(imported_names)
-        imported_names.each do |imported|
-          entity = @database.resolve_reference(imported.name)
-          next unless entity
-          # Register in the parent Database's symbol table so the
-          # renamed name resolves during link phase.
-          @database.register_symbol(imported.local_name, entity)
-        end
-      end
-
-      def entity_alias_name(entity)
-        code = entity.code
-        return code if code && !code.empty?
-        entity.preferred_name.to_s
+        Opencdd::Cddal::ImportPipeline.new(
+          database: @database,
+          resolver: @resolver,
+          source_file: @source_file,
+          loaded_modules: @loaded_modules,
+          loading_stack: @loading_stack,
+          qualified_table: @qualified_table,
+        ).process(document.import_declarations)
       end
 
       def register_instance_symbols(document)

data/lib/opencdd/cddal/import_pipeline.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Cddal
+    # Handles CDDAL module imports: resolution, cycle detection,
+    # recursive sub-document building, and symbol scoping.
+    #
+    # Extracted from Builder so the import pipeline has its own
+    # testable interface. Builder creates an ImportPipeline and
+    # delegates +apply_import_declarations+ to it.
+    #
+    # The pipeline holds shared mutable state (loaded_modules,
+    # loading_stack) that persists across recursive sub-builds.
+    # This state is passed by reference from the parent Builder
+    # so all levels of the import tree share the same cycle
+    # tracking.
+    class ImportPipeline
+      def initialize(database:, resolver:, source_file:, loaded_modules:, loading_stack:, qualified_table:)
+        @database = database
+        @resolver = resolver
+        @source_file = source_file
+        @loaded_modules = loaded_modules
+        @loading_stack = loading_stack
+        @qualified_table = qualified_table
+      end
+
+      def process(import_declarations)
+        import_declarations.each { |decl| process_import(decl) }
+      end
+
+      private
+
+      def process_import(decl)
+        canonical, source = @resolver.resolve(decl.specifier, importing_file: @source_file)
+        return if canonical.nil?
+        return if @loaded_modules.key?(canonical)
+        check_cycle!(canonical, decl.specifier)
+
+        @loading_stack.push(canonical)
+        sub_doc = Opencdd::Cddal::Parser.parse(source)
+        Builder.new(@database, resolver: @resolver, source_file: canonical,
+                                loaded_modules: @loaded_modules,
+                                loading_stack: @loading_stack,
+                                qualified_table: @qualified_table)
+          .build(sub_doc)
+        @loading_stack.pop
+        @loaded_modules[canonical] = true
+
+        apply_import_scope(decl)
+      end
+
+      def check_cycle!(canonical, specifier)
+        return unless @loading_stack.include?(canonical)
+        cycle = @loading_stack.dup
+        cycle << canonical
+        raise Opencdd::Cddal::ImportError,
+              "circular CDDAL import detected: #{cycle.join(' → ')} " \
+              "(originally imported as #{specifier.inspect})"
+      end
+
+      def apply_import_scope(decl)
+        case decl.kind
+        when :bare
+          # Bare imports leave names in the shared symbol table.
+        when :qualified
+          register_qualified_symbols(decl.qualifier)
+        when :selective
+          register_selective_symbols(decl.imported_names)
+        end
+      end
+
+      def register_qualified_symbols(qualifier)
+        @database.entities.each do |entity|
+          name = entity_alias_name(entity)
+          next unless name
+          qualified = "#{qualifier}.#{name}"
+          @qualified_table[qualified] = entity
+          @database.register_symbol(qualified, entity)
+        end
+      end
+
+      def register_selective_symbols(imported_names)
+        imported_names.each do |imported|
+          entity = @database.resolve_reference(imported.name)
+          next unless entity
+          @database.register_symbol(imported.local_name, entity)
+        end
+      end
+
+      def entity_alias_name(entity)
+        code = entity.code
+        return code if code && !code.empty?
+        entity.preferred_name.to_s
+      end
+    end
+  end
+end

data/lib/opencdd/cddal.rb

@@ -7,6 +7,7 @@ module Opencdd
     autoload :Parser,          "opencdd/cddal/parser"
     autoload :GeneratedParser, "opencdd/cddal/generated_parser"
     autoload :Builder,         "opencdd/cddal/builder"
+    autoload :ImportPipeline,  "opencdd/cddal/import_pipeline"
     autoload :Serializer,      "opencdd/cddal/serializer"
     autoload :Resolver,        "opencdd/cddal/resolver"
     autoload :Fetcher,         "opencdd/cddal/fetcher"

data/lib/opencdd/condition.rb

@@ -13,6 +13,12 @@ module Opencdd
       (?<right>.+)
     \z/x.freeze
 
+    # A single bare token (IRDI or short code) without internal whitespace.
+    # Used to detect class-reference conditions of the form
+    # `0112/2///62683#ACE132` and distinguish them from malformed input
+    # like "no operator here" (which has internal whitespace).
+    SINGLE_TOKEN_PATTERN = /\A\S+\z/.freeze
+
     attr_reader :left, :operator, :right
 
     def initialize(left, operator, right)
@@ -24,6 +30,10 @@ module Opencdd
       @right = right
     end
 
+    def class_reference?
+      false
+    end
+
     def set?
       @right.is_a?(Set)
     end
@@ -76,6 +86,12 @@ module Opencdd
           op   = Regexp.last_match(:op)
           raw_right = Regexp.last_match(:right).strip
           new(left, op, parse_rhs(raw_right))
+        elsif s =~ SET_PATTERN
+          body = Regexp.last_match(:body)
+          elements = body.split(/[,\s]+/).map(&:strip).reject(&:empty?)
+          ClassReference.new(irdis: elements)
+        elsif SINGLE_TOKEN_PATTERN.match?(s)
+          ClassReference.new(irdis: [s])
         else
           raise ArgumentError, "invalid condition expression: #{s.inspect}"
         end
@@ -116,5 +132,54 @@ module Opencdd
     def normalize_for_eq(value)
       value.is_a?(Set) ? value.to_a.sort : value
     end
+
+    # A condition of the form `{0112/2///62683#ACE132}` or a bare
+    # `0112/2///62683#ACE132` — meaning "this property applies when the
+    # host class is one of the listed IRDIs". IEC 62683 stores property
+    # conditions this way; the regular boolean-expression grammar in
+    # +Condition+ cannot represent it.
+    class ClassReference < Condition
+      attr_reader :irdis
+
+      # The binding key (string or symbol) consulted by +#satisfied_by?+
+      # to discover the host class IRDI. Callers that resolve the host
+      # class via a different key should override +satisfied_by?+.
+      HOST_CLASS_KEYS = [:class, :host_class, "class", "host_class"].freeze
+
+      def initialize(irdis:)
+        @irdis = Array(irdis).map(&:to_s)
+        @left = nil
+        @operator = nil
+        @right = nil
+      end
+
+      def class_reference?
+        true
+      end
+
+      def set?
+        @irdis.size > 1
+      end
+
+      def satisfied_by?(bindings)
+        hash = bindings.is_a?(Hash) ? bindings : bindings.to_h
+        actual = HOST_CLASS_KEYS.map { |k| hash[k] }.compact.first
+        return true if actual.nil?
+        @irdis.any? { |irdi| actual.to_s == irdi }
+      end
+
+      def to_s
+        @irdis.size == 1 ? @irdis.first : "{#{@irdis.join(', ')}}"
+      end
+
+      def ==(other)
+        other.is_a?(ClassReference) && Set.new(@irdis) == Set.new(other.irdis)
+      end
+      alias_method :eql?, :==
+
+      def hash
+        Set.new(@irdis).hash
+      end
+    end
   end
 end

data/lib/opencdd/entity/name_synthesizer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class Entity
+    # Reverse name-to-ID resolution for Parcel sheets that omit the
+    # #PROPERTY_ID directive row. Some cdd.iec.ch export formats
+    # (notably RELATION exports) include only #PROPERTY_NAME.en,
+    # leaving the importer unable to map column positions to property
+    # IDs. NameSynthesizer bridges that gap using the IEC 62656-1
+    # defined column names.
+    #
+    # Extracted from SheetSchema so SheetSchema focuses on header
+    # parsing + Column construction. Name synthesis is a separate
+    # concern with its own test surface.
+    #
+    # The name→ID table itself lives in Opencdd::PropertyIds::IEC_COLUMN_NAMES
+    # (the lint-exempt SSOT). NAME_TO_PROPERTY_ID is kept here as a
+    # back-compat alias so existing callers see no public-API change.
+    module NameSynthesizer
+      NAME_TO_PROPERTY_ID = Opencdd::PropertyIds::IEC_COLUMN_NAMES
+
+      # Given a PROPERTY_NAME directive row (Array of name strings),
+      # returns a parallel Array of property IDs (or nil where the
+      # name is unrecognized). Language suffixes (.EN, .FR) are
+      # stripped for lookup and re-appended to the synthesized ID.
+      #
+      #   synthesize(["Code", "PreferredName.EN", "Unknown"])
+      #   => ["MDC_P001_5", "MDC_P004.en", nil]
+      def self.synthesize(name_values)
+        Array.new(name_values.size) do |idx|
+          val = name_values[idx]
+          next nil if val.nil? || val.to_s.strip.empty?
+          raw = val.to_s.strip
+          if raw =~ /\A(.+)\.([A-Za-z]{2})\z/
+            base = $1
+            lang = $2
+            pid = NAME_TO_PROPERTY_ID[base]
+            pid ? "#{pid}.#{lang.downcase}" : nil
+          else
+            NAME_TO_PROPERTY_ID[raw]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opencdd/entity/yaml.rb

@@ -96,55 +96,52 @@ module Opencdd
       # ── Catch-all for unknown properties (lossless) ────────
       attribute :extra, :hash
 
+      # Fields that should NOT be driven from FieldRegistry in
+      # from_entity — they're either identity fields (irdi, code)
+      # or catch-all (extra, raw_properties, version_history, etc.)
+      # handled separately.
+      SKIP_FIELDS = %i[
+        raw_properties version_history dates
+        source_document_of_definition synonymous_names
+        simplified_drawing example time_stamp
+        status_level publisher published_in responsible_committee
+        change_request_id data_object_identifier
+        alternative_unit_irdis domain_of_function_irdis
+        formula_language external_solver trigger_event
+        domain_element_type codomain_element_type role segment
+        super_relation_irdi sgml_representation
+        unit_sgml class_value_assignment coded_name
+        symbol_in_text constraint type_classification
+        applicable_documents imported_documents
+        superclass_type_property
+      ].freeze
+
       # ── Conversion: Entity → Entity::Yaml ───────────────────
+      # Drives from FieldRegistry — the same SSOT that drives the
+      # JSON exporter. Each field's wire_name (from the `as:` DSL
+      # option) determines the YAML attribute to set. Adding a new
+      # field requires zero changes here if the wire_name matches
+      # a declared YAML attribute.
       def self.from_entity(entity)
         attrs = {
           irdi: entity.irdi&.to_s,
           type: entity.type&.to_s,
           code: entity.code,
-          guid: entity[Opencdd::PropertyIds::MDC_P066],
-          version: entity[Opencdd::PropertyIds::MDC_P002_1],
-          revision: entity[Opencdd::PropertyIds::MDC_P002_2],
         }
 
-        attrs[:preferred_name] = extract_ml(entity, Opencdd::PropertyIds::MDC_P004)
-        attrs[:short_name]     = extract_ml(entity, Opencdd::PropertyIds::MDC_P005)
-        attrs[:definition]     = extract_ml(entity, Opencdd::PropertyIds::MDC_P006)
-        attrs[:note]           = extract_ml(entity, Opencdd::PropertyIds::MDC_P008)
-        attrs[:remark]         = extract_ml(entity, Opencdd::PropertyIds::MDC_P009)
-        attrs[:description]    = extract_ml(entity, Opencdd::PropertyIds::MDC_P112)
-
-        case entity.type
-        when :class
-          attrs[:class_type] = entity.read_field(:class_type)&.to_s
-          attrs[:superclass] = entity.read_field(:superclass_irdi)&.to_s
-          attrs[:is_case_of] = entity.read_field(:is_case_of_irdis)&.map(&:to_s) || []
-          attrs[:applicable_properties] = entity.read_field(:applicable_property_irdis)&.map(&:to_s) || []
-          attrs[:imported_properties] = entity.read_field(:imported_property_irdis)&.map(&:to_s) || []
-          attrs[:sub_class_selection] = entity.read_field(:sub_class_selection_irdis)&.map(&:to_s) || []
-        when :property
-          attrs[:data_type] = entity.read_field(:parsed_data_type)&.to_s
-          attrs[:value_format] = entity.read_field(:parsed_value_format)&.to_s
-          attrs[:definition_class] = entity.read_field(:definition_class_irdi)&.to_s
-          attrs[:unit] = entity.read_field(:unit_irdi)&.to_s
-          attrs[:condition] = entity.read_field(:condition)&.to_s
-          attrs[:property_data_element_type] = entity.read_field(:property_data_element_type)&.to_s
-        when :unit
-          attrs[:unit_structure] = entity.read_field(:structure)
-          attrs[:unit_text] = entity.read_field(:text_representation)
-        when :value_list
-          attrs[:list_type] = entity.read_field(:list_type)&.to_s
-          attrs[:code_list] = entity.read_field(:code_list) || []
-          attrs[:term_irdis] = entity.read_field(:term_irdis)&.map(&:to_s) || []
-        when :value_term
-          attrs[:enumeration_code] = entity.read_field(:enumeration_code)
-        when :relation
-          attrs[:relation_type] = entity.read_field(:relation_type)&.to_s
-          attrs[:codomain] = entity.read_field(:codomain_irdi)&.to_s
-          attrs[:formula] = entity.read_field(:formula)
-        when :view_control
-          attrs[:controlled_classes] = entity.read_field(:controlled_class_irdis)&.map(&:to_s) || []
-          attrs[:shown_properties] = entity.read_field(:shown_property_irdis)&.map(&:to_s) || []
+        declared_attrs = attribute_names
+        seen_property_ids = {}
+
+        Opencdd::Entity::FieldRegistry.fields_for(entity.class).each do |field|
+          next if SKIP_FIELDS.include?(field.name)
+          next unless declared_attrs.include?(field.wire_name)
+          next if field.property_id && seen_property_ids.key?(field.property_id)
+          seen_property_ids[field.property_id] = true if field.property_id
+
+          value = read_field_for_yaml(entity, field)
+          next if value.nil?
+
+          attrs[field.wire_name.to_sym] = value
         end
 
         extra = extract_extra(entity)
@@ -186,10 +183,17 @@ module Opencdd
         props[Opencdd::PropertyIds::MDC_P023_1] = unit_text if unit_text
 
         props[Opencdd::PropertyIds::MDC_P046] = list_type if list_type
-        props[Opencdd::PropertyIds::MDC_P044] = rejoin_set(code_list) if code_list&.any?
         props[Opencdd::PropertyIds::MDC_P043] = rejoin_set(term_irdis) if term_irdis&.any?
 
-        props[Opencdd::PropertyIds::MDC_P044] = enumeration_code if enumeration_code
+        # MDC_P044 is overloaded: code_list (value_list, collection)
+        # vs enumeration_code (value_term, scalar). Guard by type to
+        # prevent the value_term path from clobbering the value_list.
+        case type&.to_sym
+        when :value_list
+          props[Opencdd::PropertyIds::MDC_P044] = rejoin_set(code_list) if code_list&.any?
+        when :value_term
+          props[Opencdd::PropertyIds::MDC_P044] = enumeration_code if enumeration_code
+        end
 
         props[Opencdd::PropertyIds::MDC_P200] = relation_type if relation_type
         props[Opencdd::PropertyIds::MDC_P203] = codomain if codomain
@@ -229,7 +233,7 @@ module Opencdd
         MDC_P011 MDC_P010 MDC_P010_1
         MDC_P013 MDC_P014 MDC_P090 MDC_P016
         MDC_P022 MDC_P024 MDC_P021 MDC_P041 MDC_P028 MDC_P020
-        MDC_P023 MDC_P023_1
+        MDC_P023 MDC_P023_1 MDC_P023_2
         MDC_P046 MDC_P044 MDC_P043
         MDC_P200 MDC_P203 MDC_P204
         EXT_P002 EXT_P003
@@ -262,6 +266,53 @@ module Opencdd
       def rejoin_set(list)
         Opencdd::StructuredValues.rejoin(list)
       end
+
+      # ── FieldRegistry-driven value conversion ───────────────
+      # For multilingual fields, returns the full Hash<lang,text>
+      # by scanning @properties for <property_id>.<lang> keys.
+      # For scalar/collection fields, reads through the field DSL
+      # and converts to YAML-compatible types.
+      def self.read_field_for_yaml(entity, field)
+        if field.multilingual? && field.property_id
+          extract_ml(entity, field.property_id)
+        else
+          value = entity.read_field(field.name)
+          return nil if value.nil?
+          field_to_yaml(value, field)
+        end
+      end
+
+      def self.field_to_yaml(value, field)
+        case field.value_kind
+        when :synonym_pairs
+          return nil if value.nil?
+          value.transform_keys(&:to_s)
+        when :irdi, :identifier_ref, :class_ref
+          value&.to_s
+        when :set_of_refs, :string_list
+          return nil if value.nil? || value.empty?
+          value.map(&:to_s)
+        when :string, :date, :date_time, :condition
+          value&.to_s
+        when :integer
+          value
+        when :boolean
+          value
+        else
+          case value
+          when Array then value.empty? ? nil : value.map(&:to_s)
+          when Hash then value.empty? ? nil : value
+          else value.to_s
+          end
+        end
+      end
+
+      # Returns the list of declared lutaml-model attribute names.
+      # Used by from_entity to check if a field's wire_name matches
+      # a declared YAML attribute.
+      def self.attribute_names
+        attributes.map { |name, _| name.to_s }
+      end
     end
   end
 end

data/lib/opencdd/entity.rb

@@ -15,6 +15,7 @@ module Opencdd
     autoload :FieldReader,     "opencdd/entity/field_reader"
     autoload :VersionHistory,  "opencdd/entity/version_history"
     autoload :Yaml,            "opencdd/entity/yaml"
+    autoload :NameSynthesizer, "opencdd/entity/name_synthesizer"
 
     class << self
       # Declare a typed field on this entity class. Defaults for

data/lib/opencdd/parcel/sheet_schema.rb

@@ -197,57 +197,8 @@ module Opencdd
         freeze
       end
 
-      # When a sheet has no #PROPERTY_ID directive row (only
-      # #PROPERTY_NAME), synthesize property IDs from the names.
-      # This happens with some export formats (notably RELATION
-      # exports from cdd.iec.ch) that omit the PROPERTY_ID row.
-      NAME_TO_PROPERTY_ID = {
-        "Code"                   => "MDC_P001_5",
-        "Version"                => "MDC_P002_1",
-        "Revision"               => "MDC_P002_2",
-        "VersionInitiationDate"  => "MDC_P003_1",
-        "VersionReleaseDate"     => "MDC_P003_2",
-        "RevisionReleaseDate"    => "MDC_P003_3",
-        "PreferredName"          => "MDC_P004",
-        "SynonymousName"         => "MDC_P007",
-        "ShortName"              => "MDC_P005",
-        "Definition"             => "MDC_P006",
-        "DefinitionSource"       => "MDC_P006_1",
-        "Note"                   => "MDC_P008",
-        "Remark"                 => "MDC_P009",
-        "Drawing"                => "MDC_P008_1",
-        "GUID"                   => "MDC_P066",
-        "TimeStamp"              => "MDC_P067",
-        "ClassType"              => "MDC_P011",
-        "Superclass"             => "MDC_P010",
-        "IsCaseOf"               => "MDC_P013",
-        "ApplicableProperties"   => "MDC_P014",
-        "ImportedProperties"     => "MDC_P090",
-        "SubClassSelection"      => "MDC_P016",
-        "DataType"               => "MDC_P022",
-        "ValueFormat"            => "MDC_P024",
-        "DefinitionClass"        => "MDC_P021",
-        "Unit"                   => "MDC_P041",
-        "Condition"              => "MDC_P028",
-        "ListType"               => "MDC_P046",
-        "CodeList"               => "MDC_P044",
-        "TermList"               => "MDC_P043",
-        "EnumerationCode"        => "MDC_P044",
-        "RelationType"           => "MDC_P200",
-        "RelationDomain"         => "MDC_P201",
-        "FunctionDomain"         => "MDC_P202",
-        "FunctionCodomain"       => "MDC_P203",
-        "Formula"                => "MDC_P204",
-        "FormulaLanguage"        => "MDC_P205",
-        "FormulaExternalSolver"  => "MDC_P206",
-        "TriggerEvent"           => "MDC_P207",
-        "DomainElementType"      => "MDC_P208",
-        "CodomainElementType"    => "MDC_P209",
-        "Role"                   => "MDC_P210",
-        "Segment"                => "MDC_P211",
-        "SuperRelation"          => "MDC_P212",
-      }.freeze
-
+      # Delegates to Entity::NameSynthesizer when the sheet has no
+      # #PROPERTY_ID directive row. See name_synthesizer.rb.
       def synthesize_ids_from_names
         names = nil
         @column_directives.each do |key, vals|
@@ -257,19 +208,7 @@ module Opencdd
           break
         end
         return [] unless names
-        Array.new(names.size) do |idx|
-          val = names[idx]
-          next nil if val.nil? || val.to_s.strip.empty?
-          raw = val.to_s.strip
-          if raw =~ /\A(.+)\.([A-Za-z]{2})\z/
-            base = $1
-            lang = $2
-            pid = NAME_TO_PROPERTY_ID[base]
-            pid ? "#{pid}.#{lang.downcase}" : nil
-          else
-            NAME_TO_PROPERTY_ID[raw]
-          end
-        end
+        Opencdd::Entity::NameSynthesizer.synthesize(names)
       end
 
       def [](property_id_or_name)

data/lib/opencdd/property.rb

@@ -37,10 +37,10 @@ module Opencdd
     field :type_classification,    "MDC_P033",   :string
     field :source_document,        "MDC_P006_1", :string
     field :coded_name,             "MDC_P018",  :string
-    field :definition_class_irdi,  "MDC_P021"
+    field :definition_class_irdi,  "MDC_P021", as: "definition_class"
     field :class_value_assignment, "MDC_P017"
-    field :unit_irdi,              "MDC_P041"
-    field :alternative_unit_irdis, "MDC_P042"
+    field :unit_irdi,              "MDC_P041", as: "unit"
+    field :alternative_unit_irdis, "MDC_P042", as: "alternative_units"
 
     # ── Computed fields with block-form readers (synthetic: true).
     #     Blocks are evaluated via instance_exec on the entity, so
@@ -57,11 +57,11 @@ module Opencdd
         Opencdd::PropertyDataTypeElement.parse(properties[Opencdd::PropertyIds::MDC_P020])
     }
 
-    field :parsed_data_type,       synthetic: true, &PARSED_DATA_TYPE_BLOCK
+    field :parsed_data_type,       synthetic: true, as: "data_type", &PARSED_DATA_TYPE_BLOCK
     field :data_element_type,      synthetic: true, as: "data_element_type", &DATA_ELEMENT_TYPE_BLOCK
     field :property_data_element_type,
-          synthetic: true, &DATA_ELEMENT_TYPE_BLOCK
-    field :parsed_value_format,    synthetic: true do
+          synthetic: true, as: "property_data_element_type", &DATA_ELEMENT_TYPE_BLOCK
+    field :parsed_value_format,    synthetic: true, as: "value_format" do
       Opencdd::ValueFormat.parse(properties[Opencdd::PropertyIds::MDC_P024])
     end
     field :condition_raw,          "MDC_P028", synthetic: true do
@@ -69,13 +69,6 @@ module Opencdd
     end
     field :condition,              synthetic: true do
       @condition ||= Opencdd::Condition.parse(properties[Opencdd::PropertyIds::MDC_P028])
-    rescue ArgumentError
-      # IEC CDD occasionally stores a bare class-reference set in the
-      # condition column (e.g. "{0112/2///62683#ACE132}") instead of
-      # a `left OP right` boolean expression. Condition's grammar
-      # rejects that shape; treat it as nil rather than crashing the
-      # import. Tracked in TODO.full-cdd/17-condition-grammar-fix.md.
-      @condition = nil
     end
     field :formula,                synthetic: true do
       properties[Opencdd::PropertyIds::MDC_P027_1] ||

data/lib/opencdd/property_ids.rb

@@ -142,6 +142,58 @@ module Opencdd
     # ontology registry). Kept here as an alias for back-compat.
     PARCEL_VARIANT_TO_CANONICAL = Opencdd::Parcel::SheetSchema::VARIANT_TO_CANONICAL
 
+    # IEC 62656-1 defined PROPERTY_NAME directive column names mapped
+    # to canonical property IDs. Used by Opencdd::Entity::NameSynthesizer
+    # when a Parcel sheet omits the #PROPERTY_ID directive row and
+    # only carries #PROPERTY_NAME. Declared here so the raw IDs live
+    # in the lint-exempt SSOT instead of in the synthesis module.
+    IEC_COLUMN_NAMES = {
+      "Code"                   => "MDC_P001_5",
+      "Version"                => "MDC_P002_1",
+      "Revision"               => "MDC_P002_2",
+      "VersionInitiationDate"  => "MDC_P003_1",
+      "VersionReleaseDate"     => "MDC_P003_2",
+      "RevisionReleaseDate"    => "MDC_P003_3",
+      "PreferredName"          => "MDC_P004",
+      "SynonymousName"         => "MDC_P007",
+      "ShortName"              => "MDC_P005",
+      "Definition"             => "MDC_P006",
+      "DefinitionSource"       => "MDC_P006_1",
+      "Note"                   => "MDC_P008",
+      "Remark"                 => "MDC_P009",
+      "Drawing"                => "MDC_P008_1",
+      "GUID"                   => "MDC_P066",
+      "TimeStamp"              => "MDC_P067",
+      "ClassType"              => "MDC_P011",
+      "Superclass"             => "MDC_P010",
+      "IsCaseOf"               => "MDC_P013",
+      "ApplicableProperties"   => "MDC_P014",
+      "ImportedProperties"     => "MDC_P090",
+      "SubClassSelection"      => "MDC_P016",
+      "DataType"               => "MDC_P022",
+      "ValueFormat"            => "MDC_P024",
+      "DefinitionClass"        => "MDC_P021",
+      "Unit"                   => "MDC_P041",
+      "Condition"              => "MDC_P028",
+      "ListType"               => "MDC_P046",
+      "CodeList"               => "MDC_P044",
+      "TermList"               => "MDC_P043",
+      "EnumerationCode"        => "MDC_P044",
+      "RelationType"           => "MDC_P200",
+      "RelationDomain"         => "MDC_P201",
+      "FunctionDomain"         => "MDC_P202",
+      "FunctionCodomain"       => "MDC_P203",
+      "Formula"                => "MDC_P204",
+      "FormulaLanguage"        => "MDC_P205",
+      "FormulaExternalSolver"  => "MDC_P206",
+      "TriggerEvent"           => "MDC_P207",
+      "DomainElementType"      => "MDC_P208",
+      "CodomainElementType"    => "MDC_P209",
+      "Role"                   => "MDC_P210",
+      "Segment"                => "MDC_P211",
+      "SuperRelation"          => "MDC_P212",
+    }.freeze
+
     REGISTRY.each_key do |id|
       const_set(id, id.freeze) unless const_defined?(id, false)
     end

data/lib/opencdd/relation.rb

@@ -8,8 +8,8 @@ module Opencdd
     }.freeze
 
     # ── Pure field reads ─────────────────────────────────────────
-    field :domain_of_function_irdis, "MDC_P202"
-    field :codomain_irdi,            "MDC_P203"
+    field :domain_of_function_irdis, "MDC_P202", as: "domain_of_function"
+    field :codomain_irdi,            "MDC_P203", as: "codomain"
     field :formula,                  "MDC_P204", :string
     field :formula_language,         "MDC_P205", :string
     field :external_solver,          "MDC_P206", :string

data/lib/opencdd/unit.rb

@@ -6,10 +6,10 @@ module Opencdd
     # MDC_P023/023_1/023_2 are :identifier_ref in REGISTRY but used
     # as raw strings for unit symbols/representations. Explicit :string
     # override preserves historical behavior.
-    field :structure,            "MDC_P023",   :string
-    field :text_representation,  "MDC_P023_1", :string
-    field :sgml_representation,  "MDC_P023_2", :string
-    field :definition_class_irdi, "MDC_P021"
+    field :structure,            "MDC_P023",   :string, as: "unit_structure"
+    field :text_representation,  "MDC_P023_1", :string, as: "unit_text"
+    field :sgml_representation,  "MDC_P023_2", :string, as: "unit_sgml"
+    field :definition_class_irdi, "MDC_P021", as: "definition_class"
 
     alias_method :symbol, :text_representation
   end

data/lib/opencdd/validator/condition_rule.rb

@@ -14,6 +14,9 @@ module Opencdd
 
       def call(value, _context)
         return true if value.nil? || value.to_s.strip.empty?
+        # parse returns a boolean Condition or a Condition::ClassReference
+        # for bare-IRDI / bare-set conditions (IEC 62683 shape). Both are
+        # valid; only malformed input raises ArgumentError.
         !Opencdd::Condition.parse(value.to_s).nil?
       rescue ArgumentError
         false

data/lib/opencdd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Opencdd
-  VERSION = "0.2.3"
+  VERSION = "0.3.1"
 end

data/lib/opencdd/view_control.rb

@@ -3,8 +3,8 @@
 module Opencdd
   class ViewControl < Opencdd::Entity
     # ── Pure field reads ─────────────────────────────────────────
-    field :controlled_class_irdis, "EXT_P002"
-    field :shown_property_irdis,   "EXT_P003"
+    field :controlled_class_irdis, "EXT_P002", as: "controlled_classes"
+    field :shown_property_irdis,   "EXT_P003", as: "shown_properties"
     # data_object_identifier and time_stamp inherited from Entity base.
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencdd
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - OpenCDD contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-23 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roo
@@ -217,6 +217,7 @@ files:
 - lib/opencdd/cddal/fetcher/in_memory.rb
 - lib/opencdd/cddal/fetcher/net_http.rb
 - lib/opencdd/cddal/generated_parser.rb
+- lib/opencdd/cddal/import_pipeline.rb
 - lib/opencdd/cddal/lexer.rb
 - lib/opencdd/cddal/parser.rb
 - lib/opencdd/cddal/resolver.rb
@@ -239,6 +240,7 @@ files:
 - lib/opencdd/entity.rb
 - lib/opencdd/entity/field_reader.rb
 - lib/opencdd/entity/field_registry.rb
+- lib/opencdd/entity/name_synthesizer.rb
 - lib/opencdd/entity/version_history.rb
 - lib/opencdd/entity/yaml.rb
 - lib/opencdd/entity_diff.rb