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

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

@@ -2,73 +2,37 @@
 
 module Pubid
   module Etsi
-    # Base class for all ETSI identifiers. Canonical name Pubid::Etsi::Identifier;
-    # every concrete ETSI identifier descends from it.
-    class Identifier < ::Pubid::Identifier
-      # Let Parslet::ParseFailed propagate on a bad reference (matching ISO), so
-      # relaton-cli's `rescue Parslet::ParseFailed` fetch handler catches it
-      # instead of a bare RuntimeError.
-      def self.parse(identifier)
-        unless identifier.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
+    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
 
-        if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        def to_s
+          result = "#{publisher} #{type} #{code}"
+          result += " #{version} (#{date.year}-#{date.month.to_s.rjust(2,
+                                                                       '0')})"
+          result
         end
 
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      end
-
-      attribute :type, :string
-      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?(Pubid::Etsi::Identifier)
-
-        type == other.type &&
-          code == other.code &&
-          version == other.version &&
-          date == other.date
-      end
-
-      # The document code is composed from the split index columns declared on
-      # EtsiStandard (`number`/`minor`/`parts`). Returning nil here keeps `==`
-      # and the URN generator total for the abstract base and for a supplement
-      # whose own base is missing; EtsiStandard composes the real value and
-      # SupplementIdentifier delegates to its base.
-      def code
-        nil
-      end
+        def ==(other)
+          return false unless other.is_a?(Base)
 
-      # `parts` is a plain collection attribute on the leaf, so the base
-      # #exclude reaches it directly and nils it. It must come back as an EMPTY
-      # ARRAY instead: a part-less reference parses with `parts` defaulting to
-      # [], so a nil here would make `==` — and therefore #matches? — fail
-      # against exactly the reference this exclusion exists to match. Same
-      # "reset the whole cluster" rule recorded for CSA's year and IEEE's
-      # year/month/day in CLAUDE.md.
-      #
-      # This also covers supplements: the base #exclude recurses into the
-      # nested `base` identifier through exclude_from_nested, which re-enters
-      # this method on the inner EtsiStandard.
-      def exclude(*args)
-        result = super
-        part_keys = args & %i[part parts]
-        if !part_keys.empty? && result.respond_to?(:parts=)
-          result.parts = []
+          type == other.type &&
+            code == other.code &&
+            version == other.version &&
+            date == other.date
         end
-        result
       end
     end
-
   end
 end

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

@@ -4,218 +4,15 @@ module Pubid
   module Etsi
     module Identifiers
       # Single class for all ETSI standard types
-      # Type is passed as parameter: EN, ES, EG, TS, ETR, ETS, I-ETS, TBR,
-      # TCRTR, NET, GR, GS, SR, TR, GTS
+      # Type is passed as parameter: EN, ES, EG, TS, ETR, ETS, I-ETS, TBR, TCRTR, NET, GR, GS, SR, TR, GTS
       # Format: ETSI TYPE CODE VERSION (DATE)
       # Examples:
       #   ETSI GS ZSM 012 V1.1.1 (2022-12)
       #   ETSI GR ZSM 009-3 V1.1.1 (2023-08)
       #   ETSI GTS GSM 02.01 V5.5.0 (1999-01)
