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

data/lib/pubid/cen_cenelec/renderer.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # Human-readable renderer for CEN/CENELEC identifiers.
+    #
+    # Produces strings like:
+    #   "EN 196-3:2005"
+    #   "EN ISO 8601:2019"
+    #   "prEN 12345:2020"
+    #   "CEN/TS 12345:2005"
+    #   "EN 196-3:2005+A1:2008"
+    #   "EN 60038/AC1:2012"
+    #   "ENV ISO 8601"
+    #
+    # The renderer is registered as the +:human+ format in the CEN/CENELEC format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::AdoptedEuropeanNorm
+          render_adopted_european_norm(id)
+        when Identifiers::Amendment
+          render_amendment(id)
+        when Identifiers::Corrigendum
+          render_corrigendum(id)
+        when Identifiers::ConsolidatedIdentifier
+          render_consolidated(id)
+        when Identifiers::Fragment
+          render_fragment(id)
+        when Identifiers::EuropeanPrestandard
+          render_european_prestandard(id, **opts)
+        when Identifiers::Base
+          # CEN identifiers::Base hierarchy (Amendment, Corrigendum, etc. handled above)
+          render_cen_base(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          render_single(id)
+        end
+      end
+
+      private
+
+      # SingleIdentifier (EN, Guide, TR, TS, CWA, HD, etc.):
+      # Complex rendering with draft stages, copublishers, typed stages
+      def render_single(id)
+        parts = []
+
+        # Check if we have a draft stage (prEN, FprEN) - these include both stage and type
+        is_draft_stage = id.typed_stage&.abbr && %w[prEN
+                                                     FprEN].include?(id.typed_stage.abbr.first)
+
+        # Get type short name - for draft stages, extract base type
+        type_short = if is_draft_stage
+                       id.typed_stage.type_code.to_s.upcase # :en => "EN"
+                     elsif id.type.is_a?(Components::Type)
+                       id.type.abbr
+                     elsif id.class.type.is_a?(Hash)
+                       id.class.type[:short]
+                     else
+                       "EN" # Default
+                     end
+
+        # Track if we should use slash before type
+        use_slash_before_type = false
+
+        # For CWA/HD, they act as publisher (not EN)
+        if %w[CWA HD CR].include?(type_short)
+          # Stage prefix OR type as publisher
+          parts << if id.typed_stage&.abbr && id.typed_stage.abbr.first != type_short
+                     id.typed_stage.abbr.first
+                   else
+                     type_short
+                   end
+        elsif is_draft_stage
+          # Draft stage prefix (prEN, FprEN) OR regular publisher
+          parts << id.typed_stage.abbr.first
+        elsif id.publisher
+          parts << id.publisher.render(context: @context)
+          use_slash_before_type = true # When publisher present, use slash before type
+        end
+
+        # Copublishers - add to last part (publisher) with slash
+        if id.copublishers&.any?
+          copub_str = id.copublishers.map { |cp| cp.render(context: @context) }.join("/")
+          unless copub_str.empty?
+            if parts.any?
+              parts[-1] = "#{parts[-1]}/#{copub_str}"
+            else
+              parts << copub_str
+            end
+          end
+        end
+
+        # Type for non-EN documents (TS, TR) - but not CWA/HD or Guide
+        if type_short != "EN" && !%w[CWA HD CR Guide].include?(type_short)
+          if use_slash_before_type && parts.any?
+            # Use slash separator for publisher/type combination (TS, TR only)
+            parts << "/#{type_short}"
+          else
+            parts << type_short
+          end
+        elsif type_short == "Guide"
+          # Guide uses SPACE separator, not slash
+          parts << "Guide"
+        end
+
+        # Number with part (which may be multi-level like "5-1-1")
+        if id.number
+          number_str = id.number.render(context: @context)
+          if id.part
+            number_str += "-#{id.part.render(context: @context)}"
+          end
+          parts << number_str
+        end
+
+        # Join parts - but handle slash prefix for type
+        result = ""
+        parts.each_with_index do |part, idx|
+          if idx.positive? && !part.start_with?("/")
+            result += " "
+          end
+          result += part
+        end
+
+        # Date
+        if id.date
+          year_val = id.date.is_a?(::Pubid::Components::Date) ? id.date.render(context: @context) : id.date.to_i
+          result += ":#{year_val}"
+        end
+
+        result
+      end
+
+      # CEN Identifiers::Base: simple key-value model
+      # Format: {PUBLISHER} NUMBER[-PART]:YEAR
+      def render_cen_base(id)
+        result = ""
+
+        # Stage or Publisher
+        if id.stage
+          result += id.stage
+        elsif id.publisher&.any?
+          result += id.publisher.join("/")
+        end
+
+        # If we have adopted_identifier, render it (contains all info)
+        if id.adopted_identifier
+          result += " #{id.adopted_identifier}"
+          # Don't add our own number/parts/year - they're in adopted_identifier
+        else
+          # Only render our own fields if no adoption
+          # Type - use space for Guide, slash for TR/TS
+          if id.type
+            sep = id.type == "Guide" ? " " : "/"
+            result += "#{sep}#{id.type}"
+          end
+
+          result += " #{id.number}"
+          result += id.parts.map { |p| "-#{p}" }.join if id.parts&.any?
+          result += ":#{id.year}" if id.year
+
+          # Supplements
+          if id.supplements&.any?
+            id.supplements.each do |supp|
+              sep = supp[:type] == :amendment ? "/" : "+"
+              result += "#{sep}#{supp[:type] == :amendment ? 'A' : 'AC'}"
+              result += supp[:number] if supp[:number] && !supp[:number].empty?
+              result += ":#{supp[:year]}" if supp[:year]
+            end
+          end
+
+          # Edition
+          result += " ED#{id.edition}" if id.edition
+        end
+
+        result
+      end
+
+      # AdoptedEuropeanNorm: "EN ISO 8601:2019"
+      def render_adopted_european_norm(id)
+        result = id.publisher.is_a?(Array) ? id.publisher.join("/") : id.publisher.join("/")
+        result += " #{id.adopted_identifier}" if id.adopted_identifier
+        result
+      end
+
+      # Amendment: "EN 196-3:2005/A1:2008"
+      def render_amendment(id)
+        result = if id.base_identifier
+                   "#{id.base_identifier}/A#{id.amendment_number}"
+                 else
+                   "/A#{id.amendment_number}"
+                 end
+        result += ":#{id.amendment_year}" if id.amendment_year
+        result
+      end
+
+      # Corrigendum: "EN 60038/AC1:2012"
+      def render_corrigendum(id)
+        if id.base_identifier
+          result = id.base_identifier.to_s
+          result += "/AC"
+          result += id.corrigendum_number if id.corrigendum_number && !id.corrigendum_number.empty?
+        else
+          result = "/AC#{id.corrigendum_number}"
+        end
+        if id.corrigendum_year
+          result += ":#{id.corrigendum_year}"
+          result += "-#{id.corrigendum_month}" if id.corrigendum_month && !id.corrigendum_month.empty?
+        end
+        result
+      end
+
+      # ConsolidatedIdentifier: "EN 196-3:2005+A1:2008"
+      def render_consolidated(id)
+        id.identifiers.map.with_index do |sub_id, idx|
+          if idx.zero?
+            # First identifier renders normally
+            sub_id.to_s
+          elsif sub_id.is_a?(Identifiers::Amendment)
+            # Supplements render with "+" prefix (bundled/consolidated format)
+            result = "+A#{sub_id.amendment_number}"
+            result += ":#{sub_id.amendment_year}" if sub_id.amendment_year
+            result
+          # Only render the amendment portion, not the full id.to_s
+          elsif sub_id.is_a?(Identifiers::Corrigendum)
+            # Only render the corrigendum portion
+            result = "+AC"
+            result += sub_id.corrigendum_number if sub_id.corrigendum_number && !sub_id.corrigendum_number.empty?
+            if sub_id.corrigendum_year
+              result += ":#{sub_id.corrigendum_year}"
+              result += "-#{sub_id.corrigendum_month}" if sub_id.corrigendum_month && !sub_id.corrigendum_month.empty?
+            end
+            result
+          else
+            # Other identifiers (should not happen in typical bundles) render with +
+            "+#{sub_id}"
+          end
+        end.compact.join
+      end
+
+      # Fragment: "EN 60038 AMD1 FRAG2"
+      def render_fragment(id)
+        "#{id.base_identifier} FRAG#{id.fragment_number}"
+      end
+
+      # EuropeanPrestandard: "ENV ISO 8601" or falls through to SingleIdentifier
+      def render_european_prestandard(id, **opts)
+        if id.adopted_identifier
+          "ENV #{id.adopted_identifier}"
+        else
+          render_single(id)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/single_identifier.rb

@@ -3,6 +3,12 @@
 module Pubid
   module CenCenelec
     class SingleIdentifier < Pubid::Identifier
+      # Identity for the Pubid::CenCenelec::Identifier facade. CEN/CENELEC
+      # identifiers split between two roots (Identifiers::Base and this
+      # SingleIdentifier), both direct subclasses of Pubid::Identifier, so the
+      # facade module is included into each to cover every concrete type.
+      include Pubid::CenCenelec::Identifier
+
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "EN")
       }
