pubid 2.0.0.pre.alpha.5 → 2.0.0.pre.alpha.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70b24e82967e02c1a0a641c5adc3ad9a77e563f0b7e6f69a59aa4f02971db3d2
-  data.tar.gz: c206002602026012406fa8ebe4339ff6ca0f02db7aa0b00ba49796a034cb697c
+  metadata.gz: 1b1fa5f38da07bc9a507c0c507ba9ddfc8f6541ab9f4b6793b09abe302ab8849
+  data.tar.gz: 63b7eba9c9942c177e95b9c78a09462679a11acde4fd6a2c2e486848fb43ca93
 SHA512:
-  metadata.gz: f74a26e175164470260014a2d492eadfc2f396b0b56bc9f5848fc79168c1ec1d627380bb64c83126bd0eeb2841da40828e336cf263b785b4c2c1959a712b95c5
-  data.tar.gz: b450a0f2343231dff1174c01cec84fdacda74279134fed4c913a552fcd3c7a82e662e1fba5e52018462c295de1df9ba5c78af5a62a1ebde09974fbcd8270f7d6
+  metadata.gz: 915034be3882a43991ce3c0f934c4097f216f1fdac35dcb59ed6a0decb639dd4a19882de4f28940d4f29e6e9bb351de3383b07bd95cc0dc2a53bb4ad875f072d
+  data.tar.gz: 1cb7e935accc6e66bed8b599d25605b26cd415547c1ddec9ba2ecf1b7183883102c99078b830b2de9da436bc17613db042b5fc05e0d7d5515786fae71592aeb8

data/lib/pubid/bsi/builder.rb

@@ -114,19 +114,11 @@ module Pubid
         if data[:na_prefix]
           return build_national_annex(data, supplements_data)
         elsif data[:adopted_string]
-          # Check for multi-level adoptions
-          identifier = build_adopted_identifier(data)
-
-          # Wrap with consolidated if supplements present
-          if supplements_data.any?
-            identifier = wrap_with_consolidated(identifier,
-                                                supplements_data)
-          end
-
-          # Wrap with ExpertCommentary if needed
-          identifier = wrap_with_expert_commentary(identifier) if data[:expert_commentary]
-
-          return identifier
+          # Adopted identifiers carry their supplements and Expert-commentary
+          # suffix *inside* the adopted string, so build_adopted_identifier does
+          # all the wrapping. Wrapping again here would double-wrap (a second
+          # ExpertCommentary around the first) and break #base_document.
+          return build_adopted_identifier(data)
         end
 
         # Determine identifier class using the module's lookup helpers
@@ -139,8 +131,11 @@ module Pubid
                                               supplements_data)
         end
 
-        # Wrap with ExpertCommentary if needed
-        identifier = wrap_with_expert_commentary(identifier) if data[:expert_commentary]
+        # Wrap with ExpertCommentary if needed (full "Expert Commentary" form
+        # arrives as the standalone :expert_commentary_full token)
+        if data[:expert_commentary] || data[:expert_commentary_full]
+          identifier = wrap_with_expert_commentary(identifier)
+        end
 
         identifier
       end
@@ -922,6 +917,7 @@ module Pubid
             number: (supp_data[:amd_number] || supp_data[:cor_number])&.to_s,
             year: (supp_data[:amd_year] || supp_data[:cor_year])&.to_s,
             separator: separator,
+            amd_suffix_form: !(supp_data[:amd_sep_plus] || supp_data[:amd_sep_slash]),
           }
         end
       end
@@ -1157,8 +1153,10 @@ module Pubid
         # Extract ExComm suffix before parsing (it should be preserved in data[:expert_commentary])
         # Remove it from adopted_string so ISO/IEC parsers don't choke on it
         # Handle all three formats: "Expert Commentary", "ExComm", "ExComm (Fire)"
-        if adopted_str.end_with?("Expert Commentary")
-          adopted_str = adopted_str.sub(/Expert Commentary$/, "")
+        # Expert-commentary suffix matching is case-insensitive; output is always
+        # canonicalised to "Expert Commentary" / "ExComm".
+        if adopted_str.match?(/expert commentary$/i)
+          adopted_str = adopted_str.sub(/expert commentary$/i, "")
           data[:expert_commentary_full] = "Expert Commentary"
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           # Update @original_data so wrap_with_expert_commentary can access it
@@ -1167,8 +1165,8 @@ module Pubid
             @original_data[:expert_commentary] =
               true
           end