-      class EtsiStandard < Identifier
-        # Type is stored in @type attribute from Identifier
-        # All rendering handled by Identifier class
-
-        # --- Index columns -------------------------------------------------
-        #
-        # relaton-index sorts and bsearches every row on `id.root.number.to_s`,
-        # so the document number must be reachable as `number`. ETSI used to
-        # keep it inside an Etsi::Components::Code under a `code` attribute,
-        # leaving the inherited `number` nil and every index row keyed "".
-        #
-        # The three Code fields are now plain sibling attributes, which is the
-        # shape the serialized hash ALREADY had — the converters below merely
-        # read them directly instead of reaching through `code`, so the wire
-        # format is byte-identical and relaton-data-etsi's published index-v2
-        # needs no regeneration.
-        #
-        # `number` holds the BARE number ("300 175"), never the part, so all
-        # parts of a document share one index bucket and a part-less reference
-        # finds them all — the IEEE/ISO semantics documented in CLAUDE.md.
-        #
-        # LANDMINE: these redeclare attributes inherited from ::Pubid::Identifier
-        # (`number` is a Components::Code there, and Etsi::Components::Code is
-        # NOT a subclass of it). That resolves nondeterministically under
-        # multi-flavor load when declared on a class others inherit from, so it
-        # is confined to this LEAF — EtsiStandard has no subclasses, while the
-        # shared Pubid::Etsi::Identifier is also SupplementIdentifier's parent
-        # and must stay untouched. spec/pubid/etsi/root_number_spec.rb carries
-        # the tripwire and is only meaningful under the full `rake` suite.
-        attribute :number, :string
-        attribute :minor, :string
-        attribute :parts, :string, collection: true, default: -> { [] }
-
-        # Compact serialization (mirrors ISO/JCGM/OIML): the code fields are
-        # bare scalars (`number`, a `parts` array and, rarely, a `minor`);
-        # Version flattens to a scalar `version` string with an `is_edition`
-        # boolean flag (omitted when false); Date flattens to top-level
-        # year/month/day. The constant `publisher` ("ETSI") is intentionally
-        # NOT mapped — it is reconstructed on load from its attribute default,
-        # keeping the hash compact.
-        #
-        # This block lives on EtsiStandard (a leaf) rather than the shared Identifier:
-        # SupplementIdentifier is a sibling that DELEGATES type/code/version and
-        # date to its inner `base`, so a block on Identifier would be inherited-and-
-        # merged by the supplement and re-emit every delegated field at the top.
-        key_value do
-          map "_type",      to: :_type
-          map "type",       to: :type
-          map "number",     to: :number
-          map "parts",      to: :parts
-          map "minor",      to: :minor
-          map "version",    with: { to: :version_to_kv, from: :version_from_kv }
-          map "is_edition", with: { to: :edition_to_kv, from: :edition_from_kv }
-          map "year",       with: { to: :year_to_kv,  from: :year_from_kv }
-          map "month",      with: { to: :month_to_kv, from: :month_from_kv }
-          map "day",        with: { to: :day_to_kv,   from: :day_from_kv }
-        end
-
-        # The composed document code, rebuilt on demand from the split columns
-        # so the renderer, the URN generator and #== keep one place to ask for
-        # the printed form ("300 175-1"). Deliberately NOT an attribute and NOT
-        # memoised: `number`/`parts` are writable (the base #exclude rebuilds
-        # through them), so a cached Code would go stale.
-        #
-        # nil when there is no number, preserving the old nil-`code` semantics
-        # the URN generator branches on.
-        def code
-          return nil if number.nil?
-
-          Pubid::Etsi::Components::Code.new(
-            number: number,
-            minor: minor,
-            parts: parts || [],
-          )
-        end
-
-        # MR slug number segment.
-        #
-        # The base hook reads the inherited `number` and `part`; ETSI kept
-        # neither, so before the index columns landed every ETSI slug was just
-        # `etsi.<date>` — 454 distinct slugs for 24,724 documents, and
-        # `to_slug` is what consumers use as an output FILENAME.
-        #
-        # Two things the base hook cannot do for ETSI:
-        #   * the parts live in the `parts` collection, not the inherited
-        #     scalar `part`, so they must be appended here or every part of a
-        #     document collapses onto one slug;
-        #   * an ETSI number legitimately contains a SPACE ("300 175", "GSM
-        #     02.01"), which is outside the [a-z0-9.-] charset Renderers::MrString
-        #     documents and guarantees. Sanitize BY CHARSET rather than by an
-        #     enumerated escape list (the BIPM `mr_slug` precedent in
-        #     CLAUDE.md), so a character added later cannot reach a filename.
-        # `minor` is included because it is identity-bearing everywhere else —
-        # Code#== compares it, Code#to_s renders it and the URN carries it — so
-        # omitting it here would let two distinct documents share one filename.
-        # No fixture populates it today; it is in the grammar, so it is here.
-        def mr_number_with_part
-          return nil if number.nil?
-
-          mr_sanitize([number, minor, *Array(parts)].compact.join("-"))
-        end
-
-        # ETSI's identity is type + code + version + date (see
-        # Pubid::Etsi::Identifier#==), so all four must reach the slug —
-        # CLAUDE.md's rule that an identity-bearing marker has to appear on
-        # every identity surface, not just in `==`. The base hooks find
-        # neither: `mr_type` reads `typed_stage` (ETSI has none) and
-        # `mr_edition` reads `edition.number` (ETSI models the edition as
-        # `version`). Without these, "ETSI EN 300 729 V6.1.1 (2000-04)",
-        # "…V7.1.1 (2000-04)" and "ETSI ETS 300 729 ed.2 (2000-04)" all share
-        # one slug — i.e. one output filename.
-        def mr_type
-          type&.to_s&.downcase
-        end
-
-        def mr_edition
-          mr_sanitize(version&.version)
-        end
-
-        # Segment sanitizer. Renderers::MrString joins SEGMENTS with ".", so a
-        # dot inside one would break that structure — hence "." is replaced
-        # here even though it is inside the renderer's overall charset (the
-        # BIPM `bipm.si-brochure.9e-v3-01.e` precedent in CLAUDE.md). Filtering
-        # by charset rather than by an enumerated escape list keeps a character
-        # introduced later from leaking into a filename.
-        #
-        # Public purely to keep this file's surface flat, next to the
-        # lutaml-invoked converters below — it has no external callers and
-        # would work as well private.
-        #
-        # The emptiness check is on the OUTPUT, not just the input: a value
-        # made entirely of characters outside the charset collapses to "-" and
-        # then to "", and an empty string is truthy in Ruby, so it would reach
-        # Renderers::MrString as a blank segment and produce a double dot in
-        # the joined slug. Unreachable from today's grammar, which only feeds
-        # digit/alnum captures here — but not structurally prevented.
-        def mr_sanitize(value)
-          return nil if value.nil? || value.to_s.empty?
-
-          sanitized = value.to_s.downcase
-            .gsub(/[^a-z0-9-]+/, "-").gsub(/\A-+|-+\z/, "")
-          sanitized.empty? ? nil : sanitized
-        end
-
-        # --- Version flattened to scalar version + is_edition flag ---
-        def version_to_kv(model, doc)
-          emit_kv(doc, "version", model.version&.version)
-        end
-
-        def version_from_kv(model, value)
-          version_for(model).version = value.to_s
-        end
-
-        def edition_to_kv(model, doc)
-          return unless model.version&.is_edition
-
-          doc.add_child(
-            Lutaml::KeyValue::DataModel::Element.new("is_edition", true),
-          )
-        end
-
-        def edition_from_kv(model, value)
-          version_for(model).is_edition = value
-        end
-
-        # --- Date flattened to top-level year/month/day scalars ---
-        def year_to_kv(model, doc)
-          emit_kv(doc, "year", model.date&.year)
-        end
-
-        def month_to_kv(model, doc)
-          emit_kv(doc, "month", model.date&.month)
-        end
-
-        def day_to_kv(model, doc)
-          emit_kv(doc, "day", model.date&.day)
-        end
-
-        def year_from_kv(model, value)
-          date_for(model).year = value.to_s
-        end
-
-        def month_from_kv(model, value)
-          date_for(model).month = value.to_s
-        end
-
-        def day_from_kv(model, value)
-          date_for(model).day = value.to_s
-        end
-
-        def emit_kv(doc, key, value)
-          return if value.nil? || value.to_s.empty?
-
-          doc.add_child(
-            Lutaml::KeyValue::DataModel::Element.new(key, value.to_s),
-          )
-        end
-
-        def version_for(model)
-          model.version ||= Pubid::Etsi::Components::Version.new
-        end
-
-        def date_for(model)
-          model.date ||= Pubid::Components::Date.new
-        end
+      class EtsiStandard < Base
+        # Type is stored in @type attribute from Base
+        # All rendering handled by Base class
       end
     end
   end

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

