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

data/lib/pubid/identifier.rb

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "components/code"
-require_relative "components/date"
-require_relative "components/edition"
-require_relative "components/language"
-require_relative "components/locality"
-require_relative "components/publisher"
-require_relative "components/stage"
-require_relative "components/type"
-
 module Pubid
   class Identifier < Lutaml::Model::Serializable
     class << self
@@ -23,7 +14,7 @@ module Pubid
     attribute :number, Components::Code
     attribute :part, Components::Code
     attribute :subpart, Components::Code
-    attribute :stage_iteration, Components::Code
+    attribute :stage_iteration, Components::Iteration
     attribute :date, Components::Date
     attribute :edition, Components::Edition
     attribute :languages, Components::Language, collection: true
@@ -39,6 +30,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
@@ -57,12 +53,6 @@ module Pubid
       "pubid:#{flavor}:#{type_kebab}"
     end
 
-    klass_ref = self
-    key_value do
-      klass_ref.attributes.each_key do |name|
-        map name.to_s, to: name.to_sym
-      end
-    end
 
     def root
       return base_identifier.root if base_identifier
@@ -160,7 +150,7 @@ module Pubid
       excluded_args << :date if excluded_args.delete(:year)
 
       attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
-        h[name] = excluded_args.include?(name) ? nil : send(name)
+        h[name] = excluded_args.include?(name) ? nil : public_send(name)
       end
       self.class.new(attrs)
     end