@@ -11,96 +17,12 @@ module Pubid
       #
       # @return [String] URN representation
 
-      def to_s(lang: :en, lang_single: false)
-        parts = []
-
-        # Check if we have a draft stage (prEN, FprEN) - these include both stage and type
-        is_draft_stage = typed_stage&.abbr && %w[prEN
-                                                 FprEN].include?(typed_stage.abbr.first)
-
-        # Get type short name - for draft stages, extract base type
-        type_short = if is_draft_stage
-                       typed_stage.type_code.to_s.upcase # :en => "EN"
-                     elsif type.is_a?(Components::Type)
-                       type.abbr
-                     elsif self.class.respond_to?(:type) && self.class.type.is_a?(Hash)
-                       self.class.type[:short]
-                     else
-                       "EN" # Default
-                     end
-
-        # Track if we should use slash before type
-        use_slash_before_type = false
-
-        # For CWA/HD, they act as publisher (not EN)
-        if %w[CWA HD CR].include?(type_short)
-          # Stage prefix OR type as publisher
-          parts << if typed_stage&.abbr && typed_stage.abbr.first != type_short
-                     typed_stage.abbr.first
-                   else
-                     type_short
-                   end
-        elsif is_draft_stage
-          # Draft stage prefix (prEN, FprEN) OR regular publisher
-          parts << typed_stage.abbr.first
-        elsif publisher
-          parts << (publisher.is_a?(Components::Publisher) ? publisher.body : publisher.to_s)
-          use_slash_before_type = true # When publisher present, use slash before type
-        end
-
-        # Copublishers - add to last part (publisher) with slash
-        if copublishers&.any?
-          copub_str = copublishers.map do |cp|
-            cp.is_a?(Components::Publisher) ? cp.body : cp.to_s
-          end.join("/")
-          unless copub_str.empty?
-            if parts.any?
-              parts[-1] = "#{parts[-1]}/#{copub_str}"
-            else
-              parts << copub_str
-            end
-          end
-        end
-
-        # Type for non-EN documents (TS, TR) - but not CWA/HD or Guide
-        if type_short != "EN" && !%w[CWA HD CR Guide].include?(type_short)
-          if use_slash_before_type && parts.any?
-            # Use slash separator for publisher/type combination (TS, TR only)
-            parts << "/#{type_short}"
-          else
-            parts << type_short
-          end
-        elsif type_short == "Guide"
-          # Guide uses SPACE separator, not slash
-          parts << "Guide"
-        end
-
-        # Number with part (which may be multi-level like "5-1-1")
-        if number
-          number_str = number.is_a?(Components::Code) ? number.value.to_s : number.to_s
-          if part
-            part_val = part.is_a?(Components::Code) ? part.value : part
-            number_str += "-#{part_val}"
-          end
-          parts << number_str
-        end
-
-        # Join parts - but handle slash prefix for type
-        result = ""
-        parts.each_with_index do |part, idx|
-          if idx.positive? && !part.start_with?("/")
-            result += " "
-          end
-          result += part
-        end
-
-        # Date
-        if date
-          year_val = date.is_a?(Components::Date) ? date.year : date.to_i
-          result += ":#{year_val}"
-        end
+      def self.type
+        nil
+      end
 