@@ -3,43 +3,11 @@
 module Pubid
   module Etsi
     module Identifiers
-      # Identifier class for ETSI supplements (Amendment, Corrigendum)
-      class SupplementIdentifier < Identifier
-        attribute :base, Pubid::Etsi::Identifier
+      # Base class for ETSI supplements (Amendment, Corrigendum)
+      class SupplementIdentifier < Base
+        attribute :base, Pubid::Etsi::Identifiers::Base
         attribute :number, :integer
 
-        # Compact serialization: a supplement carries only its own ordinal
-        # `number` (A1 -> 1) and the nested base standard under the compact key
-        # `base`. type/code/version/date are delegated to `base` (methods below)
-        # and NOT re-emitted here, so the old redundant duplication is gone.
-        # This block is inherited unchanged by Amendment/Corrigendum.
-        key_value do
-          map "_type",  to: :_type
-          map "number", to: :number
-          map "base",   with: { to: :base_to_kv, from: :base_from_kv }
-        end
-
-        # Serialize the base via its own to_hash so it collapses to the compact
-        # EtsiStandard shape.
-        def base_to_kv(model, doc)
-          return unless model.base
-
-          doc.add_child(
-            Lutaml::KeyValue::DataModel::Element.new(
-              "base", model.base.to_hash
-            ),
-          )
-        end
-
-        # Re-dispatch through the flavor base so `_type` resolves to the
-        # concrete EtsiStandard; a bare polymorphic cast would rebuild a plain
-        # Identifier and lose the subclass (and its custom mappings). Mirrors JCGM.
-        def base_from_kv(model, value)
-          return unless value
-
-          model.base = Pubid::Etsi::Identifier.from_hash(value)
-        end
-
         # Inherit attributes from base
         def type
           base.type
