pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/csa/identifiers/package.rb

@@ -12,7 +12,7 @@ module Pubid
       #   CSA C22.2 NO. 60601-1:15 PACKAGE WITH ADDENDUM
       #
       # This is a composite pattern where:
-      #   - base is the core CSA standard (recursively parsed)
+      #   - base_identifier is the core CSA standard (recursively parsed)
       #   - package_materials describes what's included in the package
       #   - Package portion is metadata, not a parseable identifier
       #
@@ -33,8 +33,8 @@ module Pubid
         # false = materials BEFORE: "CSA B149.1:25 Code, Handbook & Training Package"
         attribute :materials_after_keyword, :boolean, default: -> { true }
 
-        def to_s(**opts)
-          result = base.to_s
+        def to_s
+          result = base_identifier.to_s
 
           # Add package materials if present
           if package_materials && !package_materials.empty?
@@ -57,7 +57,7 @@ module Pubid
             result += " PACKAGE"
           end
 
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end

data/lib/pubid/csa/identifiers/series.rb

@@ -17,6 +17,110 @@ module Pubid
       class Series < Base
         # Series prefix (MH, RV, etc.) - optional
         attribute :series_prefix, :string
+
+        def to_s
+          result = publisher_prefix_portion
+
+          # Add code FIRST (before SERIES keyword)
+          result += code.to_s
+
+          # Add space before series prefix/SERIES keyword
+          result += " "
+
+          # Add series prefix if present
+          result += "#{series_prefix} " if series_prefix && !series_prefix.empty?
+
+          # Add SERIES keyword
+          result += "SERIES"
+
+          # Add year
+          result += year_portion
+
+          # Add language
+          result += language_portion
+
+          # Add reaffirmation
+          result += reaffirmation_portion
+
+          result
+        end
+
+        private
+
+        def publisher_prefix_portion
+          prefix = publisher_prefix || "CSA"
+
+          # Handle code_only identifiers (empty string means no prefix)
+          return "" if prefix == ""
+
+          # Determine if we need space after prefix
+          # CAN/CSA- and CAN3- end with dash, so no space needed
+          needs_space = !prefix.end_with?("-")
+
+          needs_space ? "#{prefix} " : prefix
+        end
+
+        def year_portion
+          return "" unless year
+
+          # Use dash if year_format is dash, otherwise colon
+          separator = year_format == "dash" ? "-" : ":"
+          year_part = separator
+          year_part += year_prefix if year_prefix # Add M or F prefix
+          year_part += "F" if french && year_format != "dash" && !year_prefix # Only add F if no prefix
+
+          # Convert 4-digit year back to 2-digit
+          year_str = year.to_s
+          year_part += if year_str.length == 4 && year_str.start_with?("20")
+                         year_str[2..3]
+                       else
+                         year_str
+                       end
+
+          year_part
+        end
+
+        def language_portion
+          "" # CSA doesn't use language codes in rendering
+        end
+
+        def reaffirmation_portion
+          return "" unless reaffirmation
+
+          # Check if year was originally 2-digit (original_year_4digit flag)
+          year_was_2digit = !original_year_4digit
+
+          # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
+          reaffirmation_was_4digit = original_reaffirmation_4digit
+
+          # Preserve original reaffirmation format
+          # If original was 4-digit, keep as 4-digit
+          # If original was 2-digit, convert from 4-digit storage back to 2-digit
+          reaffirmation_str = if reaffirmation_was_4digit
+                                # Original was 4-digit, keep as-is
+                                reaffirmation.to_s
+                              elsif reaffirmation.to_s.length == 4 && reaffirmation.to_s.start_with?(
+                                "19", "20"
+                              )
+                                # Original was 2-digit, convert 4-digit storage back to 2-digit
+                                # (R2004) → (R04), (R1994) → (R94)
+                                reaffirmation.to_s[2..3]
+                              else
+                                # Already 2-digit or other format
+                                reaffirmation.to_s
+                              end
+
+          # Determine spacing based on original formats
+          # Space needed if year is 2-digit and reaffirmation is 4-digit (original format)
+          # No space if both year and reaffirmation are 2-digit, or both are 4-digit
+          if year_was_2digit && reaffirmation_was_4digit
+            # Year was 2-digit, reaffirmation was 4-digit → add space
+            " (R#{reaffirmation_str})"
+          else
+            # Both 2-digit, both 4-digit, or other cases → no space
+            "(R#{reaffirmation_str})"
+          end
+        end
       end
     end
   end

