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

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

@@ -3,12 +3,15 @@
 module Pubid
   module Ccsds
     module Identifiers
-      # CCSDS identifier
-      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX]
-      # Example: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S
-      class Base < Lutaml::Model::Serializable
-        # CCSDS uses a simple architecture without typed stages
-        # TYPED_STAGES includes default stage for base identifiers
+      # CCSDS base identifier (a published standard).
+      #
+      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX][ - LANGUAGE Translated]
+      # Examples: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S, CCSDS 551.1-O-2 - Russian Translated
+      #
+      # Attributes, the key_value mapping and from_hash dispatch live on the
+      # abstract root Pubid::Ccsds::Identifier; this concrete type only carries
+      # its typed stage and rendering.
+      class Base < Pubid::Ccsds::Identifier
         TYPED_STAGES = [
           Pubid::Components::TypedStage.new(
             abbr: [""],
@@ -17,61 +20,19 @@ module Pubid
           ),
         ].freeze
 
-        # Type information for this identifier class
-        #
-        # @return [Hash] Type information with key, title, and short form
         def self.type
-          { key: :base, title: "Base Standard", short: nil }
+          { key: :base, web: :base, title: "Base Standard", short: nil }
         end
 
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-
-        # Include CCSDS-specific attributes in serialization
-        def base_hash
-          hash = super
-          # CCSDS uses plain strings for type, edition, suffix
-          hash[:type] = type if type
-          hash[:suffix] = suffix if suffix
-          hash[:language] = language if language
-          hash
-        end
-
-        attribute :number, :string
-        attribute :part, :string
-        attribute :type, :string # B, G, M, R, Y, O, etc.
-        attribute :edition, :string
-        attribute :suffix, :string # Optional suffix like -S
-        attribute :language, :string # Language metadata (e.g., "French", "Russian")
-
-        def publisher
-          "CCSDS"
-        end
-
-        def to_s
+        def to_s(**_opts)
           result = "#{publisher} #{number}"
           result += ".#{part}" if part
           result += "-#{type}" if type
           result += "-#{edition}" if edition
           result += "-#{suffix}" if suffix
-
-          # Add language metadata
           result += " - #{language} Translated" if language
-
           result
         end
-
-        def ==(other)
-          return false unless other.is_a?(Base)
-
-          number == other.number &&
-            part == other.part &&
-            type == other.type &&
-            edition == other.edition &&
-            suffix == other.suffix &&
-            language == other.language
-        end
       end
     end
   end

data/lib/pubid/ccsds/identifiers/corrigendum.rb

@@ -17,21 +17,22 @@ module Pubid
         #
         # @return [Hash] Type information with key, title, and short form
         def self.type
-          { key: :cor, title: "Corrigendum", short: "Cor" }
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "Cor" }
         end
 
-        attribute :cor_number, :integer
-
+        # The corrigendum sequence number is stored in the inherited `number`
+        # attribute (mirroring ISO), so it serializes via Base's key_value as
+        # { _type, number: '1', base: {...} } with no corrigendum-specific map.
         def to_s
           base_str = base_identifier.to_s
-          "#{base_str} Cor. #{cor_number}"
+          "#{base_str} Cor. #{number}"
         end
 
         def ==(other)
           return false unless other.is_a?(Corrigendum)
 
-          base_identifier == other.base_identifier &&
-            cor_number == other.cor_number
+          base_identifier == other.base_identifier && number == other.number
         end
       end
     end

data/lib/pubid/ccsds/parser.rb

@@ -25,8 +25,10 @@ module Pubid
       # Type (all possible type letters)
       rule(:type) { dash >> match["A-Z"].as(:type) }
 
-      # Edition (can have dots like 4.1)
-      rule(:edition) { dash >> match["0-9."].repeat(1).as(:edition) }
+      # Edition (can have dots like 4.1, and a trailing draft letter like 1.99h)
+      rule(:edition) do
+        dash >> (match["0-9."].repeat(1) >> match["A-Za-z"].maybe).as(:edition)
+      end
 
       # Suffix (like -S)
       rule(:suffix) { dash >> match["A-Z"].as(:suffix) }

data/lib/pubid/ccsds/single_identifier.rb

@@ -2,7 +2,10 @@
 
 module Pubid
   module Ccsds
-    class SingleIdentifier < Identifier
+    # Qualified as ::Pubid::Identifier to avoid resolving to the local
+    # Pubid::Ccsds::Identifier module, which is a parser entry point
+    # (`self.parse`) — not the base class.
+    class SingleIdentifier < ::Pubid::Identifier
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "CCSDS")
       }

data/lib/pubid/ccsds/supplement_identifier.rb

