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

data/lib/pubid/oiml/single_identifier.rb

@@ -15,56 +15,75 @@ module Pubid
         "short"
       } # Track parsed format
 
-      # Type is determined by the subclass
-      def type
-        type_string
+      # Serialization delta on top of Oiml::Identifier's shared block. The
+      # `code` (number/part/subpart/suffix) and `date` (year) components are
+      # flattened to top-level keys rather than nested hashes, mirroring ISO
+      # (lib/pubid/iso/identifier.rb). `type` is intentionally omitted
+      # (recomputed from the class on load).
+      key_value do
+        map "publisher", to: :publisher
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "part", with: { to: :part_to_kv, from: :part_from_kv }
+        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
+        map "suffix", with: { to: :suffix_to_kv, from: :suffix_from_kv }
+        map "space_suffix",
+            with: { to: :space_suffix_to_kv, from: :space_suffix_from_kv }
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "edition", to: :edition
+        map "stage", to: :stage
+        map "iteration", to: :iteration
       end
 
-      def to_s(format: nil)
-        # Use parsed format if not explicitly overridden
-        format ||= (parsed_format == "long" ? :long : :short)
+      # --- code components flattened to top-level keys ---
+      def number_to_kv(model, doc) = emit_kv(doc, "number", model.code&.number)
+      def number_from_kv(model, value) = code_for(model).number = value.to_s
+      def part_to_kv(model, doc) = emit_kv(doc, "part", model.code&.part)
+      def part_from_kv(model, value) = code_for(model).part = value.to_s
+      def subpart_to_kv(model, doc) = emit_kv(doc, "subpart", model.code&.subpart)
+      def subpart_from_kv(model, value) = code_for(model).subpart = value.to_s
+      def suffix_to_kv(model, doc) = emit_kv(doc, "suffix", model.code&.suffix)
+      def suffix_from_kv(model, value) = code_for(model).suffix = value.to_s
 
-        result = "#{publisher} #{type_string} #{code}"
+      def space_suffix_to_kv(model, doc)
+        return unless model.code&.space_suffix
 
-        # Track if we're using Edition format for language spacing
-        using_edition_format = false
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("space_suffix", true),
+        )
+      end
 
-        # Add edition/date portion
-        if edition && date
-          # Has edition number: "6th Edition 2015"
-          result += " #{edition} Edition #{date.year}"
-          using_edition_format = true
-        elsif edition
-          # Edition without year (shouldn't happen but handle it)
-          result += " #{edition}"
-          using_edition_format = true
-        elsif date
-          # Date without edition number
-          if format == :long
-            result += " Edition #{date.year}"
-            using_edition_format = true
-          else
-            result += ":#{date.year}"
-          end
-        end
+      def space_suffix_from_kv(model, value)
+        code_for(model).space_suffix = value
+      end
 
-        # Add draft stage if present (iteration + stage)
-        if stage || iteration
-          result += " "
-          result += iteration.to_s if iteration
-          result += stage.to_s if stage
-        end
+      # --- date flattened to a top-level year ---
+      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
 
-        # Add language portion - depends on format
-        if language
-          result += if using_edition_format || parsed_format == "short_with_space"
-                      " (#{language})"
-                    else
-                      "(#{language})"
-                    end
-        end
+      def year_from_kv(model, value)
+        (model.date ||= Pubid::Components::Date.new).year = value.to_s
+      end
+
+      def emit_kv(doc, key, value)
+        return if value.nil? || value.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
+      end
+
+      def code_for(model)
+        model.code ||= Components::Code.new
+      end
+
+      attr_reader :requested_format
+
+      # Type is determined by the subclass
+      def type
+        type_string
+      end
 
-        result
+      def to_s(format: nil, **opts)
+        # Store requested format so the renderer can access it
+        @requested_format = format
+        render(format: :human, **opts)
       end
 
       def edition_portion

data/lib/pubid/oiml/supplement_identifier.rb

