pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/iho/urn_parser.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Parses IHO URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:iho:{type-lower}:{number}[:{part-kind}.{part}]:{version}
+    #
+    # type-lower is the lowercase series letter (s, p, m, b, c).
+    # part-kind is the lowercase part label (part, ap, annex, suppl).
+    # version is the dotted version string.
+    #
+    # Examples:
+    # - urn:iho:s:44:5.0.0                → IHO S-44 5.0.0
+    # - urn:iho:s:100:part.4a:1.0.0       → IHO S-100 Part 4a 1.0.0
+    # - urn:iho:s:65:ap.A:1.0.0           → IHO S-65 Ap. A 1.0.0
+    class UrnParser < Pubid::UrnParser::Base
+      PART_LABELS = {
+        "part" => "Part",
+        "ap" => "Ap.",
+        "annex" => "Annex",
+        "suppl" => "Suppl",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0).upcase
+        number = parts.fetch(1)
+        idx = 2
+        part_label = nil
+        if parts[idx] && part_kind?(parts[idx])
+          kind, value = parts[idx].split(".", 2)
+          label = PART_LABELS.fetch(kind.downcase) { kind.capitalize }
+          part_label = "#{label} #{value}"
+          idx += 1
+        end
+        version = parts[idx]
+
+        text = "IHO #{type_token}-#{number}"
+        text += " #{part_label}" if part_label
+        text += " #{version}" if version
+        flavor_parse(text)
+      end
+
+      private
+
+      # A part-kind token starts with letters followed by a dot, e.g.,
+      # "part.4a", "ap.A", "annex.A", "suppl.1". A version like "5.0.0"
+      # starts with a digit.
+      def part_kind?(token)
+        token.match?(/^[a-z]+\./i)
+      end
+    end
+  end
+end

data/lib/pubid/iho.rb

@@ -6,8 +6,9 @@ module Pubid
     autoload :Identifier,   "#{__dir__}/iho/identifier"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
     autoload :Parser,       "#{__dir__}/iho/parser"
-    autoload :Scheme,       "#{__dir__}/iho/scheme"
+    autoload :Renderer,     "#{__dir__}/iho/renderer"
     autoload :UrnGenerator, "#{__dir__}/iho/urn_generator"
+    autoload :UrnParser, "#{__dir__}/iho/urn_parser"
 
     # Parse an IHO identifier string into an identifier object
     # @param identifier [String] The IHO identifier string to parse
@@ -15,6 +16,54 @@ module Pubid
     def self.parse(identifier)
       Identifier.parse(identifier)
     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: Iho::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    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 < Pubid::Identifier }
+        .reject { |c| c.name&.split("::")&.last == "Base" }
+    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
+
+    # Look up an identifier class by its IHO series letter (S/P/M/B/C).
+    # @param letter [String]
+    # @return [Class<Identifiers::Base>]
+    def self.identifier_klass_for_type_letter(letter)
+      @by_letter ||= identifier_types.to_h { |klass| [klass.type[:short], klass] }
+      @by_letter.fetch(letter.to_s)
+    end
   end
 end
 

data/lib/pubid/iso/builder.rb

@@ -3,8 +3,15 @@
 module Pubid
   module Iso
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
+      def initialize
+        # No state needed: lookups are delegated to the Pubid::Iso module.
+      end
+
+      # Override the base implementation to avoid relying on @scheme.
+      # @param typed_stage_string [String, nil]
+      # @return [Pubid::Components::TypedStage, nil]
+      def locate_typed_stage(typed_stage_string)
+        Pubid::Iso.locate_stage(typed_stage_string.to_s)
       end
 
       def locate_identifier_klass(parsed_hash)
@@ -25,6 +32,16 @@ module Pubid
           return Identifiers::TcDocument
         end
 
