pubid 2.0.25 → 2.0.27

data/lib/pubid/cen_pfs/urn_generator.rb

@@ -1,12 +1,84 @@
 module Pubid
   module CenPfs
-    # The official URN generator, pinned to the scheme's declared
-    # namespace ("cen") so to_urn stays
-    # scheme-canonical under the compiled flavor key.
+    # The official URN generator: the scheme's declared namespace
+    # ("cen") and the ordered fused segments
+    # (feature 6) — the publisher group, the adopted document's
+    # fused MR string, the composed code, the year, the draft
+    # stage. A wrapper reads through to its subject and appends
+    # its declared chain; the consolidated bundle marks each
+    # member with the plus marker.
     class UrnGenerator < ::Pubid::UrnGenerator::Base
       def urn_namespace
         "cen"
       end
+
+      def generate
+        id = @identifier
+        members = nil
+        frag_segments = []
+        wrapper = []
+        if id.is_a?(Identifiers::Fragment)
+          frag_segments = wrapper_segments(id)
+          id = id.base
+        end
+        if id.is_a?(Identifiers::ConsolidatedIdentifier)
+          base, *consolidated = id.identifiers
+          members = consolidated
+          id = base
+        end
+        while id.is_a?(Identifiers::Supplement)
+          wrapper.prepend(*wrapper_segments(id))
+          id = id.base
+        end
+        @identifier = id
+        parts = ["urn", urn_namespace]
+        parts.concat(official_segments)
+        parts.concat(wrapper)
+        members&.each do |member|
+          parts << "plus"
+          parts.concat(wrapper_segments(member))
+        end
+        parts.concat(frag_segments)
+        parts.join(":")
+      end
+
+      private
+
+      def official_segments
+        segments = []
+        group = [@identifier.publisher&.respond_to?(:body) ? @identifier.publisher.body : @identifier.publisher,
+                *Array(@identifier.copublishers).map { |p| p.respond_to?(:body) ? p.body : p }].compact.map(&:to_s)
+                segments << group.map(&:downcase).join("-") unless group.empty?
+        adopted = @identifier.respond_to?(:adopted) ? @identifier.adopted : nil
+                mr = adopted&.to_mr_string
+                segments << mr.tr("._", "::") unless mr.nil? || mr.empty?
+        code = []
+        code << @identifier.number.to_s if @identifier.number
+        code << "-" + @identifier.part.to_s if @identifier.part
+        segments << code.join unless code.empty?
+        date = [@identifier.date&.year].compact
+        segments << date.join("-") unless date.empty?
+        stage = @identifier.typed_stage
+                code = stage&.stage_code
+                segments << "stage." + code.to_s if code && code.to_s != "published"
+        segments
+      end
+
+      # One wrapper's declared URN chain: the kind word, then the
+      # wrapper's columns (the ordinal, the year-month date).
+      def wrapper_segments(id)
+        segments = case id
+        when Identifiers::Amendment
+          ["amd", id.number, id.year]
+        when Identifiers::Corrigendum
+          ["cor", id.number, (id.respond_to?(:supplement_date) ? id.supplement_date : [id.year, id.month].compact.join("-") )]
+        when Identifiers::Fragment
+          ["frag", id.number]
+        else
+          []
+        end
+        segments.map(&:to_s).reject(&:empty?)
+      end
     end
   end
 end

data/lib/pubid/cen_pfs.rb

@@ -1,34 +1,25 @@
 # frozen_string_literal: true
 #
 # PFS-generated flavor — DO NOT EDIT BY HAND.
-# Source: definitions/cen.pfs (pfs:1) sha256:bc1edd5874f8938b5f946416a2b052d9d9b9df3d99f6c20a3d88fcab9ae1d70c
+# Source: definitions/cen.pfs (pfs:1) sha256:b8f2c00e392dbc03c1fddedad141afa7c930c5430738721b7df0ac69a371d028
 # Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
 # Regenerate: ruby scripts/pfs compile definitions/cen.pfs --as cen_pfs --ruby-out <dir>
 
 require "pubid"
 
 module Pubid
-  # CEN/CENELEC European Norms (module composition) flavor, compiled from its PFS definition
+  # CEN/CENELEC flavor, compiled from its PFS definition
   # (pubid/pubid#706). A compiled flavor is a peer of the coded
   # flavors: same registry, same input guards, same error
   # namespace, same URN contracts.
   module CenPfs
     extend Pubid::PrefixesSupport
 
