pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

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}"

data/lib/pubid/iec.rb

@@ -2,84 +2,60 @@
 
 module Pubid
   module Iec
-  end
-end
-
-# Require scheme first
-require_relative "scheme"
+    autoload :Components, "#{__dir__}/iec/components"
+    autoload :Identifier, "#{__dir__}/iec/identifier"
+    autoload :Identifiers, "#{__dir__}/iec/identifiers"
+    autoload :SingleIdentifier, "#{__dir__}/iec/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/iec/supplement_identifier"
+    autoload :Parser, "#{__dir__}/iec/parser"
+    autoload :Builder, "#{__dir__}/iec/builder"
+    autoload :UrnParser, "#{__dir__}/iec/urn_parser"
+    autoload :UrnGenerator, "#{__dir__}/iec/urn_generator"
+    autoload :RenderingStyle, "#{__dir__}/iec/rendering_style"
+    autoload :Renderer, "#{__dir__}/iec/renderer"
 
-# Require all identifier classes
-require_relative "iec/identifiers/international_standard"
-require_relative "iec/identifiers/technical_report"
-require_relative "iec/identifiers/technical_specification"
-require_relative "iec/identifiers/publicly_available_specification"
-require_relative "iec/identifiers/guide"
-require_relative "iec/identifiers/test_report_form"
-require_relative "iec/identifiers/interpretation_sheet"
-require_relative "iec/identifiers/systems_reference_document"
-require_relative "iec/identifiers/working_document"
-require_relative "iec/identifiers/amendment"
-require_relative "iec/identifiers/corrigendum"
+    def self.parse(identifier_string)
+      if identifier_string.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
 
-# Wrapper identifier types
-require_relative "iec/identifiers/vap_identifier"
-require_relative "iec/identifiers/sheet_identifier"
-require_relative "iec/identifiers/consolidated_identifier"
-require_relative "iec/identifiers/fragment_identifier"
+      parsed = Parser.new.parse(identifier_string)
+      Builder.new.build(parsed)
+    end
 
-# Additional document types
-require_relative "iec/identifiers/component_specification"
-require_relative "iec/identifiers/operational_document"
-require_relative "iec/identifiers/societal_technology_trend_report"
-require_relative "iec/identifiers/white_paper"
+    def self.parse_urn(urn)
+      UrnParser.parse(urn)
+    end
 
-module Pubid
-  module Iec
-    # Primary document types (not supplements)
-    IDENTIFIER_TYPES = [
-      Identifiers::InternationalStandard,
-      Identifiers::TechnicalReport,
-      Identifiers::TechnicalSpecification,
-      Identifiers::PubliclyAvailableSpecification,
-      Identifiers::Guide,
-      Identifiers::TestReportForm,
-      Identifiers::InterpretationSheet,
-      Identifiers::SystemsReferenceDocument,
-      Identifiers::WorkingDocument,
-    ].freeze
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iec::Renderer)
 
-    # Supplement types (can appear with / notation)
-    SUPPLEMENT_IDENTIFIER_TYPES = [
-      Identifiers::Amendment,
-      Identifiers::Corrigendum,
-      Identifiers::InterpretationSheet, # ISH can act as supplement (/ISH1:1996)
-      Identifiers::FragmentIdentifier,  # FRAG wraps amendments/corrigenda
-    ].freeze
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| begin; c.type.is_a?(Hash); rescue NotImplementedError; false; end }
+    end
 
-    # Create the Scheme registry with all identifier types
-    Scheme = Pubid::Scheme.new(
-      identifiers: IDENTIFIER_TYPES,
-      supplement_identifiers: SUPPLEMENT_IDENTIFIER_TYPES,
-    )
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
 
-    # Main entry point for IEC identifiers
-    def self.parse(identifier_string)
-      parsed = Parser.new.parse(identifier_string)
-      Builder.new(Scheme).build(parsed)
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
     end
 
-    # Parse an IEC URN string
-    # @param urn [String] the URN string to parse
-    # @return [Identifier] the parsed identifier
-    # @raise [Errors::ParseError] if URN is invalid
-    def self.parse_urn(urn)
-      UrnParser.parse(urn)
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
     end
   end
 end
 
-require_relative "iec/urn_parser"
-require_relative "iec/builder"
-require_relative "iec/parser"
-
 Pubid::Registry.register(:iec, Pubid::Iec)