@@ -207,7 +197,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 +206,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/identifier_facade.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Mixin for the per-flavor `Identifier` *module* facades (NIST, IHO, BSI,
+  # CEN/CENELEC, ASHRAE). The class-pattern flavors (ISO, IEC, JIS, …) expose
+  # their root identifier as a real class, so `id.is_a?(Pubid::Iso::Identifier)`
+  # and `Pubid::Iso::Identifier.from_hash` already work natively. The
+  # module-pattern flavors keep `Identifier` as a thin parse/factory module;
+  # this mixin gives that module the same two capabilities a consumer relies on
+  # when it is handed the module as its identifier class (e.g. relaton-index's
+  # `pubid_class`):
+  #
+  #   * `from_hash` — polymorphic deserialization that dispatches on the
+  #     `_type` discriminator to the correct concrete `Identifiers::*` class,
+  #     reusing the flavor's own `identifier_types` registry rather than a
+  #     hand-maintained map.
+  #   * identity — `extend`ing this mixin into the `Identifier` module is paired
+  #     with `include`-ing that module into the flavor's `Identifiers::Base`, so
+  #     every concrete identifier descends from it. That makes
+  #     `id.is_a?(Pubid::Nist::Identifier)` and `Pubid::Nist::Identifier === id`
+  #     both true (`Module#===` delegates to `is_a?`) — the test a consumer
+  #     holding the module needs to ask "is this one of my identifiers?".
+  #
+  # The flavor namespace, the `Identifiers` namespace, and the fallback `Base`
+  # class are all derived from the extending module's own name by convention
+  # (`Pubid::<Flavor>::Identifier`), so a flavor opts in with a single
+  # `extend Pubid::IdentifierFacade`.
+  #
+  # Opt-in is deliberately GATED to flavors whose `to_hash`/`from_hash`
+  # round-trips cleanly. Some module-pattern flavors (AMCA, ITU, PLATEAU, IEEE)
+  # have a broken `to_hash` (publisher stored as a String) or a lossy
+  # `from_hash`; for those the facade's identity check would route ids through a
+  # consumer's `to_hash` and crash or silently corrupt them, so they
+  # intentionally do not opt in (see the NOTE in each of their identifier.rb).
+  module IdentifierFacade
+    # Reconstruct a concrete identifier from its serialized key_value hash by
+    # dispatching on the `_type` discriminator. Falls back to the flavor's
+    # `Identifiers::Base` for an absent/unknown type, matching lutaml's own
+    # non-polymorphic default.
+    #
+    # @param data [Hash] the serialized identifier hash (string or symbol keys)
+    # @return [Pubid::Identifier] the concrete identifier instance
+    def from_hash(data, options = {})
+      type = data && (data["_type"] || data[:_type])
+      klass = polymorphic_type_map[type] || identifier_base_class
+      klass.from_hash(data, options)
+    end
+
+    # Map of polymorphic_name ("pubid:nist:interagency-report") => concrete
+    # class, built once from the flavor's identifier-type registry so it tracks
+    # newly registered types automatically.
+    # @return [Hash{String => Class}]
+    def polymorphic_type_map
+      @polymorphic_type_map ||=
+        (identifier_registry_classes + [identifier_base_class]).uniq
+          .each_with_object({}) do |klass, map|
+            poly_name = klass.polymorphic_name
+            map[poly_name] = klass if poly_name
+          end
+    end
+
+    private
+
+    # The flavor module that namespaces this facade, e.g. Pubid::Nist for
+    # Pubid::Nist::Identifier.
+    def facade_flavor_module
+      @facade_flavor_module ||=
+        Object.const_get(name.split("::")[0...-1].join("::"))
+    end
+
+    def facade_identifiers_namespace
+      @facade_identifiers_namespace ||=
+        facade_flavor_module.const_get(:Identifiers)
+    end
+
+    # Fallback class for an absent/unknown `_type`. Most flavors expose a
+    # concrete `Identifiers::Base`; flavors without one (e.g. BSI, whose common
+    # ancestor is SingleIdentifier) fall back to the shared root, which is only
+    # ever reached for an unrecognized `_type`.
+    def identifier_base_class
+      if facade_identifiers_namespace.const_defined?(:Base, false)
+        facade_identifiers_namespace.const_get(:Base)
+      else
+        ::Pubid::Identifier
+      end
+    end
+
+    # Every concrete identifier class whose `_type` may appear in a serialized
+    # hash. Scans the `Identifiers` namespace for descendants of
+    # Pubid::Identifier (the complete set, independent of whatever filtering the
+    # flavor's `identifier_types` applies) and unions in `identifier_types`,
+    # which may register classes living outside that namespace.
+    def identifier_registry_classes
+      (scanned_identifier_classes + registered_identifier_classes).uniq
+    end
+
+    # Concrete identifier classes found directly in the `Identifiers` namespace.
+    def scanned_identifier_classes
+      facade_identifiers_namespace.constants.filter_map do |const|
+        klass = facade_identifiers_namespace.const_get(const)
+        klass if klass.is_a?(Class) && klass < ::Pubid::Identifier
+      rescue NameError
+        nil
+      end
+    end
+
+    # Classes the flavor explicitly registers via `identifier_types`, if any.
+    def registered_identifier_classes
+      return [] unless facade_flavor_module.respond_to?(:identifier_types)
+
+      Array(facade_flavor_module.identifier_types)
+    end
+  end
+end

data/lib/pubid/identifier_metadata.rb

@@ -102,7 +102,7 @@ module Pubid
       # Get the metadata for this class
       # @return [Metadata, nil]
       def metadata
-        @metadata ||= if superclass.is_a?(Class) && superclass.respond_to?(:metadata)
+        @metadata ||= if superclass.is_a?(Class) && superclass.ancestors.include?(Pubid::IdentifierMetadata)
                         superclass.metadata
                       end
       end

data/lib/pubid/idf/builder.rb

@@ -13,8 +13,8 @@ module Pubid
       }.freeze
 
       def build(parsed_hash)
-        typed_stage = Scheme.locate_typed_stage_by_abbr(parsed_hash[:type_with_stage])
-        identifier = Scheme.locate_identifier_klass_by_type_code(typed_stage.type_code).new
+        typed_stage = Pubid::Idf.locate_stage(parsed_hash[:type_with_stage])
+        identifier = Pubid::Idf.locate_type(typed_stage.type_code).new
 
         if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
           parsed_hash[:type_with_stage] = type_with_stage_fr
