pubid 2.0.0.pre.alpha.4 → 2.0.0.pre.alpha.6

data/lib/pubid/iala/identifiers/resolution.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Resolutions and other Council publications (P prefix,
+      # planned). Today resolutions carry no code; P is reserved for
+      # future numbered resolutions.
+      class Resolution < Base
+        def self.type
+          { key: :resolution, title: "Resolution", short: "P" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/standard.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Standards (S series).
+      # Examples: S1010, S1020 Ed 2.0, S1070 Ed 2.0.
+      class Standard < Base
+        def self.type
+          { key: :standard, title: "Standard", short: "S" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      autoload :Base,           "#{__dir__}/identifiers/base"
+      autoload :Standard,       "#{__dir__}/identifiers/standard"
+      autoload :Recommendation, "#{__dir__}/identifiers/recommendation"
+      autoload :Guideline,      "#{__dir__}/identifiers/guideline"
+      autoload :Manual,         "#{__dir__}/identifiers/manual"
+      autoload :ModelCourse,    "#{__dir__}/identifiers/model_course"
+      autoload :Report,         "#{__dir__}/identifiers/report"
+      autoload :Resolution,     "#{__dir__}/identifiers/resolution"
+    end
+  end
+end

data/lib/pubid/iala/parser.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iala
+    # Parslet grammar for IALA identifiers.
+    #
+    # Accepts every shape that appears on the IALA website or cover page:
+    #
+    #   S1070
+    #   S1070 Ed 2.0
+    #   IALA S1070 Ed 2.0
+    #   S1070 Ed 2.0 (F)
+    #   R1016:ed2.0(F)
+    #   C0103-1
+    #   C0103-1 Ed 3.0
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+
+      root :identifier
+
+      rule(:space)  { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:dash)   { str("-") }
+      rule(:colon)  { str(":") }
+      rule(:dot)    { str(".") }
+      rule(:lparen) { str("(") }
+      rule(:rparen) { str(")") }
+
+      # Type letter — one of IALA's seven document classes. Captured to
+      # route to the right Identifiers::* subclass.
+      rule(:type_letter) do
+        (str("S") | str("R") | str("G") | str("M") |
+         str("C") | str("X") | str("P")).as(:type_letter)
+      end
+
+      # 4-digit document number, e.g. "1070", "0126".
+      rule(:doc_number) do
+        match("[0-9]").repeat(4, 4).as(:doc_number)
+      end
+
+      # Numeric sub-part suffix(es): "-1", "-9-10", "-11". The catalogue
+      # uses ranges like R0124-9-10 & 11 — that compound is captured
+      # verbatim and resolved by the caller, not here.
+      rule(:subpart) do
+        (dash >> digits.as(:subpart_number)).repeat(1).as(:subpart)
+      end
+
+      rule(:code) do
+        type_letter >> doc_number >> subpart.maybe
+      end
+
+      # Edition forms observed on covers and listing pages:
+      #   " Ed 2.0"      — cover-page human form
+      #   ":ed2.0"       — listing-page compact form
+      rule(:edition_human) do
+        (space >> str("Ed") >> space >> edition_value).as(:edition)
+      end
+
+      rule(:edition_compact) do
+        (colon >> str("ed") >> edition_value).as(:edition)
+      end
+
+      rule(:edition_value) do
+        (digits >> (dot >> digits).repeat).as(:edition_value)
+      end
+
+      rule(:edition) do
+        edition_human | edition_compact
+      end
+
+      # Language is a single uppercase letter inside parens: (E), (F), …
+      rule(:language) do
+        (space? >> lparen >>
+          (str("E") | str("F") | str("S") | str("C") | str("A") | str("R")).as(:language) >>
+          rparen).as(:language_group)
+      end
+
+      # Optional "IALA " prefix.
+      rule(:publisher) do
+        (str("IALA") >> space).maybe
+      end
+
+      rule(:identifier) do
+        publisher >> code >> edition.maybe >> language.maybe
+      end
+
+      # Parse a string and return the raw parslet tree.
+      # @param string [String]
+      # @return [Hash]
+      def self.parse(string)
+        raise ArgumentError, "IALA identifier string exceeds maximum length" if string.length > ::Pubid::MAX_INPUT_LENGTH
+
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/iala/renderer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Human-readable renderer for IALA identifiers.
+    #
+    # Produces strings like:
+    #   "IALA S1070"
+    #   "IALA S1070 Ed 2.0"
+    #   "IALA R1016 Ed 2.0 (F)"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        rendered = "#{id.publisher} #{id.type_letter}#{id.number}"
+        rendered << " Ed #{id.edition}" if id.edition
+        rendered << " (#{id.language})" if id.language
+        rendered
+      end
+    end
+  end
+end

data/lib/pubid/iala/urn_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Generates URN strings for IALA identifiers using the Maritime Resource
+    # Name (MRN) namespace that IALA prints on its cover pages.
+    #
+    # Format: urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    # Example: urn:mrn:iala:pub:s1070:ed2.0
+    #          urn:mrn:iala:pub:r1016:ed2.0:f
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        parts = ["urn:mrn:iala:pub", code_segment]
+        parts << "ed#{identifier.edition}" if identifier.edition
+        parts << identifier.language.downcase if identifier.language
+        parts.join(":")
+      end
+
+      private
+
+      def code_segment
+        "#{identifier.type_letter.downcase}#{identifier.number}"
+      end
+    end
+  end
+end

data/lib/pubid/iala/urn_parser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Parses IALA MRN URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    #
+    # Examples:
+    #   urn:mrn:iala:pub:s1070:ed2.0          → IALA S1070 Ed 2.0
+    #   urn:mrn:iala:pub:r1016:ed2.0:f        → IALA R1016 Ed 2.0 (F)
+    #   urn:mrn:iala:pub:c0103-1              → IALA C0103-1
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:mrn:iala:pub:".freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        code = parts.fetch(0)
+
+        edition = nil
+        language = nil
+        parts.drop(1).each do |seg|
+          if seg.start_with?("ed")
+            edition = seg.sub(/\Aed/, "")
+          elsif seg.length == 1 && seg.match?(/\A[a-z]\z/i)
+            language = seg.upcase
+          end
+        end
+
+        text = "IALA #{code.upcase}"
+        text += " Ed #{edition}" if edition
+        text += " (#{language})" if language
+        flavor_parse(text)
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid IALA URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+    end
+  end
+end

data/lib/pubid/iala.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    autoload :Builder,      "#{__dir__}/iala/builder"
+    autoload :Identifier,   "#{__dir__}/iala/identifier"
+    autoload :Identifiers,  "#{__dir__}/iala/identifiers"
+    autoload :Parser,       "#{__dir__}/iala/parser"
+    autoload :Renderer,     "#{__dir__}/iala/renderer"
+    autoload :UrnGenerator, "#{__dir__}/iala/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/iala/urn_parser"
+
+    # Parse an IALA identifier string into an identifier object.
+    # @param identifier [String] The IALA identifier string to parse
+    # @return [Pubid::Iala::Identifier]
+    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: Iala::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 == Identifiers::Base }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>]
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    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]
+    # @return [Pubid::Components::TypedStage, nil]
+    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 IALA type letter (S, R, G, M, C, X, P).
+    # @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.upcase)
+    end
+  end
+end
+
+Pubid::Registry.register(:iala, Pubid::Iala)