-    PREFIXES = ["EN", "CEN/", "CLC/"].freeze
-    # The module composition the definition binds (issue #706 §4):
-    # each entry names the library module, the version it was bound
-    # at, and — where the module declares one — its IDENTITY
-    # composition (wrapper-with-adopted: the adopted document is
-    # the base). Carried so consumers and the wizard can
-    # introspect what the flavor is composed of.
-    MODULES = [
-      { name: "iso.inner", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
-      { name: "en.overlay", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
-      { name: "national.prefix", version: 1, identity: { composition: "wrapper-with-adopted", base_module: "iso.inner", adopted_field: :adopted } },
-      { name: "supplements.core", version: 1, identity: { composition: "wrapper-with-adopted", adopted_field: :base } },
-    ].freeze
-
+    PREFIXES = ["CEN", "CLC", "CENELEC", "EN", "CWA", "HD", "ES", "CR", "ENV"].freeze
+    # The adopted-base dispatch hook (the §4 coded escape hatch):
+    # vendored beside the generated classes — a missing hook file
+    # fails loudly on the first adoption, never silently.
+    autoload :AdoptedBase, "#{__dir__}/cen_pfs/adopted_base"
     autoload :Builder, "#{__dir__}/cen_pfs/builder"
     autoload :Identifier, "#{__dir__}/cen_pfs/identifier"
     autoload :Identifiers, "#{__dir__}/cen_pfs/identifiers"

data/lib/pubid/doi_pfs/builder.rb

@@ -7,8 +7,8 @@
 
         def build(data)
           Identifiers::Resource.new(
-            prefix: data[:prefix],
-            suffix: data[:suffix],
+          prefix: data[:prefix],
+          suffix: data[:suffix],
           )
         end
       end

data/lib/pubid/etsi_pfs/CLAUDE.md

@@ -39,57 +39,65 @@ Measured surface (see the spec header for the numbers and their meaning):
   (all 15 type tokens; the four number shapes GSM/dotted/complex/simple;
   minor; the parts run; the /A//C supplement runs; `V`-versions and
   `ed.N`; the `(YYYY-MM)` date).
-- **to_hash and to_pubid_urn byte parity: 18,945/24,718** — exactly the
-  rows carrying none of the three constructs pfs:1 cannot declare. Each
-  gap is pinned per construct in the spec, so compiler progress turns the
-  pin red:
-  1. **collection bindings** — the coded model stores `["1","0"]` (the
-     `part -> parts[].part` binding); the compiled capture is the printed
-     dash run `"-1-0"`.
-  2. **the edition face** — the coded model folds `ed.N` into
-     `Version(version: "N", is_edition: true)`; the compiled hash carries
-     `edition: "N"`.
-  3. **supplement wrappers** — the coded model wraps `/A1` `/C1` as
-     Amendment/Corrigendum classes with an Integer ordinal delegating to
-     their base; the compiled row stays a flat etsi-standard carrying the
-     printed run `"/A1"`.
-- **to_s** renders the canonical CORE face (`ETSI <type> <number>`) —
-  pfs:1 render faces cannot render optionals, so every corpus row (all of
-  which carry version/ed + date) renders shorter; bare ids agree
-  byte-for-byte.
-- **to_urn** is a compiler gap (the coded generator is hand-written Ruby
-  composing `urn:etsi:{type}:{code}:{version}:{date}`; the generated
-  generator pins the namespace only). Note the CODED generator raises
-  `ArgumentError` on months 08/09 (`format('%02d', "08")` — the zero-padded
-  string reads as an invalid octal); pre-existing on main, pinned by the
-  parity spec.
-- **to_mr_string** is a compiler gap (the coded slug reads the flavor's
-  `mr_*` hooks — type/parts/edition/date segments; the base hooks find
-  none of them on the compiled columns).
+- **to_hash and to_pubid_urn byte parity: 24,718/24,718** (phase 3
+  closed all three constructs; the former per-construct pins are now
+  parity rows):
+  1. **collection bindings** (3,772 rows) — `parts` is a `kind: list`
+     field binding its `part` item per repetition; the compiled model
+     stores the coded `["1","0"]` array, dropped when empty.
+  2. **the edition face** (1,833 rows) — the `ed.N` capture folds onto
+     `version` + `is_edition: true` (the coded Version component shape).
+  3. **supplement wrappers** (168 rows) — the `supplements:` declaration
+     folds the printed run into SYNTHESIZED Amendment/Corrigendum classes
+     over the base standard, outermost last ("/A1/C1" is Corrigendum over
+     Amendment over the standard).
+  Trajectory: 18,945 → 22,717 (collections) → 24,718 (fold + wrappers).
+- **to_s** renders the full printed face — the canonical template's
+  presence-guarded optionals and the V/ed alternated tail render what
+  the input carried (the conditional-render segment feature).
+- **to_urn** is DECLARED (`urn.official`): type lowercased, the composed
+  code (number + minor + prefix-glued parts), the v/ed version face
+  (the edition affix under the fold flag), the year-month date group —
+  byte-identical with the coded generator everywhere the coded one
+  renders at all. The CODED generator raises `ArgumentError` on months
+  08/09 (`format('%02d', "08")` — the zero-padded string reads as an
+  invalid octal); pre-existing on main, pinned by the parity spec — the
+  compiled generator renders the captured month verbatim and does not
+  share the defect.
+- **to_mr_string** is DECLARED (`mr:`): the coded mr_type /
+  mr_number_with_part / mr_year / mr_edition hooks over the columns,
+  byte-identical slugs (`etsi.eg.200-053.2004-06.1-5-1`), with the
+  wrapper's supplement suffix (`…_a1.1`) carried by the synthesized
+  classes.
 
 ## Non-obvious facts, learned the hard way
 
 - The generated `--ruby-out` lands at `lib/etsi_pfs.rb`; the autoload and
   the `#{__dir__}` paths require it at `lib/pubid/etsi_pfs.rb` — move both
   the file and the directory (commands above).
-- `core: ["number"]` in a `.pfs` urn type row would generate
-  `core: [:number]`, which crashes `PubidUrn.define` at load time (the
-  generator emits `core.map(&:to_sym)`); only `core: []` round-trips.
-  The instance's URNs resolve through the CODED schema anyway (the flavor
-  segment of the canonical tag is `etsi`), so the alias rows are the
-  future-cutover shape.
+- The instance's URNs resolve through the CODED schema anyway (the
+  flavor segment of the canonical tag is `etsi`), so the alias's schema
+  rows are the future-cutover shape; the wrapper rows now carry the
+  coded `core: [["number", :int]]` ordinals (the phase-3 int-kind
+  cores).
 - `V1..1` parses in BOTH flavors (`.` is a version_char) and `GS` is a
   real type token — neither is a parity negative.
 - `Pubid::EtsiPfs.parse("ETSI …")` never hijacks `Pubid.parse` (registry
   keys sort `"etsi"` first), and `Pubid.from_hash` of an alias hash
   resolves the coded `EtsiStandard` (one scheme, one `_type`).
 - The corpus inventory (`spec/fixtures/etsi/identifiers/full/`) is the
