pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

data/lib/pubid/urn_generator/base.rb

@@ -6,6 +6,9 @@ module Pubid
     # Provides template methods for common URN parts.
     # Flavors subclass and override only what differs.
     class Base
+      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
+      private_constant :URN_CONTEXT
+
       attr_reader :identifier
 
       def initialize(identifier)
@@ -35,7 +38,7 @@ module Pubid
         pub = maybe(:publisher)
         return nil unless pub
 
-        pub.to_s.downcase
+        pub.is_a?(Components::Publisher) ? pub.render(context: URN_CONTEXT) : pub.to_s.downcase
       end
 
       def urn_type
@@ -46,34 +49,31 @@ module Pubid
         val = maybe(:number) || maybe(:code)
         return nil unless val
 
-        val.is_a?(Components::Code) ? val.value.to_s : val.to_s
+        val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val.to_s
       end
 
       def urn_part
         val = maybe(:part)
         return nil unless val
 
-        "-#{val.is_a?(Components::Code) ? val.value : val}"
+        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
       end
 
       def urn_subpart
         val = maybe(:subpart)
         return nil unless val
 
-        "-#{val.is_a?(Components::Code) ? val.value : val}"
+        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
       end
 
       def urn_year
         date = maybe(:date)
-        if date
-          year = date.is_a?(Components::Date) ? date.year : date.to_s
-          return year.to_s if year
-        end
-        if maybe(:year)
-          return identifier.year.to_s
+        if date.is_a?(Components::Date)
+          return date.render(context: URN_CONTEXT) if date.present?
+        elsif date
+          return date.to_s
         end
-
-        nil
+        maybe(:year)&.to_s
       end
 
       def urn_edition

data/lib/pubid/urn_parser/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnParser
+    # Base class for flavor-specific URN parsers.
+    #
+    # A UrnParser inverts its sibling UrnGenerator: it consumes the URN
+    # emitted by {Pubid::{Flavor}::UrnGenerator} and rebuilds an Identifier.
+    # The preferred strategy is to reconstruct a human-readable identifier
+    # string from the URN fields and delegate to the flavor's text parser —
+    # this keeps parsing logic in one place (the flavor's text parser).
+    #
+    # Subclasses MUST override {#parse_urn}. They typically use
+    # {#strip_namespace} and {#flavor_parse} helpers and may pass through
+    # {#build_from_parts} for the common `urn:{flavor}:{publisher}:{type}:
+    # {number}:{year}` shape.
+    class Base
+      # Parse a URN string into an Identifier.
+      # @param urn [String]
+      # @return [Pubid::Identifier]
+      def self.parse(urn)
+        new.parse_urn(urn)
+      end
+
+      # Subclasses override.
+      # @raise [NotImplementedError]
+      def parse_urn(_urn)
+        raise NotImplementedError,
+              "#{self.class} must implement #parse_urn"
+      end
+
+      protected
+
+      # The flavor module this parser belongs to (e.g., Pubid::Sae).
+      # Derived from the class name: Pubid::Sae::UrnParser → Pubid::Sae.
+      def flavor_module
+        @flavor_module ||=
+          begin
+            path = self.class.name.to_s.split("::")
+            Object.const_get(path[0..-2].join("::"))
+          end
+      end
+
+      # The lowercase flavor name used as the URN namespace (e.g., "sae").
+      # Defaults to the last segment of the module name. Override in
+      # subclasses whose URN namespace differs from the module name
+      # (e.g., CenCenelec emits URNs under "urn:cen:").
+      def flavor_name
+        @flavor_name ||= flavor_module.name.split("::").last.downcase
+      end
+
+      # Validate the URN starts with `urn:{flavor}:` and return the body.
+      # @param urn [String]
+      # @return [String] body after `urn:{flavor}:`
+      # @raise [Errors::ParseError] if prefix is wrong
+      def strip_namespace(urn)
+        prefix = "urn:#{flavor_name}:"
+        unless urn.downcase.start_with?(prefix)
+          raise Errors::ParseError,
+                "Invalid #{flavor_name.upcase} URN: #{urn.inspect}"
+        end
+
+        urn[prefix.length..]
+      end
+
+      # Delegate to the flavor's text parser.
+      # @param code [String] human-readable identifier
+      # @return [Pubid::Identifier]
+      def flavor_parse(code)
+        flavor_module.parse(code)
+      end
+
+      # Split the URN body on ":" into parts.
+      # @param body [String]
+      # @return [Array<String>]
+      def split_parts(body)
+        body.split(":")
+      end
+    end
+  end
+end