data/lib/pubid/identifier.rb

@@ -120,11 +120,96 @@ module Pubid
       nil
     end
 
+    # The underlying standard, with amendment / corrigendum / Expert-commentary
+    # / Flex-version wrappers peeled recursively. Wrapper subclasses override
+    # this; a plain identifier is its own base document.
+    def base_document
+      self
+    end
+
     # @return [String, nil] publication year from the date component
     def year
       date&.year&.to_s
     end
 
+    # Canonicalize the serialized hash so it never carries a defaulted attribute
+    # still at its default (or empty) value. This makes to_hash a pure function
+    # of the identifier's values, independent of how the object was built.
+    #
+    # Motivation: lutaml materializes each attribute's default as an explicit
+    # assignment during deserialization (flipping using_default? to false), so a
+    # naive from_hash(x).to_hash re-emits defaults that parse(x).to_hash omits —
+    # breaking the exact-equality round-trip relaton-index relies on
+    # (from_hash(raw).to_hash == raw). pubid never consults lutaml's unset
+    # tracking and defines no render_default: true, so a defaulted attribute at
+    # its default/empty value carries no meaning and does not belong in the
+    # canonical hash. Dropping it here (rather than repairing from_hash) fixes
+    # the round-trip through every construction path — parse, from_hash, manual.
+    def to_hash(*args)
+      hash = super
+      canonicalize_hash(self, hash) if hash.is_a?(::Hash)
+      hash
+    end
+
+    # Recursively drop attributes holding only their default (or empty) value
+    # from +hash+, the serialization of +model+. Recurses into nested component
+    # / identifier values because lutaml serializes those via its own transform
+    # — bypassing their public to_hash — so a nested defaulted attribute (e.g.
+    # Components::Supplement#has_revision) would otherwise leak into the parent
+    # hash and break the idempotent round-trip.
+    def canonicalize_hash(model, hash)
+      register = model.lutaml_register
+      model.class.attributes(register).each do |name, attr|
+        canonicalize_attr(model, hash, name, attr) unless name == :_type
+      end
+    end
+
+    # Canonicalize a single attribute against its serialized value in +hash+:
+    # drop it when it holds only its default/empty value, else recurse into it.
+    def canonicalize_attr(model, hash, name, attr)
+      key = hash.key?(name.to_s) ? name.to_s : name
+      return unless hash.key?(key)
+
+      value = model.public_send(name)
+      if default_valued?(value, attr, model)
+        hash.delete(key)
+      else
+        canonicalize_nested(value, hash[key])
+      end
+    end
+
+    # True when +value+ is +attr+'s default (or empty), so it can be dropped.
+    def default_valued?(value, attr, model)
+      register = model.lutaml_register
+      attr.default_set?(register, model) &&
+        (Lutaml::Model::Utils.empty?(value) ||
+          value == attr.default(register, model))
+    end
+
+    # Recurse into a nested component / identifier (or a collection of them) so
+    # its own defaulted attributes are canonicalized against its sub-hash.
+    def canonicalize_nested(value, sub)
+      if value.is_a?(Lutaml::Model::Serialize)
+        canonicalize_hash(value, sub) if sub.is_a?(::Hash)
+      elsif value.is_a?(::Array)
+        canonicalize_collection(value, sub)
+      end
+    end
+
+    # Canonicalize each element of a collection against its serialized sub-hash.
+    # Only zip when object and serialized sizes match, so a (never-observed)
+    # length mismatch can't pair an element with the wrong sub-hash — worst case
+    # it leaves that collection untouched.
+    def canonicalize_collection(models, subs)
+      return unless subs.is_a?(::Array) && models.size == subs.size
+
+      models.each_with_index do |model, i|
+        canonicalize_nested(model, subs[i])
+      end
+    end
+    private :canonicalize_hash, :canonicalize_attr, :default_valued?,
+            :canonicalize_nested, :canonicalize_collection
+
     def initialize(attrs = {}, options = {})
       attrs = attrs.dup
       attrs[:_type] ||= self.class.polymorphic_name