-  parity source; its bucket split is pinned: plain 18,945 / parts 3,772 /
-  edition 1,833 / supplement 168.
+  parity source; its former bucket split (plain 18,945 / parts 3,772 /
+  edition 1,833 / supplement 168) is now the per-gap parity trajectory —
+  all 24,718 rows agree on to_hash, to_pubid_urn, to_s, to_urn and
+  to_mr_string.
+- The run's internal captures (`supplement_kind` / `supplement_number`)
+  bind only through the run's item rows, and unbound captures arrive as
+  raw `Parsanol::Slice` leaves — the generated builder unwraps
+  `Slice#content` (the cen_cenelec precedent).
 
-## v1 boundaries
+## v1 boundaries (still)
 
-Single-type schemes only, `kind: string` fields only, no free-standing
-`stages:`/`supplements:` sections, no semantic decode rules — see
-`pubid-grammar`'s `definitions/README.md` for the language reference and
-the fail-closed validation rules.
+Single declared type per scheme (the `supplements:` wrappers are the one
+multi-class shape), no free-standing `stages:` maps, no semantic decode
+rules — see `pubid-grammar`'s `definitions/README.md` for the language
+reference and the fail-closed validation rules.

data/lib/pubid/etsi_pfs/builder.rb

@@ -1,25 +1,58 @@
-  module Pubid
-    module EtsiPfs
-      class Builder
-        def self.build(parsed_data)
-          new.build(parsed_data)
-        end
+module Pubid
+  module EtsiPfs
+    class Builder
+      # The wrapper classes by kind face: the run's dispatch.
+      SUPPLEMENT_WRAPPERS = {
+        "A" => Identifiers::Amendment,
+        "C" => Identifiers::Corrigendum,
+      }.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
 