-        elsif adopted_str.end_with?("ExComm (")
-          adopted_str = adopted_str.sub(/ExComm \(.*\)$/, "")
+        elsif adopted_str.match?(/excomm \($/i)
+          adopted_str = adopted_str.sub(/excomm \(.*\)$/i, "")
           data[:expert_commentary_full] = "Expert Commentary"
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           @original_data[:expert_commentary_full] = "Expert Commentary"
@@ -1176,10 +1174,10 @@ module Pubid
             @original_data[:expert_commentary] =
               true
           end
-        elsif adopted_str.include?("ExComm (")
+        elsif adopted_str.match?(/excomm \(/i)
           # Extract topic from "ExComm (Fire)"
-          topic_match = adopted_str.match(/ExComm\s*\(([^)]+)\)/)
-          adopted_str = adopted_str.sub(/ExComm\s*\(.*\)$/, "")
+          topic_match = adopted_str.match(/excomm\s*\(([^)]+)\)/i)
+          adopted_str = adopted_str.sub(/excomm\s*\(.*\)$/i, "")
           data[:expert_commentary_topic] = topic_match[1] if topic_match
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           if topic_match
@@ -1190,9 +1188,9 @@ module Pubid
             @original_data[:expert_commentary] =
               true
           end
-        elsif adopted_str.match?(/ExComm\s*$/)
+        elsif adopted_str.match?(/excomm\s*$/i)
           # Abbreviated form "ExComm" at the end
-          adopted_str = adopted_str.sub(/ExComm\s*$/, "")
+          adopted_str = adopted_str.sub(/excomm\s*$/i, "")
           data[:expert_commentary] = true unless data.key?(:expert_commentary)
           unless @original_data.key?(:expert_commentary)
             @original_data[:expert_commentary] =
@@ -1258,9 +1256,10 @@ module Pubid
         # BSI uses +A1:2020 format, but ISO/IEC parsers can't handle this
         # Patterns: +A1:2020, +A11:2021, +AMD1:2001, +C1:2020
         extracted_supplements = []
-        # Match patterns like: +A1:2020, +A11:2021, +AMD1:2001, +C1:2020, +COR1:2020
+        # Match patterns like: +A1:2020, +A11:2021, +AMD1:2001, +C1:2020, +COR1:2020,
+        # and the year-less compact forms +A2 / +C1 (the ":YYYY" is optional).
         # Must be at end of string or followed by space (not colon, which is part of date)
-        adopted_str_clean = adopted_str_clean.gsub(/([+])(A(\d+)|AMD(\d+)|C(\d+)|COR(\d+)):(\d{4})(?:\s|$)/) do |_match|
+        adopted_str_clean = adopted_str_clean.gsub(/([+])(A(\d+)|AMD(\d+)|C(\d+)|COR(\d+))(?::(\d{4}))?(?:\s|$)/) do |_match|
           separator = $1 # "+" or "/"
           type_code = $2 || $3 || $4 || $5 || $6
           $2 || $3 || $4 || $5 || $6
@@ -1285,6 +1284,8 @@ module Pubid
             number: supp_number,
             year: year,
             separator: separator,
+            # compact "+A"/"/A" join form (not the trailing " AMD5" suffix form)
+            amd_suffix_form: false,
           }
 
           "" # Remove from adopted_string
@@ -1300,6 +1301,7 @@ module Pubid
             number: amd_number,
             year: nil,
             separator: nil, # No separator for AMD without year
+            amd_suffix_form: true, # trailing " AMD5" suffix form
           }
           "" # Remove from adopted_string
         end.strip
@@ -1365,6 +1367,9 @@ module Pubid
         # Return appropriate wrapper based on adoption type
         if adopted_id
           # If adopted_id is a CEN identifier (in Cen module), use AdoptedEuropeanNorm
