pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/ccsds/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Ccsds
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
       rule(:alnum) { match["A-Za-z0-9"] }
@@ -25,10 +25,8 @@ module Pubid
       # Type (all possible type letters)
       rule(:type) { dash >> match["A-Z"].as(:type) }
 
-      # 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
+      # Edition (can have dots like 4.1)
+      rule(:edition) { dash >> match["0-9."].repeat(1).as(:edition) }
 
       # Suffix (like -S)
       rule(:suffix) { dash >> match["A-Z"].as(:suffix) }

data/lib/pubid/ccsds/scheme.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Base,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Corrigendum,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def supplement_typed_stages
+          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "" if abbr.nil?
+
+          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/single_identifier.rb

@@ -2,10 +2,7 @@
 
 module Pubid
   module Ccsds
-    # 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
+    class SingleIdentifier < Identifier
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "CCSDS")
       }
@@ -19,7 +16,7 @@ module Pubid
       attribute :type, Components::Type
       attribute :typed_stage, Components::TypedStage
 
-      def to_s(lang: :en, lang_single: false, **opts)
+      def to_s(lang: :en, lang_single: false)
         result = ""
 
         # Publisher
@@ -47,7 +44,7 @@ module Pubid
         # Language (optional)
         result += " - #{language.code} Translated" if language
 
-        annotate_plain_render(result, **opts)
+        result
       end
 
       def <=>(other)

data/lib/pubid/ccsds/supplement_identifier.rb

@@ -2,30 +2,26 @@
 
 module Pubid
   module Ccsds
-    # Base class for CCSDS supplements (corrigenda, amendments, etc.).
-    # Descends from the abstract root (not the concrete Base) and points
-    # `base` 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, polymorphic: true
+    # 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
 
-      # Serialize the supplemented identifier under "base" (matches ISO/JIS).
-      # The key stays `base` 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
+      # Delegate methods to base_identifier for convenient access
+      def publisher
+        base_identifier&.publisher
+      end
+
+      def number
+        base_identifier&.number
       end
 
       def <=>(other)
         return nil unless other.is_a?(SupplementIdentifier)
 
         # Compare base identifiers first
-        if base && other.base
-          base_cmp = base <=> other.base
+        if base_identifier && other.base_identifier
+          base_cmp = base_identifier <=> other.base_identifier
           return base_cmp unless base_cmp.zero?
         end
 

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.number || edition.value
               else
                 edition.to_s
               end
@@ -91,18 +91,18 @@ module Pubid
 
         while current.is_a?(SupplementIdentifier)
           supplement_chain.unshift(current)
-          current = current.base
+          current = current.base_identifier
         end
 
         base_gen = self.class.new(current)
         base_urn = base_gen.generate_base_urn
 
-        base_part = base_urn.sub(/^urn:ccsds:/, "")
-        parts << base_part
+        base_identifier_part = base_urn.sub(/^urn:ccsds:/, "")
+        parts << base_identifier_part
 
         supplement_chain.each do |supp|
-          if supp.number && !supp.number.to_s.empty?
-            parts << "cor.#{supp.number}"
+          if supp.number&.value
+            parts << "cor.#{supp.number.value}"
           elsif supp.typed_stage
             parts << supp.typed_stage.type_code.to_s
           end

data/lib/pubid/ccsds.rb

@@ -2,61 +2,18 @@
 
 module Pubid
   module Ccsds
-    extend Pubid::PrefixesSupport
-
-    # Sole CCSDS publisher token (see the parser's `ccsds_prefix` rule).
-    PREFIXES = ["CCSDS"].freeze
-
     autoload :Builder, "#{__dir__}/ccsds/builder"
     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,8 +3,12 @@
 module Pubid
   module CenCenelec
     class Builder < Pubid::Builder::Base
-      def self.build(parsed_data)
-        new.build(parsed_data)
+      def initialize(scheme)
+        @scheme = scheme
+      end
+
+      def self.build(parsed_data, scheme = Scheme.new)
+        new(scheme).build(parsed_data)
       end
 
       def build(data)
@@ -33,26 +37,10 @@ module Pubid
           return build_standalone_supplement(data)
         end
 
-        # Implicit adoption: when an EN has no explicit "IEC" prefix but
-        # the number falls in the IEC range (60000-79999), treat it as an
-        # adoption of the corresponding IEC standard. The lower ISO-only
-        # range (1-59999) is intentionally NOT mapped here — too many
-        # existing CEN publications (EN Guide N, EN N as a real CEN-assigned
-        # number) would change type. Callers who want explicit adoption
-        # can still write "EN ISO 12345".
-        # (https://github.com/pubid/pubid/issues/249)
-        # Skip when parts are present — they would be lost when we rebuild
-        # the identifier from just the base number.
-        if data[:publisher]&.to_s == "EN" && !data[:adopted_string] &&
-           data[:parts].to_a.empty? &&
-           (adopted = build_implicit_adoption(data))
-          return adopted
-        end
-
         # Extract supplements before building base identifier (only plus/bundled)
         supplements_data = extract_supplements(data)
 
