pubid 2.0.0.pre.alpha.3 → 2.0.0.pre.alpha.4

data/lib/pubid/etsi/identifier.rb

@@ -1,14 +1,6 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Etsi
-    class Identifier
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
-      end
-    end
-  end
-end
+# Pubid::Etsi::Identifier is the ETSI base class (a real Pubid::Identifier
+# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
+# live in identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

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

@@ -2,34 +2,41 @@
 
 module Pubid
   module Etsi
-    module Identifiers
-      # Base class for all ETSI identifiers
-      class Base < Pubid::Identifier
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-        attribute :type, :string
-        attribute :code, Pubid::Etsi::Components::Code
-        attribute :version, Pubid::Etsi::Components::Version
-        attribute :date, Pubid::Components::Date
-
-        def publisher
-          "ETSI"
-        end
+    # Base class for all ETSI identifiers. Canonical name Pubid::Etsi::Identifier
+    # (Identifiers::Base is a back-compat alias); every concrete ETSI identifier
+    # descends from it.
+    class Identifier < ::Pubid::Identifier
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
+      end
 
-        def to_s
-          render(format: :human)
-        end
+      attribute :type, :string
+      attribute :code, Pubid::Etsi::Components::Code
+      attribute :version, Pubid::Etsi::Components::Version
+      attribute :date, Pubid::Components::Date
+      # Stored as a plain string (always "ETSI") so it round-trips through
+      # to_hash/from_hash. Was previously a `def publisher` method, which made
+      # lutaml serialize a String against the Components::Publisher attribute and
+      # raise on to_hash.
+      attribute :publisher, :string, default: -> { "ETSI" }
 
-        def ==(other)
-          return false unless other.is_a?(Base)
+      def ==(other)
+        return false unless other.is_a?(Pubid::Etsi::Identifier)
 
-          type == other.type &&
-            code == other.code &&
-            version == other.version &&
-            date == other.date
-        end
+        type == other.type &&
+          code == other.code &&
+          version == other.version &&
+          date == other.date
       end
     end
+
+    module Identifiers
+      # Backward-compatible alias: ETSI's base class used to be
+      # Pubid::Etsi::Identifiers::Base. It is now Pubid::Etsi::Identifier.
+      Base = Pubid::Etsi::Identifier
+    end
   end
 end

data/lib/pubid/etsi/identifiers/supplement_identifier.rb

@@ -26,9 +26,6 @@ module Pubid
         end
 
         # Render via renderer
-        def to_s
-          render(format: :human)
-        end
 
         # Recursively collect supplement notations from the supplement chain
         def collect_supplement_notations(current_supplement, notations)

data/lib/pubid/etsi.rb

@@ -27,7 +27,9 @@ module Pubid
       @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.name&.split("::")&.last == "Base" }
+        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # alias for Pubid::Etsi::Identifier, so name-based matching misses it).
+        .reject { |c| c == Identifiers::Base }
     end
 
     # Build typed stage index from identifier types

data/lib/pubid/identifier.rb

@@ -8,6 +8,96 @@ module Pubid
       end
 
       attr_writer :format_registry
