pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

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

@@ -18,108 +18,8 @@ module Pubid
         # 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
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
       end
     end

data/lib/pubid/csa/renderer.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    # Human-readable renderer for CSA identifiers that extend Pubid::Identifier.
+    #
+    # Produces strings like:
+    #   "CSA B149.1:20"
+    #   "CAN/CSA-C22.2 NO. 60601-1-9:15"
+    #   "CSA C22.2 NO. 286:23"
+    #   "CSA MH SERIES 3.14:20"
+    #
+    # The renderer is registered as the +:human+ format in the CSA format
+    # registry and invoked via +render(format: :human)+.
+    #
+    # Note: Some CSA identifier types (Bundled, Combined, CanadianAdopted,
+    # CsaAdopted, Package) extend Lutaml::Model::Serializable directly,
+    # not Pubid::Identifier, so they keep their own to_s implementations.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::Series
+          render_series(id)
+        when Identifiers::Cec
+          render_cec(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      # Base rendering: "CSA B149.1:20", "CAN/CSA-C22.2-05"
+      def render_base(id)
+        prefix = id.publisher_prefix || "CSA"
+
+        # Handle code_only identifiers (empty string means no prefix)
+        if prefix == ""
+          # No prefix for code_only identifiers
+          parts = []
+        else
+          # Determine if we need space after prefix
+          # CAN/CSA- and CAN3- end with dash, so no space needed
+          needs_space = !prefix.end_with?("-")
+
+          parts = []
+          parts << prefix
+        end
+
+        # Code and year together
+        code_part = id.code.to_s if id.code
+
+        # NO. keyword
+        if id.no_number
+          code_part += " NO. #{id.no_number}"
+        end
+
+        # Series prefix and keyword (before year)
+        if id.series_prefix
+          code_part += " #{id.series_prefix} SERIES"
+        elsif id.series
+          # SERIES without prefix
+          code_part += " SERIES"
+        end
+
+        parts << code_part if code_part
+
+        # Year with proper format (colon or dash)
+        if id.year
+          # Use dash if year_format is dash, otherwise colon
+          separator = id.year_format == "dash" ? "-" : ":"
+          year_part = separator
+          year_part += id.year_prefix if id.year_prefix # Add M or F prefix
+          year_part += "F" if id.french && id.year_format != "dash" && !id.year_prefix # Only add F if no prefix
+          # Convert 4-digit year back to 2-digit for M/F prefix preservation
+          # M1983 → M83, F1983 → F83, 1983 → 83, 20xx → xx
+          # However, preserve original 4-digit format if the input was 4-digit (original_year_4digit)
+          year_str = id.year.to_s
+          year_part += if id.original_year_4digit
+                         # Preserve 4-digit format (e.g., "M1981" stays "M1981")
+                         year_str
+                       elsif id.year_prefix&.match?(/^[MF]$/) && year_str.length == 4 && year_str.start_with?("19")
+                         # M/F + 4-digit year (1900s) → convert to 2-digit with prefix
+                         year_str[2..3]
+                       elsif year_str.length == 4 && year_str.start_with?("20")
+                         # 2000s → just last 2 digits
+                         year_str[2..3]
+                       elsif year_str.length == 4 && year_str.start_with?("19") && !id.original_year_4digit
+                         # 1900s with no M/F prefix, but original was 2-digit (e.g., CAN3-Z299.0-86)
+                         # Convert back to 2-digit
+                         year_str[2..3]
+                       else
+                         # Other formats - keep as-is
+                         year_str
+                       end
+          parts[-1] += year_part
+        end
+
+        result = if prefix == ""
+                   # No prefix, just join parts
+                   parts.join(" ")
+                 elsif !prefix.end_with?("-")
+                   parts.join(" ")
+                 elsif parts.length == 2
+                   # No space after dash-ending prefix - join first two parts directly
+                   # If there are more parts after code, they should still have spaces
+                   parts.join
+                 else
+                   # More than 2 parts shouldn't happen in current design
+                   parts.join
+                 end
+
+        # Reaffirmation - preserve original format and determine spacing
+        if id.reaffirmation && !id.reaffirmation.to_s.empty?
+          result += render_reaffirmation(id)
+        end
+
+        # Package (already has leading space from parser)
+        if id.package
+          result += id.package
+        end
+
+        result
+      end
+
+      # CEC rendering: "CSA C22.2 NO. 286:23"
+      def render_cec(id)
+        parts = []
+
+        # Publisher prefix (CSA, CAN/CSA-, CAN3-)
+        prefix = id.publisher_prefix || "CSA"
+
+        # Determine if we need space after prefix
+        # CAN/CSA- and CAN3- end with dash, so no space needed
+        needs_space = !prefix.end_with?("-")
+
+        parts << prefix unless prefix == ""
+
+        # CEC Part (C22.2, C22.3, etc.)
+        parts << id.cec_part.render(context: @context) if id.cec_part
+
+        # NO. notation - this is the key semantic component
+        parts << "NO."
+
+        # Number after NO.
+        parts << id.no_number.render(context: @context) if id.no_number
+
+        # Determine separator based on prefix ending
+        result = if prefix == ""
+                   parts.join(" ")
+                 elsif needs_space
+                   parts.join(" ")
+                 elsif parts.length <= 2
+                   # No space after dash-ending prefix (CAN/CSA-, CAN3-)
+                   # Join first two parts directly, rest with spaces
+                   parts.join
+                 else
+                   parts[0] + parts[1..].join(" ")
+                 end
+
+        # Year with proper format (colon or dash)
+        if id.year
+          # Use dash if year_format is dash, otherwise colon
+          separator = id.year_format == "dash" ? "-" : ":"
+          year_part = separator
+
+          # Convert 4-digit year back to 2-digit for display
+          year_str = id.year.to_s
+          display_year = if year_str.length == 4 && year_str.start_with?("20")
+                           year_str[2..3]
+                         elsif year_str.length == 4 && year_str.start_with?("19")
+                           year_str[2..3]
+                         else
+                           year_str
+                         end
+
+          # Add prefix if present
+          year_part += if id.year_prefix
+                         id.year_prefix + display_year
+                       elsif id.french && id.year_format != "dash"
+                         # Only add F if no prefix already set
+                         "F#{display_year}"
+                       else
+                         display_year
+                       end
+
+          result += year_part
+        end
+
+        # Reaffirmation
+        if id.reaffirmation && !id.reaffirmation.to_s.empty?
+          result += render_reaffirmation(id)
+        end
+
+        result
+      end
+
+      # Series rendering: "CSA MH SERIES 3.14:20"
+      def render_series(id)
+        result = series_publisher_prefix_portion(id)
+
+        # Add code FIRST (before SERIES keyword)
+        result += id.code.to_s
+
+        # Add space before series prefix/SERIES keyword
+        result += " "
+
+        # Add series prefix if present
+        result += "#{id.series_prefix} " if id.series_prefix && !id.series_prefix.empty?
+
+        # Add SERIES keyword
+        result += "SERIES"
+
+        # Add year
+        result += series_year_portion(id)
+
+        # Add reaffirmation
+        result += render_reaffirmation(id) if id.reaffirmation && !id.reaffirmation.to_s.empty?
+
+        result
+      end
+
+      private
+
+      # Reaffirmation rendering helper - shared across Base, Cec, and Series
+      def render_reaffirmation(id)
+        # Check if year was originally 2-digit (original_year_4digit flag)
+        year_was_2digit = !id.original_year_4digit
+
+        # Check if reaffirmation was originally 4-digit (original_reaffirmation_4digit flag)
+        reaffirmation_was_4digit = id.original_reaffirmation_4digit
+
+        # Preserve original reaffirmation format
+        reaffirmation_str = if reaffirmation_was_4digit
+                              # Original was 4-digit, keep as-is
+                              id.reaffirmation.to_s
+                            elsif id.reaffirmation.to_s.length == 4 && id.reaffirmation.to_s.start_with?("19", "20")
+                              # Original was 2-digit, convert 4-digit storage back to 2-digit
+                              id.reaffirmation.to_s[2..3]
+                            else
+                              # Already 2-digit or other format
+                              id.reaffirmation.to_s
+                            end
+
+        # Determine spacing based on original formats
+        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
+
+      def series_publisher_prefix_portion(id)
+        prefix = id.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 series_year_portion(id)
+        return "" unless id.year
+
+        # Use dash if year_format is dash, otherwise colon
+        separator = id.year_format == "dash" ? "-" : ":"
+        year_part = separator
+        year_part += id.year_prefix if id.year_prefix # Add M or F prefix
+        year_part += "F" if id.french && id.year_format != "dash" && !id.year_prefix # Only add F if no prefix
+
+        # Convert 4-digit year back to 2-digit
+        year_str = id.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
+    end
+  end
+end

data/lib/pubid/csa/urn_generator.rb

@@ -12,7 +12,7 @@ module Pubid
       def urn_number
         return nil unless identifier.code
 
-        identifier.code.value.to_s
+        identifier.code.render(context: URN_CONTEXT)
       end
 
       def urn_no_number

data/lib/pubid/csa/urn_parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    # Parses CSA URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:csa:{publisher}:{code}:{year}:format.{format}
+    #
+    # The trailing `format.X` token records the year-separator style used
+    # in the human-readable form (`dash` for `-`, `colon` for `:`).
+    #
+    # Examples:
+    # - urn:csa:csa:Z240.2.1:16:format.dash → CSA Z240.2.1-16
+    class UrnParser < Pubid::UrnParser::Base
+      YEAR_SEPARATOR = { "dash" => "-", "colon" => ":" }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        format_token = parts.find { |p| p.start_with?("format.") }
+        separator = YEAR_SEPARATOR.fetch(format_token&.split(".")&.last, "-")
+
+        payload = parts.reject { |p| p.start_with?("format.") }
+        _publisher, code, year = payload
+        text = "CSA #{code}"
+        text += "#{separator}#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/csa.rb

@@ -6,9 +6,10 @@ module Pubid
     autoload :Identifier, "#{__dir__}/csa/identifier"
     autoload :Identifiers, "#{__dir__}/csa/identifiers"
     autoload :Parser, "#{__dir__}/csa/parser"
-    autoload :Scheme, "#{__dir__}/csa/scheme"
+    autoload :Renderer, "#{__dir__}/csa/renderer"
     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"
@@ -16,6 +17,42 @@ module Pubid
     def self.parse(identifier_string)
       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
@@ -23,3 +60,7 @@ 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/components/code.rb

@@ -10,9 +10,12 @@ 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 (can contain dots, letters, etc.)
-        attribute :minor, :string   # Optional minor part
+        attribute :number, :string # Main number
+        attribute :minor, :string # Optional minor part
         attribute :parts, :string, collection: true # Parts array
 
         def initialize(number:, minor: nil, parts: nil)
@@ -29,6 +32,10 @@ module Pubid
           result
         end
 
+        def render(context: nil)
+          to_s
+        end
+
         def ==(other)
           return false unless other.is_a?(Code)
 

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

@@ -18,10 +18,7 @@ module Pubid
         end
 
         def to_s
-          result = "#{publisher} #{type} #{code}"
-          result += " #{version} (#{date.year}-#{date.month.to_s.rjust(2,
-                                                                       '0')})"
-          result
+          render(format: :human)
         end
 
         def ==(other)

