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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd077b48356a46dfb52d7b95e932c29e91e5fe1a7859c1128ddda22d768b4a96
-  data.tar.gz: 4e8059d20bed9297393f54bb894958a6c0ab8d92bef895fcb7528c291b3ff349
+  metadata.gz: 1b1fa5f38da07bc9a507c0c507ba9ddfc8f6541ab9f4b6793b09abe302ab8849
+  data.tar.gz: 63b7eba9c9942c177e95b9c78a09462679a11acde4fd6a2c2e486848fb43ca93
 SHA512:
-  metadata.gz: 329f3776c53f4021bfd2d25bd8698fb9c01309a66f56e9334d815aee3fde8ce25b509637f97ffc4ef91f0dfb67d10768a33505a939109a305d34b2e917af8f6c
-  data.tar.gz: 79c43b4e3ca83fe379a588f20490850e6a88757e382f0f9b9fc88d9f31923aff8fd8a5d48670c33a0d0705747820c6b3548260334ebf4e63a09b60dab82ad4ec
+  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