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

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
@@ -17,13 +8,103 @@ module Pubid
       end
 
       attr_writer :format_registry
+
+      # Polymorphic deserialization shared by every flavor base. lutaml's
+      # `key_value` polymorphic_map reads `_type` only to VALIDATE; it does not
+      # re-instantiate the concrete subclass. So a base-class `from_hash` would
+      # return a bare base object and drop subtype-specific attributes (e.g. a
+      # supplement's base_identifier). Route by `_type` to the concrete class
+      # named in `polymorphic_type_map`, then let its inherited from_hash (this
+      # method again, where klass == self) fall through to lutaml's real work.
+      #
+      # This generalizes the per-flavor `*_TYPE_MAP` dispatch that ISO, JIS,
+      # IEC, CCSDS and IHO each hand-rolled — one implementation, inherited by
+      # every flavor base.
+      def from_hash(data, options = {})
+        type = data && (data["_type"] || data[:_type])
+        klass = polymorphic_type_map[type]
+        return klass.from_hash(data, options) if klass && klass != self
+
+        super
+      end
+
+      # Map of polymorphic_name ("pubid:iso:corrigendum") => concrete class for
+      # the flavor this base belongs to. Built once by scanning the flavor's
+      # `Identifiers` namespace for Pubid::Identifier descendants and unioning
+      # the flavor's `identifier_types` registry (which may register classes
+      # living outside that namespace, e.g. ISO's BundledIdentifier). Memoized
+      # per class.
+      def polymorphic_type_map
+        @polymorphic_type_map ||=
+          identifier_registry_classes.each_with_object({}) do |klass, map|
+            poly = klass.polymorphic_name
+            map[poly] ||= klass if poly
+          end
+      end
+
+      private
+
+      # The flavor module namespacing this base, e.g. Pubid::Iso for
+      # Pubid::Iso::Identifier (and for the inherited Pubid::Iso::Identifiers::
+      # Corrigendum). Always the first two name components, so it is stable
+      # whether `self` is the base or a concrete subclass.
+      def flavor_module
+        @flavor_module ||= Object.const_get(name.split("::")[0, 2].join("::"))
+      end
+
+      def identifiers_namespace
+        @identifiers_namespace ||= flavor_module.const_get(:Identifiers)
+      end
+
+      def identifier_registry_classes
+        (scanned_identifier_classes +
+          registered_identifier_classes +
+          additional_identifier_classes).uniq
+      end
+
+      # Concrete identifier classes found directly in the flavor's `Identifiers`
+      # namespace. Empty for the abstract root (no flavor) or a flavor without
+      # that namespace. Only this namespace is scanned (never the flavor top
+      # level), to avoid force-autoloading unrelated flavor constants.
+      def scanned_identifier_classes
+        return [] unless flavor_identifiers_namespace?
+
+        identifiers_namespace.constants.filter_map do |const|
+          klass = 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 flavor_module.respond_to?(:identifier_types)
+
+        Array(flavor_module.identifier_types)
+      end
+
+      # Hook for identifier classes that carry a polymorphic `_type` but live
+      # OUTSIDE the flavor's `Identifiers` namespace (e.g. Pubid::Iso::
+      # BundledIdentifier, Pubid::Iec::SingleIdentifier). Flavors with such
+      # classes override this; the default is none. Replaces the hand-listing
+      # of these in the old static `*_TYPE_MAP`s.
+      def additional_identifier_classes
+        []
+      end
+
+      def flavor_identifiers_namespace?
+        flavor_module.const_defined?(:Identifiers)
+      rescue NameError
+        false
+      end
     end
 
     attribute :_type, :string, polymorphic_class: true
     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
@@ -62,13 +143,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
 
@@ -165,7 +239,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

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}" : ""),
@@ -56,6 +53,10 @@ module Pubid
       end
 
       def self.parse(string)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Pubid::Idf::Parser.new.parse(string)
         if parsed.nil? || parsed.empty?
           raise Pubid::Idf::Parser::ParseError,
@@ -64,66 +65,6 @@ module Pubid
 
         Pubid::Idf::Builder.new.build(parsed)
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Idf::Identifier.create` API.
-      # Default subclass is {Identifiers::InternationalStandard}.
-      #
-      # IDF's renderer requires `typed_stage` to be set (calls
-      # `.abbreviation` without a nil check); factory auto-resolves the
-      # "published" TypedStage for the chosen subclass.
-      TYPE_KEY_TO_KLASS = {
-        is:              "InternationalStandard",
-        reviewed_method: "ReviewedMethod",
-      }.freeze
-
-      def self.create(type: nil, stage: nil, **opts)
-        klass = resolve_create_class(type)
-        attrs = coerce_create_attrs(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        attrs[:typed_stage] = ts if ts
-        klass.new(**attrs)
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::InternationalStandard if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown IDF type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.resolve_create_typed_stage(klass, stage)
-        return nil unless klass.const_defined?(:TYPED_STAGES)
-
-        if stage
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.abbr.include?(stage.to_s)
-          end
-        else
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code&.to_sym == :published
-          end
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {
-          publisher: Pubid::Components::Publisher.new(
-            body: (opts[:publisher] || "IDF").to_s,
-          ),
-        }
-        if (v = opts[:number])
-          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
-        end
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class,
-                           :resolve_create_typed_stage,
-                           :coerce_create_attrs
     end
   end
 end

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,18 +6,72 @@ 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)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       parser = Parser.new
       builder = Builder.new
 
       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