pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.2

data/lib/pubid/components/factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "code"
+require_relative "date"
+require_relative "edition"
+require_relative "language"
+require_relative "publisher"
+
+module Pubid
+  module Components
+    # Coerces loose primitive kwargs (matching pubid 1.x's `Identifier.create`
+    # signature) into the structured Component objects pubid 2.x expects.
+    #
+    # Used by per-flavor `.create` factories.
+    module Factory
+      # Per-kwarg coercer. Returns a Component, or an Array<Component> for
+      # collection attributes such as `languages`.
+      COERCERS = {
+        publisher: ->(v) { Publisher.new(body: v.to_s) },
+        number:    ->(v) { Code.new(value: v.to_s) },
+        part:      ->(v) { Code.new(value: v.to_s) },
+        subpart:   ->(v) { Code.new(value: v.to_s) },
+        year:      ->(v) { Date.new(year: v.to_s) },
+        edition:   ->(v) { Edition.new(number: v) },
+        language:  ->(v) { [Language.new(code: v.to_s)] },
+      }.freeze
+
+      # 1.x kwarg name → 2.x attribute name.
+      # Applied after coercion.
+      KEY_RENAMES = {
+        year: :date,
+        language: :languages,
+      }.freeze
+
+      # Convert a hash of 1.x-style primitive kwargs into a hash of 2.x-style
+      # Component-valued attributes ready for `<IdentifierClass>.new(...)`.
+      #
+      # Unknown keys pass through unchanged; nil values are dropped.
+      def self.from_hash(opts)
+        opts.each_with_object({}) do |(k, v), out|
+          next if v.nil?
+
+          target = KEY_RENAMES.fetch(k, k)
+          coercer = COERCERS[k]
+          out[target] = coercer ? coercer.call(v) : v
+        end
+      end
+    end
+  end
+end

data/lib/pubid/components/typed_stage.rb

@@ -6,6 +6,10 @@ module Pubid
   module Components
     class TypedStage < Lutaml::Model::Serializable
       attribute :name, :string
+      # Unique per-typed-stage code (e.g. :dtr, :fdisp). Distinct from the
+      # generic stage_code (e.g. :draft, :fdis) which is shared across types.
+      # Some index data serializes this code, so it must be resolvable.
+      attribute :code, :string
       attribute :type_code, :string
       attribute :stage_code, :string
       attribute :abbr, :string, collection: true

data/lib/pubid/components.rb

@@ -5,6 +5,7 @@ module Pubid
     autoload :Code, "pubid/components/code"
     autoload :Date, "pubid/components/date"
     autoload :Edition, "pubid/components/edition"
+    autoload :Factory, "pubid/components/factory"
     autoload :Language, "pubid/components/language"
     autoload :Locality, "pubid/components/locality"
     autoload :Publisher, "pubid/components/publisher"

data/lib/pubid/csa/identifier.rb

@@ -3,6 +3,62 @@
 module Pubid
   module Csa
     class Identifier
