pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/iho/urn_generator.rb

@@ -4,7 +4,7 @@ module Pubid
   module Iho
     # Generates URN strings for IHO identifiers.
     #
-    # Format: urn:iho:{type-letter-lowercase}:{number}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version}]
+    # Format: urn:iho:{type-letter-lowercase}:{code}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version}]
     # Example: urn:iho:s:44:5.0.0 for "IHO S-44 5.0.0".
     class UrnGenerator
       attr_reader :identifier
@@ -15,8 +15,8 @@ module Pubid
 
       def generate
         parts = ["urn", "iho"]
-        parts << identifier.class.type[:short].to_s.downcase
-        parts << identifier.number.to_s
+        parts << identifier.type[:short].to_s.downcase
+        parts << identifier.code.to_s
         parts << "ap.#{identifier.appendix}"     if identifier.appendix
         parts << "part.#{identifier.part}"       if identifier.part
         parts << "annex.#{identifier.annex}"     if identifier.annex

data/lib/pubid/iho.rb

@@ -2,75 +2,19 @@
 
 module Pubid
   module Iho
-    extend Pubid::PrefixesSupport
-
-    # Sole IHO publisher token (see the parser grammar).
-    PREFIXES = ["IHO"].freeze
-
     autoload :Builder,      "#{__dir__}/iho/builder"
-    autoload :Identifier, "#{__dir__}/iho/identifiers/base"
+    autoload :Identifier,   "#{__dir__}/iho/identifier"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
     autoload :Parser,       "#{__dir__}/iho/parser"
-    autoload :Renderer,     "#{__dir__}/iho/renderer"
+    autoload :Scheme,       "#{__dir__}/iho/scheme"
     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
-    # @return [Pubid::Iho::Identifier] The appropriate identifier object
+    # @return [Pubid::Iho::Identifiers::Base] The appropriate identifier object
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.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 }
-        # Exclude the flavor base itself by identity (Identifier is now an
-        # alias for Pubid::Iho::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifier }
-    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<Identifier>]
-    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,20 +3,13 @@
 module Pubid
   module Iso
     class Builder < Pubid::Builder::Base
-      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)
+      def initialize(scheme)
+        @scheme = scheme
       end
 
       def locate_identifier_klass(parsed_hash)
         # If there is a joint_identifier, we need to use a CombinedIdentifier
-        # which takes `base` and `additional_identifiers`
+        # which takes `base_identifier` and `additional_identifiers`
         if parsed_hash[:joint_identifier]
           return CombinedIdentifier
         end
@@ -32,29 +25,19 @@ 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.
         # b) It is a Directive Supplements. The "SUP" keyword may be entirely missing, and hence nil. If the base type_with_stage is a directive, then if the type_with_stage is blank, it is a directive supplement.
 
-        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base] && parsed_hash[:base][:type_with_stage] == "DIR"
+        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base_identifier] && parsed_hash[:base_identifier][:type_with_stage] == "DIR"
           # Directive Supplement without "SUP" keyword
           parsed_hash[:type_with_stage] = "SUP"
         end
 
         typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
 
-        Pubid::Iso.locate_type(typed_stage.type_code)
+        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
       end
 
       def build(parsed_hash)
@@ -106,7 +89,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 = Pubid::Iso.locate_stage("")
+          default_typed_stage = @scheme.locate_typed_stage_by_abbr("")
           identifier.typed_stage = default_typed_stage
           identifier.stage = default_typed_stage.to_stage
           identifier.type = default_typed_stage.to_type
@@ -125,37 +108,14 @@ 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
+        when :base_identifier
           # If it has a base identifier, we need to build a supplement
           # We assume that the base identifier is already a valid Identifier object
           build(value)
 
-          # If there is a base, and it has a joint_identifier, we need to use a CombinedIdentifier.
+          # If there is a base_identifier, and it has a joint_identifier, we need to use a CombinedIdentifier.
 
         when :publisher, :directives_supplement_body, :supplement_publisher
           # value can be either a string OR a hash with publisher + copublisher
@@ -165,12 +125,7 @@ module Pubid
               copublisher: value[:copublisher],
             )
           else
-            # Default copublisher to [] (not nil) so a bare-string publisher
-            # (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)
           end
 
         when :copublishers
@@ -197,7 +152,45 @@ module Pubid
           # or "105/F" ('F' is part)
           # or "5843/6" ('6' is part)
           # LEGACY: "4037-1979" (number-year, year should become date)
-          parse_number_with_part(value, code_class: Pubid::Iso::Components::Code)
+
+          # 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
 
         when :directives_type
           # nothing to do here, just return nil
@@ -225,22 +218,17 @@ module Pubid
           }
         when :stage_iteration
           # "1" or "2"
