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

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

@@ -8,6 +8,33 @@ 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
@@ -28,12 +55,6 @@ module Pubid
         def type
           identifiers&.first&.type
         end
-
-        # The origin document. Members live in `identifiers` (not `base`), so
-        # walk the first member to its root.
-        def root
-          identifiers&.first&.root || self
-        end
       end
     end
   end

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

@@ -6,13 +6,28 @@ module Pubid
       # Corrigendum Identifier
       # Contains a base identifier plus corrigendum parameters
       class Corrigendum < Base
-        attribute :base, Base, polymorphic: true
+        attribute :base_identifier, Base, polymorphic: true
         attribute :corrigendum_number, :string
         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&.publisher
+          base_identifier&.publisher
         end
       end
     end

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

@@ -6,92 +6,34 @@ module Pubid
       # European Norm (EN) identifier
       class EuropeanNorm < SingleIdentifier
         TYPED_STAGES = [
-          # Published (puben): 60.00-60.60 + publication milestones (65.xx)
           Components::TypedStage.new(
             code: :puben,
             stage_code: :published,
             type_code: :en,
             abbr: ["EN"],
             name: "European Norm",
-            harmonized_stages: %w[60.00 60.55 60.60 65.31 65.51 65.62],
+            harmonized_stages: %w[60.00 60.60],
           ),
-          # Preliminary (pwien): proposal/WI stages
-          Components::TypedStage.new(
-            code: :pwien,
-            stage_code: :preliminary,
-            type_code: :en,
-            abbr: ["pWI EN"],
-            name: "Preliminary Work Item EN",
-            harmonized_stages: %w[00.60 10.98 10.99 20.60],
-          ),
-          # Proposal (pren): working draft stages + split/merge interruption end
           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.97 30.98 30.99],
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.98 30.99],
           ),
-          # Final Proposal (fpren): enquiry stages
           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.97 40.98 40.99],
-          ),
-          # Formal Vote (fven): COCOR + FV dispatch stages
-          Components::TypedStage.new(
-            code: :fven,
-            stage_code: :formal_vote,
-            type_code: :en,
-            abbr: ["FV prEN"],
-            name: "Formal Vote EN",
-            harmonized_stages: %w[43.20 43.60 43.97 43.98 45.97 45.98 45.99],
-          ),
-          # Vote (ven): enquiry/vote stages
-          Components::TypedStage.new(
-            code: :ven,
-            stage_code: :vote,
-            type_code: :en,
-            abbr: ["vEN"],
-            name: "Vote EN",
-            harmonized_stages: %w[50.20 50.60 50.97 50.98],
-          ),
-          # Review (rven): 2-year review stages
-          Components::TypedStage.new(
-            code: :rven,
-            stage_code: :review,
-            type_code: :en,
-            abbr: ["rvEN"],
-            name: "Review EN",
-            harmonized_stages: %w[90.00 90.20 90.60 90.92 90.93 90.98],
-          ),
-          # Reactivation (racen): re-activation stage
-          Components::TypedStage.new(
-            code: :racen,
-            stage_code: :reactivation,
-            type_code: :en,
-            abbr: ["racEN"],
-            name: "Re-activated EN",
-            harmonized_stages: %w[96.60],
-          ),
-          # Withdrawn (wden): withdrawal stage
-          Components::TypedStage.new(
-            code: :wden,
-            stage_code: :withdrawn,
-            type_code: :en,
-            abbr: ["wdEN"],
-            name: "Withdrawn EN",
-            harmonized_stages: %w[99.60],
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.98 40.99],
           ),
         ].freeze
 
         def self.type
-          { key: :en,
-            web: :european_norm, title: "European Norm", short: "EN" }
+          { key: :en, title: "European Norm", short: "EN" }
         end
       end
     end

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

@@ -21,28 +21,15 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :env,
-            web: :european_prestandard, title: "European Prestandard", short: "ENV" }
+          { key: :env, title: "European Prestandard", short: "ENV" }
         end
 
-        # An "ENV ISO 11079:1999" is a WRAPPER: the whole document identity
-        # lives on the nested `adopted_identifier`, and this class carries no
-        # number of its own, so `root.number` — the key relaton-index sorts and
-        # bsearches on — was "". Walk to the adopted document instead.
-        #
-        # The chain reached further than this flavor: Bsi's
-        # `AdoptedEuropeanNorm#number` delegates INTO this class, so a
-        # "DD ENV ISO 11079:1999" keyed "" for the same reason.
-        #
-        # This is deliberately `#root` and not a `#number` method. `number` is a
-        # lutaml attribute in this hierarchy, and a method of that name collides
-        # with the generated accessor and corrupts attribute resolution
-        # hierarchy-wide (the IEEE landmine in CLAUDE.md). `#root` is a plain
-        # method on ::Pubid::Identifier, and walking a wrapper's member is its
-        # documented shape — ConsolidatedIdentifier already walks
-        # `identifiers.first.root`.
-        def root
-          adopted_identifier ? adopted_identifier.root : self
+        def to_s(lang: :en, lang_single: false)
+          if adopted_identifier
+            "ENV #{adopted_identifier}"
+          else
+            super
+          end
         end
       end
     end

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

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

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

@@ -6,11 +6,15 @@ module Pubid
       # Fragment Identifier - wraps an Amendment with a fragment number
       # Example: "EN 60038 AMD1 FRAG2" = Fragment 2 of Amendment 1 to EN 60038
       class Fragment < Base