@@ -48,7 +48,7 @@ module Pubid
         when :type_with_stage
           iteration = value.to_s.match(/(\d+)$/)
           value = value.to_s.sub(iteration.to_s, "")
-          typed_stage = Scheme.locate_typed_stage_by_abbr(value || "")
+          typed_stage = Pubid::Idf.locate_stage(value || "")
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,

data/lib/pubid/idf/identifier.rb

@@ -7,11 +7,8 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       attribute :typed_stage, Components::TypedStage
 
-      def to_s(lang: :en, lang_single: false, with_edition: false)
-        [
-          publisher_portion(lang: lang),
-          number_portion(lang_single: lang_single),
-        ].join
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
 
       def publisher_portion(lang: :en)
@@ -31,7 +28,7 @@ module Pubid
           (subpart ? "-#{subpart.value}" : ""),
 
           # Stage iteration is optional
-          (stage_iteration ? ".#{stage_iteration.value}" : ""),
+          (stage_iteration ? ".#{stage_iteration.number}" : ""),
 
           # Date is optional
           (date ? ":#{date.year}" : ""),

data/lib/pubid/idf/identifiers/amendment.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd, title: "Amendment", short: "AMD" }
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
         end
       end
     end

data/lib/pubid/idf/identifiers/corrigendum.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cor, title: "Corrigendum", short: "COR" }
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "COR" }
         end
       end
     end

data/lib/pubid/idf/identifiers/international_standard.rb

@@ -115,7 +115,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :is, title: "International Standard", short: nil }
+          { key: :is,
+            web: :international_standard, title: "International Standard", short: nil }
         end
       end
     end

data/lib/pubid/idf/identifiers/reviewed_method.rb

@@ -92,7 +92,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :rm, title: "Reviewed Method", short: "RM" }
+          { key: :rm,
+            web: :reviewed_method, title: "Reviewed Method", short: "RM" }
         end
       end
     end

data/lib/pubid/idf/parser.rb

@@ -9,9 +9,10 @@ module Pubid
       include ::Pubid::Parser::CommonParseMethods
 
       # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Idf::Scheme.typed_stages
+      TYPED_STAGES = Pubid::Idf.all_typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf::Scheme.supplement_typed_stages
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf.all_typed_stages
+        .select { |ts| %w[amd cor].include?(ts.type_code.to_s) }
         .map(&:abbr).flatten.sort_by(&:length).reverse
 
       root :identifier

data/lib/pubid/idf/renderer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Human-readable renderer for IDF identifiers.
+    #
+    # Produces strings like:
+    #   "IDF 125:1988"
+    #   "IDF/AMD 1:2023"
+    #   "IDF 125:1988/AMD 1:2023"
+    #
+    # The renderer is registered as the `:human` format in the IDF 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, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      private
+
+      def render_single(id, opts, context)
+        [
+          publisher_portion(id, context),
+          number_portion(id, opts, context),
+        ].join
+      end
+
+      def publisher_portion(id, context)
+        [
+          id.publisher.render(context:),
+          (id.typed_stage.abbreviation.empty? ? "" : "/#{id.typed_stage.abbreviation}"),
+        ].join
+      end
+
+      def number_portion(id, opts, context)
+        lang_single = opts[:lang_single] || false
+
+        [
+          (id.number ? " #{id.number.render(context:)}" : ""),
+          (id.part ? "-#{id.part.render(context:)}" : ""),
+          (id.subpart ? "-#{id.subpart.render(context:)}" : ""),
+          (id.stage_iteration ? ".#{id.stage_iteration.render(context:)}" : ""),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+          language_portion(id, lang_single: lang_single),
+        ].join
+      end
+
+      def language_portion(id, lang_single: false)
+        return "" unless id.languages&.any?
+
+        [
+          "(",
+          id.languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def render_supplement(id, opts, context)
+        lang = opts[:lang] || :en
+        lang_single = opts[:lang_single] || false
+        with_edition = opts[:with_edition] || false
+
+        [
+          id.base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                   with_edition: with_edition),
+          "/",
+          id.typed_stage.abbreviation,
+          " ",
+          id.number.render(context:),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+        ].join
+      end
+    end
+  end
+end

