opencdd 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b88da823f5a7adb8f4d88f16a2f1e97d4f3136579bea025ef28c178753ab7f0e
-  data.tar.gz: 6171d27282b147b1c80fb137d8523d9644bb58fcaf364d13e89fee8713b7b814
+  metadata.gz: 907feca38dccee34a74c306983cdbe506bf3b18843640000501e7482cea75414
+  data.tar.gz: 2581c9dfac24e7bb1b8fcb973ef311854d8096947daf9a6d01ca726e672d2612
 SHA512:
-  metadata.gz: b373faf0cd5ac6d5e2d6f62af3e0a3a57abe2300589fd9d4c19135ccaf7ac28b385bf9946a4d090d178b293b15dfcce4a77c60a1b452d2e31cbf0ceab2f3ab89
-  data.tar.gz: b7ceac12c85b84943405c25fd04b112e5e282332b30c24ccc3367779a2a4bb3688c945efb81ee3e9641108e6b99e57d3c889f32e5dbad1249e50c9e2728cd344
+  metadata.gz: eb42bba181fa6e5802a6c3ed1ea46dce2d7ee9197dea2f929bd8b2e9565826cdd19dc503ba58a231b5555208244e5d8e084b92199944d8b7d30aa1e2e6879c2f
+  data.tar.gz: 74ab77f45f8365a433a638414c982d092140b07f9084fbb97ea94d846cc60a0c3787a29a2180d729a424715896514008c6ec0b2d5e9060ca8b3c60197d09f2fb

data/bin/lint-no-raw-mdc

@@ -1,3 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
 # 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.
@@ -13,29 +16,50 @@
 #
 # Comment lines (lines whose first non-whitespace character is '#')
 # are also exempt.
-#
-set -euo pipefail
-
-excludes=(
-  ':!lib/opencdd/property_ids.rb'
-  ':!lib/opencdd/meta_class.rb'
-  ':!lib/opencdd/alias_table.rb'
-  ':!lib/opencdd/parcel/sheet_schema.rb'
-  ':!lib/opencdd/cddal/generated_parser.rb'
-)
-
-# Collect hits, filtering out Ruby comment-only lines.
-hits=$(git grep -nE '"(MDC_[CP][0-9]+(_[0-9]+)?|EXT_[CP][0-9]+|CIM_P[0-9]+)"' \
-  -- 'lib/opencdd/**/*.rb' "${excludes[@]}" 2>/dev/null \
-  | grep -vE '^[^:]+:[0-9]+:\s*#' \
-  || true)
-
-if [ -n "$hits" ]; then
-  echo "ERROR: raw MDC/EXT/CIM literal found outside designated SSOT files." >&2
-  echo "Use Opencdd::PropertyIds::REGISTRY / Opencdd::MetaClasses::REGISTRY instead." >&2
-  echo "" >&2
-  echo "$hits" >&2
+
+require "open3"
+
+EXCLUDED_PATHS = %w[
+  lib/opencdd/property_ids.rb
+  lib/opencdd/meta_class.rb
+  lib/opencdd/alias_table.rb
+  lib/opencdd/parcel/sheet_schema.rb
+  lib/opencdd/cddal/generated_parser.rb
+].freeze
+
+# Match "MDC_P###", "MDC_C###", "EXT_P###", "EXT_C###", "CIM_P###"
+# with optional _### sub-ids, as a double-quoted Ruby string literal.
+# Source string is POSIX ERE (not Ruby regex) — git grep -E requires it.
+LITERAL_PATTERN_SOURCE = '"(MDC_[CP][0-9]+(_[0-9]+)?|EXT_[CP][0-9]+|CIM_P[0-9]+)"'.freeze
+
+# Each git grep hit looks like: <path>:<lineno>:<content>
+# Skip comment-only lines (content's first non-space char is '#').
+HIT_LINE_PATTERN = /\A(?<path>[^:]+):(?<lineno>\d+):(?<content>.*)\z/m.freeze
+
+# lib/opencdd/**/*.rb minus the excluded SSOT files.
+pathspecs = ["lib/opencdd/**/*.rb"].concat(EXCLUDED_PATHS.map { |p| ":!#{p}" })
+
+cmd = ["git", "grep", "-n", "-E", LITERAL_PATTERN_SOURCE] + ["--"] + pathspecs
+stdout, _stderr, status = Open3.capture3(*cmd)
+
+# git grep returns 1 when there are no matches, which is the success
+# case. Treat anything other than 0/1 as a real failure.
+unless [0, 1].include?(status.exitstatus)
+  warn "ERROR: git grep failed (exit #{status.exitstatus})"
+  exit 2
+end
+
+hits = stdout.each_line.map(&:chomp).reject do |line|
+  match = HIT_LINE_PATTERN.match(line)
+  match && match[:content].lstrip.start_with?("#")
+end
+
+if hits.any?
+  warn "ERROR: raw MDC/EXT/CIM literal found outside designated SSOT files."
+  warn "Use Opencdd::PropertyIds::REGISTRY / Opencdd::MetaClasses::REGISTRY instead."
+  warn ""
+  hits.each { |hit| warn hit }
   exit 1
