pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

data/lib/pubid/iana/renderer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Human-readable renderer for IANA registry identifiers.
+    #
+    # Produces the authoritative printed form:
+    #   "IANA _6lowpan-parameters"
+    #   "IANA _6lowpan-parameters/lowpan_nhc"
+    #
+    # With `with_publisher: false` on the identifier it renders the bare
+    # index-key slug instead (no "IANA " token).
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "IANA"
+
+      def render(**_opts)
+        id = @id
+        code = id.code
+        with_publisher?(id) ? "#{PUBLISHER} #{code}" : code
+      end
+
+      private
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/iana/urn_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Emits `urn:iana:<registry>[:<sub_registry>]`. Slugs contain no ":"
+    # (charset is [a-zA-Z0-9._-]), so the two levels split unambiguously.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "iana", identifier.registry]
+        parts << identifier.sub_registry if identifier.sub_registry
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/iana/urn_parser.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    # Parses IANA URNs back into identifiers.
+    #
+    # UrnGenerator emits `urn:iana:<registry>[:<sub_registry>]`; this rebuilds
+    # the bare slug and delegates to the flavor's text parser (which normalizes
+    # it back to the "IANA "-prefixed printed form).
+    #
+    # Examples:
+    # - urn:iana:calipso -> IANA calipso
+    # - urn:iana:_6lowpan-parameters:lowpan_nhc
+    #     -> IANA _6lowpan-parameters/lowpan_nhc
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        registry, sub_registry = split_parts(body)
+        slug = sub_registry ? "#{registry}/#{sub_registry}" : registry
+        flavor_parse(slug)
+      end
+    end
+  end
+end

data/lib/pubid/iana.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iana
+    extend Pubid::PrefixesSupport
+
+    # Sole IANA publisher token (see the parser's optional `IANA ` prefix).
+    # IANA entries are protocol registries whose printed form always leads with
+    # the "IANA" token; routing relies on it since the raw slug carries no
+    # publisher.
+    PREFIXES = ["IANA"].freeze
+
+    autoload :Builder, "#{__dir__}/iana/builder"
+    autoload :Identifier, "#{__dir__}/iana/identifier"
+    autoload :Identifiers, "#{__dir__}/iana/identifiers"
+    autoload :Parser, "#{__dir__}/iana/parser"
+    autoload :Renderer, "#{__dir__}/iana/renderer"
+    autoload :UrnGenerator, "#{__dir__}/iana/urn_generator"
+    autoload :UrnParser, "#{__dir__}/iana/urn_parser"
+
+    # Parse an IANA identifier string
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iana::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    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
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register IANA flavor with the registry
+Pubid::Registry.register(:iana, Pubid::Iana)

data/lib/pubid/identifier.rb

@@ -13,27 +13,53 @@ module Pubid
       # `key_value` polymorphic_map reads `_type` only to VALIDATE; it does not
       # re-instantiate the concrete subclass. So a base-class `from_hash` would
       # return a bare base object and drop subtype-specific attributes (e.g. a
-      # supplement's base_identifier). Route by `_type` to the concrete class
+      # supplement's base). Route by `_type` to the concrete class
       # named in `polymorphic_type_map`, then let its inherited from_hash (this
       # method again, where klass == self) fall through to lutaml's real work.
       #
       # This generalizes the per-flavor `*_TYPE_MAP` dispatch that ISO, JIS,
       # IEC, CCSDS and IHO each hand-rolled — one implementation, inherited by
-      # every flavor base.
+      # every flavor base. Cross-flavor dispatch (a nested adopted identifier
+      # whose _type belongs to a different flavor) is delegated to
+      # {TypeResolver}, which knows about every registered flavor.
       def from_hash(data, options = {})
-        type = data && (data["_type"] || data[:_type])
-        klass = polymorphic_type_map[type]
+        klass = concrete_class_for(data)
         return klass.from_hash(data, options) if klass && klass != self
-
         super
       end
 
