pubid 2.0.22 → 2.0.24

data/lib/pubid/calconnect_pfs/builder.rb

@@ -0,0 +1,35 @@
+  module Pubid
+    module CalconnectPfs
+      class Builder
+        def self.build(parsed_data)
+          new.build(parsed_data)
+        end
+
+        def build(data)
+          Identifiers::Standard.new(
+          series: data[:series],
+          number: data[:number],
+            date: build_date(data),
+          )
+        end
+
+        private
+
+        # The publication date as the shared Components::Date, or
+        # nil when the reference omits the calendar fields (a
+        # partial reference matches by excluding the date).
+        def build_date(data)
+          values = [data[:year], data[:month], data[:day]]
+          return nil if values.compact.empty?
+
+          ::Pubid::Components::Date.new(
+          year: data[:year]&.to_s,
+          month: data[:month]&.to_s,
+          day: data[:day]&.to_s,
+          )
+        end
+      end
+    end
+  end
+
+  Pubid::CalconnectPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/calconnect_pfs/identifier.rb

@@ -0,0 +1,84 @@
+  module Pubid
+    module CalconnectPfs
+      class Identifier < ::Pubid::Identifier
+        attribute :series, :string
+        attribute :number, :string
+        attribute :date, ::Pubid::Components::Date
+
+        CC_TYPE_MAP = {
+          "pubid:calconnect:standard" => "Pubid::CalconnectPfs::Identifiers::Standard",
+        }.freeze
+
+        key_value do
+          map "_type", to: :_type, polymorphic_map: CC_TYPE_MAP
+          map "series", to: :series
+          map "number", to: :number
+          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
+
+          # --- date serialized flat (the shared flat-scalar shape) ---
+          def year_to_kv(model, doc)
+            emit_date_part(doc, "year", model.date&.year)
+          end
+
+          def year_from_kv(model, value)
+            date_for(model).year = value.to_s
+          end
+
+          # --- date serialized flat (the shared flat-scalar shape) ---
+          def month_to_kv(model, doc)
+            emit_date_part(doc, "month", model.date&.month)
+          end
+
+          def month_from_kv(model, value)
+            date_for(model).month = value.to_s
+          end
+
+          # --- date serialized flat (the shared flat-scalar shape) ---
+          def day_to_kv(model, doc)
+            emit_date_part(doc, "day", model.date&.day)
+          end
+
+          def day_from_kv(model, value)
+            date_for(model).day = value.to_s
+          end
+
+          def emit_date_part(doc, key, val)
+            return if val.nil? || val.to_s.empty?
+
+            doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
+          end
+
+          def date_for(model)
+            model.date ||= ::Pubid::Components::Date.new
+          end
+
+        PUBLISHER = "CC"
+
+        # 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
+
+          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(:calconnect_pfs, identifier)
+          Builder.build(parsed)
+        end
+      end
+    end
+  end

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

@@ -0,0 +1,31 @@
+  module Pubid
+    module CalconnectPfs
+      module Identifiers
+        # Concrete CalConnect Standard identifier type (PFS type `standard`).
+        class Standard < Identifier
+          TYPED_STAGES = [
+            Pubid::Components::TypedStage.new(
+              code: :pubcc,
+              stage_code: :published,
+              type_code: :cc,
+              abbr: ["CC"],
+              name: "CalConnect Standard",
+              harmonized_stages: [],
+            ),
+          ].freeze
+
+          def self.type
+            { key: :cc, web: :standard, title: "CalConnect Standard", short: "CC" }
+          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:calconnect:standard"
+          end
+        end
+      end
+    end
+  end

data/lib/pubid/calconnect_pfs/identifiers.rb

@@ -0,0 +1,7 @@
+module Pubid
+  module CalconnectPfs
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/calconnect_pfs/parser.rb

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

data/lib/pubid/calconnect_pfs/pubid_urn_schema.rb

@@ -0,0 +1,17 @@
+  module Pubid
+    module CalconnectPfs
+      # The pubid-scheme URN schema, registered under the compiled
+      # flavor key. The definition's declared namespace
+      # ("calconnect") 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("calconnect_pfs") do
+        atom "series", "series"
+        atom "year", "year"
+        atom "month", "month"
+        atom "day", "day"
+        type "pubid:calconnect:identifier", "id", core: []
+        type "pubid:calconnect:standard", "std", core: ["number"]
+      end
+    end
+  end