data/lib/pubid/csa/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Csa
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:dash) { str("-") }
@@ -179,7 +179,7 @@ module Pubid
           # Optional series prefix (MH, RV, etc.) before SERIES keyword
           (series_prefix >> space).maybe >>
           series_keyword.as(:series_type) >>
-          (colon_year | dash_year).maybe >>
+          (colon_year | dash_year) >>
           reaffirmation.maybe
       end
 
@@ -194,7 +194,7 @@ module Pubid
           ).as(:cec_part) >>
           no_notation >>
           no_number >>
-          (colon_year | dash_year).maybe >>
+          (colon_year | dash_year) >>
           reaffirmation.maybe
       end
 
@@ -257,7 +257,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 4: just year (no series, no NO.)
             (colon_year | dash_year)
-          ).maybe >> # trailing year optional (partial reference)
+          ) >>
           amendment_slash.maybe # Add amendment support here
       end
 
@@ -274,7 +274,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 4: just year
             (colon_year | dash_year)
-          ).maybe # trailing year optional (partial reference)
+          )
       end
 
       # Continuation code (optional CSA publisher prefix, for combined identifiers)
@@ -290,7 +290,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 4: just year
             (colon_year | dash_year)
-          ).maybe >> # trailing year optional (partial reference)
+          ) >>
           amendment_slash.maybe
       end
 
@@ -353,7 +353,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 3: just year
             (colon_year | dash_year)
-          ).maybe >> # trailing year optional (partial reference)
+          ) >>
           (space >> str("PACKAGE")).as(:package_portion).maybe
       end
 
@@ -367,11 +367,7 @@ module Pubid
       # Preprocessing to normalize input
       def parse(input)
         # Skip comment lines
-        if input.strip.start_with?("#")
-          raise Pubid::Errors::ParseError.new(
-            "Comment line", input: input, flavor: "csa"
-          )
-        end
+        raise Parslet::ParseFailed.new("Comment line") if input.strip.start_with?("#")
 
         # Remove CONSOLIDATED notation FIRST (before other processing)
         normalized = input.gsub(/\s*\(\s*CONSOLIDATED\s*\)\s*/, " ")

data/lib/pubid/csa/scheme.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          @identifiers ||= [
+            Identifiers::Standard,
+            Identifiers::Bundled,
+            Identifiers::CanadianAdopted,
+            Identifiers::CsaAdopted,
+            Identifiers::Package,
+            Identifiers::Series,
+            Identifiers::Cec,
+            Identifiers::Combined,
+          ].freeze
+        end
+
+        def supplement_identifiers
+          @supplement_identifiers ||= [].freeze
+        end
+
+        def typed_stages
+          @typed_stages ||= [].freeze
+        end
+
+        def supplement_typed_stages
+          @supplement_typed_stages ||= [].freeze
+        end
+
+        def locate_typed_stage_by_abbr(_abbr)
+          raise ArgumentError,
+                "CSA identifiers do not use typed stages"
+        end
+
+        def locate_identifier_klass_by_type_code(_type_code)
+          raise ArgumentError,
+                "CSA identifiers do not use type codes"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/csa/single_identifier.rb

@@ -2,19 +2,12 @@
 
 module Pubid
   module Csa
-    class SingleIdentifier < Identifier
-      # The document code — "B149.1", "Z240", "C22.2" — and the relaton index
-      # key: Relaton::Index sorts and bsearches every row on
-      # `id.root.number.to_s`, so it must never be empty.
+    class SingleIdentifier < Pubid::Identifier
+      # Generate URN for this identifier
       #
-      # It is the `number` INHERITED from ::Pubid::Identifier, not a
-      # redeclaration: Pubid::Csa::Components::Code is a bare alias of
-      # Pubid::Components::Code, which is exactly the parent's declared type.
-      # That matters. CSA's base is split across two files (csa/identifier.rb +
-      # csa/single_identifier.rb) — the IEEE shape in which a leaf can snapshot
-      # a half-built parent attribute table (CLAUDE.md, the `number`
-      # determinism landmine). Declaring nothing here keeps CSA clear of it.
-      # The attribute was named `code` before; there is no alias.
+      # @return [String] URN representation
+
+      attribute :code, Components::Code
       attribute :no_number, :string
       attribute :year, :string
       attribute :year_format, :string  # "colon" or "dash"
