pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/conformance/runner.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Conformance
+    # Executes the pubid-testsuite corpus against this implementation.
+    # CLEAN flavors hard-gate (failures abort); DIRTY flavors report as
+    # the known reference-defect ledger.
+    class Runner
+      REGISTRY_KEYS = { "tgpp" => "3gpp" }.freeze
+
+      def run(flavors = corpus_flavors)
+        require "pubid"
+
+        if flavors.empty?
+          raise ArgumentError, "no corpus flavors found at #{corpus_dir} - " \
+                               "refusing to report vacuous success"
+        end
+
+        Pubid.eager_load_flavors!
+        flavors.each_with_object([]) do |flavor, failures|
+          failures.concat(run_flavor(flavor))
+        end
+      end
+
+      private
+
+      def corpus_flavors
+        Dir[File.join(corpus_dir, "*")].select { |p| File.directory?(p) }
+          .map { |p| File.basename(p) }
+      end
+
+      def corpus_dir
+        File.join(ENV.fetch("PUBID_TESTSUITE_PATH",
+                            File.expand_path("../../../../pubid-testsuite",
+                                             __dir__)), "tests")
+      end
+
+      def run_flavor(flavor)
+        flavor_module = Pubid::Registry.get(
+          REGISTRY_KEYS.fetch(flavor, flavor),
+        )
+        raise ArgumentError, "unknown flavor #{flavor}" if flavor_module.nil?
+
+        stats = Hash.new(0)
+        failures = []
+        each_payload_case(flavor) do |test_case|
+          execute(test_case, flavor_module, stats, failures)
+        end
+        Corpus.negative_file(flavor, corpus_dir).each do |path|
+          Corpus.load_file(path).each do |test_case|
+            execute_negative(test_case, flavor_module, stats, failures)
+          end
+        end
+        report(flavor, stats, failures)
+        known_dirty?(flavor) ? [] : failures
+      end
+
+      def each_payload_case(flavor, &block)
+        Corpus.case_files(flavor, corpus_dir).each do |path|
+          Corpus.load_file(path).each(&block)
+        end
+      end
+
+      def known_dirty?(flavor)
+        status = File.join(corpus_dir, flavor, "_status.yaml")
+        File.exist?(status) && !YAML.safe_load_file(status)["clean"]
+      end
+
+      # Every corpus case lands in exactly one quadrant:
+      #   pass | FAIL (not pending, breaks the CLEAN gate) | pending
+      #   (explicitly not handled yet, see Conformance::Pending) | review
+      #   (the expectation itself is flagged for human verification).
+      def execute(test_case, flavor_module, stats, failures)
+        id = test_case.id
+        return stats[:review] += 1 if test_case.review?
+
+        if Pending.for(id)
+          run_pending(id, test_case, flavor_module, stats, failures)
+        else
+          run_case(test_case, flavor_module, stats, failures)
+        end
+      end
+
+      # Pending cases still run: a pending case that PASSES is reported as
+      # pending-satisfied - a cleanup alarm, the marker must be removed.
+      def run_pending(id, test_case, flavor_module, stats, failures)
+        stats[:pending] += 1
+        before = failures.size
+        run_case(test_case, flavor_module, stats, failures)
+        return failures.slice!(before..) if failures.size > before
+
+        stats[:pending_satisfied] += 1
+        puts "  PENDING-SATISFIED #{id} - remove the marker"
+      end
+
+      def run_case(test_case, flavor_module, stats, failures)
+        if test_case.error_case?
+          execute_error_case(test_case, flavor_module, stats, failures)
+          return
+        end
+        return stats[:quarantined] += 1 if test_case.quarantined?
+
+        stats[:cases] += 1
+        Checks.check_case(test_case, flavor_module).each do |mismatch|
+          stat_for(mismatch, stats)
+          failures << mismatch
+        end
+      end
+
+      def stat_for(mismatch, stats)
+        case mismatch
+        when / raised\z/ then stats[:fail_parse] += 1
+        when /canonical hash/ then stats[:fail_tree] += 1
+        when / human\z/, / urn\z/
+          stats[:"fail_#{mismatch.split.last}"] += 1
+        when / alias/ then stats[:fail_alias] += 1
+        else stats[:fail_roundtrip] += 1
+        end
+      end
+
+      # Negatives (fail fixtures decoded by the exporter). A row with
+      # expect.error must be rejected by the reference; a row without it
+      # is the exporter's reclassification alarm - the fail-fixture line
+      # now parses, so the fixture belongs in pass/ - reported, never
+      # gated, like the PENDING-SATISFIED alarm.
+      def execute_negative(test_case, flavor_module, stats, failures)
+        return stats[:reclass] += 1 unless test_case.error_case?
+
+        execute_error_case(test_case, flavor_module, stats, failures)
+      end
+
+      def execute_error_case(test_case, flavor_module, stats, failures)
+        stats[:error_cases] += 1
+        flavor_module.parse(test_case.input)
+        stats[:fail_error] += 1
+        failures << "#{test_case.id} unexpectedly parsed"
+      rescue StandardError
+        stats[:error_ok] += 1
+      end
+
+      def report(flavor, stats, failures)
+        puts format(
+          "%-6s cases=%-6d err=%-4d quar=%-3d fail=%-4d " \
+          "pend=%-4d pendok=%-3d reclass=%-4d review=%d",
+          flavor, stats[:cases], stats[:error_cases], stats[:quarantined],
+          failures.size, stats[:pending], stats[:pending_satisfied],
+          stats[:reclass], stats[:review]
+        )
+        failures.first(10).each { |f| puts "  FAIL #{f}" }
+      end
+    end
+  end
+end