-        def build(data)
-          Identifiers::Standard.new(
+      def build(data)
+        identifier = Identifiers::Standard.new(
           type: data[:type],
           number: data[:number],
           minor: data[:minor],
-          parts: data[:parts],
-          supplements: data[:supplements],
-          version: data[:version],
-          edition: data[:edition],
+          parts: build_parts(data),
+          version: data[:version] || data[:edition],
+          is_edition: !data[:edition].nil?,
           year: data[:year],
           month: data[:month],
+        )
+        run = Array(data[:supplements])
+        run.each do |row|
+          item = row[:supplement] || row["supplement"] || {}
+          kind = unwrap(item[:supplement_kind] || item["supplement_kind"])
+          identifier = SUPPLEMENT_WRAPPERS.fetch(kind).new(
+            number: unwrap(item[:supplement_number] || item["supplement_number"]).to_i,
+            base: identifier,
           )
         end
+        identifier
+      end
+
+      # The run's internal captures bind only through the item row
+      # (the cen_cenelec precedent), so unbound ones arrive as raw
+      # leaves — a Parsanol::Slice or a {value:, offset: ...} span.
+      # Unwrap the captured value.
+      def unwrap(capture)
+        return capture.content if capture.is_a?(Parsanol::Slice)
+        return capture[:value] if capture.is_a?(Hash) && capture.key?(:value)
+
+        capture
+      end
+
+      # The parts column from its bound item rows.
+      def build_parts(data)
+        Array(data[:parts]).map do |row|
+          row[:part] || row["part"]
+        end.compact
       end
     end
   end
 
   Pubid::EtsiPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)
+end

data/lib/pubid/etsi_pfs/identifier.rb

@@ -1,50 +1,32 @@
-  module Pubid
-    module EtsiPfs
-      class Identifier < ::Pubid::Identifier
-        attribute :type, :string
-        attribute :number, :string
-        attribute :minor, :string
-        attribute :parts, :string
-        attribute :supplements, :string
-        attribute :version, :string
-        attribute :edition, :string
-        attribute :year, :string
-        attribute :month, :string
+module Pubid
+  module EtsiPfs
+    class Identifier < ::Pubid::Identifier
+      attribute :publisher, :string, default: -> { "ETSI" }
 
-        ETSI_TYPE_MAP = {
-          "pubid:etsi:etsi-standard" => "Pubid::EtsiPfs::Identifiers::Standard",
-        }.freeze
+      PUBLISHER = "ETSI"
 
-        key_value do
-          map "_type", to: :_type, polymorphic_map: ETSI_TYPE_MAP
-          map "type", to: :type
-          map "number", to: :number
-          map "minor", to: :minor
-          map "parts", to: :parts
-          map "supplements", to: :supplements
-          map "version", to: :version
-          map "edition", to: :edition
-          map "year", to: :year
-          map "month", to: :month
-        end
-
-        PUBLISHER = "ETSI"
+      # The scheme's declared publisher token: the internal-form
+      # cut (to_s(with_publisher: false)) strips it from the
+      # rendered face.
+      def publisher_prefixes
+        [PUBLISHER]
+      end
 
-        def self.parse(identifier)
-          unless identifier.is_a?(String)
-            raise Pubid::Errors::InvalidInputError,
-                  Pubid::INPUT_NOT_A_STRING_MESSAGE
-          end
+      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
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
 
-          identifier = ::Pubid.utf8_input(identifier)
+        identifier = ::Pubid.utf8_input(identifier)
 
-          parsed = Pubid::Parg::Model.bound(:etsi_pfs, identifier)
-          Builder.build(parsed)
-        end
+        parsed = Pubid::Parg::Model.bound(:etsi_pfs, identifier)
+        Builder.build(parsed)
       end
     end
   end
+end

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

@@ -0,0 +1,20 @@
+module Pubid
+  module EtsiPfs
+    module Identifiers
+      # The synthesized Amendment wrapper (PFS supplements
+      # declaration): the kind face "A" is the run's
+      # dispatch token and the printed notation's face.
+      class Amendment < Supplement
+        FACE = "A".freeze
+
+        def self.face
+          FACE
+        end
+
+        def self.polymorphic_name
+          "pubid:etsi:amendment"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Pubid
+  module EtsiPfs
+    module Identifiers
+      # The synthesized Corrigendum wrapper (PFS supplements
+      # declaration): the kind face "C" is the run's
+      # dispatch token and the printed notation's face.
+      class Corrigendum < Supplement
+        FACE = "C".freeze
+
+        def self.face
+          FACE
+        end
+
+        def self.polymorphic_name
+          "pubid:etsi:corrigendum"
+        end
+      end
+    end
+  end
+end

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

@@ -1,22 +1,71 @@
-  module Pubid
-    module EtsiPfs
-      module Identifiers
-        # Concrete ETSI Standard identifier type (PFS type `standard`).
-        class Standard < Identifier
+module Pubid
+  module EtsiPfs
+    module Identifiers
+      # Concrete ETSI Standard identifier type (PFS type `standard`).
+      class Standard < Identifier
           TYPED_STAGES = [].freeze
 