@@ -5,33 +5,47 @@ module Pubid
     class SupplementIdentifier < Identifier
       # Base class for OIML supplements (amendments, annexes)
       # These wrap a base identifier like ISO amendments
-      attribute :base_identifier, Oiml::Identifier
+      attribute :base_identifier, Oiml::Identifier, polymorphic: true
       attribute :year, :string
       attribute :language, :string
+      # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
+      # where the supplement word is appended after a dated base instead of the
+      # "Amendment (YYYY) to BASE" prose form. The word itself comes from the
+      # concrete class (#supplement_type), so only this flag is stored.
+      attribute :trailing, :boolean, default: false
       attribute :parsed_format, :string, default: -> {
         "short"
       } # Track supplement's parsed format
 
-      def to_s(format: :short)
-        # Determine base format: explicit parameter takes priority, else use parsed format
-        base_format = if format && format != :short
-                        format # Use explicit override
-                      elsif base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
-                        :long
-                      else
-                        :short
-                      end
+      # Serialization delta on top of Oiml::Identifier's shared block. The
+      # nested base_identifier is (de)serialized recursively through the
+      # polymorphic router so its own `_type` selects the right subclass.
+      key_value do
+        map "base_identifier",
+            with: { to: :base_identifier_to_kv, from: :base_identifier_from_kv }
+        map "year", to: :year
+        map "trailing", to: :trailing
+      end
+
+      def base_identifier_to_kv(model, doc)
+        base = model.base_identifier
+        return unless base
 
-        # Render base with determined format (preserves Edition vs colon)
-        base_str = base_identifier.to_s(format: base_format)
-        base_str = base_str.sub(/\s*\([^)]+\)\s*$/, "").strip # Remove language from base
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("base_identifier",
+                                                   base.to_hash),
+        )
+      end
 
-        result = "#{supplement_type} (#{year}) to #{base_str}"
+      def base_identifier_from_kv(model, value)
+        model.base_identifier = ::Pubid::Oiml::Identifier.from_hash(value) if value
+      end
 
-        # Supplements ALWAYS add space before their language
-        result += " (#{language})" if language
+      attr_reader :requested_format
 
-        result
+      def to_s(format: nil, **opts)
+        @requested_format = format
+        render(format: :human, **opts)
       end
 
       # Subclasses override this

data/lib/pubid/oiml/urn_generator.rb

@@ -15,14 +15,6 @@ module Pubid
         identifier.code.to_s
       end
 
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        nil
-      end
-
       def urn_stage
         identifier.stage&.to_s&.downcase
       end

data/lib/pubid/oiml/urn_parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    # Parses OIML URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:oiml:{type}:{number}[-{part}]` where type
+    # is the lowercase document class (r for Recommendation, d for Document).
+    #
+    # Examples:
+    # - urn:oiml:r:111-1 → OIML R 111-1
+    # - urn:oiml:d:1     → OIML D 1
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        type_token, number = parts
+        flavor_parse("OIML #{type_token.upcase} #{number}")
+      end
+    end
+  end
+end

data/lib/pubid/oiml.rb

@@ -7,10 +7,11 @@ module Pubid
     autoload :Identifier, "#{__dir__}/oiml/identifier"
     autoload :Identifiers, "#{__dir__}/oiml/identifiers"
     autoload :Parser, "#{__dir__}/oiml/parser"
-    autoload :Scheme, "#{__dir__}/oiml/scheme"
+    autoload :Renderer, "#{__dir__}/oiml/renderer"
     autoload :SingleIdentifier, "#{__dir__}/oiml/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/oiml/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/oiml/urn_generator"
+    autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
 
     def self.parse(identifier)
       parser = Parser.new
@@ -19,6 +20,46 @@ module Pubid
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Oiml::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    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
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    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
 

data/lib/pubid/plateau/identifier.rb