data/lib/pubid/calconnect_pfs/renderer.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module CalconnectPfs
+    # Human renderer, generated from the canonical template.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        "CC#{"/#{@id.series}" if @id.series} #{@id.number}#{":#{@id.date.year}#{"-#{@id.date.month}-#{@id.date.day}" if @id.date&.month && @id.date&.day}" if @id.date&.year}"
+      end
+    end
+  end
+end

data/lib/pubid/calconnect_pfs/urn_generator.rb

@@ -0,0 +1,30 @@
+module Pubid
+  module CalconnectPfs
+    # The official URN generator: the scheme's declared namespace
+    # ("calconnect") and the ordered segments the
+    # definition's urn.official declares — an absent field leaves no
+    # segment, a date group joins its fields with "-".
+    class UrnGenerator < ::Pubid::UrnGenerator::Base
+      def urn_namespace
+        "calconnect"
+      end
+
+      def generate
+        parts = ["urn", urn_namespace]
+        parts.concat(official_segments)
+        parts.join(":")
+      end
+
+      private
+
+      def official_segments
+        segments = []
+        segments << @identifier.series if @identifier.series
+        segments << @identifier.number if @identifier.number
+        date = [@identifier.date&.year, @identifier.date&.month, @identifier.date&.day].compact
+        segments << date.join("-") unless date.empty?
+        segments
+      end
+    end
+  end
+end

data/lib/pubid/calconnect_pfs.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+#
+# PFS-generated flavor — DO NOT EDIT BY HAND.
+# Source: definitions/calconnect.pfs (pfs:1) sha256:2e864f0185a1a2f18a392f2f401ad3c9d65d1f32a9ec3f3f04f7dfca9b2226c4
+# Compiler: pubid/grammar/pfs 0.1.0 (baked with parsanol 1.3.126)
+# Regenerate: ruby scripts/pfs compile definitions/calconnect.pfs --as calconnect_pfs --ruby-out <dir>
+
+require "pubid"
+
+module Pubid
+  # CalConnect Standards 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 CalconnectPfs
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["CC"].freeze
+    
+
+    autoload :Builder, "#{__dir__}/calconnect_pfs/builder"
+    autoload :Identifier, "#{__dir__}/calconnect_pfs/identifier"
+    autoload :Identifiers, "#{__dir__}/calconnect_pfs/identifiers"
+    autoload :Parser, "#{__dir__}/calconnect_pfs/parser"
+    autoload :Renderer, "#{__dir__}/calconnect_pfs/renderer"
+    autoload :PubidUrnSchema, "#{__dir__}/calconnect_pfs/pubid_urn_schema"
+    autoload :UrnGenerator, "#{__dir__}/calconnect_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: CalconnectPfs::Renderer)
+
+    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
+
+    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 { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+Pubid::Registry.register(:calconnect_pfs, Pubid::CalconnectPfs)

data/lib/pubid/cen_pfs/builder.rb

@@ -0,0 +1,33 @@
+  module Pubid
+    module CenPfs
+      class Builder
+        def self.build(parsed_data)
+          new.build(parsed_data)
+        end
+
+        def build(data)
+          Identifiers::EuropeanNorm.new(
+          number: data[:number],
+          part: data[:part],
+            date: build_date(data),
+          )
+        end
+
+        private
+
+        # The publication date as the shared Components::Date, or
+        # nil when the reference omits the calendar fields (a
+        # partial reference matches by excluding the date).
+        def build_date(data)
+          values = [data[:year]]
+          return nil if values.compact.empty?
+
+          ::Pubid::Components::Date.new(
+          year: data[:year]&.to_s,
+          )
+        end
+      end
+    end
+  end
+
+  Pubid::CenPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)

data/lib/pubid/cen_pfs/identifier.rb