+
+      # Polymorphic deserialization shared by every flavor base. lutaml's
+      # `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
+      # 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.
+      def from_hash(data, options = {})
+        type = data && (data["_type"] || data[:_type])
+        klass = polymorphic_type_map[type]
+        return klass.from_hash(data, options) if klass && klass != self
+
+        super
+      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.
+      def polymorphic_type_map
+        @polymorphic_type_map ||=
+          identifier_registry_classes.each_with_object({}) do |klass, map|
+            poly = klass.polymorphic_name
+            map[poly] ||= klass if poly
+          end
+      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
+      # whether `self` is the base or a concrete subclass.
+      def flavor_module
+        @flavor_module ||= Object.const_get(name.split("::")[0, 2].join("::"))
+      end
+
+      def identifiers_namespace
+        @identifiers_namespace ||= flavor_module.const_get(:Identifiers)
+      end
+
+      def identifier_registry_classes
+        (scanned_identifier_classes +
+          registered_identifier_classes +
+          additional_identifier_classes).uniq
+      end
+
+      # Concrete identifier classes found directly in the flavor's `Identifiers`
+      # namespace. Empty for the abstract root (no flavor) or a flavor without
+      # that namespace. Only this namespace is scanned (never the flavor top
+      # level), to avoid force-autoloading unrelated flavor constants.
+      def scanned_identifier_classes
+        return [] unless flavor_identifiers_namespace?
+
+        identifiers_namespace.constants.filter_map do |const|
+          klass = identifiers_namespace.const_get(const)
+          klass if klass.is_a?(Class) && klass < ::Pubid::Identifier
+        rescue NameError
+          nil
+        end
+      end
+
+      # Classes the flavor explicitly registers via `identifier_types`, if any.
+      def registered_identifier_classes
+        return [] unless flavor_module.respond_to?(:identifier_types)
+
+        Array(flavor_module.identifier_types)
+      end
+
+      # Hook for identifier classes that carry a polymorphic `_type` but live
+      # OUTSIDE the flavor's `Identifiers` namespace (e.g. Pubid::Iso::
+      # BundledIdentifier, Pubid::Iec::SingleIdentifier). Flavors with such
+      # classes override this; the default is none. Replaces the hand-listing
+      # of these in the old static `*_TYPE_MAP`s.
+      def additional_identifier_classes
+        []
+      end
+
+      def flavor_identifiers_namespace?
+        flavor_module.const_defined?(:Identifiers)
+      rescue NameError
+        false
+      end
     end
 
     attribute :_type, :string, polymorphic_class: true
@@ -53,7 +143,6 @@ module Pubid
       "pubid:#{flavor}:#{type_kebab}"
     end
 
-
     def root
       return base_identifier.root if base_identifier
 

data/lib/pubid/idf/identifier.rb

@@ -53,6 +53,10 @@ module Pubid
       end
 
       def self.parse(string)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Pubid::Idf::Parser.new.parse(string)
         if parsed.nil? || parsed.empty?
           raise Pubid::Idf::Parser::ParseError,

data/lib/pubid/idf.rb

@@ -13,6 +13,10 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/idf/urn_parser"
 
     def self.parse(identifier)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       parser = Parser.new
       builder = Builder.new
 

data/lib/pubid/iec/identifier.rb

@@ -98,6 +98,14 @@ module Pubid
         "pubid:iec:single-identifier" => "Pubid::Iec::SingleIdentifier",
       }.freeze
 
+      # SingleIdentifier lives outside Pubid::Iec::Identifiers but appears as a
+      # nested `_type`, so the shared polymorphic_type_map needs it explicitly
+      # (see Pubid::Identifier#additional_identifier_classes).
+      def self.additional_identifier_classes
+        [Pubid::Iec::SingleIdentifier]
+      end
+      private_class_method :additional_identifier_classes
+
       # Build the type map from the live class list, for the validation spec.
       def self.build_type_map
         types = Pubid::Iec.identifier_types
@@ -259,6 +267,10 @@ module Pubid
       end
 
       def self.parse(string)
+        if string.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         # Route URN strings to the URN parser (mirrors Iso::Identifier.parse)
         if Pubid::FormatDetector.detect(string) == :urn
           return Pubid::Iec::UrnParser.parse(string)
@@ -275,20 +287,8 @@ module Pubid
         Pubid::Iec::Builder.new.build(parsed)
       end
 
-      # lutaml's polymorphic key_value mapping reads `_type` only to validate; it
-      # does not re-instantiate the concrete subclass on root deserialization. So
-      # `Identifier.from_hash(amendment_hash)` would return a bare Identifier and
-      # drop base_identifier. Route by `_type` to the right subclass and let its
-      # (inherited) from_hash do the real work, mirroring ISO/JIS.
-      def self.from_hash(data, options = {})
-        type = data["_type"] || data[:_type]
-        klass_name = IEC_TYPE_MAP[type]
-        if klass_name
-          klass = Object.const_get(klass_name)
-          return klass.from_hash(data, options) unless klass == self
-        end
-        super
-      end
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # IEC_TYPE_MAP remains as the key_value polymorphic_map.
     end
   end
 end

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