-        # Determine identifier class using the module's lookup helpers
+        # Determine identifier class using Scheme
         identifier = locate_identifier_klass(data).new
         assign_attributes(identifier, data)
 
@@ -72,18 +60,18 @@ module Pubid
         base_data.delete(:amendment_number)
         base_data.delete(:fragment_number)
 
-        base = locate_identifier_klass(base_data).new
-        assign_attributes(base, base_data)
+        base_identifier = locate_identifier_klass(base_data).new
+        assign_attributes(base_identifier, base_data)
 
         # Build Amendment identifier wrapping the base
         amendment = Identifiers::Amendment.new(
-          base: base,
+          base_identifier: base_identifier,
           amendment_number: data[:amendment_number].to_s,
         )
 
         # Build Fragment wrapping the amendment
         Identifiers::Fragment.new(
-          base: amendment,
+          base_identifier: amendment,
           fragment_number: data[:fragment_number].to_s,
         )
       end
@@ -95,23 +83,21 @@ 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 = CenCenelec.locate_stage(publisher_str)
-          if (klass = CenCenelec.locate_type(typed_stage.type_code))
-            return klass
-          end
+          typed_stage = @scheme.locate_typed_stage_by_abbr(publisher_str)
+          return @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
         end
 
-        # Use type or stage to determine class via the module's registry
+        # Use type or stage to determine class via Scheme
         type_or_stage = parsed_hash[:type_with_stage] || parsed_hash[:type] || parsed_hash[:stage] || ""
-        typed_stage = CenCenelec.locate_stage(type_or_stage) || CenCenelec::DEFAULT_TYPED_STAGE
-        CenCenelec.locate_type(typed_stage.type_code) || Identifiers::EuropeanNorm
+        typed_stage = @scheme.locate_typed_stage_by_abbr(type_or_stage)
+        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
       end
 
       def cast(type, value)
         case type
         when :type_with_stage
           # Lookup from register
-          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
+          typed_stage = @scheme.locate_typed_stage_by_abbr(value || "")
           {
             stage: typed_stage.to_stage,
             type: typed_stage.to_type,
@@ -132,7 +118,7 @@ module Pubid
           end
 
         when :number
-          value.to_s
+          Components::Code.new(value: value.to_s)
 
         when :parts
           # Extract first part, preserve full multi-level part string
@@ -142,11 +128,11 @@ module Pubid
             part_str = parts_array.first[:part].to_s
 
             # Store the full part value for multi-level parts
-            { part: part_str }
+            { part: Components::Code.new(value: part_str) }
           end
 
         when :part
-          value[:part].to_s if value.is_a?(Hash)
+          Components::Code.new(value: value[:part].to_s) if value.is_a?(Hash)
 
         when :year, :date
           # Check if month is present in the data and include it
@@ -164,7 +150,7 @@ module Pubid
 
         when :stage
           # Lookup stage in TYPED_STAGES register
-          typed_stage = CenCenelec.locate_stage(value.to_s) || CenCenelec::DEFAULT_TYPED_STAGE
+          typed_stage = @scheme.locate_typed_stage_by_abbr(value.to_s)
           {
             stage: typed_stage.to_stage,
             typed_stage: typed_stage,
@@ -223,24 +209,6 @@ module Pubid
         )
       end
 
-      # Implicit adoption by number range. Returns an AdoptedEuropeanNorm
-      # wrapping the IEC identifier that the EN number implies, or nil if the
-      # number doesn't fall in the IEC range. Limited to IEC range only —
-      # see the call site comment for why the ISO range is excluded.
-      def build_implicit_adoption(data)
-        number = data[:number].to_s
-        num_str = number.to_s.strip
-        return nil unless num_str.match?(/\A\d{1,6}\z/)
-
-        num = num_str.to_i
-        return nil unless (60_000..79_999).cover?(num)
-
-        Identifiers::AdoptedEuropeanNorm.new(
-          publisher: ["EN"],
-          adopted_identifier: Pubid::Iec.parse("IEC #{num_str}"),
-        )
-      end
-
       def build_env_adopted_identifier(data)
         # Parse the adopted identifier string
         adopted_str = data[:adopted_string]&.to_s&.strip
@@ -259,17 +227,17 @@ module Pubid
         )
       end
 
-      def wrap_with_consolidated(base, supplements_data)
+      def wrap_with_consolidated(base_identifier, supplements_data)
         supplement_ids = supplements_data.map do |supp|
           if supp[:type] == :amendment
             Identifiers::Amendment.new(
-              base: base,
+              base_identifier: base_identifier,
               amendment_number: supp[:number],
               amendment_year: supp[:year]&.to_i,
             )
           else
             corr_attrs = {
-              base: base,
+              base_identifier: base_identifier,
               corrigendum_number: supp[:number],
               corrigendum_year: supp[:year]&.to_i,
             }