@@ -32,88 +25,6 @@ module Pubid
       attribute :series, :boolean         # Track if SERIES keyword present
       attribute :package, :string         # Package portion (Code, Handbook, etc.)
       attribute :publisher_prefix, :string # Original prefix: "CAN/CSA-", "CSA", "CAN3-"
-
-      # True when the reference printed no publisher at all ("C22.1-15"), so
-      # rendering must not supply the default "CSA".
-      #
-      # This used to be an empty-string `publisher_prefix` sentinel, which the
-      # canonical `to_hash` drops (it strips empty and default-valued
-      # attributes by design) — so a code-only identifier came back
-      # from `from_hash` with a nil prefix and re-rendered as
-      # "CSA C22.1-15". Named for the RARE case with a `false` default,
-      # per CLAUDE.md, so it is dropped from every ordinary row.
-      attribute :code_only, :boolean, default: -> { false }
-
-      # A flat, index-friendly serialized shape: the `Components::Code`
-      # attributes collapse to bare scalars (`number: C22.2-286`, not
-      # `number: {value: C22.2-286}`), the ISO/ETSI/ITU `key_value` pattern.
-      #
-      # This is deliberately a serialization mapping rather than an
-      # `attribute :number, :string` redeclaration. CSA's base is split across
-      # two files (csa/identifier.rb + csa/single_identifier.rb) — the IEEE
-      # shape in which a leaf can snapshot a half-built parent attribute table
-      # — so a retype here would reintroduce the `number` determinism landmine
-      # recorded in CLAUDE.md. The runtime attribute stays a Components::Code;
-      # only the hash is flat.
-      #
-      # A lutaml key_value block is EXHAUSTIVE — an unmapped attribute is
-      # dropped, `_type` included — so every attribute above appears here. It
-      # lives on SingleIdentifier, which only the single-document types
-      # inherit; the container types descend from Csa::Identifier directly and
-      # keep the default shape for their nested `base`/`identifiers`.
-      key_value do
-        map "_type", to: :_type
-        map "number", with: { to: :number_to_kv, from: :number_from_kv }
-        map "no_number",
-            with: { to: :no_number_to_kv, from: :no_number_from_kv }
-        map "year", to: :year
-        map "year_format", to: :year_format
-        map "year_prefix", to: :year_prefix
-        map "original_year_4digit", to: :original_year_4digit
-        map "french", to: :french
-        map "reaffirmation", to: :reaffirmation
-        map "original_reaffirmation_4digit", to: :original_reaffirmation_4digit
-        map "has_publisher", to: :has_publisher
-        map "series_prefix", to: :series_prefix
-        map "series", to: :series
-        map "package", to: :package
-        map "publisher_prefix", to: :publisher_prefix
-        map "code_only", to: :code_only
-      end
-
-      def number_to_kv(model, doc)
-        emit_kv(doc, "number", model.number)
-      end
-
-      def number_from_kv(model, value)
-        model.number = Components::Code.new(value: value.to_s)
-      end
-
-      # `no_number` is a plain :string here but a Components::Code on Cec, so
-      # the converter reads through whichever it is given.
-      def no_number_to_kv(model, doc)
-        emit_kv(doc, "no_number", model.no_number)
-      end
-
-      def no_number_from_kv(model, value)
-        model.no_number =
-          if model.class.attributes[:no_number].type == Components::Code
-            Components::Code.new(value: value.to_s)
-          else
-            value.to_s
-          end
-      end
-
-      # Emit a scalar, skipping a nil or empty value so the canonical
-      # no-defaults hash never gains an empty key.
-      def emit_kv(doc, key, value)
-        text = value.respond_to?(:value) ? value.value : value
-        return if text.nil? || text.to_s.empty?
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new(key, text.to_s),
-        )
-      end
     end
   end
 end

data/lib/pubid/csa/urn_generator.rb

@@ -3,23 +3,16 @@
 module Pubid
   module Csa
     class UrnGenerator < Pubid::UrnGenerator::Base
-      # A code_only identifier printed no publisher, so it keeps an empty
-      # publisher segment rather than falling back to "csa" in #generate.
       def urn_publisher_prefix
-        return "" if code_only?
         return nil unless identifier.publisher_prefix
 
         identifier.publisher_prefix.to_s.downcase
       end
 
-      def code_only?
-        identifier.respond_to?(:code_only) && identifier.code_only
-      end
-
       def urn_number
-        return nil unless identifier.number
+        return nil unless identifier.code
 