@@ -2,18 +2,22 @@
 
 module Pubid
   module Ccsds
-    # Base class for CCSDS supplements (corrigenda, amendments, etc.)
-    # Following ISO pattern: inherits from Base and uses Lutaml::Model
-    class SupplementIdentifier < Identifiers::Base
-      attribute :base_identifier, Identifiers::Base, polymorphic: true
+    # Base class for CCSDS supplements (corrigenda, amendments, etc.).
+    # Descends from the abstract root (not the concrete Base) and points
+    # `base_identifier` at the root, so the polymorphic attribute never
+    # resolves to its own superclass — which is what prevents lutaml from
+    # recursing forever while building a supplement from a hash.
+    class SupplementIdentifier < Identifier
+      attribute :base_identifier, Identifier, polymorphic: true
 
-      # Delegate methods to base_identifier for convenient access
-      def publisher
-        base_identifier&.publisher
-      end
-
-      def number
-        base_identifier&.number
+      # Serialize the supplemented identifier under "base" (matches ISO/JIS).
+      # The key stays `base_identifier` for the attribute/getter, which
+      # relaton-index's get_id_number relies on. A supplement's own code
+      # attributes (number/part/edition/...) stay nil — they live inside
+      # `base` — so the merged root key_value omits them here, keeping the
+      # serialization lean and non-duplicated.
+      key_value do
+        map "base", to: :base_identifier
       end
 
       def <=>(other)

data/lib/pubid/ccsds/urn_generator.rb

@@ -47,7 +47,7 @@ module Pubid
         edition = maybe(:edition)
         if edition
           e = if edition.is_a?(Pubid::Components::Edition)
-                edition.number || edition.value
+                edition.number
               else
                 edition.to_s
               end
@@ -101,8 +101,8 @@ module Pubid
         parts << base_identifier_part
 
         supplement_chain.each do |supp|
-          if supp.number&.value
-            parts << "cor.#{supp.number.value}"
+          if supp.number && !supp.number.to_s.empty?
+            parts << "cor.#{supp.number}"
           elsif supp.typed_stage
             parts << supp.typed_stage.type_code.to_s
           end

data/lib/pubid/ccsds/urn_parser.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    # Parses CCSDS URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:ccsds:{code}` where the code is the full
+    # identifier suffix after "CCSDS " (e.g., "120.0-G-4").
+    #
+    # Examples:
+    # - urn:ccsds:120.0-G-4  → CCSDS 120.0-G-4
+    # - urn:ccsds:100.0-G-1-S → CCSDS 100.0-G-1-S
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        flavor_parse("CCSDS #{body}")
+      end
+    end
+  end
+end

data/lib/pubid/ccsds.rb

@@ -6,14 +6,52 @@ module Pubid
     autoload :Identifier, "#{__dir__}/ccsds/identifier"
     autoload :Identifiers, "#{__dir__}/ccsds/identifiers"
     autoload :Parser, "#{__dir__}/ccsds/parser"
-    autoload :Scheme, "#{__dir__}/ccsds/scheme"
     autoload :SingleIdentifier, "#{__dir__}/ccsds/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/ccsds/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/ccsds/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ccsds/urn_parser"
 
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # CCSDS identifier classes extend Lutaml::Model::Serializable directly
+    # but do define self.type returning a Hash.
+    # @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
 

data/lib/pubid/cen_cenelec/builder.rb

@@ -3,12 +3,8 @@
 module Pubid
   module CenCenelec
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
-      def self.build(parsed_data, scheme = Scheme.new)
-        new(scheme).build(parsed_data)
+      def self.build(parsed_data)
+        new.build(parsed_data)
       end
 
       def build(data)
@@ -40,7 +36,7 @@ module Pubid
         # Extract supplements before building base identifier (only plus/bundled)
         supplements_data = extract_supplements(data)
 
-        # Determine identifier class using Scheme
+        # Determine identifier class using the module's lookup helpers
         identifier = locate_identifier_klass(data).new
         assign_attributes(identifier, data)
 
@@ -83,21 +79,23 @@ module Pubid
         # Check if publisher is actually a type code (CWA, HD, ES, CR, ENV act as publisher)
         publisher_str = parsed_hash[:publisher].to_s
         if %w[CWA HD ES CR ENV].include?(publisher_str)
-          typed_stage = @scheme.locate_typed_stage_by_abbr(publisher_str)
-          return @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+          typed_stage = CenCenelec.locate_stage(publisher_str)
+          if (klass = CenCenelec.locate_type(typed_stage.type_code))
+            return klass
+          end
         end
 
