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

data/lib/pubid/cen_cenelec/identifiers/consolidated_identifier.rb

@@ -8,33 +8,6 @@ module Pubid
       class ConsolidatedIdentifier < Base
         attribute :identifiers, Base, polymorphic: true, collection: true
 
-        def to_s
-          identifiers.map.with_index do |id, idx|
-            if idx.zero?
-              # First identifier renders normally
-              id.to_s
-            elsif id.is_a?(Amendment)
-              # Supplements render with "+" prefix (bundled/consolidated format)
-              result = "+A#{id.amendment_number}"
-              result += ":#{id.amendment_year}" if id.amendment_year
-              result
-            # Only render the amendment portion, not the full id.to_s
-            elsif id.is_a?(Corrigendum)
-              # Only render the corrigendum portion
-              result = "+AC"
-              result += id.corrigendum_number if id.corrigendum_number && !id.corrigendum_number.empty?
-              if id.corrigendum_year
-                result += ":#{id.corrigendum_year}"
-                result += "-#{id.corrigendum_month}" if id.corrigendum_month && !id.corrigendum_month.empty?
-              end
-              result
-            else
-              # Other identifiers (should not happen in typical bundles) render with +
-              "+#{id}"
-            end
-          end.compact.join
-        end
-
         # Delegate to first identifier (base document)
         def publisher
           identifiers&.first&.publisher

data/lib/pubid/cen_cenelec/identifiers/corrigendum.rb

@@ -11,21 +11,6 @@ module Pubid
         attribute :corrigendum_year, :integer
         attribute :corrigendum_month, :string
 
-        def to_s
-          if base_identifier
-            result = base_identifier.to_s
-            result += "/AC"
-            result += corrigendum_number if corrigendum_number && !corrigendum_number.empty?
-          else
-            result = "/AC#{corrigendum_number}"
-          end
-          if corrigendum_year
-            result += ":#{corrigendum_year}"
-            result += "-#{corrigendum_month}" if corrigendum_month && !corrigendum_month.empty?
-          end
-          result
-        end
-
         def publisher
           base_identifier&.publisher
         end

data/lib/pubid/cen_cenelec/identifiers/european_norm.rb

@@ -33,7 +33,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :en, title: "European Norm", short: "EN" }
+          { key: :en,
+            web: :european_norm, title: "European Norm", short: "EN" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/european_prestandard.rb

@@ -21,16 +21,10 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :env, title: "European Prestandard", short: "ENV" }
+          { key: :env,
+            web: :european_prestandard, title: "European Prestandard", short: "ENV" }
         end
 
-        def to_s(lang: :en, lang_single: false)
-          if adopted_identifier
-            "ENV #{adopted_identifier}"
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/pubid/cen_cenelec/identifiers/european_specification.rb

@@ -20,7 +20,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :es, title: "European Specification", short: "ES" }
+          { key: :es,
+            web: :european_specification, title: "European Specification", short: "ES" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/fragment.rb

@@ -9,10 +9,6 @@ module Pubid
         attribute :base_identifier, Amendment
         attribute :fragment_number, :string
 
-        def to_s
-          "#{base_identifier} FRAG#{fragment_number}"
-        end
-
         def publisher
           base_identifier&.base_identifier&.publisher
         end

data/lib/pubid/cen_cenelec/identifiers/harmonization_document.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :hd, title: "Harmonization Document", short: "HD" }
+          { key: :hd,
+            web: :harmonization_document, title: "Harmonization Document", short: "HD" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/technical_report.rb

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tr, title: "Technical Report", short: "TR" }
+          { key: :tr,
+            web: :technical_report, title: "Technical Report", short: "TR" }
         end
       end
     end

data/lib/pubid/cen_cenelec/identifiers/technical_specification.rb

@@ -27,7 +27,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts, title: "Technical Specification", short: "TS" }
+          { key: :ts,
+            web: :technical_specification, title: "Technical Specification", short: "TS" }
         end
       end
     end

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

@@ -2,7 +2,10 @@
 
 module Pubid
   module CenCenelec
-    class SingleIdentifier < Pubid::Identifier
+    # The second of CEN/CENELEC's two identifier roots (the other is
+    # Identifiers::Base); both descend from Pubid::CenCenelec::Identifier so every
+    # concrete type is `is_a?` it.
+    class SingleIdentifier < Pubid::CenCenelec::Identifier
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "EN")
       }
@@ -11,96 +14,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