-        result
+      def to_s(lang: :en, lang_single: false, **opts)
+        render(format: :human, lang: lang, lang_single: lang_single, **opts)
       end
 
       def <=>(other)

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -50,9 +50,10 @@ module Pubid
         end
 
         date = maybe(:date)
-        if date
-          year = date.year
-          parts << year.to_s
+        if date&.is_a?(::Pubid::Components::Date) && date.present?
+          parts << date.render(context: URN_CONTEXT)
+        elsif date
+          parts << date.to_s
         elsif identifier.year
           parts << identifier.year.to_s
         end
@@ -104,9 +105,8 @@ module Pubid
           amendment_year = maybe(:amendment_year)
           if amendment_year
             parts << amendment_year.to_s
-          elsif identifier.date
-            year = identifier.date.year
-            parts << 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"

data/lib/pubid/cen_cenelec/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    # Parses CEN/CENELEC URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:cen:{type}:{number}:{year}` where type is
+    # the lowercase document class (en, etsg, ts, tr).
+    #
+    # Examples:
+    # - urn:cen:en:9001:2015 → EN 9001:2015
+    class UrnParser < Pubid::UrnParser::Base
+      # UrnGenerator uses "cen" rather than "cencenelec" as the namespace.
+      def flavor_name
+        "cen"
+      end
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        type_token, number, year = parts
+        text = "#{type_token.upcase} #{number}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec.rb