-        # Use type or stage to determine class via Scheme
+        # Use type or stage to determine class via the module's registry
         type_or_stage = parsed_hash[:type_with_stage] || parsed_hash[:type] || parsed_hash[:stage] || ""
-        typed_stage = @scheme.locate_typed_stage_by_abbr(type_or_stage)
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        typed_stage = CenCenelec.locate_stage(type_or_stage) || CenCenelec::DEFAULT_TYPED_STAGE
+        CenCenelec.locate_type(typed_stage.type_code) || Identifiers::EuropeanNorm
       end
 
       def cast(type, value)
         case type
         when :type_with_stage
           # Lookup from register
-          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
+          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,
@@ -150,7 +148,7 @@ module Pubid
 
         when :stage
           # Lookup stage in TYPED_STAGES register
-          typed_stage = @scheme.locate_typed_stage_by_abbr(value.to_s)
+          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
           {
             stage: typed_stage.to_stage,
             typed_stage: typed_stage,

data/lib/pubid/cen_cenelec/identifier.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
+
 module Pubid
   module CenCenelec
+    # `extend Pubid::IdentifierFacade` adds polymorphic `from_hash` and pairs
+    # with `include Pubid::CenCenelec::Identifier` in Identifiers::Base for
+    # identity (`is_a?`/`===`), so a consumer handed this module can deserialize
+    # and identity-check CEN/CENELEC ids through it.
     module Identifier
+      extend Pubid::IdentifierFacade
+
       def self.parse(identifier)
-        scheme = Scheme.new
         parsed = Parser.parse(identifier)
-        Builder.new(scheme).build(parsed)
+        Builder.new.build(parsed)
       rescue Parslet::ParseFailed => e
         raise "Failed to parse CEN identifier '#{identifier}': #{e.message}"
       end

data/lib/pubid/cen_cenelec/identifiers/adopted_european_norm.rb

@@ -8,10 +8,19 @@ module Pubid
       class AdoptedEuropeanNorm < EuropeanNorm
         attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC/IEEE object
 
-        def to_s
-          result = publisher.is_a?(Array) ? publisher.join("/") : publisher.join("/")
-          result += " #{adopted_identifier}" if adopted_identifier
-          result
+        # Override self.type to return nil so that AdoptedEuropeanNorm is NOT
+        # registered as a type in CenCenelec.identifier_types. The class is a
+        # polymorphic wrapper that wraps an adopted ISO/IEC identifier under an
+        # EN publisher; it is constructed explicitly by Builder#build_adopted_identifier,
+        # not selected via type-code lookup. Returning nil here prevents
+        # identifier_types auto-discovery from shadowing EuropeanNorm (which
+        # also reports :en) in CenCenelec.locate_type(:en).
+        def self.type
+          nil
+        end
+
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
 
         # Delegate common methods to adopted identifier

data/lib/pubid/cen_cenelec/identifiers/amendment.rb

@@ -10,14 +10,8 @@ module Pubid
         attribute :amendment_number, :string
         attribute :amendment_year, :integer
 
-        def to_s
-          result = if base_identifier
-                     "#{base_identifier}/A#{amendment_number}"
-                   else
-                     "/A#{amendment_number}"
-                   end
-          result += ":#{amendment_year}" if amendment_year
-          result
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
 
         def publisher

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

@@ -6,6 +6,9 @@ module Pubid
       # Base CEN identifier
       # Format: {PUBLISHER} NUMBER[-PART]:YEAR
       class Base < Pubid::Identifier
+        # Identity for the Pubid::CenCenelec::Identifier facade (see its comment).
+        include Pubid::CenCenelec::Identifier
+
         # Generate URN for this identifier
         #
         # @return [String] URN representation
@@ -20,47 +23,8 @@ module Pubid
         attribute :adopted_identifier, Base, polymorphic: true # Nested identifier object (ISO, IEC, etc.)
         attribute :edition, :string # Edition number
 
-        def to_s
-          result = ""
-
-          # Stage or Publisher
-          if stage
-            result += stage
-          elsif publisher&.any?
-            result += publisher.join("/")
-          end
-
-          # If we have adopted_identifier, render it (contains all info)
-          if adopted_identifier
-            result += " #{adopted_identifier}"
-            # Don't add our own number/parts/year - they're in adopted_identifier
-          else
-            # Only render our own fields if no adoption
-            # Type - use space for Guide, slash for TR/TS
-            if type
-              sep = type == "Guide" ? " " : "/"
-              result += "#{sep}#{type}"
-            end
-
-            result += " #{number}"
-            result += parts.map { |p| "-#{p}" }.join if parts&.any?
-            result += ":#{year}" if year
-
-            # Supplements
-            if supplements&.any?
-              supplements.each do |supp|
-                sep = supp[:type] == :amendment ? "/" : "+"
-                result += "#{sep}#{supp[:type] == :amendment ? 'A' : 'AC'}"
-                result += supp[:number] if supp[:number] && !supp[:number].empty?
-                result += ":#{supp[:year]}" if supp[:year]
-              end
-            end
-
-            # Edition
-            result += " ED#{edition}" if edition
-          end
-
-          result
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
 
         def ==(other)

data/lib/pubid/cen_cenelec/identifiers/cen_report.rb

@@ -20,7 +20,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cr, title: "CEN Report", short: "CR" }
+          { key: :cr,
+            web: :cen_report, title: "CEN Report", short: "CR" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/cen_workshop_agreement.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cwa, title: "CEN Workshop Agreement", short: "CWA" }
+          { key: :cwa,
+            web: :cen_workshop_agreement, title: "CEN Workshop Agreement", short: "CWA" }
         end
       end
     end

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