@@ -279,7 +247,7 @@ module Pubid
         end
 
         Identifiers::ConsolidatedIdentifier.new(
-          identifiers: [base] + supplement_ids,
+          identifiers: [base_identifier] + supplement_ids,
         )
       end
 
@@ -328,8 +296,8 @@ module Pubid
         # Build base identifier first (without supplements)
         base_data = data.dup
         base_data.delete(:supplements)
-        base = locate_identifier_klass(base_data).new
-        assign_attributes(base, base_data)
+        base_identifier = locate_identifier_klass(base_data).new
+        assign_attributes(base_identifier, base_data)
 
         # Get the first supplement (slash means only one supplement)
         supp_array = data[:supplements]
@@ -339,13 +307,13 @@ module Pubid
         # Build appropriate supplement identifier
         if supp_data[:amd_number]
           Identifiers::Amendment.new(
-            base: base,
+            base_identifier: base_identifier,
             amendment_number: supp_data[:amd_number].to_s,
             amendment_year: supp_data[:amd_year]&.to_i,
           )
         else
           corr_attrs = {
-            base: base,
+            base_identifier: base_identifier,
             corrigendum_number: supp_data[:cor_number]&.to_s,
             corrigendum_year: (supp_data[:cor_year] || supp_data[:year])&.to_i,
           }

data/lib/pubid/cen_cenelec/identifier.rb

@@ -2,36 +2,13 @@
 
 module Pubid
   module CenCenelec
-    # Common base class for all CEN/CENELEC identifiers. CEN/CENELEC has a split
-    # hierarchy — some concrete types descend from Identifiers::Base, others from
-    # SingleIdentifier — so this class is the shared parent of BOTH, making every
-    # CEN/CENELEC identifier `is_a?(Pubid::CenCenelec::Identifier)` natively (and
-    # giving them the shared polymorphic `from_hash`). No facade needed.
-    class Identifier < ::Pubid::Identifier
-      # `number`/`part`/`subpart` are declared here rather than inherited as a
-      # Components::Code: CEN/CENELEC stores a bare string in every one of them.
-      # This class is the shared parent of BOTH branches, so one declaration
-      # here replaces the three that used to disagree (Identifiers::Base said
-      # :string, SingleIdentifier inherited Code, SupplementIdentifier declared
-      # Code again). Declaring here is safe because this body lives in one file
-      # and is never reopened, so every subclass body opens after it has run
-      # (lutaml deep-dups the parent attribute table at class-definition time).
-      attribute :number, :string
-      attribute :part, :string
-      attribute :subpart, :string
-
+    module Identifier
       def self.parse(identifier)
-        unless identifier.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
+        scheme = Scheme.new
         parsed = Parser.parse(identifier)
-        Builder.new.build(parsed)
+        Builder.new(scheme).build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse CEN identifier '#{identifier}': #{e.message}"
       end
     end
   end

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

@@ -8,15 +8,10 @@ module Pubid
       class AdoptedEuropeanNorm < EuropeanNorm
         attribute :adopted_identifier, Base, polymorphic: true # ISO/IEC/IEEE object
 
-        # 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
+        def to_s
+          result = publisher.is_a?(Array) ? publisher.join("/") : publisher.join("/")
+          result += " #{adopted_identifier}" if adopted_identifier
+          result
         end
 
         # Delegate common methods to adopted identifier

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

@@ -6,12 +6,22 @@ module Pubid
       # Amendment Identifier
       # Contains a base identifier plus amendment parameters
       class Amendment < Base
-        attribute :base, Base, polymorphic: true
+        attribute :base_identifier, Base, polymorphic: true
         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
+        end
+
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
       end
     end

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

@@ -3,18 +3,16 @@
 module Pubid
   module CenCenelec
     module Identifiers
-      # Base CEN identifier (one of two roots; see Pubid::CenCenelec::Identifier).
+      # Base CEN identifier
       # Format: {PUBLISHER} NUMBER[-PART]:YEAR
-      class Base < Pubid::CenCenelec::Identifier
+      class Base < Pubid::Identifier
         # Generate URN for this identifier
         #
         # @return [String] URN representation
 
         attribute :publisher, :string, collection: true # EN, CEN, CLC, etc.
         attribute :type, :string # TR, TS, Guide
-        # `number` is inherited as a :string from Pubid::CenCenelec::Identifier;
-        # a same-type redeclaration here is the determinism landmine in
-        # miniature, and it moves the generated accessor onto this class.
+        attribute :number, :string
         attribute :parts, :string, collection: true
         attribute :year, :integer
         attribute :stage, :string # prEN, FprEN
@@ -22,6 +20,49 @@ 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
+        end
+
         def ==(other)
           return false unless other.is_a?(Base)
 

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

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

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

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