@@ -1,57 +1,6 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Plateau
-    # Plateau factory entry point. `.parse` lives on `Pubid::Plateau`
-    # itself for historical reasons; this module hosts `.create` for API
-    # consistency with the other pubid flavors.
-    module Identifier
-      # Delegate to the flavor module so callers can use
-      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
-      def self.parse(identifier)
-        Pubid::Plateau.parse(identifier)
-      end
-
-      # Factory that builds a PLATEAU identifier from a hash of primitives.
-      #
-      # Dispatch on `:type`:
-      #   * `:handbook` (default)            → Identifiers::Handbook
-      #   * `:technical_report` / `:tr`      → Identifiers::TechnicalReport
-      #   * `:annex`                         → Identifiers::Annex
-      #
-      # Attributes are plain integers/strings — no Component wrapping.
-      # `:publisher` is silently ignored (PLATEAU is hardcoded).
-      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)
-        case type&.to_sym
-        when nil, :handbook
-          Identifiers::Handbook
-        when :technical_report, :tr
-          Identifiers::TechnicalReport
-        when :annex
-          Identifiers::Annex
-        else
-          raise ArgumentError, "Unknown PLATEAU type: #{type.inspect}"
-        end
-      end
-
-      def self.coerce_create_attrs(opts, klass:)
-        attrs = {}
-        attrs[:number] = opts[:number].to_i if opts[:number]
-        attrs[:annex]  = opts[:annex].to_i  if opts[:annex]
-        # :edition exists only on Handbook (and possibly TechnicalReport);
-        # silently drop on Annex.
-        if opts[:edition] && klass.attributes.key?(:edition)
-          attrs[:edition] = opts[:edition].to_s
-        end
-        # TODO(create-shim): :publisher silently ignored (PLATEAU hardcoded).
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
-    end
-  end
-end
+# Pubid::Plateau::Identifier is the PLATEAU base class (a real Pubid::Identifier
+# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
+# live in identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

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

@@ -2,50 +2,59 @@
 
 module Pubid
   module Plateau
-    module Identifiers
-      # Base class for all PLATEAU identifiers
-      class Base < Pubid::Identifier
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-        attribute :number, :integer
-        attribute :annex, :integer, default: -> {}
-
-        def publisher
-          "PLATEAU"
-        end
+    # Base class for all PLATEAU identifiers. Canonical name
+    # Pubid::Plateau::Identifier (Identifiers::Base is a back-compat alias).
+    class Identifier < ::Pubid::Identifier
+      # Delegate to the flavor module so callers can use
+      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
+      def self.parse(identifier)
+        Pubid::Plateau.parse(identifier)
+      end
 
-        # Subclasses must implement type_string
-        def type_string
-          raise NotImplementedError, "Subclasses must implement type_string"
-        end
+      attribute :number, :integer
+      attribute :annex, :integer, default: -> {}
 
-        def formatted_number
-          "#%02d" % number
-        end
+      # Stored as a plain string (always "PLATEAU") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute.
+      attribute :publisher, :string, default: -> { "PLATEAU" }
 
-        def formatted_annex
-          annex ? "-#{annex}" : ""
-        end
+      # Subclasses must implement type_string
+      def type_string
+        raise NotImplementedError, "Subclasses must implement type_string"
+      end
+
+      def formatted_number
+        "#%02d" % number
+      end
+
+      def formatted_annex
+        annex ? "-#{annex}" : ""
+      end
 
-        def ==(other)
-          return false unless other.class == self.class
+      def ==(other)
+        return false unless other.class == self.class
 
-          number == other.number &&
-            annex == other.annex
-        end
+        number == other.number &&
+          annex == other.annex
+      end
 
-        # Include type_string and annex in serialization for round-trip compatibility
-        def base_hash
-          hash = super
-          if self.class.attributes.key?(:type_string) && type_string
-            hash[:type] =
-              type_string
-          end
-          hash[:annex] = annex if annex
-          hash
+      # Include type_string and annex in serialization for round-trip compatibility
+      def base_hash
+        hash = super
+        if self.class.attributes.key?(:type_string) && type_string
+          hash[:type] =
+            type_string
         end