+        # An explicit document type (e.g. from a URN's `:tr:`/`:ts:` token) pins
+        # the class regardless of the stage. The stage and type are separate URN
+        # fields, but the stage is later folded into `:type_with_stage` (e.g.
+        # "WDA" for 90.93), which would otherwise mis-resolve the class to the
+        # stage's owning type (IS). Consume the hint here, before assign_attributes.
+        if (doc_type = parsed_hash.delete(:document_type))
+          type_stage = locate_typed_stage(doc_type)
+          return Pubid::Iso.locate_type(type_stage.type_code) if type_stage
+        end
+
         # Check the `:type_with_stage` to determine the identifier class
         # 1. :type_with_stage will be nil if:
         # a) It is an IS.
@@ -37,7 +54,7 @@ module Pubid
 
         typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
 
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        Pubid::Iso.locate_type(typed_stage.type_code)
       end
 
       def build(parsed_hash)
@@ -89,7 +106,7 @@ module Pubid
         # If typed_stage, stage, or type are still nil after building,
         # set them to the default International Standard values
         if identifier.typed_stage.nil?
-          default_typed_stage = @scheme.locate_typed_stage_by_abbr("")
+          default_typed_stage = Pubid::Iso.locate_stage("")
           identifier.typed_stage = default_typed_stage
           identifier.stage = default_typed_stage.to_stage
           identifier.type = default_typed_stage.to_type
@@ -108,6 +125,29 @@ module Pubid
         end
       end
 
+      # ISO normalizes em/en dashes, slashes, and spaces to hyphens so that
+      # "4037/1979", "4037-1979", and "ISO/IEC DIR 1 IEC" all split cleanly.
+      def normalize_number_with_part(value)
+        value.to_s
+             .tr("#{Parser::DASH_CHARS.join}/", "-")
+             .gsub(" ", "-")
+      end
+
+      # LEGACY: "ISO 4037-1979" used a hyphen where the modern form is
+      # "ISO 4037:1979". When the part looks like a 4-digit year in a
+      # plausible range, treat it as a date instead of a part number.
+      def extract_legacy_year(number, part, code_class)
+        return nil unless part&.match?(/^\d{4}$/)
+
+        year_value = part.to_i
+        return nil unless year_value.between?(1900, 2099)
+
+        {
+          number: code_class.new(value: number),
+          date: ::Pubid::Components::Date.new(year: part),
+        }
+      end
+
       def cast(type, value)
         case type
         when :base_identifier
@@ -129,7 +169,8 @@ module Pubid
             # (e.g. a TC document, which skips the copublisher merge) matches
             # the [] convention used by copublisher-merged parses and by
             # Identifier.create. Otherwise equality fails on [] vs nil.
-            Pubid::Iso::Components::Publisher.new(publisher: value, copublisher: [])
+            Pubid::Iso::Components::Publisher.new(publisher: value, 
+                                                  copublisher: [])
           end
 
         when :copublishers
@@ -156,45 +197,7 @@ module Pubid
           # or "105/F" ('F' is part)
           # or "5843/6" ('6' is part)
           # LEGACY: "4037-1979" (number-year, year should become date)
-
-          # Split the number into parts
-          normalized_value = value.to_s.tr("#{Parser::DASH_CHARS.join}/", "-")
-
-          # for "1 IEC" ('IEC' is part) (in case of "ISO/IEC DIR 1 IEC")
-          normalized_value.gsub!(" ", "-")
-
-          parts = normalized_value.split("-").reject(&:empty?)
-          number = parts.shift # The first part is always the number
-          part = parts.shift&.strip # The second part is the part, if present
-          subpart = parts.any? ? parts.join("-") : nil # The remaining parts form the subpart, if present
-
-          # LEGACY FORMAT FIX: If "part" is a 4-digit year (1900-2099), move it to date field
-          # This handles legacy formats like "ISO 4037-1979" where hyphen was used instead of colon
-          if part&.match?(/^\d{4}$/)
-            year_value = part.to_i
-            # Only treat as year if in reasonable year range (excludes part numbers like "1751")
-            if year_value.between?(1900, 2099)
-              return {
-                number: Pubid::Iso::Components::Code.new(number: number),
-                date: Pubid::Components::Date.new(year: part),
-              }
-            end
-          end
-
-          part = convert_roman_to_integer(part)
-
-          code_hash = { number: Pubid::Iso::Components::Code.new(number: number) }
-
-          if part
-            code_hash[:part] = Pubid::Iso::Components::Code.new(number: part)
-          end
-
-          if subpart
-            code_hash[:subpart] =
-              Pubid::Iso::Components::Code.new(number: subpart)
-          end
-
-          code_hash
+          parse_number_with_part(value, code_class: Pubid::Iso::Components::Code)
 
         when :directives_type
           # nothing to do here, just return nil
