pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.9

data/lib/pubid/isbn/parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Isbn
+    # Parslet grammar for ISBN identifiers per ISO 2108.
+    #
+    # Accepts:
+    #   [ISBN[ |:]] {10 or 13 digits with optional hyphens}
+    #
+    # ISBN-10 final digit may be "X" (check digit value 10). Hyphens are
+    # optional and may appear in any group position; they are preserved
+    # for round-trip rendering.
+    class Parser < Parslet::Parser
+      rule(:space)   { str(" ") }
+      rule(:colon)   { str(":") }
+      rule(:hyphen)  { str("-") }
+      rule(:digit)   { match("[0-9]") }
+      rule(:x_digit) { digit | str("X") }
+
+      rule(:isbn_prefix) do
+        (str("ISBN") >> (space | (space.maybe >> colon >> space.maybe))).maybe
+      end
+
+      rule(:digit_group) { digit.repeat(1) }
+      rule(:x_group)     { x_digit.repeat(1) }
+
+      # Loose "ISBN-ish" token: digits or final X, separated by hyphens.
+      rule(:isbn_body) do
+        (digit_group >> (hyphen >> digit_group).repeat >>
+          (hyphen >> x_digit).maybe).as(:body) |
+          (digit.repeat(9, 12) >> x_digit.maybe).as(:body)
+      end
+
+      rule(:identifier) { isbn_prefix >> isbn_body }
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/isbn/renderer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Human-readable renderer for ISBN identifiers.
+    #
+    # Preserves the original hyphenation when present; otherwise emits the
+    # bare digits. Always emits the "ISBN " prefix.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        body = @id.hyphenated || @id.raw
+        "ISBN #{body}"
+      end
+    end
+  end
+end

data/lib/pubid/isbn.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  # ISBN flavor — bibliographic book identifier per ISO 2108.
+  #
+  # Parses both 10-digit (ISBN-10) and 13-digit (ISBN-13) forms with
+  # optional hyphenation. The check digit is validated; an invalid check
+  # digit raises on parse.
+  module Isbn
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["ISBN"].freeze
+
+    autoload :CheckDigit, "#{__dir__}/isbn/check_digit"
+    autoload :Builder, "#{__dir__}/isbn/builder"
+    autoload :Identifier, "#{__dir__}/isbn/identifier"
+    autoload :Identifiers, "#{__dir__}/isbn/identifiers"
+    autoload :Parser, "#{__dir__}/isbn/parser"
+    autoload :Renderer, "#{__dir__}/isbn/renderer"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Isbn::Renderer)
+
+    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.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    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
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    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
+  end
+end
+
+Pubid::Registry.register(:isbn, Pubid::Isbn)

data/lib/pubid/iso/builder.rb

@@ -16,7 +16,7 @@ module Pubid
 
       def locate_identifier_klass(parsed_hash)
         # If there is a joint_identifier, we need to use a CombinedIdentifier
-        # which takes `base_identifier` and `additional_identifiers`
+        # which takes `base` and `additional_identifiers`
         if parsed_hash[:joint_identifier]
           return CombinedIdentifier
         end
@@ -47,7 +47,7 @@ module Pubid
         # a) It is an IS.
         # b) It is a Directive Supplements. The "SUP" keyword may be entirely missing, and hence nil. If the base type_with_stage is a directive, then if the type_with_stage is blank, it is a directive supplement.
 
-        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base_identifier] && parsed_hash[:base_identifier][:type_with_stage] == "DIR"
+        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base] && parsed_hash[:base][:type_with_stage] == "DIR"
           # Directive Supplement without "SUP" keyword
           parsed_hash[:type_with_stage] = "SUP"
         end
@@ -150,12 +150,12 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base_identifier
+        when :base
           # If it has a base identifier, we need to build a supplement
           # We assume that the base identifier is already a valid Identifier object
           build(value)
 
-          # If there is a base_identifier, and it has a joint_identifier, we need to use a CombinedIdentifier.
+          # If there is a base, and it has a joint_identifier, we need to use a CombinedIdentifier.
 
         when :publisher, :directives_supplement_body, :supplement_publisher
           # value can be either a string OR a hash with publisher + copublisher
