pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/iec/identifiers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :ComponentSpecification, "#{__dir__}/identifiers/component_specification"
+      autoload :ConformityAssessment, "#{__dir__}/identifiers/conformity_assessment"
+      autoload :ConsolidatedIdentifier, "#{__dir__}/identifiers/consolidated_identifier"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :FragmentIdentifier, "#{__dir__}/identifiers/fragment_identifier"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :InternationalStandard, "#{__dir__}/identifiers/international_standard"
+      autoload :InterpretationSheet, "#{__dir__}/identifiers/interpretation_sheet"
+      autoload :OperationalDocument, "#{__dir__}/identifiers/operational_document"
+      autoload :PubliclyAvailableSpecification, "#{__dir__}/identifiers/publicly_available_specification"
+      autoload :SheetIdentifier, "#{__dir__}/identifiers/sheet_identifier"
+      autoload :SocietalTechnologyTrendReport, "#{__dir__}/identifiers/societal_technology_trend_report"
+      autoload :SystemsReferenceDocument, "#{__dir__}/identifiers/systems_reference_document"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TechnicalSpecification, "#{__dir__}/identifiers/technical_specification"
+      autoload :TechnologyReport, "#{__dir__}/identifiers/technology_report"
+      autoload :TestReportForm, "#{__dir__}/identifiers/test_report_form"
+      autoload :VapIdentifier, "#{__dir__}/identifiers/vap_identifier"
+      autoload :WhitePaper, "#{__dir__}/identifiers/white_paper"
+      autoload :WorkingDocument, "#{__dir__}/identifiers/working_document"
+    end
+  end
+end

data/lib/pubid/iec/parser.rb

@@ -1,9 +1,5 @@
 require "parslet"
 # frozen_string_literal: true
-require_relative "../parser/common_parse_rules"
-require_relative "../parser/common_parse_methods"
-require_relative "identifier"
-require_relative "supplement_identifier"
 
 module Pubid
   module Iec
@@ -14,10 +10,9 @@ module Pubid
       DASH_CHARS = ["-", "‑", "‐"].freeze
 
       # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Iec::Scheme.typed_stages
-        .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Iec::Scheme.supplement_typed_stages
+      TYPED_STAGES = Pubid::Iec.all_typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
+      TYPED_STAGES_SUPPLEMENTS = TYPED_STAGES
 
       root :identifier
 
@@ -277,16 +272,22 @@ module Pubid
       # EXV = Example version
       # PAC = Package
       # PRV = Preview version
-      rule(:vap_suffix) do
-        space >> (
-          str("CSV") |
+      # Internal helper (no `.as`): a single VAP code. The capture key stays
+      # :vap_suffix below; this rule just lets the suffix be one or more codes.
+      rule(:vap_code) do
+        str("CSV") |
           str("CMV") |
           str("RLV") |
           str("SER") |
           str("EXV") |
           str("PAC") |
           str("PRV")
-        ).as(:vap_suffix)
+      end
+
+      # One or more VAP codes joined by "-", captured whole, e.g. "CSV" or
+      # "EXV-CMV"; the builder splits it into the VapIdentifier `vap` array.
+      rule(:vap_suffix) do
+        space >> (vap_code >> (str("-") >> vap_code).repeat).as(:vap_suffix)
       end
 
       # Database suffix: " DB"
@@ -358,7 +359,7 @@ module Pubid
       end
 
       rule(:iso_identifier) do
-        Iso::Parser.new.identifier
+        Pubid::Iso.joint_grammar_atom(:identifier)
       end
 
       rule(:supplement_type_with_stage) do