+      # Factory that builds a CSA identifier from a hash of primitives.
+      # Default is {Identifiers::Standard}.
+      TYPE_KEY_TO_KLASS = {
+        standard:         "Standard",
+        bundled:          "Bundled",
+        canadian_adopted: "CanadianAdopted",
+        cec:              "Cec",
+        combined:         "Combined",
+        csa_adopted:      "CsaAdopted",
+        package:          "Package",
+        series:           "Series",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        klass.new(**coerce_create_attrs(opts, klass: klass))
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Standard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown CSA type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts, klass:)
+        attrs = {}
+
+        if (v = opts[:code] || opts[:number])
+          attrs[:code] = Pubid::Components::Code.new(value: v.to_s)
+        end
+
+        if opts[:year]
+          year_str = opts[:year].to_s
+          attrs[:year] = year_str
+          # Preserve 4-digit year rendering (e.g. "B51:2024") rather than
+          # collapsing to "B51:24".
+          attrs[:original_year_4digit] = year_str.length == 4 unless opts.key?(:original_year_4digit)
+        end
+        attrs[:original_year_4digit] = opts[:original_year_4digit] if opts.key?(:original_year_4digit)
+        attrs[:year_format] = opts[:year_format].to_s if opts[:year_format]
+        attrs[:year_prefix] = opts[:year_prefix].to_s if opts[:year_prefix]
+        attrs[:reaffirmation] = opts[:reaffirmation].to_s if opts[:reaffirmation]
+        attrs[:french] = opts[:french] if opts.key?(:french)
+        attrs[:has_publisher] = opts.fetch(:has_publisher, true)
+        attrs[:publisher_prefix] = opts[:publisher_prefix].to_s if opts[:publisher_prefix]
+        attrs[:series_prefix] = opts[:series_prefix].to_s if opts[:series_prefix]
+        attrs[:series] = opts[:series] if opts.key?(:series) && [true, false].include?(opts[:series])
+        attrs[:package] = opts[:package].to_s if opts[:package]
+        attrs[:no_number] = opts[:no_number].to_s if opts[:no_number]
+        attrs
+      end
+      private_class_method :resolve_create_class, :coerce_create_attrs
+
       def self.parse(input)
         # Filter out comments
         return nil if input.start_with?("#")

data/lib/pubid/etsi/identifier.rb

@@ -9,6 +9,49 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
       end
+
+      # Factory mirroring pubid 1.x's `Pubid::Etsi::Identifier.create` API.
+      #
+      # ETSI's `type` kwarg (EN, ES, EG, TS, TR, GS, GR, GTS, …) is data
+      # stored on the identifier instance, not a class-dispatch key — all
+      # ETSI standards share the {Identifiers::EtsiStandard} class.
+      #
+      # @param opts [Hash] :type, :code/:number, :parts, :version, :year,
+      #   :month, :date
+      def self.create(**opts)
+        Identifiers::EtsiStandard.new(**coerce_create_attrs(opts))
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+        attrs[:type] = opts[:type].to_s if opts[:type]
+
+        code_value = opts[:code] || opts[:number]
+        if code_value
+          attrs[:code] = Pubid::Etsi::Components::Code.new(
+            number: code_value.to_s,
+            parts:  opts[:parts] ? Array(opts[:parts]).map(&:to_s) : nil,
+          )
+        end
+
+        if (v = opts[:version])
+          attrs[:version] = Pubid::Etsi::Components::Version.new(
+            version: v.to_s,
+          )
+        end
+
+        if opts[:year] || opts[:month]
+          attrs[:date] = ::Pubid::Components::Date.new(
+            year:  opts[:year]&.to_s,
+            month: opts[:month]&.to_s,
+          )
+        end
+
+        # TODO(create-shim): Amendment and Corrigendum supplements need a
+        # base_identifier and aren't yet wired through.
+        attrs
+      end
+      private_class_method :coerce_create_attrs
     end
   end
 end

data/lib/pubid/identifier.rb

@@ -39,6 +39,11 @@ module Pubid
       nil
     end
 
+    # @return [String, nil] publication year from the date component
+    def year
+      date&.year&.to_s
+    end
+
     def initialize(attrs = {}, options = {})
       attrs = attrs.dup
       attrs[:_type] ||= self.class.polymorphic_name
@@ -207,7 +212,8 @@ module Pubid
 
     def build_rendering_context(_renderer, format:, with_edition: false,
                                 lang: :en, lang_single: false,
-                                stage_format_long: nil, with_date: nil)
+                                stage_format_long: nil, with_date: nil,
+                                annotated: false)
       if format == :mr_string
         nil
       else
@@ -215,6 +221,7 @@ module Pubid
           with_language_code: lang_single ? :single : :none,
           stage_format_long: stage_format_long || false,
           with_date: with_date.nil? || with_date,
+          annotated: annotated,
         )
       end
     end

data/lib/pubid/idf/identifier.rb

@@ -64,6 +64,66 @@ module Pubid
 
         Pubid::Idf::Builder.new.build(parsed)
       end