@@ -233,17 +318,48 @@ module Pubid
       Pubid::UrnGenerator::Base
     end
 
+    # Excluded attributes are nilled; every other value is passed through
+    # #exclude_from_nested so the exclusion also propagates into nested
+    # identifiers — wrapper types (adopted standards, consolidated amendments,
+    # expert-commentary wrappers) delegate their date to an inner identifier
+    # rather than storing it in their own attribute.
     def exclude(*args)
+      # :amendment / :supplement are structural, not attributes — they reduce
+      # a supplemented identifier to the standard it wraps (#drop_supplements).
+      supplement_keys = args & %i[amendment supplement]
+      unless supplement_keys.empty?
+        return drop_supplements.exclude(*(args - supplement_keys))
+      end
+
       excluded_args = args.dup
       # Map :year to :date since identifiers store years inside date
       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 : public_send(name)
+        value = excluded_args.include?(name) ? nil : public_send(name)
+        h[name] = exclude_from_nested(value, args)
       end
       self.class.new(attrs)
     end
 
+    # The standard this identifier supplements, dropping its own supplement
+    # layer (one level). Overridden by ConsolidatedIdentifier / Amendment /
+    # Corrigendum; a non-supplement identifier supplements nothing, so it is
+    # returned unchanged.
+    def drop_supplements
+      self
+    end
+
+    # Fuzz-level equality: two identifiers match when they are equal after
+    # excluding the given aspects. `ignore` accepts the same symbols as #exclude
+    # (e.g. :date, :edition, :amendment). This is the primitive relaton uses to
+    # match a reference against catalogue hits at varying strictness.
+    def matches?(other, ignore: [])
+      return false unless other.is_a?(::Pubid::Identifier)
+
+      exclude(*ignore) == other.exclude(*ignore)
+    end
+
     def new_edition_of?(other)
       unless publisher == other.publisher
         raise ArgumentError,