data/lib/pubid/conformance.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+
+module Pubid
+  # The shared, language-independent conformance corpus (conformance/).
+  # The identifier structure in each case is THE GEM'S OWN canonical
+  # to_hash, embedded verbatim (the same wire format relaton persists).
+  # Nothing is reinvented: the corpus adds only what the gem cannot know -
+  # representations, normalization aliases, styling, and neutral error
+  # codes for debt/negative records.
+  module Conformance
+    autoload :Checks, "pubid/conformance/checks"
+    autoload :Corpus, "pubid/conformance/corpus"
+    autoload :Generator, "pubid/conformance/generator"
+    autoload :Pending, "pubid/conformance/pending"
+    autoload :Runner, "pubid/conformance/runner"
+
+    # Neutral error vocabulary. Each implementation maps its native
+    # exceptions onto these codes; the corpus never records Ruby classes.
+    ERROR_CODES = {
+      "Parslet::ParseFailed" => "parse_failed",
+      "ArgumentError" => "invalid_argument",
+    }.freeze
+
+    class << self
+      def error_code_for(exception)
+        ERROR_CODES.fetch(exception.class.name, "unclassified")
+      end
+
+      # Heuristic PubID styling version. v1 = legacy "ISO/R 2533/3-1975";
+      # v2 = dotted/uppercase ("AMD.1"); v3 = modern ("Amd 1"). Heuristic
+      # until the model exposes its parsed format (TODO.restructure/12).
+      def style_for(input)
+        return "v1" if /\bISO\/R\b|\bISO R\b/.match?(input)
+        return "v2" if /\b(?:Amd|AMD|Cor|COR|Suppl|SUPPL)\.\d/.match?(input)
+
+        "v3"
+      end
+
+      # Hygiene only (not a redesign): guarantee the corpus is pure YAML -
+      # component objects leaking through serialization are reduced to
+      # their string rendering.
+      def plainify(value)
+        case value
+        when Hash then value.to_h { |key, entry| [key.to_s, plainify(entry)] }
+        when Array then value.map { |entry| plainify(entry) }
+        when String, Integer, Float, TrueClass, FalseClass, NilClass then value
+        else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/pubid/core.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Core module for shared functionality across all flavors.
   module Core
     autoload :UpdateCodes, "#{__dir__}/core/update_codes"
+    autoload :PatternDocGenerator, "#{__dir__}/core/pattern_doc_generator"
   end
 end

data/lib/pubid/csa/builder.rb

@@ -53,7 +53,7 @@ module Pubid
         # Build base identifier (without package_portion)
         base_data = parsed_hash.dup
         base_data.delete(:package_portion)
-        package.base_identifier = build_single(base_data)
+        package.base = build_single(base_data)
 
         # Set package materials
         if parsed_hash[:package_portion]
@@ -101,7 +101,7 @@ module Pubid
           else
             begin
               Pubid::Iso.parse(base_str)
-            rescue Pubid::Errors::ParseError
+            rescue Parslet::ParseFailed
               Pubid::Iec.parse(base_str)
             end
           end