@@ -20,10 +20,6 @@ module Pubid
           map "database", to: :database, render_default: false
         end
 
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
-
         def number_portion
           return "" unless number
 

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

@@ -35,10 +35,6 @@ module Pubid
           end
         end
 
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
-
         # Delegate common attributes to first identifier (base document)
         def publisher
           identifiers&.first&.publisher

data/lib/pubid/iec/identifiers/fragment_identifier.rb

@@ -38,7 +38,7 @@ module Pubid
           return unless base
 
           doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
-                                                                base.to_hash))
+                                                                 base.to_hash))
         end
 
         def base_from_kv(model, value)
@@ -118,10 +118,6 @@ module Pubid
             web: :fragment_identifier, title: "Fragment", short: "FRAG" }
         end
 
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
-
         # Delegate common attributes to base_identifier
         def publisher
           base_identifier&.publisher

data/lib/pubid/iec/identifiers/sheet_identifier.rb

@@ -27,17 +27,13 @@ module Pubid
           return unless base
 
           doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
-                                                                base.to_hash))
+                                                                 base.to_hash))
         end
 
         def base_from_kv(model, value)
           model.base_identifier = ::Pubid::Iec::Identifier.from_hash(value) if value
         end
 
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
-
         # Delegate common attributes to base_identifier
         def publisher
           base_identifier&.publisher

data/lib/pubid/iec/identifiers/test_report_form.rb

@@ -40,9 +40,6 @@ module Pubid
         end
 
         # TRF uses special rendering via the Renderer
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
       end
     end
   end

data/lib/pubid/iec/identifiers/vap_identifier.rb

@@ -27,7 +27,7 @@ module Pubid
           return unless base
 
           doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
-                                                                base.to_hash))
+                                                                 base.to_hash))
         end
 
         def base_from_kv(model, value)
@@ -42,10 +42,6 @@ module Pubid
           "SER" => "Serial version",
         }.freeze
 
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
-
         # Delegate common attributes to base_identifier
         def publisher
           base_identifier&.publisher

data/lib/pubid/iec/identifiers/working_document.rb

@@ -42,10 +42,6 @@ module Pubid
 
           @stage ||= ::Pubid::Components::Stage.new(stage_code: stage_code)
         end
-
-        def to_s(**opts)
-          render(format: :human, **opts)
-        end
       end
     end
   end

data/lib/pubid/iec.rb

@@ -15,6 +15,10 @@ module Pubid
     autoload :Renderer, "#{__dir__}/iec/renderer"
 
     def self.parse(identifier_string)
+      if identifier_string.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       parsed = Parser.new.parse(identifier_string)
       Builder.new.build(parsed)
     end

data/lib/pubid/ieee/identifier.rb

@@ -1,19 +1,7 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Ieee
-    # NOTE: intentionally does NOT `extend Pubid::IdentifierFacade`. IEEE's
-    # `to_hash`/`from_hash` does not round-trip yet (e.g. `code`/`year` are
-    # dropped on rebuild), so the facade would advertise a `from_hash` that
-    # silently returns lossy objects — and a consumer's `instance_of?(module)`
-    # validation can't catch it. Re-enable once IEEE serialization round-trips
-    # cleanly. See identifier_facade.rb.
-    module Identifier
-      class << self
-        def parse(input)
-          Identifiers::Base.parse(input)
-        end
-      end
-    end
-  end
-end
+# Pubid::Ieee::Identifier is the IEEE base class (a real Pubid::Identifier
+# subclass); IEEE builds its identifiers as instances of it directly. Its body,
+# `.parse`, and the Identifiers::Base back-compat alias live in
+# identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

data/lib/pubid/ieee/identifiers/adopted_standard.rb

@@ -15,10 +15,6 @@ module Pubid
         attribute :adopted_identifiers, Base, polymorphic: true,
                                               collection: true
 
-        def to_s
-          render(format: :human)
-        end
-
         def publisher
           ieee_identifier&.publisher || "IEEE"
         end