data/lib/pubid/etsi/identifiers/supplement_identifier.rb

@@ -25,16 +25,9 @@ module Pubid
           base.date
         end
 
-        # Render as: ETSI TYPE CODE/SUPPLEMENTS VERSION (DATE)
-        # When multiple supplements are present, they appear in order: /A1/C1
+        # Render via renderer
         def to_s
-          supplement_notations = collect_supplement_notations(self, [])
-          # Get the actual base ETSI standard (not supplements)
-          actual_base = find_actual_base(base)
-          code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
-          "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.year}-#{actual_base.date.month.to_s.rjust(
-            2, '0'
-          )})"
+          render(format: :human)
         end
 
         # Recursively collect supplement notations from the supplement chain

data/lib/pubid/etsi/renderer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # Human-readable renderer for ETSI identifiers.
+    #
+    # Produces strings like:
+    #   "ETSI EN 301 419 V1.1.1 (2020-01)"
+    #   "ETSI TS 102 606-1/A1 V1.1.1 (2021-06)"
+    #   "ETSI GS NFV 002 ed.1 (2013-10)"
+    #
+    # The renderer is registered as the `:human` format in the ETSI format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::SupplementIdentifier
+          render_supplement(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        result = "#{id.publisher} #{id.type} #{id.code}"
+        result += " #{id.version} (#{id.date.render})"
+        result
+      end
+
+      def render_supplement(id)
+        supplement_notations = id.collect_supplement_notations(id, [])
+        actual_base = id.find_actual_base(id.base)
+        code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
+        "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements} #{actual_base.version} (#{actual_base.date.render})"
+      end
+    end
+  end
+end

data/lib/pubid/etsi/urn_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # Parses ETSI URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:etsi:{type}:{code}:{version}:{date}[:{supplement_notation}:{number}]
+    #
+    # type is the lowercase type abbreviation (en, ets, ts, tr, gs, sr).
+    # code is the identifier code with internal whitespace preserved.
+    # version is the lowercase Vx.y.z form.
+    # date is YYYY or YYYY-MM.
+    #
+    # Examples:
+    # - urn:etsi:en:300 100:v1.1.1:1998-04 → ETSI EN 300 100 V1.1.1 (1998-04)
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0).upcase
+        code = parts.fetch(1)
+        version = parts[2]
+        date = parts[3]
+
+        text = "ETSI #{type_token} #{code}"
+        text += " #{version.upcase}" if version
+        text += " (#{date})" if date
+        flavor_parse(text)
+      end
+    end
+  end
+end