+          # The Expert-commentary suffix is represented uniformly by an outer
+          # ExpertCommentary wrapper (below), never a boolean on the inner norm,
+          # so that #base_document peels cleanly to the bare standard.
           identifier = if adopted_id.class.name.start_with?("Pubid::CenCenelec::")
                          Identifiers::AdoptedEuropeanNorm.new(
                            publisher: Components::Publisher.new(body: bsi_prefix),
@@ -1372,10 +1377,6 @@ module Pubid
                            edition: final_edition&.to_s,
                            translation_lang: data[:translation_lang]&.to_s,
                            translation_upper: data[:translation_upper]&.to_s,
-                           # Pass expert_commentary data so ConsolidatedIdentifier can render it
-                           expert_commentary: data[:expert_commentary],
-                           # Pass expert_commentary_topic if present
-                           expert_commentary_topic: data[:expert_commentary_topic],
                            # Pass translation_suffix_type for rendering
                            translation_suffix_type: data[:translation_suffix_type]&.to_s,
                            # Pass reaffirmation_year for rendering
@@ -1389,11 +1390,6 @@ module Pubid
                            edition: final_edition&.to_s,
                            translation_lang: data[:translation_lang]&.to_s,
                            translation_upper: data[:translation_upper]&.to_s,
-                           # Pass expert_commentary data ONLY if no supplements
-                           # When supplements are present, ConsolidatedIdentifier will add ExComm later
-                           expert_commentary: data[:expert_commentary] && extracted_supplements.none?,
-                           # Pass expert_commentary_topic if present and no supplements
-                           expert_commentary_topic: (data[:expert_commentary_topic] if extracted_supplements.none?),
                            # Pass translation_suffix_type for rendering
                            translation_suffix_type: data[:translation_suffix_type]&.to_s,
                            # Pass reaffirmation_year for rendering
@@ -1401,20 +1397,13 @@ module Pubid
                          )
                        end
 
-          # NEW: Wrap with supplements if any were extracted from adopted_string
-          # This must happen BEFORE wrapping with ExpertCommentary so that supplements
-          # render before ExComm suffix
+          # Wrap supplements first (they render before the ExComm suffix), then
+          # wrap the whole thing in a single ExpertCommentary — same shape as the
+          # pure-BSI path, keeping #base_document uniform.
           if extracted_supplements.any?
-            # When supplements are present, wrap with ConsolidatedIdentifier
-            # Pass expert_commentary data so ConsolidatedIdentifier can render it later
-            identifier = wrap_with_consolidated(
-              identifier,
-              extracted_supplements,
-              expert_commentary: data[:expert_commentary],
-              expert_commentary_topic: data[:expert_commentary_topic],
-            )
-          elsif data[:expert_commentary]
-            # When no supplements but ExComm present, wrap with ExpertCommentary
+            identifier = wrap_with_consolidated(identifier, extracted_supplements)
+          end
+          if data[:expert_commentary] || data[:expert_commentary_full]
             identifier = wrap_with_expert_commentary(identifier)
           end
 
@@ -1451,6 +1440,7 @@ expert_commentary: nil, expert_commentary_topic: nil)
               amendment_number: supp[:number],
               amendment_year: year_val&.to_i,
               separator: supp[:separator] || "+",
+              amd_suffix_form: supp[:amd_suffix_form] ? true : false,
             )
           else
             Identifiers::Corrigendum.new(
@@ -1484,6 +1474,9 @@ expert_commentary: nil, expert_commentary_topic: nil)
             number: (supp_data[:amd_number] || supp_data[:cor_number])&.to_s,
             year: (supp_data[:amd_year] || supp_data[:cor_year])&.to_s,
             separator: separator,
+            # The compact "+A"/"/A" amendment rule captures an explicit separator;
+            # the trailing " AMD5" suffix form does not.
+            amd_suffix_form: !(supp_data[:amd_sep_plus] || supp_data[:amd_sep_slash]),
           }
         end
       end

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

@@ -10,10 +10,38 @@ module Pubid
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
         attribute :separator, :string, default: -> { "+" }
+        # true for the trailing " AMD5" / " AMD AA" suffix form, false for the
+        # compact "+A5" / "/A5" join form. Distinguishes the two when no year is
+        # present (previously the presence of a year was a reliable proxy).
+        attribute :amd_suffix_form, :boolean, default: -> { false }
 
         def publisher
           base_identifier&.publisher
         end
