pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.12

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -4,14 +4,76 @@ module Pubid
   module CenCenelec
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        if identifier.is_a?(CenCenelec::SupplementIdentifier)
-          generate_supplement_urn
+        urn_for(identifier)
+      end
+
+      protected
+
+      # The URN of +id+, walking the wrapper structure:
+      #   EN 13250:2000/A1:2005    urn:cen:en:13250:2000:amd:1:2005
+      #   EN 285:2015+A1:2021      urn:cen:en:285:2015:plus:amd:1:2021
+      #   EN 60038 AMD1 FRAG2      urn:cen:en:60038:amd:1:frag:2
+      #   CEN ISO/TS 21003-7:2019  urn:cen:cen:iso:ts:21003-7:2019
+      #   ENV ISO 11079:1999       urn:cen:env:iso:11079:1999
+      #   prEN ISO 1234:2020       urn:cen:en:iso:1234:2020:stage.proposal
+      # The "plus" marker keeps a consolidated identifier apart from the
+      # standalone amendment with the same number and year.
+      def urn_for(id)
+        case id
+        when nil
+          "urn:cen"
+        when Identifiers::Amendment, Identifiers::Corrigendum,
+             Identifiers::Fragment
+          [urn_for(id.base), *supplement_segments(id)].join(":")
+        when Identifiers::ConsolidatedIdentifier
+          base, *supplements = id.identifiers
+          [urn_for(base), *supplements.flat_map do |s|
+            ["plus", *supplement_segments(s)]
+          end].join(":")
         else
-          generate_base_urn
+          if adoption?(id)
+            # The publisher, then the adopted document's MR string with its
+            # dot and underscore separators as colons, then a draft stage as
+            # the base URN writes it.
+            body = [id.mr_publisher, id.adopted&.to_mr_string]
+              .compact.reject(&:empty?).join(".").tr("._", "::")
+            ["urn:cen:#{body}", *stage_segment(id)].join(":")
+          else
+            self.class.new(id).generate_base_urn
+          end
         end
       end
 
-      protected
+      # "EN ISO 8601:2019" or "ENV ISO 11079:1999": the document identity is
+      # on the adopted ISO/IEC identifier, not on this one.
+      def adoption?(id)
+        id.is_a?(Identifiers::AdoptedEuropeanNorm) ||
+          (id.is_a?(Identifiers::EuropeanPrestandard) && id.adopted)
+      end
+
+      # ["stage.proposal"] for a draft stage, [] for a published document.
+      def stage_segment(id)
+        code = id.typed_stage&.stage_code
+        return [] if code.nil? || code.to_s == "published"
+
+        ["stage.#{code}"]
+      end
+
+      # The segments that a supplement adds to its base: type, number (none
+      # for an unnumbered "/AC"), then the date.
+      def supplement_segments(id)
+        segments = case id
+                   when Identifiers::Amendment
+                     ["amd", id.number, id.year]
+                   when Identifiers::Corrigendum
+                     ["cor", id.number, id.supplement_date]
+                   when Identifiers::Fragment
+                     ["frag", id.number]
+                   else
+                     []
+                   end
+        segments.map(&:to_s).reject(&:empty?)
+      end
 
       def generate_base_urn
         parts = ["urn", "cen"]
@@ -75,46 +137,6 @@ module Pubid
         parts.join(":")
       end
 
-      def generate_supplement_urn
-        parts = ["urn", "cen"]
-
-        base_id = maybe(:base)
-        if base_id
-          base_gen = self.class.new(base_id)
-          base_urn = base_gen.generate_base_urn
-
-          base_part = base_urn.sub(/^urn:cen:/, "")
-          base_parts = base_part.split(":")
-
-          parts.concat(base_parts)
-
-          typed_stage = maybe(:typed_stage)
-          if typed_stage
-            supp_type = typed_stage.type_code.to_s
-            parts << supp_type if supp_type
-          end
-
-          amendment_number = maybe(:amendment_number)
-          if amendment_number
-            parts << amendment_number.to_s
-          elsif identifier.number
-            number = identifier.number.to_s
-            parts << number
-          end
-
-          amendment_year = maybe(:amendment_year)
-          if amendment_year
-            parts << amendment_year.to_s
-          elsif identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-            parts << identifier.date.render(context: URN_CONTEXT)
-          end
-        else
-          parts << "unknown"
-        end
-
-        parts.join(":")
-      end
-
       def type_component
         typed_stage = maybe(:typed_stage)
         return nil unless typed_stage

