pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

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/single_identifier.rb

@@ -2,7 +2,7 @@
 
 module Pubid
   module Csa
-    class SingleIdentifier < Pubid::Identifier
+    class SingleIdentifier < Identifier
       # Generate URN for this identifier
       #
       # @return [String] URN representation

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,16 +6,57 @@ 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"
 
     def self.parse(identifier_string)
+      if identifier_string.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, 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
@@ -23,3 +64,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,16 +10,13 @@ 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 :parts, :string, collection: true # Parts array
-
-        def initialize(number:, minor: nil, parts: nil)
-          @number = number
-          @minor = minor
-          @parts = parts || []
-        end
+        attribute :number, :string # Main number
+        attribute :minor, :string # Optional minor part
+        attribute :parts, :string, collection: true, default: [] # Parts array
 
         # Render code with space for minor and dash-separated parts
         def to_s
@@ -29,6 +26,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/components/version.rb

@@ -13,11 +13,6 @@ 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,57 +1,6 @@
 # frozen_string_literal: true
 
-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
-
-      # Factory mirroring pubid 1.x's `Pubid::Etsi::Identifier.create` API.
-      #
-      # ETSI's `type` kwarg (EN, ES, EG, TS, TR, GS, GR, GTS, …) is data
-      # stored on the identifier instance, not a class-dispatch key — all
-      # ETSI standards share the {Identifiers::EtsiStandard} class.
-      #
-      # @param opts [Hash] :type, :code/:number, :parts, :version, :year,
-      #   :month, :date
-      def self.create(**opts)
-        Identifiers::EtsiStandard.new(**coerce_create_attrs(opts))
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-        attrs[:type] = opts[:type].to_s if opts[:type]
-
-        code_value = opts[:code] || opts[:number]
-        if code_value
-          attrs[:code] = Pubid::Etsi::Components::Code.new(
-            number: code_value.to_s,
-            parts:  opts[:parts] ? Array(opts[:parts]).map(&:to_s) : nil,
-          )
-        end
-
-        if (v = opts[:version])
-          attrs[:version] = Pubid::Etsi::Components::Version.new(
-            version: v.to_s,
-          )
-        end
-
-        if opts[:year] || opts[:month]
-          attrs[:date] = ::Pubid::Components::Date.new(
-            year:  opts[:year]&.to_s,
-            month: opts[:month]&.to_s,
-          )
-        end
-
-        # TODO(create-shim): Amendment and Corrigendum supplements need a
-        # base_identifier and aren't yet wired through.
-        attrs
-      end
-      private_class_method :coerce_create_attrs
-    end
-  end
-end
+# Pubid::Etsi::Identifier is the ETSI base class (a real Pubid::Identifier
+# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
+# live in identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

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

@@ -2,37 +2,41 @@
 
 module Pubid
   module Etsi
-    module Identifiers
-      # Base class for all ETSI identifiers
-      class Base < Pubid::Identifier
-        # Generate URN for this identifier
-        #
-        # @return [String] URN representation
-        attribute :type, :string
-        attribute :code, Pubid::Etsi::Components::Code
-        attribute :version, Pubid::Etsi::Components::Version
-        attribute :date, Pubid::Components::Date
-
-        def publisher
-          "ETSI"
-        end
+    # Base class for all ETSI identifiers. Canonical name Pubid::Etsi::Identifier
+    # (Identifiers::Base is a back-compat alias); every concrete ETSI identifier
+    # descends from it.
+    class Identifier < ::Pubid::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
 
-        def to_s
-          result = "#{publisher} #{type} #{code}"
-          result += " #{version} (#{date.year}-#{date.month.to_s.rjust(2,
-                                                                       '0')})"
-          result
-        end
+      attribute :type, :string
+      attribute :code, Pubid::Etsi::Components::Code
+      attribute :version, Pubid::Etsi::Components::Version
+      attribute :date, Pubid::Components::Date
+      # Stored as a plain string (always "ETSI") so it round-trips through
+      # to_hash/from_hash. Was previously a `def publisher` method, which made
+      # lutaml serialize a String against the Components::Publisher attribute and
+      # raise on to_hash.
+      attribute :publisher, :string, default: -> { "ETSI" }
 
-        def ==(other)
-          return false unless other.is_a?(Base)
+      def ==(other)
+        return false unless other.is_a?(Pubid::Etsi::Identifier)
 
-          type == other.type &&
-            code == other.code &&
-            version == other.version &&
-            date == other.date
-        end
+        type == other.type &&
+          code == other.code &&
+          version == other.version &&
+          date == other.date
       end
     end
+
+    module Identifiers
+      # Backward-compatible alias: ETSI's base class used to be
+      # Pubid::Etsi::Identifiers::Base. It is now Pubid::Etsi::Identifier.
+      Base = Pubid::Etsi::Identifier
+    end
   end
 end

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

@@ -25,17 +25,7 @@ module Pubid
           base.date
         end
 
-        # Render as: ETSI TYPE CODE/SUPPLEMENTS VERSION (DATE)
-        # When multiple supplements are present, they appear in order: /A1/C1
-        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'
-          )})"
-        end
+        # Render via renderer
 
         # Recursively collect supplement notations from the supplement chain
         def collect_supplement_notations(current_supplement, notations)

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