data/lib/pubid/idf/supplement_identifier.rb

@@ -27,16 +27,8 @@ module Pubid
       # @param lang_single [Boolean] Use single-char language codes (default: false)
       # @param with_edition [Boolean] Include edition (default: false)
       # @return [String] String representation of supplement
-      def to_s(lang: :en, lang_single: false, with_edition: false)
-        [
-          base_identifier.to_s(lang: lang, lang_single: lang_single,
-                               with_edition: with_edition),
-          "/",
-          typed_stage.abbreviation,
-          " ",
-          number.value,
-          (date ? ":#{date.year}" : ""),
-        ].join
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
     end
   end

data/lib/pubid/idf/urn_generator.rb

@@ -9,41 +9,6 @@ module Pubid
         identifier.type.abbr.to_s.downcase
       end
 
-      def urn_number
-        return nil unless identifier.number
-
-        identifier.number.value.to_s
-      end
-
-      def urn_part
-        return nil unless identifier.part
-
-        "-#{identifier.part.value}"
-      end
-
-      def urn_subpart
-        return nil unless identifier.subpart
-
-        "-#{identifier.subpart.value}"
-      end
-
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        identifier.year&.to_s
-      end
-
-      def urn_edition
-        return nil unless identifier.edition
-
-        num = identifier.edition.number
-        return nil unless num
-
-        "ed.#{num}"
-      end
-
       def generate
         parts = ["urn", "idf"]
         parts << urn_number if urn_number
@@ -54,12 +19,12 @@ module Pubid
         parts << urn_type if urn_type
 
         if identifier.publisher
-          parts[1] = identifier.publisher.body.to_s.downcase
+          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
         end
 
         if identifier.copublishers&.any?
-          copubs = identifier.copublishers.map(&:body)
-          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
+          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
+          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
         end
 
         if identifier.languages&.any?
@@ -73,7 +38,7 @@ module Pubid
           end
 
           if identifier.number
-            parts << identifier.number.value.to_s
+            parts << identifier.number.render(context: URN_CONTEXT)
           end
         end
 

data/lib/pubid/idf/urn_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Parses IDF URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:idf:{number}:{year}:` with a trailing empty
+    # field (a known quirk of the generator).
+    #
+    # Examples:
+    # - urn:idf:87:2019: → IDF 87:2019
+    # - urn:idf:100:     → IDF 100
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject(&:empty?)
+
+        number, year = parts
+        text = "IDF #{number}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/idf.rb

@@ -6,10 +6,11 @@ module Pubid
     autoload :Identifier, "#{__dir__}/idf/identifier"
     autoload :Identifiers, "#{__dir__}/idf/identifiers"
     autoload :Parser, "#{__dir__}/idf/parser"
-    autoload :Scheme, "#{__dir__}/idf/scheme"
+    autoload :Renderer, "#{__dir__}/idf/renderer"
     autoload :SingleIdentifier, "#{__dir__}/idf/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/idf/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/idf/urn_generator"
+    autoload :UrnParser, "#{__dir__}/idf/urn_parser"
 
     def self.parse(identifier)
       parser = Parser.new
@@ -18,6 +19,55 @@ module Pubid
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
+
+    # Build an IDF identifier from a parse-tree hash (used by ISO joint-identifier
+    # parsing). This is the public seam: callers should never reach into
+    # `Idf::Builder` directly.
+    # @param hash [Hash] parse tree for the joint identifier
+    # @return [Pubid::Idf::Identifier]
+    def self.build_from_parse(hash)
+      Builder.new.build(hash)
+    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: Idf::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