@@ -222,7 +225,7 @@ module Pubid
           }
         when :stage_iteration
           # "1" or "2"
-          Pubid::Iso::Components::Code.new(number: value.to_s)
+          Pubid::Components::Iteration.new(number: value.to_s)
 
         when :date
           parse_date(value)
@@ -232,7 +235,7 @@ module Pubid
           original_text = value.to_s
           # Extract just the digit(s) for the number field
           number_string = original_text.match(/\d+/)&.to_s
-          number_code = number_string ? Pubid::Iso::Components::Code.new(number: number_string) : nil
+          number_code = number_string ? Pubid::Iso::Components::Code.new(value: number_string) : nil
           Pubid::Components::Edition.new(number: number_code,
                                          original_text: original_text)
 
@@ -247,14 +250,13 @@ module Pubid
         when :joint_identifier
           case value[:publisher]
           when "IDF"
-            require_relative "../idf/builder"
-            Idf::Builder.new.build(value)
+            Pubid::Idf.build_from_parse(value)
           end
 
         when :subgroup
           # Handle JTC 1 subgroup in directives (ISO/IEC JTC 1 DIR)
           # Store as a component for potential use in rendering
-          Pubid::Iso::Components::Code.new(number: value.to_s)
+          Pubid::Iso::Components::Code.new(value: value.to_s)
 
         when :supplements
           # Handle bundled supplements (+ operator)
@@ -268,11 +270,11 @@ module Pubid
         # TC Document attributes
         when :tc_type, :sc_type, :wg_type
           # TC, SC, WG types are code components
-          Pubid::Iso::Components::Code.new(number: value.to_s)
+          Pubid::Iso::Components::Code.new(value: value.to_s)
 
         when :tc_number, :sc_number, :wg_number
           # TC, SC, WG numbers are code components
-          Pubid::Iso::Components::Code.new(number: value.to_s)
+          Pubid::Iso::Components::Code.new(value: value.to_s)
 
         when :year
           # For TC documents with year, convert to Date
@@ -283,7 +285,7 @@ module Pubid
           # For regular identifiers, this is handled in :number_with_part
           if value.is_a?(Parslet::Slice) || value.is_a?(String) ||
               value.is_a?(Integer)
-            Pubid::Iso::Components::Code.new(number: value.to_s)
+            Pubid::Iso::Components::Code.new(value: value.to_s)
           else
             value
           end
@@ -292,7 +294,7 @@ module Pubid
           # Raw stage code from URN parser (e.g., "10.00", "50.00")
           # Convert to type_with_stage format for builder
           # Look up the typed stage from stage code
-          typed_stage = Scheme.locate_typed_stage_by_stage_code(value.to_s)
+          typed_stage = Pubid::Iso.locate_stage_by_stage_code(value.to_s)
           if typed_stage
             typed_stage.abbr.is_a?(Array) ? typed_stage.abbr.first : typed_stage.abbr
           else

data/lib/pubid/iso/bundled_identifier.rb

@@ -10,6 +10,57 @@ module Pubid
                                                    collection: true
       attribute :type, :string, default: -> { "bundled_identifier" }
 