+      # lutaml's nested polymorphic cast (Attribute#cast → apply_mappings)
+      # bypasses {from_hash}, so cross-flavor dispatch wouldn't fire for a
+      # nested attribute that carries another flavor's _type. Intercept
+      # apply_mappings and route to {from_hash} so the concrete class's own
+      # mappings (with their flavor-specific custom cast methods, e.g. ISO's
+      # number_from_kv) drive deserialization.
+      def apply_mappings(doc, format, options = {})
+        return super unless hash_with_type?(doc, format)
+
+        klass = concrete_class_for(doc)
+        return super unless klass && klass != self
+
+        klass.from_hash(doc, options)
+      end
+
+      # Resolve a polymorphic _type to the concrete class that owns it:
+      # this flavor's own map first, then any registered flavor's map via
+      # {TypeResolver}. Returns nil for blank or unknown types.
+      def concrete_class_for(data)
+        type = data && (data["_type"] || data[:_type])
+        return nil unless type
+
+        polymorphic_type_map[type] || ::Pubid::TypeResolver.resolve(type)
+      end
+
       # Map of polymorphic_name ("pubid:iso:corrigendum") => concrete class for
       # the flavor this base belongs to. Built once by scanning the flavor's
       # `Identifiers` namespace for Pubid::Identifier descendants and unioning
       # the flavor's `identifier_types` registry (which may register classes
       # living outside that namespace, e.g. ISO's BundledIdentifier). Memoized
-      # per class.
+      # per class. Public so {TypeResolver} can read another flavor's map for
+      # cross-flavor polymorphic dispatch.
       def polymorphic_type_map
         @polymorphic_type_map ||=
           identifier_registry_classes.each_with_object({}) do |klass, map|
@@ -44,6 +70,12 @@ module Pubid
 
       private
 
+      def hash_with_type?(doc, format)
+        format == :hash && doc.is_a?(Hash) && (doc["_type"] || doc[:_type])
+      end
+
+      private
+
       # The flavor module namespacing this base, e.g. Pubid::Iso for
       # Pubid::Iso::Identifier (and for the inherited Pubid::Iso::Identifiers::
       # Corrigendum). Always the first two name components, so it is stable
@@ -115,8 +147,8 @@ module Pubid
     attribute :locality, Components::Locality
     attribute :typed_stage, Components::TypedStage
     attribute :all_parts, Lutaml::Model::Type::Boolean, default: false
-    # base_identifier is declared by supplement subclasses with proper type
-    def base_identifier
+    # base is declared by supplement subclasses with proper type
+    def base
       nil
     end
 
@@ -229,7 +261,7 @@ module Pubid
     end
 
     def root
-      return base_identifier.root if base_identifier
+      return base.root if base
 
       self
     end
@@ -246,8 +278,13 @@ module Pubid
         raise ArgumentError, "No renderer registered for format: #{format}"
       end
 
-      context = build_rendering_context(renderer, format:, **opts)
-      renderer.new(self).render(context:, **opts.slice(:with_edition))
+      # `:trademark` is a render-time flag consumed by the renderer, not the
+      # rendering context — and some flavors override build_rendering_context
+      # with a strict signature, so strip it here.
+      ctx_opts = opts.except(:trademark)
+      context = build_rendering_context(renderer, format:, **ctx_opts)
+      render_opts = opts.slice(:with_edition, :trademark)
+      renderer.new(self).render(context:, **render_opts)
     end
 
     def to_s(**opts)
@@ -258,38 +295,103 @@ module Pubid
       render(format: :mr_string)
     end
 
-    # MR string template methods — flavors override as needed
+    # Filesystem-/URL-safe slug derived from the MR string. Defaults to
+    # `to_mr_string` because every flavor except NIST already emits an
+    # all-lowercase, filename-safe MR (only `[a-z0-9.-]` characters, plus
+    # `_` as the supplement separator and `-` as the copublisher separator).
+    # Flavors whose MR is not slug-safe (notably NIST, whose MR format is
+    # fixed by the pubid standard) override this to project the MR into a
+    # slug-safe form.
+    def to_slug
+      to_mr_string
+    end
+
+    # MR string template methods — flavors override as needed.
+    #
+    # The MR format is a lossless, dot-separated, all-lowercase, filename-safe
+    # slug mirroring `to_s`'s structure:
+    #
+    #   {publisher}[-{copublisher}…][.{type}].{number}[-{part}[-{subpart}…]]
+    #   [.{year}[-{month}[-{day}]]|’--’}][.{edition}][.{language}-{language}…]
+    #   [.all-parts][_supplements…]
+    #
+    # Supplements append `_{type}.{number}.{year}` recursively, so a chained
+    # supplement like `…/Amd 3:2016/Cor 1:2017` round-trips as
+    # `…_amd.3.2016_cor.1.2017`. Copublishers join with `-`
+    # (`iso-iec.17031-1.2020`) so the slug never contains a path separator.
+    # Distinct identifiers never collide on `to_mr_string` (issue #142).
     def mr_publisher