@@ -57,7 +25,17 @@ module Pubid
           base.date
         end
 
-        # Render via renderer
+        # Render as: ETSI TYPE CODE/SUPPLEMENTS VERSION (DATE)
+        # When multiple supplements are present, they appear in order: /A1/C1
+        def to_s
+          supplement_notations = collect_supplement_notations(self, [])
+          # Get the actual base ETSI standard (not supplements)
+          actual_base = find_actual_base(base)
+          code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
+          "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.year}-#{actual_base.date.month.to_s.rjust(
+            2, '0'
+          )})"
+        end
 
         # Recursively collect supplement notations from the supplement chain
         def collect_supplement_notations(current_supplement, notations)
@@ -88,16 +66,6 @@ module Pubid
           raise NotImplementedError
         end
 
-        # Make Renderers::MrString recurse into `base` instead of slugging the
-        # supplement flat. Without this the flat path reads the supplement's own
-        # `number` — its ordinal, 1 — and the base document is dropped entirely,
-        # so every "/C1" corrigendum published in one month shared the slug
-        # `etsi.1.<date>`. `to_slug` is an output FILENAME, so that is an
-        # overwrite. Same fix as ITU's AnnexOfRecommendation (see CLAUDE.md).
-        def mr_supplement_suffix
-          [supplement_notation.to_s.downcase, number].compact.join(".")
-        end
-
         def ==(other)
           return false unless other.is_a?(SupplementIdentifier)
           return false unless other.class == self.class

data/lib/pubid/etsi/identifiers.rb

@@ -4,6 +4,7 @@ module Pubid
   module Etsi
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :EtsiStandard, "#{__dir__}/identifiers/etsi_standard"
       autoload :SupplementIdentifier,

data/lib/pubid/etsi/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Etsi
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic elements
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
@@ -114,19 +114,13 @@ module Pubid
       end
 
       # Main identifier
-      #
-      # The mandatory core is `etsi_prefix type number` (+ optional
-      # minor/parts/supplements), mirroring ISO. The version/edition and date
-      # suffixes are optional so a partial reference (e.g. "ETSI GS ZSM 012")
-      # parses with version/date left nil. Each `.maybe` guards its own leading
-      # space so no trailing space is demanded when the suffix is absent.
       rule(:identifier) do
         etsi_prefix >>
           type >> space >>
           number >> minor.maybe >> parts >>
           supplements.maybe >>