data/lib/pubid/iec/renderer.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Human-readable renderer for IEC identifiers.
+    #
+    # Components are accessed only through `component.render(context:)`.
+    #
+    # Produces strings like:
+    #   "IEC 60038:2009"
+    #   "IEC/CD 60038"
+    #   "IEC 60038:2009/AMD1:2011"
+    #   "IEC/FDAM 60038-1"
+    #   "IEC 60529:1989+AMD1:1999 CSV"
+    #
+    # The renderer is registered as the `:human` format in the IEC format
+    # registry and invoked via `render(format: :human)`.
+    #
+    # For simple (non-wrapper) identifiers, the renderer delegates to the
+    # identifier's own `publisher_portion` / `number_portion` helpers so that
+    # per-type overrides (e.g. TR, TS, Guide) continue to work without
+    # duplication.  Wrapper types (Consolidated, VAP, Sheet, Fragment,
+    # Supplement, WorkingDocument, TestReportForm) have rendering logic
+    # here because their structure differs fundamentally.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::ConsolidatedIdentifier
+          render_consolidated(id, opts, context)
+        when Identifiers::VapIdentifier
+          render_vap(id, opts, context)
+        when Identifiers::SheetIdentifier
+          render_sheet(id, opts, context)
+        when Identifiers::FragmentIdentifier
+          render_fragment(id, opts, context)
+        when Identifiers::WorkingDocument
+          render_working_document(id, context)
+        when Identifiers::TestReportForm
+          render_test_report_form(id, context)
+        when SupplementIdentifier
+          render_supplement(id, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      private
+
+      def render_single(id, opts, context)
+        parts = []
+        parts << id.publisher_portion
+        parts << id.number_portion
+
+        if id.is_a?(Identifiers::Base)
+          parts << " #{id.edition.render(context:)}" if id.edition&.number
+        elsif opts[:with_edition] && id.edition&.number
+          parts << " #{id.edition.render(context:)}"
+        end
+
+        # VAP codes live on VapIdentifier (rendered in render_vap), not Base.
+
+        if id.is_a?(Identifiers::Base) && id.database
+          parts << " DB"
+        end
+
+        parts << " (all parts)" if id.all_parts
+
+        result = parts.compact.join
+
+        result << id.language_portion(lang_single: opts[:lang_single]) if id.languages&.any?
+
+        result
+      end
+
+      def render_supplement(id, opts, context)
+        id.ensure_base_identifier
+
+        if id.synthetic_base?
+          render_supplement_standalone(id, context)
+        elsif id.base_identifier
+          render_supplement_attached(id, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      def render_supplement_standalone(id, context)
+        parts = []
+
+        if id.publisher
+          parts << id.publisher.render(context:)
+          if id.copublishers&.any?
+            parts << "/#{id.copublishers.map { |c| c.render(context:) }.join('/')}"
+          end
+        end
+
+        abbr = id.typed_stage.abbr.first
+        number_str = id.base_identifier.number.to_s
+        number_str += "-#{id.number}" if id.number
+        number_str += "-#{id.subpart}" if id.subpart
+        parts << "#{abbr} #{number_str}"
+
+        result = parts.join("/")
+        result += ":#{id.date.render(context:)}" if id.date
+        result += " #{id.edition.render(context:)}" if id.edition&.number
+        result
+      end
+
+      def render_supplement_attached(id, opts, context)
+        parts = []
+        parts << id.base_identifier.to_s(**opts)
+
+        abbr = id.typed_stage.abbr.first.upcase
+        supp_part = "/#{abbr}#{id.number}"
+        supp_part += ":#{id.date.render(context:)}" if id.date
+        parts << supp_part
+
+        parts << " #{id.edition.render(context:)}" if id.edition&.number
+
+        parts.join
+      end
+
+      def render_consolidated(id, opts, _context)
+        id.identifiers.map.with_index do |sub_id, idx|
+          if idx.zero?
+            sub_id.to_s(**opts)
+          elsif sub_id.is_a?(Identifiers::Amendment)
+            render_consolidated_amendment(sub_id)
+          elsif sub_id.is_a?(Identifiers::Corrigendum)
+            render_consolidated_corrigendum(sub_id)
+          else
+            "+#{sub_id.to_s(**opts)}"
+          end
+        end.join
+      end
+
+      def render_consolidated_amendment(id)
+        if id.date&.present?
+          "+AMD#{id.number}:#{id.date.render}"
+        else
+          "+AMD#{id.number}"
+        end
+      end
+
+      def render_consolidated_corrigendum(id)
+        if id.date&.present?
+          "+COR#{id.number}:#{id.date.render}"
+        else
+          "+COR#{id.number}"
+        end
+      end
+
+      def render_vap(id, opts, context)
+        parts = []
+
+        parts << id.base_identifier.to_s(**opts.merge(with_edition: false))
+        parts << " #{id.vap.join('-')}" if id.vap&.any?
+        parts << " #{id.edition.render(context:)}" if id.edition&.number
+
+        parts.compact.join
+      end
+
+      def render_sheet(id, opts, context)
+        parts = []
+        parts << id.base_identifier.to_s(**opts)
+        parts << "/#{id.sheet_number}"
+        parts << ":#{id.year}" if id.year
+        parts.join
+      end
+
+      def render_fragment(id, opts, context)
+        parts = []
+        parts << id.base_identifier.to_s(**opts)
+
+        parts << if id.base_identifier.is_a?(Identifiers::Corrigendum)
+                   "/FRAGC#{id.fragment_number}"
+                 else
+                   "/FRAG#{id.fragment_number}"
+                 end
+
+        parts << " #{id.edition.render(context:)}" if id.edition&.number
+
+        parts.join
+      end
+
+      def render_working_document(id, context)
+        if id.wp_stage
+          parts = []
+          if id.publisher
+            parts << id.publisher.render(context:)
+            if id.copublishers&.any?
+              parts << "/#{id.copublishers.map { |c| c.render(context:) }.join('/')}"
+            end
+            parts << "/"
+          end
+          parts << id.wp_stage
+          if id.wp_type && !id.wp_type.strip.empty?
+            parts << " #{id.wp_type.strip}"
+          end
+
+          if id.number
+            num_str = id.number.to_s
+            num_str += "-#{id.part}" if id.part && id.part.to_s != ""
+            num_str += "-#{id.subpart}" if id.subpart && id.subpart.to_s != ""
+            parts << " #{num_str}"
+          end
+
+          parts << " #{id.edition.render(context:)}" if id.edition&.number
+          return parts.join
+        end
+
+        parts = []
+        parts << id.technical_committee if id.technical_committee
+
+        if id.wd_number
+          num_part = id.wd_number.to_s
+          num_part += "(#{id.wd_language})" if id.wd_language
+          parts << num_part
+        end
+
+        parts << id.wd_stage if id.wd_stage
+
+        parts.join("/")
+      end
+
+      def render_test_report_form(id, context)
+        parts = []
+        parts << id.publisher_portion
+
+        if id.cispr_identifier
+          cispr_parts = []
+          cispr_parts << id.cispr_identifier.publisher.render(context:)
+
+          num_str = id.cispr_identifier.number.to_s
+          num_str += "-#{id.cispr_identifier.part}" if id.cispr_identifier.part && id.cispr_identifier.part.to_s != ""
+          cispr_parts << num_str
+
+          cispr_str = cispr_parts.join(" ")
+          cispr_str += ":#{id.date.render(context:)}" if id.date
+
+          parts << " #{cispr_str}"
+        else
+          parts << id.number_portion
+        end
+
+        parts << id.trf_info.to_s if id.trf_info && !id.trf_info.empty?
+
+        parts.compact.join
+      end
+    end
+  end
+end

data/lib/pubid/iec/single_identifier.rb

@@ -1,25 +1,19 @@
-require_relative "identifier"
 # frozen_string_literal: true
-require_relative "../components/typed_stage"
-require_relative "urn_generator"
 
 module Pubid
   module Iec
     class SingleIdentifier < Identifier
-      attribute :typed_stage, Components::TypedStage
+      # Default to the class's published typed_stage so an omitted "stage" key
+      # reconstructs the published state on from_hash.
+      attribute :typed_stage, ::Pubid::Components::TypedStage,
+                default: -> { self.class.published_typed_stage }
 
       # Generate URN for this identifier
       #
       # @return [String] URN representation
 
-      def to_s(lang: :en, lang_single: false, with_edition: false)
-        [].tap do |parts|
-          parts << publisher_portion(lang: lang)
-          parts << number_portion(lang_single: lang_single)
-          parts << edition_portion(lang: lang) if with_edition
-        end.compact.join(" ").tap do |s|
-          s << language_portion(lang_single: lang_single) if languages&.any?
-        end
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
 
       def publisher_portion(lang: :en)

data/lib/pubid/iec/supplement_identifier.rb

@@ -1,5 +1,3 @@
-require_relative "identifier"
-require_relative "single_identifier"
 # frozen_string_literal: true
 
 module Pubid
@@ -8,6 +6,55 @@ module Pubid
     class SupplementIdentifier < SingleIdentifier
       attribute :base_identifier, Identifier, polymorphic: true
 
+      # Serialize the supplemented document under "base". The supplement's own
+      # number/date/stage come from the inherited common maps; route the nested
+      # base hash back through Identifier.from_hash so its concrete subclass (and
+      # any further nesting) is reconstructed.
+      key_value do
+        map "base", with: { to: :base_to_kv, from: :base_from_kv }
+      end
+
+      def base_to_kv(model, doc)
+        base = model.base_identifier
+        return unless base
+
+        # `base_identifier` synthesises a base for a supplement that has none
+        # (e.g. a bare "+AMD1:2008" nested in a consolidation): a fake doc whose
+        # number equals the supplement's own. It renders nothing and the getter
+        # recreates it identically on load, so don't persist it. A standalone
+        # supplement ("IEC/FDAM 60038-1") instead moves the real base number into
+        # the synthetic base (base.number != own number), which must be kept.
+        return if model.synthetic_base? && base.number.to_s == model.number.to_s
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
+                                                              base.to_hash))
+      end
+
+      def base_from_kv(model, value)
+        return unless value
+
+        base = ::Pubid::Iec::Identifier.from_hash(value)
+        model.base_identifier = base
+
+        # A base of the exact SingleIdentifier class is the synthetic self-base
+        # of a standalone supplement ("IEC/FDAM 60038-1"); a real attached base
+        # is always a concrete type (InternationalStandard, etc.). Re-engage the
+        # synthetic-base state so the supplement renders in standalone form
+        # (publisher/TYPE base-number-supp-number) instead of attached form.
+        if base.instance_of?(::Pubid::Iec::SingleIdentifier)
+          model.mark_synthetic_standalone!
+        end
+      end
+
+      # Re-engage the standalone synthetic-base state on a deserialized
+      # supplement. At this point `number` already holds the supplement number
+      # (set from the "number" key before "base"), so preserve it as the
+      # supplement number and flag the synthetic base.
+      def mark_synthetic_standalone!
+        @synthetic_base = true
+        @supplement_number = @number
+      end
+
       # Override base_identifier getter to ensure it's always created for standalone supplements
       def base_identifier
         @base_identifier || ensure_base_identifier