@@ -0,0 +1,64 @@
+  module Pubid
+    module CenPfs
+      class Identifier < ::Pubid::Identifier
+        attribute :number, :string
+        attribute :part, :string
+        attribute :date, ::Pubid::Components::Date
+
+        EN_TYPE_MAP = {
+          "pubid:cencenelec:european-norm" => "Pubid::CenPfs::Identifiers::EuropeanNorm",
+        }.freeze
+
+        key_value do
+          map "_type", to: :_type, polymorphic_map: EN_TYPE_MAP
+          map "number", to: :number
+          map "part", to: :part
+          map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        end
+
+          # --- date serialized flat (the shared flat-scalar shape) ---
+          def year_to_kv(model, doc)
+            emit_date_part(doc, "year", model.date&.year)
+          end
+
+          def year_from_kv(model, value)
+            date_for(model).year = value.to_s
+          end
+
+          def emit_date_part(doc, key, val)
+            return if val.nil? || val.to_s.empty?
+
+            doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
+          end
+
+          def date_for(model)
+            model.date ||= ::Pubid::Components::Date.new
+          end
+
+        PUBLISHER = "CEN"
+
+        # 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
+
+          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(:cen_pfs, identifier)
+          Builder.build(parsed)
+        end
+      end
+    end
+  end

data/lib/pubid/cen_pfs/identifiers/european_norm.rb

@@ -0,0 +1,31 @@
+  module Pubid
+    module CenPfs
+      module Identifiers
+        # Concrete European Norm identifier type (PFS type `european_norm`).
+        class EuropeanNorm < Identifier
+          TYPED_STAGES = [
+            Pubid::Components::TypedStage.new(
+              code: :puben,
+              stage_code: :published,
+              type_code: :en,
+              abbr: ["EN"],
+              name: "European Norm",
+              harmonized_stages: [],
+            ),
+          ].freeze
+
+          def self.type
+            { key: :en, web: :"european-norm", title: "European Norm", short: "EN" }
+          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:cencenelec:european-norm"
+          end
+        end
+      end
+    end
+  end

data/lib/pubid/cen_pfs/identifiers.rb

@@ -0,0 +1,7 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      autoload :EuropeanNorm, "#{__dir__}/identifiers/european_norm"
+    end
+  end
+end

data/lib/pubid/cen_pfs/parser.rb

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

data/lib/pubid/cen_pfs/pubid_urn_schema.rb

@@ -0,0 +1,15 @@
+  module Pubid
+    module CenPfs
+      # The pubid-scheme URN schema, registered under the compiled
+      # flavor key. The definition's declared namespace
+      # ("cen") 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("cen_pfs") do
+        atom "part", "part"
+        atom "year", "year"
+        type "pubid:cencenelec:identifier", "id", core: []
+        type "pubid:cencenelec:european-norm", "en", core: ["number"]
+      end
+    end
+  end

data/lib/pubid/cen_pfs/renderer.rb

@@ -0,0 +1,10 @@
+module Pubid
+  module CenPfs
+    # Human renderer, generated from the canonical template.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        "EN #{@id.number}#{"-#{@id.part}" if @id.part}#{":#{@id.date.year}" if @id.date&.year}"
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/urn_generator.rb

@@ -0,0 +1,12 @@
+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.
+    class UrnGenerator < ::Pubid::UrnGenerator::Base
+      def urn_namespace
+        "cen"
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+#
+# PFS-generated flavor — DO NOT EDIT BY HAND.
+# Source: definitions/cen.pfs (pfs:1) sha256:bc1edd5874f8938b5f946416a2b052d9d9b9df3d99f6c20a3d88fcab9ae1d70c
+# 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
+  # (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
+
+    autoload :Builder, "#{__dir__}/cen_pfs/builder"
+    autoload :Identifier, "#{__dir__}/cen_pfs/identifier"
+    autoload :Identifiers, "#{__dir__}/cen_pfs/identifiers"
+    autoload :Parser, "#{__dir__}/cen_pfs/parser"
+    autoload :Renderer, "#{__dir__}/cen_pfs/renderer"
+    autoload :PubidUrnSchema, "#{__dir__}/cen_pfs/pubid_urn_schema"
+    autoload :UrnGenerator, "#{__dir__}/cen_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: CenPfs::Renderer)
+
+    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
+
+    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 { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+Pubid::Registry.register(:cen_pfs, Pubid::CenPfs)

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)