-          (space >> version_or_edition).maybe >>
-          (space >> date_part).maybe
+          space >> version_or_edition >>
+          space >> date_part
       end
 
       rule(:root) { identifier }

data/lib/pubid/etsi/scheme.rb

@@ -0,0 +1,42 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    class Scheme < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :number, :string
+      attribute :part, :string, collection: true, default: -> { [] }
+      attribute :version, :string, default: -> {}
+      attribute :edition, :string, default: -> {}
+      attribute :date, :string
+      attribute :amendment, :string, default: -> {}
+      attribute :corrigendum, :string, default: -> {}
+
+      def to_s
+        result = "ETSI #{type} #{number}"
+
+        # Add parts
+        part.each do |p|
+          result += "-#{p}"
+        end
+
+        # Add amendment or corrigendum
+        result += "/A#{amendment}" if amendment
+        result += "/C#{corrigendum}" if corrigendum
+
+        # Add version or edition
+        if version
+          result += " V#{version}"
+        elsif edition
+          result += " ed.#{edition}"
+        end
+
+        # Add date (only if present)
+        result += " (#{date})" if date
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/etsi.rb

@@ -4,67 +4,17 @@ require "lutaml/model"
 
 module Pubid
   module Etsi
-    extend Pubid::PrefixesSupport
-
-    # Sole ETSI publisher token (see the parser's `etsi_prefix` rule). The
-    # document-type tokens (EN, TS, TR, ...) are sub-types that follow the ETSI
-    # prefix, not standalone routing tokens, so they are excluded.
-    PREFIXES = ["ETSI"].freeze
-
     autoload :Builder, "#{__dir__}/etsi/builder"
     autoload :Components, "#{__dir__}/etsi/components"
-    autoload :Identifier, "#{__dir__}/etsi/identifiers/base"
+    autoload :Identifier, "#{__dir__}/etsi/identifier"
     autoload :Identifiers, "#{__dir__}/etsi/identifiers"
     autoload :Parser, "#{__dir__}/etsi/parser"
-    autoload :Renderer, "#{__dir__}/etsi/renderer"
+    autoload :Scheme, "#{__dir__}/etsi/scheme"
     autoload :UrnGenerator, "#{__dir__}/etsi/urn_generator"
-    autoload :UrnParser, "#{__dir__}/etsi/urn_parser"
 
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Etsi::Renderer)
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
-    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 < Pubid::Identifier }
-        # Exclude the flavor base itself by identity (Identifier is now an
-        # alias for Pubid::Etsi::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifier }
-    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/export/data_class_exporter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Strategy for flavors using Lutaml::Model::Serializable as their Scheme
+    # (ETSI, Plateau). These have identifier classes in the Identifiers module
+    # that may not have def self.type.
+    class DataClassExporter < FlavorExporter
+      def export
+        klasses = resolve_identifier_classes_from_module
+        return nil if klasses.empty?
+
+        fixture_data = fixture_examples
+
+        identifier_types = klasses.map do |klass|
+          info = extract_type_info(klass)
+          type_key = info[:key]
+          examples = fixture_data[type_key] || fixture_data[type_key.to_s] || []
+
+          IdentifierTypeResult.new(
+            key: info[:key],
+            title: info[:title],
+            short: info[:short],
+            abbr: info[:abbr],
+            typed_stages: [],
+            examples: examples,
+          )
+        end
+
+        scheme = scheme_class
+        attrs = scheme&.methods&.include?(:attributes) ? scheme.attributes.keys.map(&:to_s) : []
+
+        FlavorResult.new(
+          flavor: flavor,
+          identifier_types: identifier_types,
+          attributes: attrs,
+        )
+      end
+
+      private
+
+      def resolve_identifier_classes_from_module
+        mod = scheme_module
+        return [] unless mod
+
+        idents_mod = mod.const_get(:Identifiers)
+        skip = %w[Base Supplement]
+
+        idents_mod.constants.filter_map do |c|
+          klass = begin; idents_mod.const_get(c); rescue NameError; next; end
+          next unless klass.is_a?(Class)
+          next if skip.include?(klass.name&.split("::")&.last)
+
+          klass
+        end
+      end
+    end
+  end
+end