-        identifier.number.render(context: URN_CONTEXT)
+        identifier.code.value.to_s
       end
 
       def urn_no_number

data/lib/pubid/csa/wrapper_identifier.rb

@@ -4,61 +4,28 @@ require "lutaml/model"
 
 module Pubid
   module Csa
-    # WrapperIdentifier is the base class for all CSA identifiers that wrap
-    # other identifiers.
+    # WrapperIdentifier is the base class for all CSA identifiers that wrap other identifiers
     # Examples:
-    #   - CanadianAdopted: CAN/{base}
-    #   - CsaAdopted:      CSA {ISO/IEC/CISPR identifier}
+    #   - CanadianAdoptedIdentifier: CAN/{wrapped_identifier}
+    #   - CsaAdoptedIdentifier: CSA {ISO/IEC/CISPR identifier}
     #
-    # The wrapper pattern allows proper MODEL-DRIVEN architecture where
-    # adoptions are objects that contain other identifier objects, not string
-    # prefixes.
-    class WrapperIdentifier < Identifier
-      # The wrapped identifier (recursively parsed).
-      #
-      # A real lutaml attribute, not an attr_accessor: the accessor was
-      # invisible to `to_hash`, `from_hash` AND `#exclude` (which iterates
-      # `self.class.attributes`), so a wrapper serialized to a hash with no
-      # identifier in it at all. It is named `base` — the uniform parent
-      # accessor every flavor uses — so the inherited `#root` walks it to the
-      # origin document and `exclude_from_nested` reaches inside. There is no
-      # `wrapped_identifier` alias.
-      #
-      # Typed as the cross-flavor `::Pubid::Identifier`, not the CSA one:
-      # CsaAdopted wraps ISO/IEC/CISPR ids, and lutaml enforces the declared
-      # type — `polymorphic: true` widens it only to SUBCLASSES, so a narrower
-      # type raises Lutaml::Model::IncorrectModelError on `to_hash`. The
-      # Ieee::Identifiers::AdoptedStandard precedent. The nested child carries
-      # its own `_type`, so `from_hash` routes it back via TypeResolver.
-      attribute :base, ::Pubid::Identifier, polymorphic: true
+    # The wrapper pattern allows proper MODEL-DRIVEN architecture where adoptions
+    # are objects that contain other identifier objects, not string prefixes.
+    class WrapperIdentifier < Lutaml::Model::Serializable
+      # The wrapped identifier (recursively parsed)
+      # Use attr_accessor since it can be any identifier object (CSA, ISO, IEC, etc.)
+      attr_accessor :wrapped_identifier
 
       # Reaffirmation year (common across wrappers)
       attribute :reaffirmation, :string
 
-      # Whether the reaffirmation was printed 4-digit ("(R2004)") rather than
-      # 2-digit ("(R04)"). CanadianAdopted#to_s reads it to choose the spacing
-      # and to render the year back in its original width.
-      attribute :original_reaffirmation_4digit, :boolean, default: -> { false }
-
       # Year format tracking (for compatibility)
       attribute :year_format, :string
 
       # Subclasses MUST implement to_s
-      def to_s(**_opts)
+      def to_s
         raise NotImplementedError, "Subclasses must implement to_s method"
       end
-
-      # The matching primitives relaton uses to normalise a reference before
-      # comparing it. An adoption wrapper peels to the document it adopts;
-      # without these the inherited defaults return the WRAPPER, which is a
-      # silently wrong answer rather than a loud one.
-      def base_document
-        base ? base.base_document : self
-      end
-
-      def drop_supplements
-        base || self
-      end
     end
   end
 end

data/lib/pubid/csa.rb

@@ -2,71 +2,20 @@
 
 module Pubid
   module Csa
-    extend Pubid::PrefixesSupport
-
-    # Sole CSA publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["CSA"].freeze
-
     autoload :Builder, "#{__dir__}/csa/builder"
     autoload :Identifier, "#{__dir__}/csa/identifier"
     autoload :Identifiers, "#{__dir__}/csa/identifiers"
     autoload :Parser, "#{__dir__}/csa/parser"
-    autoload :Renderer, "#{__dir__}/csa/renderer"
+    autoload :Scheme, "#{__dir__}/csa/scheme"
     autoload :SingleIdentifier, "#{__dir__}/csa/single_identifier"
     autoload :UrnGenerator, "#{__dir__}/csa/urn_generator"
