pubid 2.0.22 → 2.0.23

data/lib/pubid/doi_pfs/CLAUDE.md

@@ -0,0 +1,72 @@
+# DoiPfs — the PFS-compiled doi dev alias
+
+This flavor is **generated**, not hand-written: every file here is compiler
+output from `pubid-grammar`'s `definitions/doi.pfs` (pubid/pubid#706),
+reproduce with
+
+```bash
+cd ../pubid-grammar
+ruby scripts/pfs compile definitions/doi.pfs --as doi_pfs \
+  --parsanol-version <CI pin> --ruby-out ../pubid/lib
+cp artifacts/doi_pfs.json ../pubid/data/parg/doi_pfs.json
+```
+
+DO NOT EDIT these files by hand — a hand edit is silently overwritten by
+the next compile, and the grammar SSOT is the definition, not this module
+(the `data/parg/doi_pfs.json` artifact's freshness envelope and the
+definition's source sha pin the lineage).
+
+## The coexistence semantics (read before touching anything)
+
+`doi_pfs` is the **dev-alias key** of the doi scheme: it registers beside
+the coded `Pubid::Doi` so the compiled pipeline can be proven against the
+coded flavor without cutover (cutover — replacing `doi` with the compiled
+flavor — is a separate, later decision).
+
+- **Wire tag**: the definition declares `tag: "pubid:doi:resource"` — the
+  SCHEME's canonical tag — so `to_hash` is byte-identical with the coded
+  flavor. `Resource.polymorphic_name` overrides the class-name-derived
+  tag for exactly this reason. Consequence: a GLOBAL `Pubid.from_hash` of
+  a doi_pfs hash resolves the coded class (one scheme, one `_type`, one
+  global resolution); the alias's own `DoiPfs::Identifier.from_hash`
+  routes the tag back to `DoiPfs::Identifiers::Resource` through its
+  `DOI_TYPE_MAP`.
+- **URN namespace**: the definition declares `urn.namespace: doi`, so the
+  generated `UrnGenerator` pins `urn_namespace` to `"doi"` and `to_urn`
+  is byte-identical (`"urn:doi"`). The pubid-scheme schema registers
+  under the FLAVOR key (`PubidUrn.define("doi_pfs")`) — never re-register
+  under `"doi"`, that would overwrite the coded flavor's registration.
+- **Routing**: `Pubid.parse` keeps routing `doi:`-faced strings to the
+  coded flavor (registry keys sort `"doi"` first; both flavors claim the
+  same prefixes). The alias is reached through `Pubid::DoiPfs.parse`.
+
+## The parity gate
+
+`spec/pubid/doi_pfs/parity_spec.rb` is the spike's whole point: over the
+full doi inventory (coded fixtures + corpus rows + aliases + constructed
+edge cases), both flavors must agree byte-for-byte on `to_s`, `to_hash`,
+`to_urn`, `to_mr_string`, `to_pubid_urn` and fail on the same inputs with
+`Pubid::Errors::ParseError`. Drift is a defect in the definition or the
+compiler — never relax an expectation here.
+
+Non-obvious inventory facts, learned the hard way:
+
+- The combined faces (`https://doi.org/doi:10.1000/182`) are rejected by
+  the CODED flavor too (the optional faces compose non-backtracking), so
+  they are negatives.
+- `Pubid.parse("10.1000/182")` routes to **UN** on main, pre-existing:
+  the bare `10.` form is not a doi prefix-owner claim at a token
+  boundary (`10.` followed by a digit), and un's token run accepts it.
+  Only the scheme-faced form routes to Doi.
+- The coded builder re-adds `"10."` to the registrar digits its grammar
+  captures; the doi.pfs pattern captures the whole `10.` face, so the
+  doi_pfs builder binds `prefix` directly. Model-level outputs are
+  identical; only the bound wire map differs (`prefix: "1000"` vs
+  `"10.1000"` in the artifact's corpus).
+
+## v1 boundaries
+
+Single-type schemes only, `kind: string` fields only, no free-standing
+`stages:`/`supplements:` sections, no semantic decode rules (the
+DAM-family problem) — see `pubid-grammar`'s `definitions/README.md` for
+the language reference and the fail-closed validation rules.

data/lib/pubid/doi_pfs/builder.rb

@@ -0,0 +1,18 @@
+  module Pubid
+    module DoiPfs
+      class Builder
+        def self.build(parsed_data)
+          new.build(parsed_data)
+        end
+
+        def build(data)
+          Identifiers::Resource.new(
+            prefix: data[:prefix],
+            suffix: data[:suffix],
+          )
+        end
+      end
+    end
+  end
+
+  Pubid::DoiPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/doi_pfs/identifier.rb

@@ -0,0 +1,36 @@
+  module Pubid
+    module DoiPfs
+      class Identifier < ::Pubid::Identifier
+        attribute :prefix, :string
+        attribute :suffix, :string
+
+        DOI_TYPE_MAP = {
+          "pubid:doi:resource" => "Pubid::DoiPfs::Identifiers::Resource",
+        }.freeze
+
+        key_value do
+          map "_type", to: :_type, polymorphic_map: DOI_TYPE_MAP
+          map "prefix", to: :prefix
+          map "suffix", to: :suffix
+        end
+
+        PUBLISHER = "DOI".freeze
+
+        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
+
+          identifier = ::Pubid.utf8_input(identifier)
+
+          parsed = Pubid::Parg::Model.bound(:doi_pfs, identifier)
+          Builder.build(parsed)
+        end
+      end
+    end
+  end

data/lib/pubid/doi_pfs/identifiers/resource.rb

@@ -0,0 +1,31 @@
+  module Pubid
+    module DoiPfs
+      module Identifiers
+        # Concrete DOI identifier type (PFS type `resource`).
+        class Resource < Identifier
+          TYPED_STAGES = [
+            Pubid::Components::TypedStage.new(
+              code: :pubdoi,
+              stage_code: :published,
+              type_code: :doi,
+              abbr: ["DOI"],
+              name: "DOI",
+              harmonized_stages: [],
+            ),
+          ].freeze
+
+          def self.type
+            { key: :doi, web: :doi, title: "DOI", short: "DOI" }
+          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:doi:resource"
+          end
+        end
+      end
+    end
+  end

data/lib/pubid/doi_pfs/identifiers.rb

@@ -0,0 +1,7 @@
+module Pubid
+  module DoiPfs
+    module Identifiers
+      autoload :Resource, "#{__dir__}/identifiers/resource"
+    end
+  end
+end

data/lib/pubid/doi_pfs/parser.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module DoiPfs
+    # PFS-generated parser shell. Parsing runs through the baked
+    # PARG artifact (data/parg/doi_pfs.json) via Pubid::Parg::Model.bound;
+    # the grammar source lives in pubid-grammar
+    # (grammars/doi_pfs.parg, compiled from definitions/doi.pfs).
+    class Parser
+    end
+  end
+end

data/lib/pubid/doi_pfs/pubid_urn_schema.rb

@@ -0,0 +1,15 @@
+  module Pubid
+    module DoiPfs
+      # The pubid-scheme URN schema, registered under the compiled
+      # flavor key. The definition's declared namespace
+      # ("doi") is the scheme's canonical
+      # namespace; identifiers carry the scheme's wire tag, so their
+      # pubid URNs encode through the scheme's own schema.
+      PubidUrnSchema = Pubid::PubidUrn.define("doi_pfs") do
+        atom "prefix", "prefix"
+        atom "suffix", "suffix"
+        type "pubid:doi_pfs:identifier", "id", core: []
+        type "pubid:doi_pfs:resource", "resource", core: []
+      end
+    end
+  end

data/lib/pubid/doi_pfs/renderer.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module DoiPfs
+    # Human renderer, generated from the canonical template.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        "doi:#{@id.prefix}/#{@id.suffix}"
+      end
+    end
+  end
+end

data/lib/pubid/doi_pfs/urn_generator.rb

@@ -0,0 +1,12 @@
+module Pubid
+  module DoiPfs
+    # The official URN generator, pinned to the scheme's declared
+    # namespace ("doi") so to_urn stays
+    # scheme-canonical under the compiled flavor key.
+    class UrnGenerator < ::Pubid::UrnGenerator::Base
+      def urn_namespace
+        "doi"
+      end
+    end
+  end
+end

data/lib/pubid/doi_pfs.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+#
+# PFS-generated flavor — DO NOT EDIT BY HAND.
+# Source: definitions/doi.pfs (pfs:1) sha256:60abc3c403c61019d727ee44d9a72591c1549672451e6609a72d36189cae6340
+# Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
+# Regenerate: ruby scripts/pfs compile definitions/doi.pfs --as doi_pfs --ruby-out <dir>
+
+require "pubid"
+
+module Pubid
+  # Digital Object Identifier 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 DoiPfs
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["doi:", "DOI:", "10."].freeze
+
+    autoload :Builder, "#{__dir__}/doi_pfs/builder"
+    autoload :Identifier, "#{__dir__}/doi_pfs/identifier"
+    autoload :Identifiers, "#{__dir__}/doi_pfs/identifiers"
+    autoload :Parser, "#{__dir__}/doi_pfs/parser"
+    autoload :Renderer, "#{__dir__}/doi_pfs/renderer"
+    autoload :PubidUrnSchema, "#{__dir__}/doi_pfs/pubid_urn_schema"
+    autoload :UrnGenerator, "#{__dir__}/doi_pfs/urn_generator"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: DoiPfs::Renderer)
+
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map do |c| 
+        
+        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
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find do |s| 
+        s.abbr.any? do |a|
+          a.to_s.upcase == abbr_str
+        end
+      end
+    end
+  end
+end
+
+Pubid::Registry.register(:doi_pfs, Pubid::DoiPfs)

data/lib/pubid/nist/CLAUDE.md

@@ -184,3 +184,39 @@ Read this before you change `lib/pubid/nist/` or `spec/pubid/nist/`. The root
   nothing (its flag defaults to true, so it means a spelled form anyway).
   Locked by
   `spec/pubid/nist/bare_fips_publisher_spec.rb`.
+
+- **The default-series plain-number branch (pubid#711).** A citation
+  shaped like the docnumber — "800-90B", the docid-derived citation face
+  of NIST.SP.800-90B — and its publisher-led spelling "NIST 800-90B"
+  carry NO series token, and the grammar's series alternatives never
+  reached them: every branch demanded a series token (or, after a bare
+  publisher, only the dated ISO-date digits). The grammar (nist.parg,
+  fleet compiler 1.3.126) gained two trailing `identifier` alternatives
+  that ride the SAME report-number tail as the series-bearing branches —
+  `(publisher) (space) (report_number) …` and bare `(report_number) …` —
+  placed LAST so PEG ordering leaves every previously accepted form on
+  its original alternative (they only catch inputs that previously
+  failed outright). The identity defaults onto the SP series: the Router
+  dispatches `SpecialPublication` when the parse carries no series and
+  no dated date, and the Builder fills `series` from the new
+  `Identifier.default_series` class method (SP is the default — the
+  docid of the real document is NIST.SP.800-90B). The publisher rides
+  the #704 machinery: `SpecialPublication.series_default_publisher` is
+  now "NIST", so the bare parse fills the publisher after
+  `publisher_was_parsed: false` and is `==` to the spelled form (URN-,
+  MR- and hash-equal but for that equality-ignored flag; the MR face is
+  the exact "NIST.SP.800-90B" DOI surface relaton-data-nist stores).
+  The SHORT face keeps the bare spelling (publisher suppressed);
+  the MR face always carries the publisher (`to_mr_style` prints
+  `(publisher || "NIST")`), so the bare parse lands on the DOI-style
+  face directly. The dated alternative keeps priority
+  ("NIST 2023-04-15 001" stays `DatedDocument`), and the routing probe
+  ("zzqx-nonsense-9714") still fails, so NIST is not disqualified as a
+  `Pubid.parse` fallback. `to_hash` of the two bare-series probes
+  ("SP 123", "SP 800-90B") gained `publisher: NIST` — the #704 ruling
+  generalized to the SP series; no corpus row moved. Locked by
+  `spec/pubid/nist/default_series_plain_number_spec.rb`; the corpus
+  round froze the four faces (the two publisher-led spellings as
+  non-normalized aliases of the canonical cases, the two bare ones as
+  canonical `publisher_was_parsed: false` cases) with the gem twin in
+  lockstep.

data/lib/pubid/nist/builder.rb

@@ -99,6 +99,16 @@ module Pubid
         # Locate the appropriate identifier class via Router
         identifier = @router.locate_identifier_klass(parsed_hash).new
 
+        # The default-series plain-number branch (pubid#711): the grammar's
+        # trailing alternatives carry no series token ("800-90B" /
+        # "NIST 800-90B"), so the identity gains the class's default series
+        # and parses == to the spelled "NIST SP 800-90B" form. The bare
+        # publisher rides the #704 rule below (apply_series_default_publisher).
+        if parsed_hash[:series].nil? &&
+            (default = identifier.class.default_series)
+          identifier.series = Components::Code.new(value: default)
+        end
+
         # Resolve the series policy once — every series-specific decision
         # flows through this object instead of branching on the parsed shape.
         series = Series.for(parsed_hash)

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

@@ -302,6 +302,16 @@ module Pubid
         nil
       end
 
+      # The series an input implies when it spells none — the grammar's
+      # default-series plain-number branch (pubid#711: "800-90B" /
+      # "NIST 800-90B" carry no series token). The Router dispatches the
+      # class from this default and the Builder fills the attribute, so a
+      # docnumber-shaped citation parses onto the same identity as the
+      # spelled form. nil: no default.
+      def self.default_series
+        nil
+      end
+
       # Fill the series default publisher on an id whose input spelled
       # none. Shared by the Builder and from_hash, so both construction
       # paths agree.

data/lib/pubid/nist/identifiers/special_publication.rb

@@ -35,6 +35,21 @@ module Pubid
             { key: :sp,
             web: :special_publication, title: "NIST Special Publication", short: "SP" }
           end
+
+          # The default-series plain-number branch (pubid#711): a citation
+          # shaped like the docnumber ("800-90B", publisher-led
+          # "NIST 800-90B") names an SP document — the docid-derived
+          # citation of NIST.SP.800-90B is exactly "800-90B".
+          def default_series
+            "SP"
+          end
+
+          # A bare plain-number parse carries the series' NIST publisher
+          # (the #704 shape), so it is == to the spelled
+          # "NIST SP 800-90B" form a lookup compares against.
+          def series_default_publisher
+            "NIST"
+          end
         end
 
         def series_code

data/lib/pubid/nist/router.rb

@@ -46,6 +46,17 @@ module Pubid
 
         series = parsed_hash[:series]&.to_s
 
+        # The default-series plain-number branch (pubid#711): the grammar's
+        # trailing alternatives accept a bare report number ("800-90B") and
+        # its publisher-led spelling ("NIST 800-90B") with NO series token.
+        # The SP series is the default: the docid-derived citation of
+        # NIST.SP.800-90B is exactly the bare docnumber "800-90B", and the
+        # Builder fills the same SP series the spelled form carries, so the
+        # two spellings are one identity to a lookup. No other branch can
+        # arrive here series-less (dated shapes returned above; every
+        # series-bearing branch captures :series).
+        return Identifiers::SpecialPublication if series.nil?
+
         # Handle compound series that include publisher (both space and dot separated)
         if series&.start_with?("NBS ")
           simple_series = series.sub("NBS ", "")

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.22"
+  VERSION = "2.0.23"
 end

data/lib/pubid.rb

@@ -224,6 +224,10 @@ module Pubid
   autoload :Ashrae, "pubid/ashrae"
   autoload :Asme, "pubid/asme"
   autoload :Doi, "pubid/doi"
+  # The PFS-compiled dev alias of doi (pubid/pubid#706): registered
+  # beside the coded flavor, never routed by Pubid.parse (registry keys
+  # sort "doi" first).
+  autoload :DoiPfs, "pubid/doi_pfs"
   autoload :Easc, "pubid/easc"
   autoload :Astm, "pubid/astm"
   autoload :Bipm, "pubid/bipm"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.22
+  version: 2.0.23
 platform: ruby
 authors:
 - Ribose Inc.
@@ -97,6 +97,7 @@ files:
 - data/parg/cie.json
 - data/parg/csa.json
 - data/parg/doi.json
+- data/parg/doi_pfs.json
 - data/parg/easc.json
 - data/parg/ecma.json
 - data/parg/etsi.json
@@ -470,6 +471,16 @@ files:
 - lib/pubid/doi/parser.rb
 - lib/pubid/doi/pubid_urn_schema.rb
 - lib/pubid/doi/renderer.rb
+- lib/pubid/doi_pfs.rb
+- lib/pubid/doi_pfs/CLAUDE.md
+- lib/pubid/doi_pfs/builder.rb
+- lib/pubid/doi_pfs/identifier.rb
+- lib/pubid/doi_pfs/identifiers.rb
+- lib/pubid/doi_pfs/identifiers/resource.rb
+- lib/pubid/doi_pfs/parser.rb
+- lib/pubid/doi_pfs/pubid_urn_schema.rb
+- lib/pubid/doi_pfs/renderer.rb
+- lib/pubid/doi_pfs/urn_generator.rb
 - lib/pubid/easc.rb
 - lib/pubid/easc/builder.rb
 - lib/pubid/easc/identifier.rb