@@ -284,6 +400,21 @@ module Pubid
 
     private
 
+    # Propagate an #exclude into a nested attribute value: recurse when it is
+    # (or contains) another identifier, otherwise return it unchanged.
+    # Components and scalars are copied as-is. Passes the original args so
+    # nested identifiers re-apply the same :year->:date mapping themselves.
+    def exclude_from_nested(value, args)
+      case value
+      when ::Pubid::Identifier
+        value.exclude(*args)
+      when Array
+        value.map { |item| exclude_from_nested(item, args) }
+      else
+        value
+      end
+    end
+
     def build_rendering_context(_renderer, format:, with_edition: false,
                                 lang: :en, lang_single: false,
                                 stage_format_long: nil, with_date: nil,

data/lib/pubid/oiml/builder.rb

@@ -78,13 +78,14 @@ module Pubid
 
       def build_supplement(parsed_hash)
         marker = parsed_hash[:trailing_marker].to_s if parsed_hash[:trailing_marker]
+        plus_marker = parsed_hash[:plus_marker].to_s if parsed_hash[:plus_marker]
 
         # Determine supplement type. The trailing word ("Amendment"/"Errata")
         # selects the class; the concrete class then carries the word via
         # #supplement_type, so only the `trailing` flag needs storing.
         supplement_class = if parsed_hash[:annex_letter] || parsed_hash[:annex_marker]
                              Identifiers::Annex
-                           elsif marker == "Errata"
+                           elsif marker == "Errata" || plus_marker == "Errata"
                              Identifiers::Errata
                            else
                              Identifiers::Amendment
@@ -92,6 +93,7 @@ module Pubid
 
         supplement = supplement_class.new
         supplement.trailing = true if marker
+        supplement.joined = true if plus_marker
 
         # Recursively parse base identifier
         if parsed_hash[:base_identifier]

data/lib/pubid/oiml/parser.rb

@@ -19,7 +19,8 @@ module Pubid
       # Main identifier pattern - check supplements first
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
-          annex_identifier | trailing_supplement_identifier | base_identifier
+          annex_identifier | plus_supplement_identifier |
+          trailing_supplement_identifier | base_identifier
       end
 
       # Publisher - always "OIML"
@@ -172,6 +173,18 @@ module Pubid
           language_portion.maybe.as(:language)
       end
 
+      # Plus-joined supplement - "BASE:YEAR+Supplement:YEAR" form where both
+      # the base and the supplement carry their own year. Used for amendments
+      # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
+      # Annexes already encode the year-on-base intent via their own model.
+      rule(:plus_supplement_identifier) do
+        base_without_language.as(:base_identifier) >>
+          str("+") >>
+          (str("Amendment") | str("Errata")).as(:plus_marker) >>
+          (colon >> year_digits.as(:year)).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
       # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
       # "BASE:YYYY Annexes" (year on the base, no annex year).
       rule(:annex_identifier) do

data/lib/pubid/oiml/renderer.rb

@@ -84,6 +84,16 @@ module Pubid
       def render_supplement(id)
         format = effective_format(id)
 
+        # Plus-joined: "BASE+Amendment:YEAR" / "BASE+Errata:YEAR" with both
+        # the base and the supplement carrying their own year.
+        if id.joined
+          base_str = strip_language(id.base_identifier.to_s)
+          result = "#{base_str}+#{id.supplement_type}"
+          result += ":#{id.year}" if id.year
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
         # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
         # publication year kept on the base identifier. The word comes from the
         # concrete supplement class.

data/lib/pubid/oiml/supplement_identifier.rb

@@ -13,6 +13,9 @@ module Pubid
       # "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
+      # True for the plus-joined form ("OIML B 10:2011+Amendment:2012") where
+      # both the base and the supplement carry their own year, joined by "+".
+      attribute :joined, :boolean, default: false
       attribute :parsed_format, :string, default: -> {
         "short"
       } # Track supplement's parsed format
@@ -25,6 +28,7 @@ module Pubid
             with: { to: :base_identifier_to_kv, from: :base_identifier_from_kv }
         map "year", to: :year
         map "trailing", to: :trailing
+        map "joined", to: :joined
       end
 
       def base_identifier_to_kv(model, doc)

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.pre.alpha.4"
+  VERSION = "2.0.0.pre.alpha.6"
 end

data/lib/pubid.rb

@@ -95,6 +95,7 @@ module Pubid
   autoload :Idf, "pubid/idf"
   autoload :Iec, "pubid/iec"
   autoload :Ieee, "pubid/ieee"
+  autoload :Iala, "pubid/iala"
   autoload :Iho, "pubid/iho"
   autoload :Iso, "pubid/iso"
   autoload :Itu, "pubid/itu"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.4
+  version: 2.0.0.pre.alpha.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-03 00:00:00.000000000 Z
+date: 2026-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -335,6 +335,22 @@ files:
 - lib/pubid/export/result.rb
 - lib/pubid/format_detector.rb
 - lib/pubid/format_registry.rb
+- lib/pubid/iala.rb
+- lib/pubid/iala/builder.rb
+- lib/pubid/iala/identifier.rb
+- lib/pubid/iala/identifiers.rb
+- lib/pubid/iala/identifiers/base.rb
+- lib/pubid/iala/identifiers/guideline.rb
+- lib/pubid/iala/identifiers/manual.rb
+- lib/pubid/iala/identifiers/model_course.rb
+- lib/pubid/iala/identifiers/recommendation.rb
+- lib/pubid/iala/identifiers/report.rb
+- lib/pubid/iala/identifiers/resolution.rb
+- lib/pubid/iala/identifiers/standard.rb
+- lib/pubid/iala/parser.rb
+- lib/pubid/iala/renderer.rb
+- lib/pubid/iala/urn_generator.rb
+- lib/pubid/iala/urn_parser.rb
 - lib/pubid/identifier.rb
 - lib/pubid/identifier_metadata.rb
 - lib/pubid/idf.rb