@@ -38,17 +85,21 @@ module Pubid
         end
       end
 
-      # Delegate publisher and copublishers to base_identifier if not set
+      # Delegate publisher and copublishers to base_identifier whenever there is
+      # a base (a supplement carries the publisher of the document it
+      # supplements). Checking base first — rather than `@publisher || base` — is
+      # required now that the publisher attribute has an IEC default, which would
+      # otherwise mask the delegation.
       def publisher
         return @publisher if @ensuring_base
 
-        @publisher || base_identifier&.publisher
+        base_identifier ? base_identifier.publisher : @publisher
       end
 
       def copublishers
         return @copublishers if @ensuring_base
 
-        @copublishers || base_identifier&.copublishers
+        base_identifier ? base_identifier.copublishers : @copublishers
       end
 
       # Ensure we have a base_identifier for standalone supplements
@@ -83,7 +134,6 @@ module Pubid
 
         # Create typed_stage for the base - use "IS" (International Standard) type
         # not the supplement type
-        require_relative "../components/typed_stage"
         base.typed_stage = Pubid::Components::TypedStage.new(
           abbr: ["IS"],
           type_code: :is,
@@ -107,54 +157,8 @@ module Pubid
         @synthetic_base ||= false
       end
 
-      def to_s(lang: :en, lang_single: false, with_edition: false)
-        # Ensure we have a base_identifier for standalone supplements
-        ensure_base_identifier
-
-        # For standalone supplements (synthetic base), use standalone format
-        # IEC/FDAM 60038-1, not IEC/IS 60038/FDAM1
-        if synthetic_base?
-          parts = []
-
-          # Publisher portion
-          if publisher
-            parts << publisher.body
-            parts << "/#{copublishers.map(&:body).join('/')}" if copublishers&.any?
-          end
-
-          # Supplement type and number with part (use base number)
-          abbr = typed_stage.abbr.first
-          number_str = base_identifier.number.to_s
-          number_str += "-#{number}" if number # supplement number
-          number_str += "-#{subpart}" if subpart
-          parts << "#{abbr} #{number_str}"
-
-          result = parts.join("/")
-          result += ":#{date.year}" if date
-          result += " #{edition}" if edition&.number
-          result
-        elsif base_identifier
-          # Normal supplement with real base identifier
-          # Format: "IEC 60050-102:2007/AMD1:2017"
-          parts = []
-          parts << base_identifier.to_s(lang: lang, lang_single: lang_single,
-                                        with_edition: with_edition)
-
-          # Supplement notation
-          # Use uppercase abbreviation without space: /AMD1, /COR1
-          abbr = typed_stage.abbr.first.upcase
-          supp_part = "/#{abbr}#{number}"
-          supp_part += ":#{date.year}" if date
-          parts << supp_part
-
-          # Add edition if present
-          parts << " #{edition}" if edition&.number
-
-          parts.join
-        else
-          # Fallback - shouldn't happen
-          super
-        end
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
     end
   end

data/lib/pubid/iec/urn_generator.rb

@@ -14,10 +14,10 @@ module Pubid
     # omits the language slot (8 fields), so it has a dedicated branch.
     class UrnGenerator < Pubid::UrnGenerator::Base
       # Deliverable markers occupying the positional deliverable slot.
-      DELIVERABLES = /cmv|csv|exv|prv|rlv|ser/.freeze
+      DELIVERABLES = /cmv|csv|exv|prv|rlv|ser/
 
       def generate
-        return series_urn if identifier.respond_to?(:all_parts) && identifier.all_parts
+        return series_urn if identifier.class.attributes.key?(:all_parts) && identifier.all_parts
 
         code_to_urn(identifier.to_s, urn_language)
       end
@@ -26,7 +26,7 @@ module Pubid
 
       # Hyphen-joined language codes (e.g. "en-fr"), or nil when unset.
       def urn_language
-        return nil unless identifier.respond_to?(:languages)
+        return nil unless identifier.class.attributes.key?(:languages)
 
         langs = identifier.languages
         return nil unless langs&.any?

data/lib/pubid/iec/urn_parser.rb

@@ -38,8 +38,8 @@ module Pubid
         raise Errors::ParseError, "Invalid IEC URN: #{urn}" unless code
 
         id = Pubid::Iec::Identifier.parse(code)
-        id.all_parts = true if all_parts && id.respond_to?(:all_parts=)
-        if lang && !lang.empty? && id.respond_to?(:languages=)
+        id.all_parts = true if all_parts && id.class.attributes.key?(:all_parts)
+        if lang && !lang.empty? && id.class.attributes.key?(:languages)
           id.languages = [::Pubid::Components::Language.new(code: lang)]
         end
         id
@@ -65,7 +65,7 @@ module Pubid
         # "ser" marks an all-parts series rather than a deliverable suffix; it
         # is signalled out-of-band (the code built from a series URN carries no
         # part or date, so to_s renders "IEC NNNN (all parts)").
-        if deliv && deliv.casecmp("SER").zero?
+        if deliv&.casecmp("SER")&.zero?
           all_parts = true
         elsif deliv && !deliv.empty?
           code += " #{deliv}"