data/lib/pubid/cen_cenelec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module CenCenelec
     extend Pubid::PrefixesSupport
@@ -9,14 +10,17 @@ module Pubid
     # are excluded — they route to their own SDOs, not to CEN.
     PREFIXES = %w[EN CEN CLC CWA HD ES CR ENV].freeze
 
+    # Publisher tokens that are also the document type. "CWA 14050" has no
+    # separate type token, so the builder picks the class from the publisher
+    # and the renderer prints the token once, not as "CWA/CWA 14050".
+    PUBLISHER_TYPES = %w[CWA HD ES CR ENV].freeze
+
     autoload :Builder, "#{__dir__}/cen_cenelec/builder"
     autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
     autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
     autoload :Parser, "#{__dir__}/cen_cenelec/parser"
     autoload :Renderer, "#{__dir__}/cen_cenelec/renderer"
     autoload :SingleIdentifier, "#{__dir__}/cen_cenelec/single_identifier"
-    autoload :SupplementIdentifier,
-             "#{__dir__}/cen_cenelec/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/cen_cenelec/urn_generator"
     autoload :UrnParser, "#{__dir__}/cen_cenelec/urn_parser"
 
@@ -152,8 +156,13 @@ module Pubid
     ).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 ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       CenCenelec::Identifier.parse(identifier)
@@ -188,16 +197,25 @@ module Pubid
       abbr_str = abbr.to_s.upcase
       all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
     end
+
+    # Lookup: typed-stage code -> typed stage ("pren" -> the prEN entry).
+    # The serialized form of a draft stage is this code.
+    # @param code [String, Symbol] the typed-stage code to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage_by_code(code)
+      all_typed_stages.find { |s| s.code.to_s == code.to_s }
+    end
   end
 end
 
 Pubid::Registry.register(:cen_cenelec, Pubid::CenCenelec)
 Pubid::Registry.register(:cen, Pubid::CenCenelec)
 
-# Per-flavor format registry: inherits global formats, overrides :human
-# Register on both root hierarchies: SingleIdentifier and Identifiers::Base
-cen_renderer = Pubid::CenCenelec::Renderer
-Pubid::CenCenelec::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::CenCenelec::SingleIdentifier.format_registry.register(:human, renderer: cen_renderer)
-Pubid::CenCenelec::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::CenCenelec::Identifiers::Base.format_registry.register(:human, renderer: cen_renderer)
+# Per-flavor format registry: inherits global formats, overrides :human.
+# Registered on the shared parent of every CEN/CENELEC class, so it covers
+# SingleIdentifier, Identifiers::Base and the supplement wrappers, which
+# descend from neither.
+Pubid::CenCenelec::Identifier.format_registry =
+  Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::CenCenelec::Identifier.format_registry
+  .register(:human, renderer: Pubid::CenCenelec::Renderer)

data/lib/pubid/cie/builder.rb

@@ -30,6 +30,16 @@ module Pubid
           attributes.merge!(build_bundle(original_string))
         end
 
+        # `extract_attributes` builds one attribute hash for every CIE type,
+        # but the types do not share one attribute set — only Standard,
+        # DualPublished and Identical declare `s_prefix`, while Conference,
+        # Bundle, Proceedings and TutorialBundle do not. lutaml used to drop
+        # the surplus key without a word; the constructor now refuses it, so
+        # the builder has to stop offering it.
+        attributes = attributes.select do |key, _|
+          identifier_class.attributes.key?(key)
+        end
+
         # Construct identifier
         identifier_class.new(**attributes)
       end

data/lib/pubid/cie/identifier.rb