+
+        # Base document = the standard this amendment applies to, fully peeled.
+        def base_document
+          base_identifier&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard.
+        def drop_supplements
+          base_identifier || self
+        end
+
+        # Uniform supplement interface (shared with Corrigendum) so callers need
+        # not special-case the class.
+        def supplement_type
+          :amendment
+        end
+
+        def supplement_number
+          amendment_number
+        end
+
+        def supplement_year
+          amendment_year
+        end
       end
     end
   end

data/lib/pubid/bsi/identifiers/consolidated_identifier.rb

@@ -6,7 +6,7 @@ module Pubid
       # Consolidated Identifier - contains base document plus supplements
       # Example: "BS 4592-0:2006+A1:2012" = [BS 4592-0:2006, Amendment 1:2012]
       class ConsolidatedIdentifier < SingleIdentifier
-        attribute :identifiers, ::Pubid::Identifier, polymorphic: true, 
+        attribute :identifiers, ::Pubid::Identifier, polymorphic: true,
                                                      collection: true
 
         def to_urn
@@ -62,6 +62,16 @@ module Pubid
           base = identifiers&.first
           base.type if base&.class&.attributes&.key?(:type)
         end
+
+        # Base document = the wrapped standard (first entry), fully peeled.
+        def base_document
+          identifiers&.first&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard alone.
+        def drop_supplements
+          identifiers&.first || self
+        end
       end
     end
   end

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

@@ -14,6 +14,30 @@ module Pubid
         def publisher
           base_identifier&.publisher
         end
+
+        # Base document = the standard this corrigendum applies to, fully peeled.
+        def base_document
+          base_identifier&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard.
+        def drop_supplements
+          base_identifier || self
+        end
+
+        # Uniform supplement interface (shared with Amendment) so callers need
+        # not special-case the class.
+        def supplement_type
+          :corrigendum
+        end
+
+        def supplement_number
+          corrigendum_number
+        end
+
+        def supplement_year
+          corrigendum_year
+        end
       end
     end
   end

data/lib/pubid/bsi/identifiers/expert_commentary.rb

@@ -25,6 +25,11 @@ module Pubid
         def year
           base_identifier&.year
         end
+
+        # Base document = the commented standard, fully peeled.
+        def base_document
+          base_identifier&.base_document || self
+        end
       end
     end
   end

data/lib/pubid/bsi/identifiers/flex.rb

@@ -20,6 +20,10 @@ module Pubid
           { key: :flex, title: "BSI Flex", short: "BSI Flex" }
         end
 
+        # Base document = the Flex standard without its version (edition).
+        def base_document
+          exclude(:edition)
+        end
       end
     end
   end

data/lib/pubid/bsi/parser.rb

@@ -5,6 +5,19 @@ require "parslet"
 module Pubid
   module Bsi
     class Parser < Parslet::Parser
+      # Case-insensitive string match (Parslet 2.0 has no built-in `stri`).
+      # Each character becomes a two-case character class; other characters
+      # (spaces, punctuation) match verbatim.
+      def stri(string)
+        string.each_char.map do |char|
+          if char =~ /[a-z]/i
+            match["#{char.upcase}#{char.downcase}"]
+          else
+            str(char)
+          end
+        end.reduce(:>>)
+      end
+
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
       rule(:space) { str(" ") }
@@ -296,14 +309,15 @@ module Pubid
       # Single letter (a-z or A-Z) that comes immediately after number or part
       rule(:letter_edition) { match["a-zA-Z"].as(:letter_edition) }
 
-      # Amendment (+A1:2008 or /A2:2019 or /Amd 1:2020 or +A1:15 for short year)
+      # Amendment (+A1:2008 or /A2:2019 or /Amd 1:2020 or +A1:15 for short year,
+      # or +A2 / /A2 without a year — mirrors the optional-year corrigendum rule)
       rule(:amendment) do
         ((plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
           str("A") >> digits.as(:amd_number) >>
-          colon >> digit.repeat(2, 4).as(:amd_year)) |
+          (colon >> digit.repeat(2, 4).as(:amd_year)).maybe) |
           ((plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
             str("Amd") >> space >> digits.as(:amd_number) >>
-            colon >> digit.repeat(4, 4).as(:amd_year))
+            (colon >> digit.repeat(4, 4).as(:amd_year)).maybe)
       end
 
       # Corrigendum (+AC:2009 or +AC1:2008 or /AC1:2005 or +C1:2018 or +C1 without year)