-fi
+end
 
 exit 0

data/lib/cdd.rb

@@ -6,6 +6,6 @@
 require "opencdd"
 
 # Alias for backward compatibility. The module was renamed from
-# Cdd to Opencdd, but many callers (cdd-data Rakefile, specs, etc.)
+# Cdd to Opencdd, but many callers (data-private Rakefile, specs, etc.)
 # still reference Cdd::. This alias lets them keep working.
 Cdd = Opencdd unless defined?(Cdd)

data/lib/opencdd/cddal/serializer.rb

@@ -174,7 +174,6 @@ module Opencdd
       def format_value(value)
         s = value.to_s
         return quote_string(s) if string_literal?(s)
-        return format_set(s) if set_like?(s)
         s
       end
 
@@ -194,15 +193,6 @@ module Opencdd
         "\"#{escaped}\""
       end
 
-      def set_like?(s)
-        s.start_with?("(") && s.end_with?(")")
-      end
-
-      def format_set(s)
-        elements = Opencdd::StructuredValues.unwrap_and_split(s)
-        "{ #{elements.join(', ')} }"
-      end
-
       def symbol_name_for(entity)
         code = entity.code&.to_s
         return code if code && !code.empty?

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

@@ -12,56 +12,12 @@ module Opencdd
     # 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
-      # IEC 62656-1 defined column names mapped to canonical
-      # property IDs. These names appear in the #PROPERTY_NAME
-      # directive row when #PROPERTY_ID is absent.
-      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
+      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

data/lib/opencdd/languages.rb

@@ -12,6 +12,12 @@ module Opencdd
   # "what languages does this dictionary have?" — used by the browser
   # to render a language switcher and by the data pipeline to report
   # language coverage.
+  #
+  # This is a model object. It does not normalize language codes:
+  # source-format quirks (e.g. IEC CDD .xls files using "jp" for
+  # Japanese) are normalized at the SheetSchema ingestion boundary
+  # via +Opencdd::Parcel::LanguageAliases+, so every consumer of
+  # this class can assume ISO 639-1 codes unconditionally.
   class Languages
     attr_reader :source, :translations
 
@@ -58,7 +64,7 @@ module Opencdd
     def self.from_properties(properties, default_source: "en")
       langs = properties.keys.each_with_object(Set.new) do |key, acc|
         next unless key.include?(".")
-        prefix, lang = key.split(".", 2)
+        _, lang = key.split(".", 2)
         next unless lang =~ /\A[a-z]{2}(-[a-z0-9]+)?\z/i
         acc << lang
       end
@@ -67,4 +73,4 @@ module Opencdd
       new(source: source, translations: translations)
     end
   end
-end
+end

data/lib/opencdd/parcel/language_aliases.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Parcel
+    # Maps non-conformant language codes found in IEC CDD source .xls
+    # exports to their ISO 639-1 equivalents.
+    #
+    # This is a Parcel-layer concern, not a model concern: the aliases
+    # exist because one specific source format (IEC CDD XLS) uses
+    # non-standard codes in its property ID suffixes and directive
+    # rows. The +Languages+ value object — and every downstream
+    # consumer (JSON wire format, browser, TS model) — speaks ISO
+    # 639-1 unconditionally.
+    #
+    # The normalization happens at the SheetSchema ingestion
+    # boundary so downstream code never sees an alias. SheetSchema
+    # also exposes the set of original-to-canonical mappings it
+    # applied via +#normalized_language_codes+ for data-quality
+    # reporting.
+    module LanguageAliases
+      ALIASES = {
+        "jp" => "ja",
+      }.freeze
+
+      # Returns the ISO 639-1 form of +code+, or the input unchanged
+      # if it is already standard. Pure function: no I/O, no side
+      # effects.
+      def self.normalize(code)
+        return code if code.nil?
+        s = code.to_s.strip
+        return s if s.empty?
+        ALIASES.fetch(s, s)
+      end
+
+      # True when +code+ would be rewritten by +normalize+.
+      def self.alias?(code)
+        return false if code.nil?
+        ALIASES.key?(code.to_s.strip)
+      end
+    end
+  end
+end