@@ -6,16 +6,183 @@ module Pubid
     autoload :Identifier, "#{__dir__}/cen_cenelec/identifier"
     autoload :Identifiers, "#{__dir__}/cen_cenelec/identifiers"
     autoload :Parser, "#{__dir__}/cen_cenelec/parser"
-    autoload :Scheme, "#{__dir__}/cen_cenelec/scheme"
+    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"
+
+    # TYPED_STAGES_REGISTRY for native CEN types
+    TYPED_STAGES_REGISTRY = [
+      # European Norm (EN)
+      Pubid::Components::TypedStage.new(
+        code: :puben,
+        stage_code: :published,
+        type_code: :en,
+        abbr: ["EN"],
+        name: "European Norm",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :pren,
+        stage_code: :proposal,
+        type_code: :en,
+        abbr: ["prEN"],
+        name: "Proposal European Norm",
+        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :fpren,
+        stage_code: :final_proposal,
+        type_code: :en,
+        abbr: ["FprEN"],
+        name: "Final Proposal European Norm",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
+      ),
+
+      # Technical Specification (TS)
+      Pubid::Components::TypedStage.new(
+        code: :pubts,
+        stage_code: :published,
+        type_code: :ts,
+        abbr: ["TS"],
+        name: "Technical Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+      Pubid::Components::TypedStage.new(
+        code: :prts,
+        stage_code: :proposal,
+        type_code: :ts,
+        abbr: ["prTS"],
+        name: "Proposal Technical Specification",
+        harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+      ),
+
+      # Technical Report (TR)
+      Pubid::Components::TypedStage.new(
+        code: :pubtr,
+        stage_code: :published,
+        type_code: :tr,
+        abbr: ["TR"],
+        name: "Technical Report",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # CEN Workshop Agreement (CWA)
+      Pubid::Components::TypedStage.new(
+        code: :pubcwa,
+        stage_code: :published,
+        type_code: :cwa,
+        abbr: ["CWA"],
+        name: "CEN Workshop Agreement",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Guide
+      Pubid::Components::TypedStage.new(
+        code: :pubguide,
+        stage_code: :published,
+        type_code: :guide,
+        abbr: ["Guide"],
+        name: "Guide",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # Harmonization Document (HD)
+      Pubid::Components::TypedStage.new(
+        code: :pubhd,
+        stage_code: :published,
+        type_code: :hd,
+        abbr: ["HD"],
+        name: "Harmonization Document",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # European Specification (ES)
+      Pubid::Components::TypedStage.new(
+        code: :pubes,
+        stage_code: :published,
+        type_code: :es,
+        abbr: ["ES"],
+        name: "European Specification",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # CEN Report (CR)
+      Pubid::Components::TypedStage.new(
+        code: :pubcr,
+        stage_code: :published,
+        type_code: :cr,
+        abbr: ["CR"],
+        name: "CEN Report",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+
+      # European Prestandard (ENV)
+      Pubid::Components::TypedStage.new(
+        code: :pubenv,
+        stage_code: :published,
+        type_code: :env,
+        abbr: ["ENV"],
+        name: "European Prestandard",
+        harmonized_stages: %w[60.00 60.60],
+      ),
+    ].freeze
+
+    # Default typed stage for when no match is found
+    DEFAULT_TYPED_STAGE = Pubid::Components::TypedStage.new(
+      code: :puben,
+      stage_code: :published,
+      type_code: :en,
+      abbr: ["EN"],
+      name: "European Norm",
+      harmonized_stages: %w[60.00 60.60],
+    ).freeze
 
     def self.parse(identifier)
       CenCenelec::Identifier.parse(identifier)
     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 the module's TYPED_STAGES_REGISTRY
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      TYPED_STAGES_REGISTRY
+    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
 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)

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

@@ -7,6 +7,10 @@ module Pubid
     module Components
       # Code component for CIE identifiers
       # Handles number-part-iteration with style awareness
+      #
+      # Stays independent of Pubid::Components::Code because CIE tracks
+      # +style+ ("legacy" / "current") and +part_separator+ to round-trip
+      # slash vs dash notation, plus an +iteration+ sub-field.
       class Code < Lutaml::Model::Serializable
         attribute :number, :string        # "013", "170", "198"
         attribute :part, :string          # "1", "2", "3"
@@ -66,6 +70,10 @@ module Pubid
             new(number: code_str, style: style)
           end
         end
+
+        def render(context: nil)
+          to_s
+        end
       end
     end
   end

data/lib/pubid/cie/identifier.rb

@@ -2,12 +2,14 @@
 
 module Pubid
   module Cie
-    # Base Identifier class for CIE
-    # Provides parse() entry point
-    class Identifier < Lutaml::Model::Serializable
+    # Base Identifier class for CIE.
+    #
+    # Inherits the shared Pubid::Identifier contract (format_registry, render,
+    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes
+    # such as +style+ ("legacy" vs "current" date separator).
+    class Identifier < ::Pubid::Identifier
       attribute :style, :string # "legacy" or "current"
 
-      # Parse CIE identifier string
       def self.parse(input)
         parsed = Parser.parse(input)
         builder = Builder.new

data/lib/pubid/cie/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Parses CIE URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:cie:cie:{code}:{year}:sep.colon
+    #
+    # The trailing `sep.colon` token records the code/year separator used
+    # in the human-readable form (`:`). The leading `cie` after the
+    # namespace is the lowercase publisher.
+    #
+    # Examples:
+    # - urn:cie:cie:015:2018:sep.colon → CIE 015:2018
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject { |p| p.start_with?("sep.") }
+
+        _publisher, code, year = parts
+        text = "CIE #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end