+      # Serialize the bundle structure. The inherited common-field maps read the
+      # delegated base_document values; suppress them (base_document carries
+      # them) and serialize base_document + the supplements collection instead,
+      # routing each through from_hash on load.
+      key_value do
+        # Serialized key is "base" (consistent with supplements); the attribute
+        # stays base_document.
+        map "base",
+            with: { to: :base_document_to_kv, from: :base_document_from_kv }
+        map "supplements",
+            with: { to: :supplements_to_kv, from: :supplements_from_kv }
+      end
+
+      def base_document_to_kv(model, doc)
+        return unless model.base_document
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(
+                        "base", model.base_document.to_hash
+                      ))
+      end
+
+      def base_document_from_kv(model, value)
+        model.base_document = ::Pubid::Iso::Identifier.from_hash(value) if value
+      end
+
+      def supplements_to_kv(model, doc)
+        return unless model.supplements&.any?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(
+                        "supplements", model.supplements.map(&:to_hash)
+                      ))
+      end
+
+      def supplements_from_kv(model, value)
+        model.supplements = Array(value).map do |h|
+          ::Pubid::Iso::Identifier.from_hash(h)
+        end
+      end
+
+      # The delegated common fields are carried by base_document; don't duplicate
+      # them at the bundle level.
+      def number_to_kv(_model, _doc); end
+      def part_to_kv(_model, _doc); end
+      def subpart_to_kv(_model, _doc); end
+      def year_to_kv(_model, _doc); end
+      def month_to_kv(_model, _doc); end
+      def day_to_kv(_model, _doc); end
+      def publisher_to_kv(_model, _doc); end
+      def copublishers_to_kv(_model, _doc); end
+      def stage_to_kv(_model, _doc); end
+
       # Delegate key attributes to base_document for easier access in tests
       def publisher
         base_document&.publisher

data/lib/pubid/iso/components/code.rb

@@ -1,34 +1,22 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Pubid
   module Iso
     module Components
+      # Code component for ISO identifiers.
+      #
+      # Inherits +value+ and +parts+ from the shared Code; overrides
+      # rendering to join parts with "-" (ISO convention). Equality and
+      # hash are inherited from the shared Code (compare all fields).
       class Code < ::Pubid::Components::Code
-        attribute :number, :string
-        attribute :parts, :string, collection: true
-
-        def value
-          number || self[:value]
-        end
-
-        def render(context: nil)
-          result = value.to_s
-          result += parts.map { |p| "-#{p}" }.join if parts&.any?
-          result
-        end
-
         def to_s
           result = value.to_s
           result += parts.map { |p| "-#{p}" }.join if parts&.any?
           result
         end
 
-        def ==(other)
-          return false unless other.is_a?(Code)
-
-          value == other.value && parts == other.parts
+        def render(context: nil)
+          to_s
         end
       end
     end

data/lib/pubid/iso/components/publisher.rb

@@ -16,6 +16,10 @@ module Pubid
         end
 
         def render(context: nil)
+          if context&.urn?
+            return publisher&.downcase
+          end
+
           return publisher unless copublisher&.any?
 
           publisher + copublisher.map { |cp| "/#{cp}" }.join
@@ -38,19 +42,17 @@ module Pubid
         def ==(other)
           return false unless other.is_a?(Publisher)
 
-          publisher == other.publisher && copublisher == other.copublisher
+          # copublisher is a collection: parsing yields [] while building via
+          # .create (e.g. from an index hash) leaves it nil. Treat the empty
+          # collection and "no collection" as equal so both forms compare.
+          publisher == other.publisher &&
+            copublisher.to_a == other.copublisher.to_a
         end
 
-        # Returns hash code for publisher component
-        # @return [Integer] hash code
-        # @note Memoized for performance
         def hash
-          @hash ||= [publisher, copublisher].compact.map(&:hash).hash
+          @hash ||= [publisher, copublisher.to_a].map(&:hash).hash
         end
 
-        # Checks equality using hash for consistency
-        # @param other [Object] object to compare with
-        # @return [Boolean] true if equal
         def eql?(other)
           hash == other.hash && self == other
         end

data/lib/pubid/iso/components.rb

@@ -3,10 +3,8 @@
 module Pubid
   module Iso
     module Components
-      # ISO-specific components
+      autoload :Code, "#{__dir__}/components/code"
+      autoload :Publisher, "#{__dir__}/components/publisher"
     end
   end
 end
-
-require_relative "components/code"
-require_relative "components/publisher"