pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

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

@@ -2,15 +2,15 @@
 
 module Pubid
   module Etsi
-    # 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.
+    # 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)
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
       end
 
       attribute :type, :string
@@ -31,12 +31,30 @@ module Pubid
           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
+      private
+
+      # ETSI keeps the number and part together inside one Code component
+      # (unlike ISO's separate `part` attribute), so a top-level exclude(:part)
+      # can't reach the part. Handle it during the nested-exclusion pass: when
+      # :part/:parts is excluded, return a copy of the Code with its parts
+      # cleared while keeping the number/minor. This propagates into supplement
+      # wrappers too, because the base #exclude recurses through here with the
+      # original args. It lets a part-less reference match all parts via
+      # matches?(ignore: [..., :part]).
+      def exclude_from_nested(value, args)
+        part_keys = args & %i[part parts]
+        if value.is_a?(Pubid::Etsi::Components::Code) && !part_keys.empty?
+          return Pubid::Etsi::Components::Code.new(
+            number: value.number,
+            minor: value.minor,
+            parts: [],
+          )
+        end
+
+        super
+      end
     end
+
   end
 end

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

@@ -4,15 +4,139 @@ 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 < Base
-        # Type is stored in @type attribute from Base
-        # All rendering handled by Base class
+      class EtsiStandard < Identifier
+        # Type is stored in @type attribute from Identifier
+        # All rendering handled by Identifier class
+
+        # Compact serialization (mirrors ISO/JCGM/OIML): the Code component
+        # collapses to a bare `number` scalar (plus a `parts` array and, rarely,
+        # a `minor` scalar); 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",     with: { to: :number_to_kv, from: :number_from_kv }
+          map "parts",      with: { to: :parts_to_kv,  from: :parts_from_kv }
+          map "minor",      with: { to: :minor_to_kv,  from: :minor_from_kv }
+          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
+
+        # --- Code component flattened to bare number / parts / minor ---
+        def number_to_kv(model, doc)
+          emit_kv(doc, "number", model.code&.number)
+        end
+
+        def number_from_kv(model, value)
+          code_for(model).number = value.to_s
+        end
+
+        def minor_to_kv(model, doc)
+          emit_kv(doc, "minor", model.code&.minor)
+        end
+
+        def minor_from_kv(model, value)
+          code_for(model).minor = value.to_s
+        end
+
+        def parts_to_kv(model, doc)
+          parts = model.code&.parts
+          return if parts.nil? || parts.empty?
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new(
+              "parts", parts.map(&:to_s)
+            ),
+          )
+        end
+
+        def parts_from_kv(model, value)
+          code_for(model).parts = Array(value).map(&:to_s)
+        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 code_for(model)
+          model.code ||= Pubid::Etsi::Components::Code.new
+        end
+
+        def version_for(model)
+          model.version ||= Pubid::Etsi::Components::Version.new
+        end
+
+        def date_for(model)
+          model.date ||= Pubid::Components::Date.new
+        end
       end
     end
   end

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

@@ -3,11 +3,43 @@
 module Pubid
   module Etsi
     module Identifiers
-      # Base class for ETSI supplements (Amendment, Corrigendum)
-      class SupplementIdentifier < Base
-        attribute :base, Pubid::Etsi::Identifiers::Base
+      # Identifier class for ETSI supplements (Amendment, Corrigendum)
+      class SupplementIdentifier < Identifier
+        attribute :base, Pubid::Etsi::Identifier
         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

data/lib/pubid/etsi/identifiers.rb

@@ -4,7 +4,6 @@ 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

@@ -114,13 +114,19 @@ 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 >>
-          space >> date_part
+          (space >> version_or_edition).maybe >>
+          (space >> date_part).maybe
       end
 
       rule(:root) { identifier }

data/lib/pubid/etsi/renderer.rb

@@ -27,7 +27,10 @@ module Pubid
 
       def render_base(id)
         result = "#{id.publisher} #{id.type} #{id.code}"
-        result += " #{id.version} (#{id.date.render})"
+        # version/date are optional on partial references; append each only when
+        # present so a partial id renders without a stray " V… ()" suffix.
+        result += " #{id.version}" if id.version
+        result += " (#{id.date.render})" if id.date
         result
       end
 
@@ -35,7 +38,10 @@ module Pubid
         supplement_notations = id.collect_supplement_notations(id, [])
         actual_base = id.find_actual_base(id.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.render})"
+        result = "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements}"
+        result += " #{actual_base.version}" if actual_base.version
+        result += " (#{actual_base.date.render})" if actual_base.date
+        result
       end
     end
   end

data/lib/pubid/etsi.rb