-          def self.type
-            { key: :etsi, web: :etsi, title: "ETSI Standard", short: "ETSI" }
-          end
+      attribute :type, :string
+      attribute :number, :string
+      attribute :minor, :string
+      attribute :parts, :string, collection: true, initialize_empty: true
+      attribute :version, :string
+      attribute :year, :string
+      attribute :month, :string
+      attribute :is_edition, :boolean, default: -> { false }
 
-          # The scheme-canonical wire tag declared in the definition:
-          # to_hash stays byte-identical with the scheme's coded
-          # flavor, and this flavor's own from_hash routes the tag
-          # to this class.
-          def self.polymorphic_name
-            "pubid:etsi:etsi-standard"
-          end
+        key_value do
+          map "_type", to: :_type
+          map "type", to: :type
+          map "number", to: :number
+          map "minor", to: :minor
+          map "parts", to: :parts
+          map "version", to: :version
+          map "year", to: :year
+          map "month", to: :month
+          map "is_edition", to: :is_edition
+        end
+
+        def self.type
+          { key: :etsi, web: :etsi, title: "ETSI Standard", short: "ETSI" }
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:etsi:etsi-standard"
+        end
+
+        def mr_type
+          mr_sanitize(type)
+        end
+
+        def mr_number_with_part
+          mr_sanitize([number, minor, *Array(parts)].compact.join("-"))
+        end
+
+        def mr_year
+          mr_sanitize([year, month].compact.join("-"))
+        end
+
+        def mr_edition
+          mr_sanitize(version)
+        end
+
+        # The MR charset rule (the coded flavors' mr_sanitize):
+        # lowercase, [a-z0-9-], non-charset runs collapsed to one
+        # dash; empty answers nil so the joined slug never gains a
+        # blank segment.
+        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
       end
     end
   end
+end

data/lib/pubid/etsi_pfs/identifiers/supplement.rb

@@ -0,0 +1,72 @@
+module Pubid
+  module EtsiPfs
+    module Identifiers
+      # The supplement wrapper base (pubid#706 phase 3): the
+      # wrapper owns its ordinal and the base identifier; every
+      # delegated attribute reads through.
+      class Supplement < ::Pubid::EtsiPfs::Identifier
+        attribute :base, ::Pubid::EtsiPfs::Identifier
+        attribute :number, :integer
+
+        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 leaf standard shape (the coded converters'
+        # rule).
+        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 Standard (the coded JCGM/ETSI rule).
+        def base_from_kv(model, value)
+          return unless value
+
+          model.base = ::Pubid::EtsiPfs::Identifier.from_hash(value)
+        end
+
+        # Delegations: the wrapper reads through to the wrapped
+        # standard (the coded SupplementIdentifier shape).
+        def type
+          base&.type
+        end
+
+        def version
+          base&.version
+        end
+
+        def year
+          base&.year
+        end
+
+        def month
+          base&.month
+        end
+
+        def is_edition
+          base&.is_edition
+        end
+
+        # The printed notation: the kind face + the ordinal.
+        def supplement_notation
+          "#{self.class.face}#{number}"
+        end
+
+        # The MR slug's supplement suffix: the shared MrString
+        # recurses into base and appends this (the coded
+        # mr_supplement_suffix rule).
+        def mr_supplement_suffix
+          [supplement_notation.to_s.downcase, number].compact.join(".")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/etsi_pfs/identifiers.rb

@@ -1,7 +1,10 @@
 module Pubid
   module EtsiPfs
     module Identifiers
-      autoload :Standard, "#{__dir__}/identifiers/standard"
+            autoload :Standard, "#{__dir__}/identifiers/standard"
+            autoload :Supplement, "#{__dir__}/identifiers/supplement"
+            autoload :Amendment, "#{__dir__}/identifiers/amendment"
+            autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
     end
   end
 end

data/lib/pubid/etsi_pfs/pubid_urn_schema.rb

@@ -12,8 +12,10 @@
         atom "year", "year"
         atom "month", "month"
         atom "version", "v"
-        type "pubid:etsi_pfs:identifier", "id", core: []
-        type "pubid:etsi_pfs:standard", "es", core: []
+        type "pubid:etsi:etsi-standard", "es", core: []
+        type "pubid:etsi:amendment", "amd", core: [["number", :int]]
+        type "pubid:etsi:corrigendum", "cor", core: [["number", :int]]
+        type "pubid:etsi:identifier", "id", core: []
       end
     end
   end