-    autoload :UrnParser, "#{__dir__}/csa/urn_parser"
     autoload :WrapperIdentifier, "#{__dir__}/csa/wrapper_identifier"
     autoload :CompositeIdentifier, "#{__dir__}/csa/composite_identifier"
     autoload :Components, "#{__dir__}/csa/components"
 
     def self.parse(identifier_string)
-      unless identifier_string.is_a?(String)
-        raise Pubid::Errors::InvalidInputError,
-              Pubid::INPUT_NOT_A_STRING_MESSAGE
-      end
-
-      if identifier_string.length > Pubid::MAX_INPUT_LENGTH
-        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-      end
-
       Identifier.parse(identifier_string)
     end
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    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
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        if klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES)
-        else
-          []
-        end
-      end
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol] the type key to find
-    # @return [Class, nil] the matching identifier class
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    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
 
   # Register this flavor with the Pubid registry
@@ -74,7 +23,3 @@ end
 
 # Register Ucsa flavor with the registry
 Pubid::Registry.register(:csa, Pubid::Csa)
-
-# Per-flavor format registry: inherits global formats, overrides :human
-Pubid::Csa::SingleIdentifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Csa::SingleIdentifier.format_registry.register(:human, renderer: Pubid::Csa::Renderer)

data/lib/pubid/etsi/builder.rb

@@ -52,14 +52,9 @@ module Pubid
         version = build_version(data)
         date = build_date(data)
 
-        # The code fields are stored as flat index columns on the leaf (see
-        # EtsiStandard) — `number` is what relaton-index keys on — so the Code
-        # object built above is unpacked rather than assigned.
         Identifiers::EtsiStandard.new(
           type: data[:type].to_s,
-          number: code.number,
-          minor: code.minor,
-          parts: code.parts || [],
+          code: code,
           version: version,
           date: date,
         )
@@ -100,23 +95,19 @@ module Pubid
       end
 
       def build_version(data)
-        # Handle both version and edition. A partial reference omits both, in
-        # which case version is left nil (not defaulted) so exclude/matches?
-        # treat it as a wildcard.
+        # Handle both version and edition
         if data[:version]
           Components::Version.new(version: data[:version].to_s,
                                   is_edition: false)
         elsif data[:edition]
           Components::Version.new(version: data[:edition].to_s,
                                   is_edition: true)
+        else
+          Components::Version.new(version: "1.0.0", is_edition: false)
         end
       end
 
       def build_date(data)
-        # A partial reference omits the date; leave it nil rather than building
-        # an empty Date, so the canonical to_hash drops it entirely.
-        return nil unless data[:year]
-
         Pubid::Components::Date.new(
           year: data[:year].to_s,
           month: data[:month].to_s,

data/lib/pubid/etsi/components/code.rb

@@ -10,13 +10,16 @@ module Pubid
       #   Simple: 012, 123, 456
       #   GSM: GSM 02.01, 02.01
       #   Complex: ABC 123, ABC-DEF 123
-      #
-      # Stays independent of Pubid::Components::Code because ETSI uses
-      # +minor+ (a flavor-specific sub-number) plus +parts+.
       class Code < Lutaml::Model::Serializable
-        attribute :number, :string # Main number
-        attribute :minor, :string # Optional minor part
-        attribute :parts, :string, collection: true, default: [] # Parts array
+        attribute :number, :string  # Main number (can contain dots, letters, etc.)
+        attribute :minor, :string   # Optional minor part
+        attribute :parts, :string, collection: true # Parts array
+
+        def initialize(number:, minor: nil, parts: nil)
+          @number = number
+          @minor = minor
+          @parts = parts || []
+        end
 
         # Render code with space for minor and dash-separated parts
         def to_s
@@ -26,10 +29,6 @@ module Pubid
           result
         end
 
-        def render(context: nil)
-          to_s
-        end
-
         def ==(other)
           return false unless other.is_a?(Code)
 

data/lib/pubid/etsi/components/version.rb

@@ -13,6 +13,11 @@ module Pubid
           false
         } # true for ed.N format
 
+        def initialize(version:, is_edition: false)
+          @version = version
+          @is_edition = is_edition
+        end
+
         def to_s
           if is_edition
             "ed.#{version}"

data/lib/pubid/etsi/identifier.rb

@@ -1,4 +1,14 @@
 # frozen_string_literal: true
 
-# Pubid::Etsi::Identifier is the ETSI base class (a real Pubid::Identifier
-# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.
+module Pubid
+  module Etsi
+    class Identifier
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ETSI identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end