@@ -15,8 +15,13 @@ module Pubid
       attribute :style, :string, default: -> { "current" }
 
       def self.parse(input)
+        unless input.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if input.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(input)

data/lib/pubid/cie/identifiers/bundle.rb

@@ -27,13 +27,15 @@ module Pubid
         # The printed form writes the publisher once: the first member keeps its
         # "CIE " prefix, the rest are bare. A base-less member is re-based onto
         # the bundle's shared base for rendering.
-        def to_s
+        def to_s(**opts)
           return "" unless ids&.any?
 
-          ids.each_with_index.map do |id, i|
+          result = ids.each_with_index.map do |id, i|
             member = id.base ? id : rebased(id)
             i.zero? ? member.to_s : member.to_s.delete_prefix("CIE ")
           end.join(",")
+
+          annotate_plain_render(result, **opts)
         end
 
         private

data/lib/pubid/cie/identifiers/conference.rb

@@ -15,7 +15,7 @@ module Pubid
         # Techstreet opaque /slug variant (no default -> round-trips cleanly)
         attribute :variant, :string
 
-        def to_s
+        def to_s(**opts)
           result = "CIE x#{number}"
 
           # Date with separator
@@ -29,7 +29,7 @@ module Pubid
           # Opaque /slug variant if present
           result += "/#{variant}" if variant
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

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

@@ -25,8 +25,8 @@ module Pubid
           year
         end
 
-        def to_s
-          "#{base}/Cor#{number}:#{year}"
+        def to_s(**opts)
+          annotate_plain_render("#{base}/Cor#{number}:#{year}", **opts)
         end
       end
     end

data/lib/pubid/cie/identifiers/dual_published.rb

@@ -14,7 +14,7 @@ module Pubid
         attribute :s_prefix, :boolean, default: -> { false }
         attribute :iec_identifier, :string # IEC portion as string
 
-        def to_s
+        def to_s(**opts)
           parts = ["CIE"]
 
           # S prefix
@@ -33,7 +33,7 @@ module Pubid
           # IEC portion with slash separator
           result += "/IEC #{iec_identifier}" if iec_identifier
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

data/lib/pubid/cie/identifiers/identical.rb

@@ -18,7 +18,7 @@ module Pubid
         attribute :language, Components::Language
         attribute :iso_reference, :string # The ISO identifier in parentheses
 
-        def to_s
+        def to_s(**opts)
           parts = ["CIE"]
 
           # S prefix
@@ -56,7 +56,7 @@ module Pubid
           # ISO reference in parentheses
           result += " (ISO #{iso_reference})" if iso_reference
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

data/lib/pubid/cie/identifiers/joint_published.rb

@@ -15,7 +15,7 @@ module Pubid
         attribute :doc_type, :string          # "TR" for Technical Report
         attribute :stage, :string             # "DIS" for draft stage
 
-        def to_s
+        def to_s(**opts)
           parts = ["CIE", copublisher]
 
           # Document type (TR)
@@ -44,7 +44,7 @@ module Pubid
           # Language (always parenthetical for joint published)
           result += language.to_s if language
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

data/lib/pubid/cie/identifiers/proceedings.rb

@@ -26,12 +26,14 @@ module Pubid
         # Page range "1-5" (standalone form only).
         attribute :page, :string
 
-        def to_s
-          if conference
-            "CIE x#{conference}-#{number}"
-          else
-            "CIE #{number} #{page}"
-          end
+        def to_s(**opts)
+          result = if conference
+                     "CIE x#{conference}-#{number}"
+                   else
+                     "CIE #{number} #{page}"
+                   end
+
+          annotate_plain_render(result, **opts)
         end
       end
     end

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

@@ -17,7 +17,28 @@ module Pubid
         attribute :language, Components::Language
         attribute :stage, :string # DIS, DS
 