@@ -230,6 +230,11 @@ module Pubid
         when :date
           parse_date(value)
 
+        when :undated_marker
+          # ISO/IEC undated reference (e.g. "ISO 16634:--") — explicit
+          # publication-date slot with no year; round-trips via date.render.
+          { date: Pubid::Components::Date.new(undated: true) }
+
         when :edition
           # value can be "Ed.2", "Ed 2", "ED1", "Edition 13", or just "Ed"
           original_text = value.to_s

data/lib/pubid/iso/combined_identifier.rb

@@ -4,14 +4,14 @@ module Pubid
   module Iso
     # Identifier that represents a supplement to a base identifier.
     class CombinedIdentifier < Identifier
-      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :base, Identifier, polymorphic: true
       attribute :additional_identifiers, ::Pubid::Identifier,
                 polymorphic: true, collection: true
       attribute :type, :string, default: -> { "combined_identifier" }
 
       def to_s(lang: :en, lang_single: false)
         [
-          base_identifier.to_s(lang: lang, lang_single: lang_single),
+          base.to_s(lang: lang, lang_single: lang_single),
           additional_identifiers.map do |id|
             id.to_s(lang: lang, lang_single: lang_single)
           end,

data/lib/pubid/iso/identifier.rb

@@ -103,7 +103,7 @@ module Pubid
       # The base Pubid::Identifier no longer auto-maps attributes, so each
       # flavor's top class must declare its own key_value mapping. Subclasses
       # merge their own blocks on top of this one (e.g. SupplementIdentifier
-      # adds base_identifier; Directives adds subgroup), so list every base
+      # adds base; Directives adds subgroup), so list every base
       # attribute ISO serializes here once.
       key_value do
         map "_type", to: :_type, polymorphic_map: ISO_TYPE_MAP
@@ -117,6 +117,9 @@ module Pubid
         map "year", with: { to: :year_to_kv, from: :year_from_kv }
         map "month", with: { to: :month_to_kv, from: :month_from_kv }
         map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        # ISO/IEC undated reference (e.g. ISO 16634:--). The `false` default
+        # is omitted; only the meaningful `true` round-trips via to_hash.
+        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
         map "edition", to: :edition
         map "languages", to: :languages
         # publisher emitted only when the primary isn't the type default;
@@ -217,6 +220,19 @@ module Pubid
       def day_to_kv(model, doc) = emit_date_part(doc, "day", model.date&.day)
       def day_from_kv(model, value) = date_for(model).day = value.to_s
 
+      # --- date undated flag (ISO/IEC undated reference, e.g. ISO 16634:--) ---
+      # The `false` default is omitted; only the meaningful `true` round-trips
+      # via to_hash / from_hash.
+      def undated_to_kv(model, doc)
+        return unless model.date&.undated?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
+      end
+
+      def undated_from_kv(model, value)
+        date_for(model).undated = value.to_s == "true"
+      end
+
       def emit_date_part(doc, key, val)
         return if val.nil? || val.to_s.empty?
 

data/lib/pubid/iso/identifiers/directives_supplement.rb

@@ -35,11 +35,11 @@ module Pubid
 
         # Delegate base identifier attributes for easier access
         def copublishers
-          base_identifier&.copublishers
+          base&.copublishers
         end
 
         def publisher
-          base_identifier&.publisher
+          base&.publisher
         end
 
         TYPED_STAGES = [
@@ -61,7 +61,7 @@ module Pubid
         # def render_directives_supplement_identifier(identifier)
         #   raise "Not a directives supplement identifier" unless identifier.is_a?(Identifiers::DirectivesSupplement)
 
-        #   render(identifier.base_identifier) +
+        #   render(identifier.base) +
         #     " #{identifier.publisher.body}" +
         #     " #{identifier.stage.abbr}" +
         #     (identifier.date ? ":#{identifier.date.year}" : "")
@@ -69,10 +69,10 @@ module Pubid
 
         def to_s(lang: :en, lang_single: false, with_edition: false,
 format: nil, stage_format_long: nil, with_date: nil)
-          if base_identifier
+          if base
             # Full rendering with base identifier
             [
-              base_identifier.to_s(lang: lang, lang_single: lang_single,
+              base.to_s(lang: lang, lang_single: lang_single,
                                    with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date),
               " #{supplement_publisher.render}",
               " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
@@ -107,8 +107,8 @@ format: nil, stage_format_long: nil, with_date: nil)
         def to_urn
           urn_ctx = Rendering::RenderingContext.urn
 
-          # If this is a standalone supplement (no base_identifier), build URN directly
-          unless base_identifier
+          # If this is a standalone supplement (no base), build URN directly
+          unless base
             parts = ["urn", "iso", "doc"]
             parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
             parts << "sup"
@@ -118,7 +118,7 @@ format: nil, stage_format_long: nil, with_date: nil)
           end
 
           # Start with base identifier's URN parts (it will use urn:iso:doc scheme)
-          base_urn = base_identifier.to_urn
+          base_urn = base.to_urn
 
           # Handle JTC pattern specially
           if supplement_publisher&.body&.match?(/^JTC\s+(\d+)$/i)

data/lib/pubid/iso/normalizer.rb

@@ -69,10 +69,10 @@ module Pubid
           supplement_year = match[4]   # "1987" or nil
 
           base_parsed = Pubid::Iso.parser.parse(base_str)
-          base_identifier = Pubid::Iso.builder.build(base_parsed)
+          base = Pubid::Iso.builder.build(base_parsed)
 
           addendum = Identifiers::Addendum.new
-          addendum.base_identifier = base_identifier
+          addendum.base = base
           addendum.number = Iso::Components::Code.new(value: supplement_number)
           addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
 

data/lib/pubid/iso/parser.rb

@@ -99,7 +99,7 @@ module Pubid
       rule(:iso_r_supplement_identifier) do
         (
           str("ISO/R").as(:iso_r_prefix) >> space >> iso_r_second_part
-        ).as(:base_identifier) >>
+        ).as(:base) >>
           iso_r_supplement_separator >>
           supplement_type_with_stage >>
           space? >> second_part >> third_part
@@ -148,12 +148,16 @@ module Pubid
       end
 
       rule(:date) do
-        # :2005-02
+        # :2005-02 or :-- (undated reference — ISO/IEC undated-reference form,
+        # e.g. ISO 16634:--, also accepted as the em-dash variant ISO 16634:—)
         (str(":") | dash) >>
-          (year_digits >>
-            (dash >> month_digits).maybe >>
-            (dash >> day_digits).maybe
-          ).as(:date).maybe
+          (
+            (str("--") | str("—")).as(:undated_marker) |
+              (year_digits >>
+                (dash >> month_digits).maybe >>
+                (dash >> day_digits).maybe
+              ).as(:date)
+          ).maybe
       end
 
       rule(:part_and_subpart) do
@@ -270,14 +274,14 @@ module Pubid
       end
 
       # For joint identifiers, we do not treat it as a supplementary identifier
-      # (hence not a base_identifier)
+      # (hence not a base)
       # ISO only supports IDF in joint identifiers
       # ISO 5537|IDF 26
       # ISO 17678|IDF 202:2010
       # ISO/TS 4985:2023 | IDF/RM 255
       # ISO 4214:2022 | IDF 254:2022
       rule(:joint_identifier) do
-        identifier_copublishers_no_third.as(:base_identifier) >>
+        identifier_copublishers_no_third.as(:base) >>
           space? >> str("|") >> space? >>
           scope { idf_identifier }.as(:joint_identifier)
       end
@@ -336,7 +340,7 @@ module Pubid
       # ISO 8601-1:2019/Amd 2:2024
       # ISO/IEC 10646-1:1993/pDCOR.2 (legacy dot-prefixed format)
       rule(:supplement_identifier_no_third) do
-        identifier_copublishers_no_third.as(:base_identifier) >>
+        identifier_copublishers_no_third.as(:base) >>
           str("/") >> supplement_type_with_stage >>
           # The trailing number/date is optional: some draft supplements have no
           # number yet, e.g. "ISO/IEC 9579/WD Amd".
@@ -351,14 +355,14 @@ module Pubid
       # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
       # ISO/IEC 10646-1:1993/pDCOR.2 (legacy dot-prefixed format)
       rule(:supplement_supplement_identifier) do
-        supplement_identifier_no_third.as(:base_identifier) >>
+        supplement_identifier_no_third.as(:base) >>
           str("/") >> supplement_type_with_stage >>
           ((space? >> second_part >> third_part) | (str(".") >> digits.as(:number) >> third_part))
       end
 
       # ISO 12345:2020/Amd 1:2021/Cor 1:2022/Amd 2:2023 (three-level supplement)
       rule(:supplement_supplement_supplement_identifier) do
-        supplement_supplement_identifier.as(:base_identifier) >>
+        supplement_supplement_identifier.as(:base) >>
           str("/") >> supplement_type_with_stage >>
           ((space? >> second_part >> third_part) | (str(".") >> digits.as(:number) >> third_part))
       end
@@ -408,7 +412,7 @@ module Pubid
       end
 
       rule(:directives_supplement_identifier) do
-        directives_identifier_no_third.as(:base_identifier) >> space? >> directives_supplement_part
+        directives_identifier_no_third.as(:base) >> space? >> directives_supplement_part
       end
 
       DIRECTIVES_SUPPLEMENTS_TYPED_STAGES = Identifiers::DirectivesSupplement::TYPED_STAGES.map(&:abbr).flatten.sort_by(&:length).reverse

data/lib/pubid/iso/supplement_identifier.rb

@@ -3,13 +3,13 @@
 module Pubid
   module Iso
     class SupplementIdentifier < SingleIdentifier
-      attribute :base_identifier, Identifier,
+      attribute :base, Identifier,
                 polymorphic: true
 
       key_value do
         # Serialized key is "base" (matches JIS); the attribute/method stays
-        # `base_identifier`, which relaton-index's get_id_number depends on.
-        map "base", to: :base_identifier, polymorphic: {
+        # `base`, which relaton-index's get_id_number depends on.
+        map "base", to: :base, polymorphic: {
           attribute: "_type",
           class_map: Identifier::ISO_TYPE_MAP,
         }
@@ -20,14 +20,14 @@ module Pubid
       # nested supplement (e.g. ".../Amd 1/Cor 1") reads identity from the
       # underlying standard in one hop, regardless of chain depth. This keeps a
       # parsed supplement and a from_hash-deserialized one in agreement (== and
-      # index matching compare both). Guard on base_identifier: `root` returns
+      # index matching compare both). Guard on base: `root` returns
       # self when there is no base, which would otherwise recurse forever.
       def publisher
-        root.publisher if base_identifier
+        root.publisher if base
       end
 
       def copublishers
-        root.copublishers if base_identifier
+        root.copublishers if base
       end
 
       def to_s(**opts)
@@ -35,6 +35,19 @@ module Pubid
         Pubid::Renderers::SupplementRenderer.new(self).render(context:,
                                                               **opts.slice(:with_edition))
       end
+
+      # MR supplement suffix: `/{type}.{number}.{year}` (e.g. "/amd.1.2020").
+      # The MrString renderer recurses into `base` and appends this so the
+      # full supplement chain round-trips losslessly (issue #142).
+      def mr_supplement_suffix
+        segments = []
+        segments << mr_type if mr_type
+        segments << number&.to_s if number
+        segments << date&.year&.to_s if date&.year
+        return nil if segments.empty?
+
+        segments.join(".")
+      end
     end
   end
 end

data/lib/pubid/iso/urn_generator.rb

@@ -84,7 +84,7 @@ module Pubid
 
         while current.is_a?(SupplementIdentifier)
           supplement_chain.unshift(current)
-          current = current.base_identifier
+          current = current.base
         end
 
         base_id = current
@@ -258,6 +258,9 @@ module Pubid
 
       def year_component
         return nil unless identifier.date&.present?
+        # Undated references (e.g. ISO 16634:--) drop the year slot in the URN,
+        # matching the date-less identifier's URN form (per issue #138).
+        return nil if identifier.date&.undated?
         return nil if identifier.is_a?(Pubid::Iso::SingleIdentifier)
 
         identifier.date.render(context: URN_CONTEXT)

data/lib/pubid/iso/urn_parser.rb

@@ -425,7 +425,7 @@ typed_stage
 
           # Wrap current identifier with supplement
           base_hash = {
-            base_identifier: base_hash,
+            base: base_hash,
             **supp_hash,
           }
         end