-        attribute :base, Amendment
+        attribute :base_identifier, Amendment
         attribute :fragment_number, :string
 
+        def to_s
+          "#{base_identifier} FRAG#{fragment_number}"
+        end
+
         def publisher
-          base&.base&.publisher
+          base_identifier&.base_identifier&.publisher
         end
       end
     end

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

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

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

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

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

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

data/lib/pubid/cen_cenelec/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module CenCenelec
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }
       rule(:space) { str(" ") }

data/lib/pubid/cen_cenelec/scheme.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenCenelec
+    class Scheme < Pubid::Scheme
+      # 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
+
+      # Map type codes to identifier classes
+      IDENTIFIER_CLASS_MAP = {
+        en: "Identifiers::EuropeanNorm",
+        ts: "Identifiers::TechnicalSpecification",
+        tr: "Identifiers::TechnicalReport",
+        cwa: "Identifiers::CenWorkshopAgreement",
+        guide: "Identifiers::Guide",
+        hd: "Identifiers::HarmonizationDocument",
+        es: "Identifiers::EuropeanSpecification",
+        cr: "Identifiers::CenReport",
+        env: "Identifiers::EuropeanPrestandard",
+      }.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 locate_typed_stage_by_abbr(abbr)
+        abbr_str = abbr.to_s.strip
+        TYPED_STAGES_REGISTRY.find do |ts|
+          ts.abbr.include?(abbr_str)
+        end || DEFAULT_TYPED_STAGE
+      end
+
+      def locate_identifier_klass_by_type_code(type_code)
+        class_name = IDENTIFIER_CLASS_MAP[type_code.to_sym]
+        return Identifiers::EuropeanNorm unless class_name
+
+        # Convert string to actual class
+        class_name.split("::").reduce(Pubid::CenCenelec) do |mod, name|
+          mod.const_get(name)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_cenelec/single_identifier.rb

@@ -2,10 +2,7 @@
 
 module Pubid
   module CenCenelec
-    # 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
+    class SingleIdentifier < Pubid::Identifier
       attribute :publisher, Components::Publisher, default: -> {
         Components::Publisher.new(body: "EN")
       }
@@ -14,12 +11,96 @@ module Pubid
       #
       # @return [String] URN representation
 
-      def self.type
-        nil
-      end
+      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 to_s(lang: :en, lang_single: false, **opts)
-        render(format: :human, lang: lang, lang_single: lang_single, **opts)
+        result
       end
 
       def <=>(other)
@@ -30,7 +111,7 @@ module Pubid
         return num_cmp unless num_cmp.zero?
 
         # Then by part
-        part_cmp = (part || "0").to_s <=> (other.part || "0").to_s
+        part_cmp = (part || Components::Code.new(value: "0")).to_s <=> (other.part || Components::Code.new(value: "0")).to_s
         return part_cmp unless part_cmp.zero?
 
         # Then by date

data/lib/pubid/cen_cenelec/supplement_identifier.rb

@@ -5,30 +5,31 @@ require "lutaml/model"
 module Pubid
   module CenCenelec
     class SupplementIdentifier < Identifiers::Base
-      attribute :base, Identifiers::Base, polymorphic: true
+      attribute :base_identifier, Identifiers::Base, polymorphic: true
+      attribute :number, Components::Code
       attribute :date, Components::Date
       attribute :stage, Components::Stage
       attribute :type, Components::Type
       attribute :typed_stage, Components::TypedStage
 
-      # Delegate methods to base for convenient access
+      # Delegate methods to base_identifier for convenient access
       def publisher
-        base&.publisher
+        base_identifier&.publisher
       end
 
       def copublishers
-        base&.copublishers
+        base_identifier&.copublishers
       end
 
       def <=>(other)
         return nil unless other.is_a?(SupplementIdentifier)
 
         # Compare base identifiers first
-        base_cmp = base <=> other.base
+        base_cmp = base_identifier <=> other.base_identifier
         return base_cmp unless base_cmp.zero?
 
         # Then compare numbers
-        num_cmp = (number || "0").to_s <=> (other.number || "0").to_s
+        num_cmp = (number || Components::Code.new(value: "0")).to_s <=> (other.number || Components::Code.new(value: "0")).to_s
         return num_cmp unless num_cmp.zero?
 
         # Finally compare dates

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -50,10 +50,9 @@ module Pubid
         end
 
         date = maybe(:date)
-        if date&.is_a?(::Pubid::Components::Date) && date.present?
-          parts << date.render(context: URN_CONTEXT)
-        elsif date
-          parts << date.to_s
+        if date
+          year = date.year
+          parts << year.to_s
         elsif identifier.year
           parts << identifier.year.to_s
         end
@@ -78,7 +77,7 @@ module Pubid
       def generate_supplement_urn
         parts = ["urn", "cen"]
 
-        base_id = maybe(:base)
+        base_id = maybe(:base_identifier)
         if base_id
           base_gen = self.class.new(base_id)
           base_urn = base_gen.generate_base_urn
@@ -105,8 +104,9 @@ module Pubid
           amendment_year = maybe(:amendment_year)
           if amendment_year
             parts << amendment_year.to_s
-          elsif identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
-            parts << identifier.date.render(context: URN_CONTEXT)
+          elsif identifier.date
+            year = identifier.date.year
+            parts << year.to_s
           end
         else
           parts << "unknown"