-        def to_s
+        def to_s(**opts)
+          annotate_plain_render(render_plain, **opts)
+        end
+
+        # CIE Standard distinguishes S-prefixed standards (`CIE S 017`) from
+        # plain (`CIE 015`), D-prefixed (`CIE D001`), and DIS-staged. The
+        # generic mr_type looks at typed_stage, which CIE doesn't use, so
+        # without this override the `S`/`D`/stage marker would be lost in MR.
+        def mr_type
+          return stage.downcase if stage
+          return "d" if d_prefix
+          return "s" if s_prefix
+
+          nil
+        end
+
+        private
+
+        # The plain composition, extracted verbatim from `to_s`. It has two
+        # early returns (the slash_colon language form and the legacy
+        # bare slash-year form), and `to_s` needs a single exit to wrap.
+        def render_plain
           parts = ["CIE"]
 
           # Stage (DIS/DS) before code if present
@@ -66,18 +87,6 @@ module Pubid
 
           result
         end
-
-        # CIE Standard distinguishes S-prefixed standards (`CIE S 017`) from
-        # plain (`CIE 015`), D-prefixed (`CIE D001`), and DIS-staged. The
-        # generic mr_type looks at typed_stage, which CIE doesn't use, so
-        # without this override the `S`/`D`/stage marker would be lost in MR.
-        def mr_type
-          return stage.downcase if stage
-          return "d" if d_prefix
-          return "s" if s_prefix
-
-          nil
-        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module Pubid
           base&.year
         end
 
-        def to_s
+        def to_s(**opts)
           b = base
           parts = ["CIE"]
           parts << b.stage if b.respond_to?(:stage) && b.stage
@@ -39,7 +39,7 @@ module Pubid
 
           # Supplements always use the current (colon) style.
           result += ":#{b.year}" if b.year
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

data/lib/pubid/cie/identifiers/tutorial_bundle.rb

@@ -15,8 +15,8 @@ module Pubid
         # :string overrides the base ::Pubid::Identifier Components::Code type.
         attribute :number, :string
 
-        def to_s
-          "CIE Tutorials Bundle #{number}"
+        def to_s(**opts)
+          annotate_plain_render("CIE Tutorials Bundle #{number}", **opts)
         end
       end
     end

data/lib/pubid/cie/parser.rb

@@ -6,7 +6,7 @@ module Pubid
   module Cie
     # Parser for CIE identifiers
     # Handles dual-style system (legacy vs current)
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }

data/lib/pubid/cie.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Cie
     extend Pubid::PrefixesSupport
@@ -23,8 +24,13 @@ module Pubid
     # Main entry point for CIE identifiers
     # Delegates to Identifier.parse
     def self.parse(input)
+      unless input.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
       if input.length > Pubid::MAX_INPUT_LENGTH
-        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
       Identifier.parse(input)

data/lib/pubid/conformance/checks.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Conformance
+    # The single check core shared by the conformance runner and the rspec
+    # corpus gate. One corpus case in, its mismatch list out (empty ==
+    # passing). The list shape is load-bearing: RSpec's aggregate_failures
+    # does not raise on a failed expectation, so exception-based control
+    # flow would misread real failures as passes - and the runner needs to
+    # accumulate across cases rather than abort.
+    module Checks
+      class << self
+        # @param test_case [Pubid::Conformance::Corpus::Case]
+        # @param flavor_module [Module] the flavor owning the case
+        # @return [Array<String>] mismatch descriptions, empty when passing
+        def check_case(test_case, flavor_module)
+          identifier = flavor_module.parse(test_case.representations.human)
+          mismatchers(identifier, test_case, flavor_module)
+            .flat_map(&:call)
+        rescue StandardError => e
+          ["#{test_case.id} raised #{e.class}"]
+        end
+
+        # Each checker returns the case's mismatch list for its concern.
+        def mismatchers(identifier, test_case, flavor_module)
+          label = test_case.id.to_s
+          [
+            -> { canonical_mismatches(identifier, test_case, label) },
+            -> { representation_mismatches(identifier, test_case, label) },
+            -> { alias_mismatches(test_case, flavor_module, label) },
+            -> { deserialize_mismatches(identifier, flavor_module, label) },
+          ]
+        end
+
+        def canonical_mismatches(identifier, test_case, label)
+          actual = Conformance.plainify(identifier.to_hash)
+          actual == test_case.identifier ? [] : ["#{label} canonical hash"]
+        end
+
+        private
+
+        def representation_mismatches(identifier, test_case, label)
+          mismatches = []
+          reps = test_case.representations
+          mismatches << "#{label} human" if identifier.to_s != reps.human
+          if reps.urn && identifier.to_urn != reps.urn
+            mismatches << "#{label} urn"
+          end
+          mismatches
+        end
+
+        def alias_mismatches(test_case, flavor_module, label)
+          human = test_case.representations.human
+          test_case.non_normalized_aliases.filter_map do |entry|
+            aliased = flavor_module.parse(entry.spelling)
+            "#{label} alias #{entry.spelling}" if aliased.to_s != human
+          rescue StandardError
+            "#{label} alias #{entry.spelling} raised"
+          end
+        end
+
+        def deserialize_mismatches(identifier, flavor_module, label)
+          hash = identifier.to_hash
+          ok = flavor_module::Identifier.from_hash(hash).to_hash == hash
+          ok ? [] : ["#{label} deserialize"]
+        rescue StandardError
+          ["#{label} deserialize raised"]
+        end
+      end
+    end
+  end
+end