@@ -13,7 +13,7 @@ module Pubid
 
     autoload :Builder, "#{__dir__}/etsi/builder"
     autoload :Components, "#{__dir__}/etsi/components"
-    autoload :Identifier, "#{__dir__}/etsi/identifier"
+    autoload :Identifier, "#{__dir__}/etsi/identifiers/base"
     autoload :Identifiers, "#{__dir__}/etsi/identifiers"
     autoload :Parser, "#{__dir__}/etsi/parser"
     autoload :Renderer, "#{__dir__}/etsi/renderer"
@@ -25,8 +25,8 @@ module Pubid
     end
 
     # Per-flavor format registry: inherits global formats, overrides :human
-    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifiers::Base.format_registry.register(:human, renderer: Etsi::Renderer)
+    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)
@@ -34,9 +34,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 }
-        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # 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 == Identifiers::Base }
+        .reject { |c| c == Identifier }
     end
 
     # Build typed stage index from identifier types

data/lib/pubid/export/exporter.rb

@@ -9,7 +9,8 @@ module Pubid
     class Exporter
       FLAVORS = %i[
         iso iec ieee nist bsi itu cen_cenelec etsi ansi astm ashrae asme
-        ccsds cie csa jis jcgm oiml idf api amca plateau sae
+        ccsds cie csa ecma jis jcgm oiml idf api amca plateau sae ogc ietf tgpp w3c xsf
+        bipm iana oasis calconnect
       ].freeze
 
       # Export all flavors to a hash suitable for JSON serialization.

data/lib/pubid/export/flavor_exporter.rb

@@ -78,10 +78,25 @@ module Pubid
       # Scan Identifiers namespace for all Pubid::Identifier subclasses,
       # excluding structural base classes.
       def discover_from_namespace(mod)
-        return [] unless mod.const_defined?(:Identifiers)
+        if mod.const_defined?(:Identifiers)
+          classes = collect_identifier_classes(mod.const_get(:Identifiers))
+          return classes unless classes.empty?
+        end
+
+        # Single-class flavors (e.g. SAE) expose no concrete types under
+        # Identifiers — the flavor's own Identifier class IS the sole document
+        # type (previously discovered via the removed Identifiers::Base alias).
+        Array(single_class_flavor_type(mod))
+      end
+
+      # The flavor's own `Identifier` class when it is a concrete
+      # Pubid::Identifier subclass, else nil (used as the sole type for
+      # single-class flavors with an empty Identifiers namespace).
+      def single_class_flavor_type(mod)
+        return unless mod.const_defined?(:Identifier)
 
-        idents_mod = mod.const_get(:Identifiers)
-        collect_identifier_classes(idents_mod)
+        ident = mod.const_get(:Identifier)
+        ident if ident.is_a?(Class) && ident < Pubid::Identifier
       end
 
       # Recursively collect all Pubid::Identifier subclasses from a module,

