pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

@@ -1,6 +1,4 @@
-require_relative "base"
 # frozen_string_literal: true
-require_relative "../../components/stage"
 
 module Pubid
   module Iec
@@ -26,7 +24,8 @@ module Pubid
         PROJECT_STAGES = {}.freeze
 
         def self.type
-          { key: :wd, title: "Working Document", short: "WD" }
+          { key: :wd,
+            web: :working_document, title: "Working Document", short: "WD" }
         end
 
         # Return stage object for PWI/PNW stage
@@ -44,51 +43,8 @@ module Pubid
           @stage ||= ::Pubid::Components::Stage.new(stage_code: stage_code)
         end
 
-        def to_s(_format = :short)
-          # Working Programme format: "PWI TR 100-36 ED1" or "IEC/PWI 60038"
-          if wp_stage
-            parts = []
-            # Include publisher if present (for IEC/PWI format)
-            if publisher
-              parts << publisher.body
-              if copublishers&.any?
-                parts << "/#{copublishers.map(&:body).join('/')}"
-              end
-              parts << "/"
-            end
-            parts << wp_stage
-            # Only add wp_type if it exists and is not empty/whitespace
-            if wp_type && !wp_type.strip.empty?
-              parts << " #{wp_type.strip}"
-            end
-
-            # Render full number with parts
-            if number
-              num_str = number.to_s
-              num_str += "-#{part}" if part && part.to_s != ""
-              num_str += "-#{subpart}" if subpart && subpart.to_s != ""
-              parts << " #{num_str}"
-            end
-
-            parts << " #{edition}" if edition&.number
-            return parts.join
-          end
-
-          # Working Document format: "100/3705(F)/FDIS"
-          parts = []
-
-          parts << technical_committee if technical_committee
-
-          # Number with optional language
-          if wd_number
-            num_part = wd_number.to_s
-            num_part += "(#{wd_language})" if wd_language
-            parts << num_part
-          end
-
-          parts << wd_stage if wd_stage
-
-          parts.join("/")
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
       end
     end

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
 
@@ -136,8 +131,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
@@ -272,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"
@@ -353,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