-          Pubid::Components::Iteration.new(number: value.to_s)
+          Pubid::Iso::Components::Code.new(number: value.to_s)
 
         when :date
           parse_date(value)
 
-        when :undated_marker
-          # ISO/IEC undated reference (e.g. "ISO 16634:--") — explicit
-          # publication-date slot with no year; round-trips via date.render.
-          { date: Pubid::Components::Date.new(undated: true) }
-
         when :edition
           # value can be "Ed.2", "Ed 2", "ED1", "Edition 13", or just "Ed"
           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(value: number_string) : nil
+          number_code = number_string ? Pubid::Iso::Components::Code.new(number: number_string) : nil
           Pubid::Components::Edition.new(number: number_code,
                                          original_text: original_text)
 
@@ -255,13 +243,14 @@ module Pubid
         when :joint_identifier
           case value[:publisher]
           when "IDF"
-            Pubid::Idf.build_from_parse(value)
+            require_relative "../idf/builder"
+            Idf::Builder.new.build(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(value: value.to_s)
+          Pubid::Iso::Components::Code.new(number: value.to_s)
 
         when :supplements
           # Handle bundled supplements (+ operator)
@@ -275,11 +264,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(value: value.to_s)
+          Pubid::Iso::Components::Code.new(number: value.to_s)
 
         when :tc_number, :sc_number, :wg_number
           # TC, SC, WG numbers are code components
-          Pubid::Iso::Components::Code.new(value: value.to_s)
+          Pubid::Iso::Components::Code.new(number: value.to_s)
 
         when :year
           # For TC documents with year, convert to Date
@@ -290,7 +279,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(value: value.to_s)
+            Pubid::Iso::Components::Code.new(number: value.to_s)
           else
             value
           end
@@ -299,7 +288,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 = Pubid::Iso.locate_stage_by_stage_code(value.to_s)
+          typed_stage = Scheme.locate_typed_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,57 +10,6 @@ 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
@@ -86,17 +35,15 @@ module Pubid
         base_document&.copublishers
       end
 
-      # See the note on Pubid::BundledIdentifier#to_s: `**opts` carries flags
-      # this list does not name, `annotated:` above all.
       def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
-stage_format_long: nil, with_date: nil, **opts)
+stage_format_long: nil, with_date: nil)
         parts = [base_document.to_s(lang: lang, lang_single: lang_single,
-                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)]
+                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)]
 
         # Add each supplement with "+" separator
         supplements.each do |supplement|
           supplement_str = supplement.to_supplement_s(lang: lang, lang_single: lang_single,
-                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)
+                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)
           parts << "+ #{supplement_str}"
         end
 

data/lib/pubid/iso/combined_identifier.rb

@@ -4,18 +4,16 @@ module Pubid
   module Iso
     # Identifier that represents a supplement to a base identifier.
     class CombinedIdentifier < Identifier
-      attribute :base, Identifier, polymorphic: true
+      attribute :base_identifier, Identifier, polymorphic: true
       attribute :additional_identifiers, ::Pubid::Identifier,
                 polymorphic: true, collection: true
       attribute :type, :string, default: -> { "combined_identifier" }
 
-      # `**opts` carries render flags this list does not name (`annotated:`),
-      # which the closed signature used to reject outright.
-      def to_s(lang: :en, lang_single: false, **opts)
+      def to_s(lang: :en, lang_single: false)
         [
-          base.to_s(lang: lang, lang_single: lang_single, **opts),
+          base_identifier.to_s(lang: lang, lang_single: lang_single),
           additional_identifiers.map do |id|
-            id.to_s(lang: lang, lang_single: lang_single, **opts)
+            id.to_s(lang: lang, lang_single: lang_single)
           end,
         ].flatten.join(" | ")
       end

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

@@ -1,22 +1,34 @@
 # 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 render(context: nil)
-          to_s
+        def ==(other)
+          return false unless other.is_a?(Code)
+
+          value == other.value && parts == other.parts
         end
       end
     end

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

@@ -16,10 +16,6 @@ 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
@@ -42,17 +38,19 @@ module Pubid
         def ==(other)
           return false unless other.is_a?(Publisher)
 
-          # 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
+          publisher == other.publisher && copublisher == other.copublisher
         end
 
+        # Returns hash code for publisher component
+        # @return [Integer] hash code
+        # @note Memoized for performance
         def hash
-          @hash ||= [publisher, copublisher.to_a].map(&:hash).hash
+          @hash ||= [publisher, copublisher].compact.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,8 +3,10 @@
 module Pubid
   module Iso
     module Components
-      autoload :Code, "#{__dir__}/components/code"
-      autoload :Publisher, "#{__dir__}/components/publisher"
+      # ISO-specific components
     end
   end
 end
+
+require_relative "components/code"
+require_relative "components/publisher"