data/lib/pubid/gb/builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    # Builds a Pubid::Gb::Identifier from a parse tree.
+    #
+    # The parser captures the publisher code verbatim (which may already
+    # include the "/T" or "/Z" suffix). The builder normalizes: if the
+    # suffix is in the publisher_code string, it's split out into the
+    # separate +mandate+ attribute so the renderer can recompose either
+    # the inline or split form.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        publisher_code, mandate = split_mandate(data[:publisher_code].to_s)
+
+        mandate ||= data[:mandate]&.to_s
+
+        Identifiers::Standard.new(
+          publisher_code: publisher_code,
+          mandate: mandate,
+          number: data[:number].to_s,
+          part: data[:part]&.to_s,
+          date: data[:year] ? ::Pubid::Components::Date.new(year: data[:year].to_s) : nil,
+          all_parts: !data[:all_parts].to_s.empty?,
+        )
+      end
+
+      private
+
+      # If the publisher code carries an inline /T or /Z suffix, split it off
+      # and return the cleaned code + extracted mandate.
+      def split_mandate(code)
+        if code =~ %r{\A(.*?)/(T|Z)\z}
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        else
+          [code, nil]
+        end
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    # Base class for every Chinese Standard identifier AND the flavor's
+    # parse/create entry point. Concrete types under Pubid::Gb::Identifiers
+    # descend from this class, so a parsed GB id is always an instance of
+    # Pubid::Gb::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # The issuing body code as printed, e.g. "GB", "JB", "T/GZAEPI".
+      # Always non-empty for a valid identifier.
+      attribute :publisher_code, :string
+
+      # Mandate category: "T" (recommended), "Z" (guideline), or nil
+      # (mandatory). Carried after the "/" in the printed form.
+      attribute :mandate, :string
+
+      # Document number (digits, possibly dotted with part). Required.
+      # Examples: "20223", "5606.1", "001".
+      attribute :number, :string
+
+      # Optional part. Captured separately from #number when the input
+      # uses the dotted form (e.g. "5606.1" => number "5606", part "1").
+      attribute :part, :string
+
+      # All-parts flag — true for "GB/T 5606 (all parts)" forms.
+      attribute :all_parts, :boolean, default: -> { false }
+
+      # Polymorphic type map for lutaml key_value (de)serialization.
+      GB_TYPE_MAP = {
+        "pubid:gb:standard" => "Pubid::Gb::Identifiers::Standard",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: GB_TYPE_MAP
+        map "publisher_code", to: :publisher_code
+        map "mandate", to: :mandate
+        map "number", to: :number
+        map "part", to: :part
+        map "all_parts", to: :all_parts, render_default: false
+      end
+
+      PUBLISHER = "CN"
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # Parse a Chinese Standard identifier string.
+      # @param identifier [String]
+      # @return [Pubid::Gb::Identifier]
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse Chinese Standard identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifiers/standard.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    module Identifiers
+      # The default Chinese Standard identifier type. The class name yields
+      # the polymorphic _type tag "pubid:gb:standard".
+      #
+      # Examples:
+      #   GB/T 20223-2006
+      #   GB/T 5606.1-2004
+      #   GB/T 5606 (all parts)
+      #   JB/T 13368-2018
+      #   T/GZAEPI 001—2018
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubgb,
+            stage_code: :published,
+            type_code: :gb,
+            abbr: ["GB"],
+            name: "Chinese Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :gb, web: :chinese_standard, title: "Chinese Standard",
+            short: "GB" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/gb/parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Gb
+    # Parslet grammar for Chinese Standard identifiers.
+    #
+    # Accepts the canonical printed form
+    #
+    #   {PUBLISHER}[/{TYPE}] {NUMBER}[.{PART}][-|—{YEAR}] [(all parts)]
+    #
+    # PUBLISHER is one of the leading tokens from PREFIXES (GB, GB/T, JB,
+    # T/GZAEPI, ...). TYPE is T (recommended), Z (guideline), or omitted.
+    # YEAR is 4 digits, separated by either ASCII dash or em-dash (Chinese
+    # typography uses the em-dash form).
+    class Parser < Parslet::Parser
+      rule(:space)  { str(" ") }
+      rule(:dot)    { str(".") }
+      rule(:dash)   { str("-") | str("—") }
+      rule(:digits) { match("[0-9]").repeat(1) }
+
+      # Publisher token: national/industry codes (1-3 letters, optionally
+      # followed by /T or /Z) OR social-group form "T/{ACRONYM}".
+      rule(:publisher_code) do
+        # Social-group form: "T/" then 2+ uppercase letters/digits.
+        (str("T/") >> match("[A-Z0-9]").repeat(1)).as(:publisher_code) |
+          # Standard form: 1-3 letters, optional slash-T-or-Z.
+          (match("[A-Z]").repeat(1, 3) >>
+            (str("/T") | str("/Z")).maybe).as(:publisher_code)
+      end
+
+      # Mandate category captured separately when the publisher token didn't
+      # already include it. Allows "GB/T" (inline) and "GB" + " T" (separate)
+      # to both parse.
+      rule(:mandate_suffix) do
+        (str("/") >> (str("T") | str("Z")).as(:mandate)).maybe
+      end
+
+      rule(:number) { digits.as(:number) }
+      rule(:part)   { dot >> digits.as(:part) }
+      rule(:year)   { (dash >> match("[0-9]").repeat(4, 4).as(:year)).maybe }
+      rule(:all_parts_flag) do
+        (space >> str("(") >> str("all parts") >> str(")")).as(:all_parts)
+      end
+
+      rule(:identifier) do
+        publisher_code >>
+          space >>
+          number >>
+          part.maybe >>
+          year >>
+          all_parts_flag.maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/gb/renderer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    # Human-readable renderer for Chinese Standard identifiers.
+    #
+    # Produces the canonical printed form:
+    #   "GB/T 20223-2006"
+    #   "GB/T 5606.1-2004"
+    #   "GB/T 5606 (all parts)"
+    #   "T/GZAEPI 001—2018"     (social-group form, em-dash year)
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        parts = [publisher_portion, " #{number_portion}"]
+        parts << " (all parts)" if @id.all_parts
+        parts.join
+      end
+
+      private
+
+      def publisher_portion
+        code = @id.publisher_code.to_s
+        code += "/#{@id.mandate}" if @id.mandate && !@id.publisher_code.include?("/")
+        code
+      end
+
+      def number_portion
+        result = @id.number.to_s
+        result += ".#{@id.part}" if @id.part
+        result += "-#{@id.year}" if @id.year
+        result
+      end
+    end
+  end
+end