+
+      # Factory mirroring pubid 1.x's `Pubid::Idf::Identifier.create` API.
+      # Default subclass is {Identifiers::InternationalStandard}.
+      #
+      # IDF's renderer requires `typed_stage` to be set (calls
+      # `.abbreviation` without a nil check); factory auto-resolves the
+      # "published" TypedStage for the chosen subclass.
+      TYPE_KEY_TO_KLASS = {
+        is:              "InternationalStandard",
+        reviewed_method: "ReviewedMethod",
+      }.freeze
+
+      def self.create(type: nil, stage: nil, **opts)
+        klass = resolve_create_class(type)
+        attrs = coerce_create_attrs(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        attrs[:typed_stage] = ts if ts
+        klass.new(**attrs)
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::InternationalStandard if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown IDF type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        return nil unless klass.const_defined?(:TYPED_STAGES)
+
+        if stage
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.abbr.include?(stage.to_s)
+          end
+        else
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code&.to_sym == :published
+          end
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {
+          publisher: Pubid::Components::Publisher.new(
+            body: (opts[:publisher] || "IDF").to_s,
+          ),
+        }
+        if (v = opts[:number])
+          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
+        end
+        if (v = opts[:year])
+          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
+        end
+        attrs
+      end
+      private_class_method :resolve_create_class,
+                           :resolve_create_typed_stage,
+                           :coerce_create_attrs
     end
   end
 end

data/lib/pubid/iec/builder.rb

@@ -434,7 +434,8 @@ edition_data = nil, typed_stage = nil)
           parse_languages(value)
 
         when :all_parts
-          Pubid::Components::Locality.new(all_parts: true)
+          # Set all_parts boolean attribute directly on identifier (matches ISO builder)
+          true
 
         when :database
           # Database flag - return true if DB suffix present

data/lib/pubid/iec/components/code.rb

@@ -1,10 +1,11 @@
 require "lutaml/model"
+require_relative "../../components/code"
 # frozen_string_literal: true
 
 module Pubid
   module Iec
     module Components
-      class Code < Lutaml::Model::Serializable
+      class Code < ::Pubid::Components::Code
         attribute :prefix, :string, default: -> {}
         attribute :number, :string
         attribute :part, :string, default: -> {}

data/lib/pubid/iec/components/publisher.rb

@@ -1,10 +1,11 @@
 require "lutaml/model"
+require_relative "../../components/publisher"
 # frozen_string_literal: true
 
 module Pubid
   module Iec
     module Components