@@ -128,17 +128,17 @@ module Pubid
           end
           amendment_str = "#{base_str}/Amd #{parsed_hash[:adoption_amendment]}:#{wrapped_amendment_year}"
 
-          wrapped_identifier = if adoption_org.start_with?("ISO", "CEI")
-                                 Pubid::Iso.parse(amendment_str)
-                               elsif adoption_org.start_with?("IEC")
-                                 Pubid::Iec.parse(amendment_str)
-                               else
-                                 begin
-                                   Pubid::Iso.parse(amendment_str)
-                                 rescue Pubid::Errors::ParseError
-                                   Pubid::Iec.parse(amendment_str)
-                                 end
-                               end
+          base = if adoption_org.start_with?("ISO", "CEI")
+                   Pubid::Iso.parse(amendment_str)
+                 elsif adoption_org.start_with?("IEC")
+                   Pubid::Iec.parse(amendment_str)
+                 else
+                   begin
+                     Pubid::Iso.parse(amendment_str)
+                   rescue Parslet::ParseFailed
+                     Pubid::Iec.parse(amendment_str)
+                   end
+                 end
         else
           # No amendment, simple base identifier
           wrapped_id_str = "#{adoption_org} #{adoption_number}#{year_sep}#{wrapped_year}"
@@ -148,20 +148,20 @@ module Pubid
             wrapped_id_str = wrapped_id_str.sub("CEI/IEC", "IEC")
           end
 
-          wrapped_identifier = if adoption_org.start_with?("ISO", "CEI")
-                                 Pubid::Iso.parse(wrapped_id_str)
-                               elsif adoption_org.start_with?("IEC")
-                                 Pubid::Iec.parse(wrapped_id_str)
-                               else
-                                 begin
-                                   Pubid::Iso.parse(wrapped_id_str)
-                                 rescue Pubid::Errors::ParseError
-                                   Pubid::Iec.parse(wrapped_id_str)
-                                 end
-                               end
+          base = if adoption_org.start_with?("ISO", "CEI")
+                   Pubid::Iso.parse(wrapped_id_str)
+                 elsif adoption_org.start_with?("IEC")
+                   Pubid::Iec.parse(wrapped_id_str)
+                 else
+                   begin
+                     Pubid::Iso.parse(wrapped_id_str)
+                   rescue Parslet::ParseFailed
+                     Pubid::Iec.parse(wrapped_id_str)
+                   end
+                 end
         end
 
-        adoption.wrapped_identifier = wrapped_identifier
+        adoption.base = base
 
         # Handle reaffirmation
         if parsed_hash[:reaffirmation]
@@ -195,23 +195,25 @@ module Pubid
           # SERIES matched - build Series identifier with CAN/CSA- prefix
           # The Series.to_s will handle rendering as "CAN/CSA-A220 SERIES-06"
           # (keeping the full prefix instead of "CAN/CSA-A220...")
-          wrapped_identifier = build_series(wrapped_data)
+          base = build_series(wrapped_data)
           # Set the full publisher_prefix on the wrapped Series for proper rendering
-          # The test expects wrapped_identifier.publisher_prefix to be "CAN/CSA-"
+          # The test expects base.publisher_prefix to be "CAN/CSA-"
         elsif parsed_hash.key?(:cec_part)
           # CEC matched - build Cec identifier
-          wrapped_identifier = build_cec(wrapped_data)
+          base = build_cec(wrapped_data)
         else
           # Standard CSA identifier
-          wrapped_identifier = build_single(wrapped_data)
+          base = build_single(wrapped_data)
         end
-        wrapped_identifier.publisher_prefix = original_prefix if original_prefix && wrapped_identifier.class.attributes.key?(:publisher_prefix)
+        base.publisher_prefix = original_prefix if original_prefix && base.class.attributes.key?(:publisher_prefix)
 
-        canadian_adopted.wrapped_identifier = wrapped_identifier
+        canadian_adopted.base = base
 