data/lib/opencdd/parcel/sheet_schema.rb

@@ -22,6 +22,8 @@ module Opencdd
       # 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).
+      # Language codes are normalized to ISO 639-1 via
+      # +Opencdd::Parcel::LanguageAliases.normalize+.
       def self.canonical_id(raw_id)
         return nil if raw_id.nil?
         s = raw_id.to_s.strip
@@ -30,7 +32,7 @@ module Opencdd
         base = match ? match.pre_match : s
         lang = match && match[:lang]
         canonical = VARIANT_TO_CANONICAL[base] || base
-        lang ? "#{canonical}.#{lang}" : canonical
+        lang ? "#{canonical}.#{Opencdd::Parcel::LanguageAliases.normalize(lang)}" : canonical
       end
 
       DIRECTIVE_ROWS = %w[
@@ -110,7 +112,7 @@ module Opencdd
 
       DIRECTIVE_ROW_PREFIX = "#".freeze
 
-      attr_reader :columns, :columns_by_id, :column_directives
+      attr_reader :columns, :columns_by_id, :column_directives, :normalized_language_codes
 
       def initialize
         @columns = []
@@ -194,6 +196,7 @@ module Opencdd
           @columns_by_id[col.property_id] = col
         end
 
+        @normalized_language_codes = compute_normalized_language_codes.freeze
         freeze
       end
 
@@ -260,11 +263,34 @@ module Opencdd
           next if v.nil?
           s = v.to_s.strip
           next if s.empty?
+          lang = Opencdd::Parcel::LanguageAliases.normalize(lang)
           lang = "en" if lang.nil? || lang.empty?
           h[lang] = s
         end
         h
       end
+
+      # Audit trail of language-code normalizations applied at this
+      # schema's ingestion boundary. Returns a frozen Hash mapping each
+      # original (non-conformant) language code seen in the source to
+      # its ISO 639-1 equivalent. Empty when the source spoke ISO.
+      def compute_normalized_language_codes
+        seen = {}
+        @column_directives.each_key do |key|
+          _, lang = key.to_s.split(".", 2)
+          next if lang.nil? || lang.empty?
+          normalized = Opencdd::Parcel::LanguageAliases.normalize(lang)
+          seen[lang] = normalized if normalized != lang
+        end
+        @columns.each do |col|
+          next if col.raw_property_id.nil?
+          _, lang = col.raw_property_id.split(".", 2)
+          next if lang.nil? || lang.empty?
+          normalized = Opencdd::Parcel::LanguageAliases.normalize(lang)
+          seen[lang] = normalized if normalized != lang
+        end
+        seen
+      end
     end
   end
 end

data/lib/opencdd/parcel/writer.rb

@@ -147,7 +147,11 @@ module Opencdd
           rows = emitter.emit(built.sheet, built.entities)
           workbook.add_worksheet(name: built.sheet.name) do |ws|
             rows.each do |row|
-              emitted = ws.add_row(row)
+              # All property values are strings per IEC 61360 wire format.
+              # Force string cell type so values like "001" survive round-trip
+              # (otherwise caxlsx auto-types numeric-looking strings and roo
+              # reads them back as integers, breaking semantically_equal?).
+              emitted = ws.add_row(row, types: :string)
               emitted.hidden = true if row_hidden?(row, hidden_directives)
             end
           end

data/lib/opencdd/parcel.rb

@@ -7,6 +7,7 @@ module Opencdd
 
     autoload :Metadata,        "opencdd/parcel/metadata"
     autoload :SheetSchema,     "opencdd/parcel/sheet_schema"
+    autoload :LanguageAliases, "opencdd/parcel/language_aliases"
     autoload :Sheet,           "opencdd/parcel/sheet"
     autoload :Workbook,        "opencdd/parcel/workbook"
     autoload :WorkbookReader,  "opencdd/parcel/workbook_reader"

data/lib/opencdd/property.rb

@@ -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/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.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opencdd
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - OpenCDD contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-23 00:00:00.000000000 Z
+date: 2026-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: roo
@@ -263,6 +263,7 @@ files:
 - lib/opencdd/parcel/csv_writer.rb
 - lib/opencdd/parcel/entity_manifest.rb
 - lib/opencdd/parcel/flat_dir_reader.rb
+- lib/opencdd/parcel/language_aliases.rb
 - lib/opencdd/parcel/layout_detector.rb
 - lib/opencdd/parcel/metadata.rb
 - lib/opencdd/parcel/referenced_irdis.rb