-      class Publisher < Lutaml::Model::Serializable
+      class Publisher < ::Pubid::Components::Publisher
         PUBLISHERS = {
           "IEC" => "International Electrotechnical Commission",
           "ISO/IEC" => "ISO/IEC Joint Technical Committee",

data/lib/pubid/iec/identifier.rb

@@ -1,11 +1,25 @@
 require_relative "../identifier"
 # frozen_string_literal: true
 require_relative "../components/typed_stage"
+require_relative "../components/factory"
 
 module Pubid
   module Iec
     class Identifier < ::Pubid::Identifier
+      # Long-tail document types that `create` may build but which are not in
+      # Scheme.identifiers (the parse/build candidate set). Loaded lazily (not
+      # at require time) to avoid a circular load with identifiers/base.rb.
+      EXTRA_CREATE_KLASS_FILES = %w[
+        conformity_assessment technology_report white_paper
+        societal_technology_trend_report systems_reference_document
+        interpretation_sheet
+      ].freeze
       def self.parse(string)
+        # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
+        if Pubid::FormatDetector.detect(string) == :urn
+          return Pubid::Iec::UrnParser.parse(string)
+        end
+
         # Apply legacy update_codes normalization first, before any other preprocessing
         normalized = Core::UpdateCodes.apply(string, :iec)
         parsed = Pubid::Iec::Parser.new.parse(normalized)
@@ -16,6 +30,227 @@ module Pubid
 
         Pubid::Iec::Builder.new(Pubid::Iec::Scheme).build(parsed)
       end
+
+      # Factory mirroring pubid 1.x's `Pubid::Iec::Identifier.create` API.
+      # See {Pubid::Iso::Identifier.create} for the shared design. Builds the
+      # IEC `Components::*` subclasses (not the base ones) and populates
+      # type/stage from the resolved TypedStage, so that a created identifier
+      # round-trips `==` against the same identifier produced by `parse`.
+      def self.create(type: nil, stage: nil, **opts)
+        # A VAP suffix (CSV/RLV/…) is the outermost wrapper around the base
+        # document (which may itself be amended); rebuild it first.
+        if (vap = opts.delete(:vap))
+          base = create(type: type, stage: stage, **opts)
+          return Identifiers::VapIdentifier.new(
+            base_identifier: base,
+            vap_suffix: Components::VapSuffix.new(code: Array(vap).first.to_s),
+          )
+        end
+
+        # Structured index rows carry amendments/corrigendums as a flat list
+        # alongside the base document's keys; rebuild the supplement wrapping
+        # the recursively-created base, mirroring what parse produces.
+        if (supp = extract_supplement(opts))
+          return build_supplement(supp, type: type, stage: stage, opts: opts)
+        end
+
+        # A nested base: holds the base document of a supplement whose own
+        # number/year sit at the top level (e.g. an Interpretation Sheet).
+        if (base_hash = opts.delete(:base))
+          return build_based_supplement(type: type, base_hash: base_hash,
+                                        opts: opts)
+        end
+
+        klass = resolve_create_class(type: type, stage: stage)
+        attrs = coerce_create_attrs(opts)
+        ts = resolve_create_typed_stage(klass, stage)
+        if ts
+          attrs[:typed_stage] = ts
+          # Parse derives `type` and `stage` from the TypedStage (see
+          # Builder#cast for :type_with_stage); mirror that here.
+          attrs[:type] ||= ts.to_type
+          attrs[:stage] ||= ts.to_stage
+        end
+        klass.new(**attrs)
+      end
+
+      # Pop a supplement spec off the flat opts hash, if present. Returns
+      # { klass:, entry: } or nil. Amendments take precedence over
+      # corrigendums for the (rare) consolidated rows that carry both.
+      def self.extract_supplement(opts)
+        if (amds = opts.delete(:amendments))
+          { klass: Identifiers::Amendment, entry: Array(amds).first }
+        elsif (cors = opts.delete(:corrigendums))
+          { klass: Identifiers::Corrigendum, entry: Array(cors).first }
+        end
+      end
+
+      # Build an Amendment/Corrigendum from { number:, year: } wrapping a base
+      # identifier created from the remaining opts (which may themselves carry
+      # a type, e.g. an amendment to a TR).
+      def self.build_supplement(supp, type:, stage:, opts:)
+        base = create(type: type, stage: stage, **opts)
+        klass = supp[:klass]
+        entry = supp[:entry] || {}
+        ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published }
+        attrs = { base_identifier: base, typed_stage: ts,
+                  type: ts.to_type, stage: ts.to_stage }
+        if (n = entry[:number])
+          attrs[:number] = Components::Code.new(number: n.to_s)
+        end
+        if (y = entry[:year])
+          attrs[:date] = ::Pubid::Components::Date.new(year: y.to_s)
+        end
+        klass.new(**attrs)
+      end
+
+      # Build a supplement whose base document is carried in a nested base:
+      # hash (e.g. type: "ISH"); the supplement's own number/year are the
+      # remaining top-level keys.
+      def self.build_based_supplement(type:, base_hash:, opts:)
+        klass = (type && locate_klass_by_type_or_short(type)) ||
+                Identifiers::InternationalStandard
+        base = create(**base_hash.transform_keys(&:to_sym))
+        attrs = coerce_create_attrs(opts)
+                .slice(:number, :part, :subpart, :date, :publisher, :copublishers)
+        attrs[:base_identifier] = base
+        if klass.const_defined?(:TYPED_STAGES) &&
+            (ts = klass::TYPED_STAGES.find { |t| t.stage_code.to_sym == :published })
+          attrs[:typed_stage] = ts
+          attrs[:type] ||= ts.to_type
+          attrs[:stage] ||= ts.to_stage
+        end
+        klass.new(**attrs)
+      end
+
+      # Coerce a 1.x-style attribute hash into IEC Component instances,
+      # matching what the parser/builder produces. Unknown keys are dropped.
+      def self.coerce_create_attrs(opts)
+        out = {}
+        if (v = opts[:publisher])
+          out[:publisher] = Components::Publisher.new(body: v.to_s)
+        end
+        if (copubs = opts[:copublishers] || opts[:copublisher])
+          out[:copublishers] =
+            Array(copubs).map { |c| Components::Publisher.new(body: c.to_s) }
+        end
+        if (v = opts[:number])
+          out[:number] = Components::Code.new(number: v.to_s)
+        end
+        # Indexes fold the subpart into a single "2-4" part string; parse
+        # keeps part and subpart separate, so split to match.
+        part, subpart = split_part(opts[:part], opts[:subpart])
+        out[:part] = Components::Code.new(number: part.to_s) unless part.nil?
+        out[:subpart] = Components::Code.new(number: subpart.to_s) unless subpart.nil?
+        if (v = opts[:year])
+          out[:date] = ::Pubid::Components::Date.new(year: v.to_s)
+        end
+        if (v = opts[:edition])
+          out[:edition] = ::Pubid::Components::Edition.new(number: v)
+        end
+        if (v = opts[:language])
+          out[:languages] = [::Pubid::Components::Language.new(code: v.to_s)]
+        end
+        out[:database] = true if opts[:database]
+        out
+      end
+
+      # Split a folded "2-4" part into [part, subpart], matching parse. A part
+      # without a dash (or an explicit subpart already supplied) is untouched.
+      def self.split_part(part, subpart)
+        return [nil, subpart] if part.nil?
+        if subpart.nil? && part.to_s.include?("-")
+          part.to_s.split("-", 2)
+        else
+          [part, subpart]
+        end
+      end
+
+      def self.resolve_create_class(type:, stage:)
+        if type && supplement_type?(type)
+          # Supplements are built from amendments:/corrigendums: data (which
+          # carry the supplement number/year); an explicit supplement `type:`
+          # alone has no base to wrap.
+          raise ArgumentError,
+                "#{type} requires a base_identifier; pass amendments:/" \
+                "corrigendums: instead of type:"
+        end
+
+        klass =
+          if type
+            locate_klass_by_type_or_short(type)
+          elsif stage
+            ts = safe_locate_typed_stage(stage)
+            ts && locate_klass_by_type_or_short(ts.type_code)
+          end
+        klass || Identifiers::InternationalStandard
+      end
+
+      # True when `type` names a supplement identifier (Amendment/Corrigendum/
+      # Fragment) by key, downcased key, or short abbreviation.
+      def self.supplement_type?(type)
+        t = type.to_s
+        Scheme.supplement_identifiers.any? do |k|
+          k.type[:key].to_s == t || k.type[:key].to_s == t.downcase ||
+            Array(k.type[:short]).map(&:to_s).include?(t)
+        end
+      end
+
+      # Structured indexes store `type:` as the registry key (:tr), an
+      # upper-cased abbreviation ("TR"), or a title ("Technology Report").
+      # Try each spelling, across every IEC identifier class (the create
+      # candidate set is wider than Scheme.identifiers).
+      def self.locate_klass_by_type_or_short(type)
+        t = type.to_s
+        all_create_klasses.detect { |k| k.type[:key].to_s == t } ||
+          all_create_klasses.detect { |k| k.type[:key].to_s == t.downcase } ||
+          all_create_klasses.detect { |k| Array(k.type[:short]).map(&:to_s).include?(t) } ||
+          all_create_klasses.detect { |k| k.type[:title].to_s == t }
+      end
+
+      # All IEC identifier classes that `create` may build, including the
+      # long-tail document types absent from Scheme.identifiers. Memoized;
+      # the extra classes are required here (not at load time) to dodge the
+      # circular require with identifiers/base.rb.
+      def self.all_create_klasses
+        @all_create_klasses ||= begin
+          extra = EXTRA_CREATE_KLASS_FILES.map do |f|
+            require_relative "identifiers/#{f}"
+            Identifiers.const_get(camelize_klass_file(f))
+          end
+          Scheme.identifiers + extra
+        end
+      end
+
+      def self.camelize_klass_file(file)
+        file.split("_").map(&:capitalize).join
+      end
+
+      # IEC Scheme raises ArgumentError on miss instead of returning nil;
+      # wrap so the same control flow works as in the ISO factory.
+      def self.safe_locate_typed_stage(abbr)
+        Scheme.locate_typed_stage_by_abbr(abbr.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def self.resolve_create_typed_stage(klass, stage)
+        if stage
+          safe_locate_typed_stage(stage)
+        elsif klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES).find do |ts|
+            ts.stage_code.to_sym == :published
+          end
+        end
+      end
+      private_class_method :resolve_create_class,
+                           :safe_locate_typed_stage,
+                           :resolve_create_typed_stage, :coerce_create_attrs,
+                           :extract_supplement, :build_supplement,
+                           :build_based_supplement,
+                           :locate_klass_by_type_or_short, :all_create_klasses,
+                           :camelize_klass_file, :supplement_type?,
+                           :split_part
     end
   end
 end