@@ -518,8 +532,8 @@ module Pubid
       # 3. "ExComm (Fire)" (with optional topic suffix)
       rule(:expert_commentary) do
         space >> (
-          str("Expert Commentary").as(:expert_commentary_full) |
-          (str("ExComm") >> (space >> str("(") >> match["A-Za-z"].repeat(1).as(:expert_commentary_topic) >> str(")")).maybe).as(:expert_commentary)
+          stri("Expert Commentary").as(:expert_commentary_full) |
+          (stri("ExComm") >> (space >> str("(") >> match["A-Za-z"].repeat(1).as(:expert_commentary_topic) >> str(")")).maybe).as(:expert_commentary)
         )
       end
 

data/lib/pubid/bsi/renderer.rb

@@ -289,20 +289,21 @@ module Pubid
       end
 
       def render_amendment(id)
-        if id.base_identifier
-          if id.amendment_year
-            "#{id.base_identifier}#{id.separator}A#{id.amendment_number}:#{id.amendment_year}"
-          elsif id.amendment_number&.match?(/^[A-Z]+$/)
-            "#{id.base_identifier} AMD #{id.amendment_number}"
-          else
-            "#{id.base_identifier} AMD#{id.amendment_number}"
-          end
-        elsif id.amendment_year
-          "#{id.separator}A#{id.amendment_number}:#{id.amendment_year}"
-        elsif id.amendment_number&.match?(/^[A-Z]+$/)
-          "AMD #{id.amendment_number}"
+        base = id.base_identifier ? id.base_identifier.to_s : ""
+
+        if id.amd_suffix_form
+          # Trailing " AMD5" / " AMD AA" suffix form
+          suffix = if id.amendment_number&.match?(/^[A-Z]+$/)
+                     " AMD #{id.amendment_number}"
+                   else
+                     " AMD#{id.amendment_number}"
+                   end
+          base.empty? ? suffix.lstrip : "#{base}#{suffix}"
         else
-          "AMD#{id.amendment_number}"
+          # Compact "+A5" / "/A5" join form, with an optional ":year"
+          compact = "#{id.separator}A#{id.amendment_number}"
+          compact += ":#{id.amendment_year}" if id.amendment_year
+          "#{base}#{compact}"
         end
       end
 
@@ -408,15 +409,16 @@ module Pubid
 
         id.identifiers[1..].each do |idd|
           if idd.is_a?(Identifiers::Amendment)
-            if idd.amendment_year
-              sep = idd.separator || "+"
-              result += "#{sep}A#{idd.amendment_number}:#{idd.amendment_year}"
-            else
+            if idd.amd_suffix_form
               result += if idd.amendment_number&.match?(/^[A-Z]+$/)
                           " AMD #{idd.amendment_number}"
                         else
                           " AMD#{idd.amendment_number}"
                         end
+            else
+              sep = idd.separator || "+"
+              result += "#{sep}A#{idd.amendment_number}"
+              result += ":#{idd.amendment_year}" if idd.amendment_year
             end
           elsif idd.is_a?(Identifiers::Corrigendum)
             sep = idd.separator || "+"