@@ -8,31 +8,8 @@ module Pubid
       class ConsolidatedIdentifier < Base
         attribute :identifiers, Base, polymorphic: true, collection: true
 
-        def to_s
-          identifiers.map.with_index do |id, idx|
-            if idx.zero?
-              # First identifier renders normally
-              id.to_s
-            elsif id.is_a?(Amendment)
-              # Supplements render with "+" prefix (bundled/consolidated format)
-              result = "+A#{id.amendment_number}"
-              result += ":#{id.amendment_year}" if id.amendment_year
-              result
-            # Only render the amendment portion, not the full id.to_s
-            elsif id.is_a?(Corrigendum)
-              # Only render the corrigendum portion
-              result = "+AC"
-              result += id.corrigendum_number if id.corrigendum_number && !id.corrigendum_number.empty?
-              if id.corrigendum_year
-                result += ":#{id.corrigendum_year}"
-                result += "-#{id.corrigendum_month}" if id.corrigendum_month && !id.corrigendum_month.empty?
-              end
-              result
-            else
-              # Other identifiers (should not happen in typical bundles) render with +
-              "+#{id}"
-            end
-          end.compact.join
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
 
         # Delegate to first identifier (base document)

data/lib/pubid/cen_cenelec/identifiers/corrigendum.rb

@@ -11,19 +11,8 @@ module Pubid
         attribute :corrigendum_year, :integer
         attribute :corrigendum_month, :string
 
-        def to_s
-          if base_identifier
-            result = base_identifier.to_s
-            result += "/AC"
-            result += corrigendum_number if corrigendum_number && !corrigendum_number.empty?
-          else
-            result = "/AC#{corrigendum_number}"
-          end
-          if corrigendum_year
-            result += ":#{corrigendum_year}"
-            result += "-#{corrigendum_month}" if corrigendum_month && !corrigendum_month.empty?
-          end
-          result
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
 
         def publisher

data/lib/pubid/cen_cenelec/identifiers/european_norm.rb

@@ -33,7 +33,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :en, title: "European Norm", short: "EN" }
+          { key: :en,
+            web: :european_norm, title: "European Norm", short: "EN" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/european_prestandard.rb

@@ -21,15 +21,12 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :env, title: "European Prestandard", short: "ENV" }
+          { key: :env,
+            web: :european_prestandard, title: "European Prestandard", short: "ENV" }
         end
 
-        def to_s(lang: :en, lang_single: false)
-          if adopted_identifier
-            "ENV #{adopted_identifier}"
-          else
-            super
-          end
+        def to_s(lang: :en, lang_single: false, **opts)
+          render(format: :human, lang: lang, lang_single: lang_single, **opts)
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/european_specification.rb

@@ -20,7 +20,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :es, title: "European Specification", short: "ES" }
+          { key: :es,
+            web: :european_specification, title: "European Specification", short: "ES" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/fragment.rb

@@ -9,8 +9,8 @@ module Pubid
         attribute :base_identifier, Amendment
         attribute :fragment_number, :string
 
-        def to_s
-          "#{base_identifier} FRAG#{fragment_number}"
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
 
         def publisher

data/lib/pubid/cen_cenelec/identifiers/harmonization_document.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :hd, title: "Harmonization Document", short: "HD" }
+          { key: :hd,
+            web: :harmonization_document, title: "Harmonization Document", short: "HD" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/technical_report.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tr, title: "Technical Report", short: "TR" }
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/technical_specification.rb

@@ -27,7 +27,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts, title: "Technical Specification", short: "TS" }
+          { key: :ts,
+            web: :technical_specification, title: "Technical Specification", short: "TS" }
         end
       end
     end