-        # Handle reaffirmation - supports both 2-digit and 4-digit years
-        # Note: CanadianAdopted (WrapperIdentifier) doesn't track original_reaffirmation_4digit
-        # That's only for Series/Cec identifiers
+        # Handle reaffirmation - supports both 2-digit and 4-digit years.
+        # The wrapper's own original_reaffirmation_4digit is left at its
+        # default: CanadianAdopted#to_s only consults it when the wrapped id
+        # carries no reaffirmation of its own, and Series/Cec track the printed
+        # width themselves.
         if parsed_hash[:reaffirmation_4digit]
           # Original was 4-digit (e.g., "R2019")
           canadian_adopted.reaffirmation = parsed_hash[:reaffirmation_4digit].to_s
@@ -251,7 +253,7 @@ module Pubid
 
         # Code
         if parsed_hash[:code]
-          series.code = Components::Code.new(value: parsed_hash[:code].to_s)
+          series.number = Components::Code.new(value: parsed_hash[:code].to_s)
         end
 
         # Year format and year
@@ -451,10 +453,10 @@ module Pubid
       def build_combined(parsed_hash)
         combined = Identifiers::Combined.new
 
-        # Build each part
-        combined.first = build_single(parsed_hash[:first])
-        combined.second = build_single(parsed_hash[:second])
-        combined.third = build_single(parsed_hash[:third]) if parsed_hash[:third]
+        # Build each designation, in printed order, into one collection.
+        combined.identifiers = %i[first second third]
+          .filter_map { |key| parsed_hash[key] }
+          .map { |part| build_single(part) }
 
         # Detect separator from parser marker
         combined.separator = if parsed_hash[:comma_separator]
@@ -495,15 +497,13 @@ module Pubid
         identifier_class = select_identifier_class(data)
         identifier = identifier_class.new
 
-        # Publisher prefix (CAN/CSA-, CAN3-, or CSA)
-        # For code_only identifiers (no prefix in original), set to empty string
-        # to prevent default "CSA" from being added in rendering
+        # Publisher prefix (CAN/CSA-, CAN3-, or CSA).
+        # A code with no prefix in the original is a code_only identifier; the
+        # flag stops rendering from supplying the default "CSA".
         if data[:publisher_prefix]
           identifier.publisher_prefix = data[:publisher_prefix].to_s
-        elsif data[:code] && !data[:publisher_prefix]
-          # Code exists but no publisher_prefix = code_only identifier
-          # Use empty string to indicate "no prefix wanted"
-          identifier.publisher_prefix = ""
+        elsif data[:code]
+          identifier.code_only = true
         end
 
         # Publisher presence flag
@@ -520,13 +520,13 @@ module Pubid
           # Pattern: "C22.1-15" should become code="C22.1", year="2015"
           if !data[:year] && code_value =~ /^(.+)-(\d{2})$/
             # Split code and year
-            identifier.code = Components::Code.new(value: $1)
+            identifier.number = Components::Code.new(value: $1)
             # Convert 2-digit year to 4-digit
             year_2digit = $2
             identifier.year = "20#{year_2digit}"
             identifier.year_format = "dash"
           else
-            identifier.code = Components::Code.new(value: code_value)
+            identifier.number = Components::Code.new(value: code_value)
           end
         end
 

data/lib/pubid/csa/composite_identifier.rb

@@ -8,20 +8,31 @@ module Pubid
     # collections of other identifiers or package materials.
     #
     # Examples:
-    #   - PackageIdentifier: Base + package materials
-    #   - Future: BundleIdentifier refactor to use composite
+    #   - Package: base + package materials
     #
     # This follows the Composite pattern where an identifier can contain
     # other identifiers or additional metadata as a collection.
-    class CompositeIdentifier < Lutaml::Model::Serializable
-      # The primary/base identifier
-      # Use attr_accessor since it can be any identifier object
-      attr_accessor :base_identifier
+    class CompositeIdentifier < Identifier
+      # The primary/base identifier. A real lutaml attribute under the uniform
+      # `base` name, so `#root` walks it and it survives serialization — see
+      # WrapperIdentifier#base for why the type is the cross-flavor
+      # ::Pubid::Identifier.
+      attribute :base, ::Pubid::Identifier, polymorphic: true
 
       # Subclasses MUST implement to_s to define how they render
-      def to_s
+      def to_s(**_opts)
         raise NotImplementedError, "Subclasses must implement to_s method"
       end
+
+      # A package peels to the standard it packages — see
+      # WrapperIdentifier#base_document.
+      def base_document
+        base ? base.base_document : self
+      end
+
+      def drop_supplements
+        base || self
+      end
     end
   end
 end