data/lib/pubid/urn_parser/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnParser
+    module Errors
+      class ParseError < StandardError; end
+    end
+  end
+end

data/lib/pubid/urn_parser.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Parses URN strings back into Identifier objects.
+  #
+  # Each flavor's {UrnParser} inverts the corresponding {UrnGenerator}. The
+  # {Base} class provides shared utilities (validation, splitting, dispatch
+  # back to the flavor's text parser); subclasses implement the per-flavor
+  # field reconstruction.
+  module UrnParser
+    autoload :Base, "pubid/urn_parser/base"
+    autoload :Errors, "pubid/urn_parser/errors"
+  end
+end

data/lib/pubid/version.rb

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

data/lib/pubid.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "pubid/lutaml/no_store_registration"
 require "parslet"
 
+# Eagerly load the Lutaml::Model patch (disables reference store to avoid
+# unbounded memory growth during bulk parsing, and adds a default +to_urn+
+# implementation to every Serializable). This must apply before any Pubid
+# code runs.
+require "pubid/lutaml/no_store_registration"
+
 module Pubid
   # Registry for tracking all loaded flavors
   class Registry
@@ -45,20 +50,21 @@ module Pubid
   autoload :Components, "pubid/components"
   autoload :BundledIdentifier, "pubid/bundled_identifier"
   autoload :Identifier, "pubid/identifier"
+  autoload :IdentifierFacade, "pubid/identifier_facade"
   autoload :IdentifierMetadata, "pubid/identifier_metadata"
-  autoload :IdentifierRegistry, "pubid/identifier_registry"
   autoload :Rendering, "pubid/rendering"
   autoload :Renderers, "pubid/renderers"
   autoload :FormatDetector, "pubid/format_detector"
   autoload :FormatRegistry, "pubid/format_registry"
-  autoload :Scheme, "pubid/scheme"
 
   autoload :UrnGenerator, "pubid/urn_generator/base"
+  autoload :UrnParser, "pubid/urn_parser"
   autoload :Builder, "pubid/builder/base"
   autoload :Utils, "pubid/utils"
   autoload :Version, "pubid/version"
   autoload :Core, "pubid/core"
 
+
   # Require all flavor modules
   autoload :Amca, "pubid/amca"
   autoload :Ansi, "pubid/ansi"
@@ -111,8 +117,7 @@ module Pubid
     when :mr_string
       Parsers::MrString.parse(string)
     when :urn
-      # URN auto-detection: extract flavor from URN namespace
-      # e.g., "urn:iso:std:..." → Pubid::Iso
+      eager_load_flavors!
       flavor = detect_flavor_from_urn(string)
       flavor_module = Registry.get(flavor)
       unless flavor_module
@@ -121,8 +126,7 @@ module Pubid
       end
 
       urn_parser = flavor_module.const_get(:UrnParser)
-      urn_parser.parse(string)
-    else
+      urn_parser.parse(string)    else
       # Default to MR string parser for MR format, human-readable otherwise
       # The MR string parser converts to human-readable and delegates to flavor.parse
       raise ArgumentError,
@@ -136,4 +140,22 @@ module Pubid
     parts = urn.downcase.split(":")
     parts[1] # The namespace part after "urn"
   end
+
+  # Trigger autoloads for every declared flavor module so that
+  # Registry is populated before URN dispatch needs it. Safe to call
+  # repeatedly; no-op after the first invocation.
+  def self.eager_load_flavors!
+    return if @flavors_loaded
+
+    constants.each do |c|
+      next unless c.to_s.match?(/\A[A-Z][a-zA-Z]+\z/)
+
+      begin
+        const_get(c)
+      rescue StandardError
+        nil
+      end
+    end
+    @flavors_loaded = true
+  end
 end