data/lib/pubid/conformance/corpus/case.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Conformance
+    module Corpus
+      # Every proper rendering of the case's identifier.
+      class Representations < Lutaml::Model::Serializable
+        attribute :human, :string
+        attribute :urn, :string
+      end
+
+      # One old spelling that must normalize to the human form.
+      class Spelling < Lutaml::Model::Serializable
+        attribute :spelling, :string
+        attribute :style, :string
+      end
+
+      # Neutral rejection expectation - never an implementation class.
+      class Error < Lutaml::Model::Serializable
+        attribute :code, :string
+      end
+
+      class Expectation < Lutaml::Model::Serializable
+        attribute :error, Error
+      end
+
+      # One corpus case (schema/test.schema.yaml is the wire contract).
+      # `identifier` stays an opaque hash on purpose: it is the flavor's
+      # own canonical to_hash carried as DATA to compare against, not a
+      # structure the reader interprets.
+      class Case < Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :style, :string
+        attribute :identifier, :hash
+        attribute :representations, Representations
+        attribute :non_normalized_aliases, Spelling, collection: true,
+                                                     default: -> { [] }
+        attribute :roundtrip, :boolean
+        attribute :expect, Expectation
+        attribute :input, :string
+        attribute :notes, :string
+        attribute :review, :string
+
+        def error_case? = !expect.nil? && !expect.error.nil?
+
+        # Reference-bug debt: nothing to gate on.
+        def quarantined? = identifier.nil? && !error_case?
+
+        def review? = !review.to_s.empty?
+
+        def roundtrip_failure_expected? = roundtrip == false
+      end
+    end
+  end
+end

data/lib/pubid/conformance/corpus.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Conformance
+    # Typed reading layer for pubid-testsuite payloads. The YAML schema
+    # (schema/test.schema.yaml in pubid-testsuite) is the wire contract;
+    # these models are the shared typed reader for every implementation -
+    # the Ruby gem now, pubid-ts mirroring the same shape later. No
+    # consumer pokes payload hashes directly.
+    module Corpus
+      autoload :Case, "pubid/conformance/corpus/case"
+
+      class << self
+        # Cases from one payload file (underscore payloads excluded).
+        def load_file(path)
+          Array(YAML.safe_load_file(path)).map { |doc| Case.from_hash(doc) }
+        end
+
+        def case_files(flavor, corpus_dir)
+          Dir[File.join(corpus_dir, flavor, "*.yaml")]
+            .reject { |p| File.basename(p).start_with?("_") }.sort
+        end
+
+        def cases(flavor, corpus_dir)
+          case_files(flavor, corpus_dir).flat_map { |p| load_file(p) }
+        end
+
+        # The must-fail payload (fail fixtures decoded by the exporter).
+        def negative_file(flavor, corpus_dir)
+          path = File.join(corpus_dir, flavor, "_negative.yaml")
+          File.exist?(path) ? [path] : []
+        end
+      end
+    end
+  end
+end