data/lib/pubid/iec/identifiers/base.rb

@@ -38,6 +38,10 @@ module Pubid
           # Database flag
           parts << " DB" if database
 
+          # All-parts marker — rendered the same as the generic
+          # HumanReadable renderer for parity (see Pubid::Renderers::HumanReadable#render).
+          parts << " (all parts)" if all_parts
+
           parts.compact.join
         end
 

data/lib/pubid/iec/identifiers/consolidated_identifier.rb

@@ -59,10 +59,6 @@ module Pubid
           identifiers&.first&.date
         end
 
-        def type
-          :consolidated
-        end
-
         def stage
           identifiers&.first&.stage
         end

data/lib/pubid/iec/identifiers/fragment_identifier.rb

@@ -128,10 +128,6 @@ module Pubid
           base_identifier&.date
         end
 
-        def type
-          :frag
-        end
-
         def stage
           typed_stage&.to_stage || base_identifier&.stage
         end

data/lib/pubid/iec/identifiers/sheet_identifier.rb

@@ -49,10 +49,6 @@ module Pubid
           base_identifier&.date
         end
 
-        def type
-          :sheet
-        end
-
         def stage
           base_identifier&.stage
         end

data/lib/pubid/iec/identifiers/vap_identifier.rb

@@ -60,10 +60,6 @@ module Pubid
           base_identifier&.date
         end
 
-        def type
-          :vap
-        end
-
         def stage
           base_identifier&.stage
         end

data/lib/pubid/iec/parser.rb

@@ -136,8 +136,13 @@ module Pubid
       end
 
       rule(:number) do
-        # Special case for VIM publication
-        str("VIM") |
+        # ISO/IEC Directives: "DIR", "DIR 1", "DIR 1 IEC SUP", "DIR 2 IEC", "DIR IEC SUP"
+        # Captured as a flat number (no part/subpart) so it round-trips to the input
+        # and class-matches the IEC index. Must come before the IECEE [A-Z]{2,4} branch,
+        # which would otherwise match "DIR" alone and leave the trailing tokens unconsumed.
+        (str("DIR") >> (space >> match('[A-Z\d]').repeat(1)).repeat) |
+          # Special case for VIM publication
+          str("VIM") |
           # Special case for SYMBOL publication
           str("SYMBOL") |
           # IECEx TRF version notation: 62784v1a_ds, 62784v1A