+        hash[:annex] = annex if annex
+        hash
       end
     end
+
+    module Identifiers
+      # Backward-compatible alias: PLATEAU's base class used to be
+      # Pubid::Plateau::Identifiers::Base. It is now Pubid::Plateau::Identifier.
+      Base = Pubid::Plateau::Identifier
+    end
   end
 end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -13,12 +13,6 @@ module Pubid
           "Handbook"
         end
 
-        def to_s
-          result = "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
-          result += " #{formatted_edition}" if edition
-          result
-        end
-
         def formatted_edition
           "第#{edition}版"
         end

data/lib/pubid/plateau/identifiers/technical_report.rb

@@ -10,10 +10,6 @@ module Pubid
         def type_string
           "Technical Report"
         end
-
-        def to_s
-          "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
-        end
       end
     end
   end

data/lib/pubid/plateau/renderer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Human-readable renderer for PLATEAU identifiers.
+    #
+    # Produces strings like:
+    #   "PLATEAU Technical Report #01"
+    #   "PLATEAU Handbook #00 第1.0版"
+    #   "PLATEAU Handbook #01-1 Annex A"
+    #
+    # The renderer is registered as the `:human` format in the PLATEAU format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when SupplementIdentifier
+          render_supplement(id)
+        when Identifiers::Handbook
+          render_handbook(id)
+        when Identifiers::TechnicalReport
+          render_technical_report(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+      end
+
+      def render_technical_report(id)
+        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+      end
+
+      def render_handbook(id)
+        result = "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+        result += " #{id.formatted_edition}" if id.edition
+        result
+      end
+
+      def render_supplement(id)
+        "#{id.base_identifier} #{id.supplement_string}"
+      end
+    end
+  end
+end

data/lib/pubid/plateau/supplement_identifier.rb

@@ -19,10 +19,6 @@ module Pubid
         raise NotImplementedError, "Subclasses must implement supplement_string"
       end
 
-      def to_s
-        "#{base_identifier} #{supplement_string}"
-      end
-
       # Override base_hash to extract edition, type, and annex from base_identifier
       def base_hash
         hash = super

data/lib/pubid/plateau/urn_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Parses Plateau URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:plateau:{type}:{number}[:{annex}]
+    #
+    # type is one of: handbook, tr (technical report), an (annex), or another
+    # lowercase type string. Annex is a zero-padded 2-digit string when present.
+    #
+    # Examples:
+    # - urn:plateau:handbook:00        → PLATEAU Handbook #00
+    # - urn:plateau:tr:01              → PLATEAU Technical Report #01
+    class UrnParser < Pubid::UrnParser::Base
+      TYPE_MAP = {
+        "handbook" => "Handbook",
+        "tr" => "Technical Report",
+        "an" => "Annex",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0)
+        number = parts.fetch(1)
+        annex = parts[2]
+
+        text = "PLATEAU #{display_type(type_token)} ##{number}"
+        text += "-#{annex}" if annex
+        flavor_parse(text)
+      end
+
+      private
+
+      def display_type(token)
+        TYPE_MAP.fetch(token) { token.capitalize }
+      end
+    end
+  end
+end

data/lib/pubid/plateau.rb

@@ -8,9 +8,10 @@ module Pubid
     autoload :Identifier, "#{__dir__}/plateau/identifier"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
-    autoload :Scheme, "#{__dir__}/plateau/scheme"
+    autoload :Renderer, "#{__dir__}/plateau/renderer"
     autoload :SupplementIdentifier, "#{__dir__}/plateau/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/plateau/urn_generator"
+    autoload :UrnParser, "#{__dir__}/plateau/urn_parser"
 
     def self.parse(input)
       # Apply legacy update_codes normalization first
@@ -19,6 +20,47 @@ module Pubid
       parsed = parser.parse(normalized)
       Builder.build(parsed)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Plateau::Renderer)
+    SupplementIdentifier.format_registry = Identifiers::Base.format_registry
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    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
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    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