-      publisher&.to_s
+      publisher&.to_s&.downcase&.tr("/", "-")
     end
 
     def mr_type
       return nil unless typed_stage
 
       code = typed_stage.type_code
-      return nil if code.nil? || code.empty? || code == "is"
+      return nil if code.nil? || code.empty? || code.to_s == "is"
 
-      code
+      code.to_s.downcase
     end
 
     def mr_number_with_part
       num = mr_number
       return nil unless num
 
-      prt = mr_part
-      prt ? "#{num}-#{prt}" : num
+      segments = [num]
+      segments << mr_part if part
+      segments << mr_subpart if subpart
+      segments.compact.join("-").downcase
     end
 
     def mr_number
-      number&.to_s
+      number&.to_s&.downcase
     end
 
     def mr_part
-      part&.to_s
+      part&.to_s&.downcase
+    end
+
+    def mr_subpart
+      subpart&.to_s&.downcase
     end
 
     def mr_year
-      date&.year&.to_s
+      return nil unless date
+      return "--" if date.respond_to?(:undated?) && date.undated?
+      return nil unless date.year
+
+      result = date.year.to_s
+      result += "-#{date.month}" if date.respond_to?(:month) && date.month
+      result += "-#{date.day}" if date.respond_to?(:day) && date.day
+      result
+    end
+
+    def mr_edition
+      return nil unless edition&.number
+
+      "ed#{edition.number}"
+    end
+
+    def mr_languages
+      return nil unless languages&.any?
+
+      # Hyphen-joined, no parens — parens are shell-/URL-unsafe.
+      languages.map { |l| l.code.to_s.downcase }.join("-")
+    end
+
+    def mr_all_parts
+      return nil unless all_parts
+
+      "all-parts"
+    end
+
+    # Hook: supplement / wrapper subclasses return the `{type}.{number}.{year}`
+    # suffix that distinguishes them from their base. `nil` for non-supplements.
+    # The base MrString renderer recurses into `base` whenever this returns
+    # a non-nil value, so chained supplements (Cor → Amd → IS) render fully.
+    # The suffix is appended with `_` (not `/`) so the MR stays filename-safe.
+    def mr_supplement_suffix
+      nil
     end
 
     # URN template methods — flavors override as needed
@@ -332,14 +434,21 @@ module Pubid
       end
 
       excluded_args = args.dup
-      # Map :year to :date since identifiers store years inside date
-      excluded_args << :date if excluded_args.delete(:year)
+      # Map :year to :date (year-in-date flavors), but ALSO keep :year so a
+      # flavor that models the edition as a plain `year` attribute (e.g. GOST)
+      # has it excluded too. The loop below nils whichever name the flavor has.
+      excluded_args << :date if excluded_args.include?(:year)
 
       attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
         value = excluded_args.include?(name) ? nil : public_send(name)
         h[name] = exclude_from_nested(value, args)
       end
-      self.class.new(attrs)
+      # Splat the rebuilt attributes as keywords. Flavors whose identifier
+      # #initialize is keyword-only (ITU, IEEE, …) would raise ArgumentError on
+      # a positional hash under Ruby 3 kwarg separation; the base
+      # initialize(attrs = {}, options = {}) still accepts **attrs because Ruby
+      # passes keywords to a no-keyword method as a trailing positional Hash.
+      self.class.new(**attrs)
     end
 
     # The standard this identifier supplements, dropping its own supplement
@@ -388,6 +497,84 @@ module Pubid
       false
     end
 