data/lib/pubid/iala/builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Builds an IALA identifier object from the Parslet parse tree.
+    class Builder
+      def build(parsed)
+        hash = parsed
+        type_letter = stringify(hash[:type_letter])&.upcase
+
+        attrs = {
+          number:   build_number(hash),
+          edition:  stringify(hash.dig(:edition, :edition_value)),
+          language: stringify(hash.dig(:language_group, :language))&.upcase,
+        }.compact
+
+        Iala.identifier_klass_for_type_letter(type_letter).new(**attrs)
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      # Compose "1070" or "0126-1" from doc_number + optional subpart.
+      def build_number(hash)
+        base = stringify(hash[:doc_number])
+        return base unless hash[:subpart]
+
+        subpart_str = subpart_to_s(hash[:subpart])
+        subpart_str.empty? ? base : "#{base}-#{subpart_str}"
+      end
+
+      # The subpart capture may be an array of {subpart_number: "1"},
+      # {subpart_number: "9"}, … (repeated matches). Join with "-".
+      def subpart_to_s(subpart)
+        return stringify(subpart).to_s unless subpart.is_a?(Array)
+
+        subpart.filter_map { |h| h.is_a?(Hash) ? stringify(h[:subpart_number]) : nil }.join("-")
+      end
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifier.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Base class for all IALA identifiers. Canonical name
+    # Pubid::Iala::Identifier; every concrete IALA identifier
+    # (Identifiers::*) descends from it, and Identifiers::Base — aliased
+    # at the foot of identifiers/base.rb — points back to it.
+    #
+    # IALA identifiers have the form:
+    #   [IALA ]{S|R|G|M|C|X|P}<4-digit number>[-<subpart>][ Ed <edition>][ (<LangLetter>)]
+    #
+    # Examples:
+    #   S1070
+    #   IALA S1070 Ed 2.0
+    #   R1016:ed2.0(F)
+    #   C0103-1 Ed 3.0
+    class Identifier < ::Pubid::Identifier
+      # Parse an IALA identifier string into an identifier object.
+      # @param identifier [String]
+      # @return [Pubid::Iala::Identifier]
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse IALA identifier '#{identifier}': #{e.message}"
+      end
+
+      attribute :publisher, :string, default: "IALA"
+      attribute :number,    :string    # "1070", "0126", "0103-1"
+      attribute :edition,   :string    # "2.0", "1.3", nil
+      attribute :language,  :string    # "E", "F", "S", "C", "A", "R", nil
+
+      IALA_TYPE_MAP = {
+        "pubid:iala:standard"       => "Pubid::Iala::Identifiers::Standard",
+        "pubid:iala:recommendation" => "Pubid::Iala::Identifiers::Recommendation",
+        "pubid:iala:guideline"      => "Pubid::Iala::Identifiers::Guideline",
+        "pubid:iala:manual"         => "Pubid::Iala::Identifiers::Manual",
+        "pubid:iala:model-course"   => "Pubid::Iala::Identifiers::ModelCourse",
+        "pubid:iala:report"         => "Pubid::Iala::Identifiers::Report",
+        "pubid:iala:resolution"     => "Pubid::Iala::Identifiers::Resolution",
+      }.freeze
+
+      key_value do
+        map "_type",    to: :_type, polymorphic_map: IALA_TYPE_MAP
+        map "number",   to: :number
+        map "edition",  to: :edition
+        map "language", to: :language
+      end
+
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
+
+      # Single-letter type code (S, R, G, …) — convenience accessor used
+      # by Renderer and UrnGenerator.
+      def type_letter
+        self.class.type[:short]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Backward-compatible alias: IALA's base class used to be
+# Pubid::Iala::Identifiers::Base. It is now Pubid::Iala::Identifier
+# (defined in identifier.rb), which is loaded by the parent autoload.
+require_relative "../identifier" unless defined?(Pubid::Iala::Identifier)
+
+module Pubid
+  module Iala
+    module Identifiers
+      Base = Pubid::Iala::Identifier
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Guidelines (G series).
+      # Examples: G1015 Ed 2.2, G1078 Ed 2.1.
+      class Guideline < Base
+        def self.type
+          { key: :guideline, title: "Guideline", short: "G" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Manuals (M prefix, planned).
+      # Today manuals carry no code (NAVGUIDE, VTS Manual, …); M is
+      # reserved for future numbered manuals.
+      class Manual < Base
+        def self.type
+          { key: :manual, title: "Manual", short: "M" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Model Courses (C series).
+      # Examples: C0103-1 Ed 3.0, C2001-1 Ed 1.0.
+      class ModelCourse < Base
+        def self.type
+          { key: :"model-course", title: "Model Course", short: "C" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Recommendations (R series).
+      # Examples: R0103 Ed 3.1, R0126 Ed 2.0, R1024 Ed 1.0.
+      class Recommendation < Base
+        def self.type
+          { key: :recommendation, title: "Recommendation", short: "R" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Reports & Proceedings (X prefix, planned).
+      # Today reports carry no code; X is reserved for future numbered
+      # reports.
+      class Report < Base
+        def self.type
+          { key: :report, title: "Report", short: "X" }
+        end
+      end
+    end
+  end
+end

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,6 +120,13 @@ 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
@@ -311,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,
@@ -362,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.pre.alpha.5"
+  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.5
+  version: 2.0.0.pre.alpha.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-06 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