+    # --- Relational algebra (pubid/pubid#247) ---
+    # Each predicate returns true / false. Predicates that don't apply to
+    # this identifier type (e.g. supplement checks on a non-wrapper) return
+    # false rather than raising. This makes them safe for chain-of-checks
+    # patterns like `id.related_to?(other)`.
+
+    # Self is a supplement (amendment / corrigendum / errata / supplement)
+    # of +other+. Self must be a wrapper (has a +base+ attribute) whose
+    # inner base equals +other+.
+    def supplement_of?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+      return false unless self.class.attributes.key?(:base)
+
+      base == other
+    end
+
+    # Inverse of #supplement_of? — self is the base document and +other+
+    # is a supplement attached to it.
+    def has_supplement?(other)
+      other.is_a?(::Pubid::Identifier) && other.supplement_of?(self)
+    end
+
+    # Self and +other+ refer to the same document but differ only in the
+    # trailing date / year — the "dated vs undated" reference pattern.
+    def dated_version_of?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+
+      matches?(other, ignore: [:date, :year]) && self != other
+    end
+
+    # Self and +other+ have the same publisher + number but differ in
+    # part, subpart, or edition. This is the "sibling documents" pattern:
+    # same base standard, different sub-component.
+    def sibling_of?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+
+      publisher == other.publisher &&
+        number == other.number &&
+        self != other
+    end
+
+    # Self is an all-parts collection that covers +other+.
+    def includes?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+      return false unless all_parts
+
+      root == other.root
+    end
+
+    # Self is a draft version of +other+ (the published identifier).
+    # IEEE uses draft_status + draft; ISO/IEC use typed_stage.
+    def draft_of?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+
+      root == other.root &&
+        self != other &&
+        matches?(other, ignore: [:date, :year, :stage, :typed_stage])
+    end
+
+    # Self and +other+ have the same publisher + number + part but differ
+    # in edition / revision marker.
+    def edition_of?(other)
+      return false unless other.is_a?(::Pubid::Identifier)
+
+      publisher == other.publisher &&
+        number == other.number &&
+        part == other.part &&
+        self != other
+    end
+
+    # Any relational predicate holds.
+    def related_to?(other)
+      %i[supplement_of? has_supplement? dated_version_of? edition_of?
+         sibling_of? includes? draft_of?].any? do |m|
+        public_send(m, other)
+      end
+    end
+
     def hash
       @hash ||= compute_hash
     end

data/lib/pubid/idf/builder.rb

@@ -32,7 +32,7 @@ module Pubid
 
       def cast(type, value)
         case type
-        when :base_identifier
+        when :base
           build(value)
         when :publisher
           Components::Publisher.new(body: value)

data/lib/pubid/idf/parser.rb

@@ -117,7 +117,7 @@ module Pubid
       # IDF 148-1:2008 / COR 1:2009
       # IDF 140-1:2007 / AMD1:2012 (no space between AMD and 1)
       rule(:supplement_identifier_no_third) do
-        identifier_publisher_no_third.as(:base_identifier) >>
+        identifier_publisher_no_third.as(:base) >>
           space? >> str("/") >> space? >>
           supplement_type_with_stage >>
           space.maybe >> second_part
@@ -130,7 +130,7 @@ module Pubid
       # # ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
       # # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
       # rule(:supplement_supplement_identifier) do
-      #   supplement_identifier_no_third.as(:base_identifier) >>
+      #   supplement_identifier_no_third.as(:base) >>
       #     str("/") >> supplement_type_with_stage >>
       #     # digits.as(:stage_iteration).maybe >>
       #     space? >> second_part >> third_part

data/lib/pubid/idf/renderer.rb

@@ -70,7 +70,7 @@ module Pubid
         with_edition = opts[:with_edition] || false
 
         [
-          id.base_identifier.to_s(lang: lang, lang_single: lang_single,
+          id.base.to_s(lang: lang, lang_single: lang_single,
                                    with_edition: with_edition),
           "/",
           id.typed_stage.abbreviation,

data/lib/pubid/idf/supplement_identifier.rb

@@ -12,15 +12,15 @@ module Pubid
     # SingleIdentifier (which is for base documents only).
     #
     # Architecture Note:
-    # - Supplements have a base_identifier attribute (recursive structure)
+    # - Supplements have a base attribute (recursive structure)
     # - Supplements share the to_s rendering pattern
     # - Supplements inherit typed_stage from base Identifier class
     class SupplementIdentifier < Identifier
-      attribute :base_identifier, Identifier
+      attribute :base, Identifier
 
       # Render supplement identifier as string.
       #
-      # Format: "base_identifier/ABBREVIATION number:year"
+      # Format: "base/ABBREVIATION number:year"
       # Example: "IDF 125:1988/AMD 1:2023"
       #
       # @param lang [Symbol] Language (default: :en)