pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

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

@@ -5,34 +5,43 @@ module Pubid
     module Identifiers
       # Consolidated Identifier - contains base document plus supplements
       # Example: "EN 196-3:2005+A1:2008" = [EN 196-3:2005, Amendment(base + params)]
-      class ConsolidatedIdentifier < Base
-        attribute :identifiers, Base, polymorphic: true, collection: true
+      #
+      # It descends from the shared Pubid::CenCenelec::Identifier, not from
+      # the legacy Identifiers::Base. It used to inherit Base's publisher,
+      # number, year, parts and type attributes and to override each of them
+      # with a reader that delegated to the first member. `#exclude` and the
+      # serializer read every attribute through its reader, so they reached
+      # `EuropeanNorm#parts`, which does not exist, and raised. Read the base
+      # document through #base_document instead.
+      class ConsolidatedIdentifier < Pubid::CenCenelec::Identifier
+        attribute :identifiers, Pubid::CenCenelec::Identifier,
+                  polymorphic: true, collection: true
 
-        # Delegate to first identifier (base document)
-        def publisher
-          identifiers&.first&.publisher
+        # The origin document. Members live in `identifiers` (not `base`), so
+        # walk the first member to its root.
+        def root
+          identifiers&.first&.root || self
         end
 
-        def number
-          identifiers&.first&.number
+        def base_document
+          identifiers&.first&.base_document || self
         end
 
-        def year
-          identifiers&.first&.year
+        # Dropping the supplement layer yields the base standard alone.
+        def drop_supplements
+          identifiers&.first || self
         end
 
-        def parts
-          identifiers&.first&.parts
-        end
+        # "en.285.2015_plus-amd.1.2021": the base document, then each member's
+        # own supplement suffix behind a "plus" marker, so the consolidated
+        # form does not share a slug with the standalone "EN 285:2015/A1:2021".
+        def to_mr_string
+          base, *supplements = identifiers
+          return "" unless base
 
-        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
+          ([base.to_mr_string] +
+            supplements.map { |s| "plus-#{s.mr_supplement_suffix}" })
+            .join(Renderers::MrString::SEPARATOR_SUPPLEMENT)
         end
       end
     end

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

@@ -5,14 +5,53 @@ module Pubid
     module Identifiers
       # Corrigendum Identifier
       # Contains a base identifier plus corrigendum parameters
-      class Corrigendum < Base
-        attribute :base, Base, polymorphic: true
-        attribute :corrigendum_number, :string
-        attribute :corrigendum_year, :integer
-        attribute :corrigendum_month, :string
-
-        def publisher
-          base&.publisher
+      #
+      # Like Amendment, it descends from the shared
+      # Pubid::CenCenelec::Identifier and not from the legacy Identifiers::Base,
+      # and it keeps its date in `year` and `month` strings:
+      # {"base" => {…}, "year" => "2016", "month" => "11"}. An unnumbered
+      # "/AC" has no `number`.
+      class Corrigendum < Pubid::CenCenelec::Identifier
+        attribute :base, Pubid::CenCenelec::Identifier, polymorphic: true
+        attribute :year, :string
+        attribute :month, :string
+
+        def self.supplement_date_attributes
+          %i[year month]
+        end
+
+        def base_document
+          base&.base_document || self
+        end
+
+        # Dropping the supplement layer yields the base standard.
+        def drop_supplements
+          base || self
+        end
+
+        # Uniform supplement interface (shared with Amendment and with BSI)
+        # so callers need not special-case the class.
+        def supplement_type
+          :corrigendum
+        end
+
+        def supplement_number
+          number
+        end
+
+        def supplement_year
+          year
+        end
+
+        # The date part of the supplement: "2016-11", "2003", or nil.
+        def supplement_date
+          return nil unless year
+
+          [year, month].compact.reject(&:empty?).join("-")
+        end
+
+        def mr_supplement_suffix
+          mr_join_segments("cor", number, supplement_date)
         end
       end
     end

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

@@ -6,8 +6,8 @@ module Pubid
   module CenCenelec
     module Identifiers
       class EuropeanPrestandard < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
-        attribute :adopted_identifier, Pubid::Identifier, polymorphic: true
+        attribute :type, Components::Type, default: -> { self.class.default_type }
+        attribute :adopted, Pubid::Identifier, polymorphic: true
 
         TYPED_STAGES = [
           Components::TypedStage.new(
@@ -25,6 +25,31 @@ module Pubid
             web: :european_prestandard, title: "European Prestandard", short: "ENV" }
         end
 
+        # An "ENV ISO 11079:1999" is a WRAPPER: the whole document identity
+        # lives on the nested `adopted`, 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 ? adopted.root : self
+        end
+
+        # MR "env.iso.11079.1999": an adoption puts the adopted document's MR
+        # string where the number goes, as AdoptedEuropeanNorm does.
+        def mr_number_with_part
+          adopted ? adopted.to_mr_string : super
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class EuropeanSpecification < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -5,12 +5,22 @@ module Pubid
     module Identifiers
       # 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 :fragment_number, :string
+      #
+      # The fragment number is the inherited `number`, as for a supplement.
+      class Fragment < Pubid::CenCenelec::Identifier
+        attribute :base, Pubid::CenCenelec::Identifier, polymorphic: true
 
-        def publisher
-          base&.base&.publisher
+        def base_document
+          base&.base_document || self
+        end
+
+        # Dropping the fragment layer yields the amendment it is part of.
+        def drop_supplements
+          base || self
+        end
+
+        def mr_supplement_suffix
+          mr_join_segments("frag", number)
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class Guide < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -5,7 +5,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class HarmonizationDocument < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -5,7 +5,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class TechnicalReport < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

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

@@ -5,7 +5,7 @@ module Pubid
   module CenCenelec
     module Identifiers
       class TechnicalSpecification < SingleIdentifier
-        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+        attribute :type, Components::Type, default: -> { self.class.default_type }
 
         TYPED_STAGES = [
           Components::TypedStage.new(

data/lib/pubid/cen_cenelec/parser.rb

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

data/lib/pubid/cen_cenelec/renderer.rb

@@ -51,8 +51,7 @@ module Pubid
         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)
+        is_draft_stage = !draft_stage_abbr(id).nil?
 
         # Get type short name - for draft stages, extract base type
         type_short = if is_draft_stage
@@ -68,8 +67,8 @@ module Pubid
         # 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)
+        # CWA, HD, ES, CR and ENV act as the publisher (not EN)
+        if CenCenelec::PUBLISHER_TYPES.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
@@ -96,8 +95,10 @@ module Pubid
           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)
+        # Type for non-EN documents (TS, TR) - but not the publisher-types
+        # or Guide
+        if type_short != "EN" && type_short != "Guide" &&
+            !CenCenelec::PUBLISHER_TYPES.include?(type_short)
           if use_slash_before_type && parts.any?
             # Use slash separator for publisher/type combination (TS, TR only)
             parts << "/#{type_short}"
@@ -111,9 +112,9 @@ module Pubid
 
         # Number with part (which may be multi-level like "5-1-1")
         if id.number
-          number_str = id.number.render(context: @context)
+          number_str = id.number
           if id.part
-            number_str += "-#{id.part.render(context: @context)}"
+            number_str += "-#{id.part}"
           end
           parts << number_str
         end
@@ -136,6 +137,13 @@ module Pubid
         result
       end
 
+      # "prEN" or "FprEN" when +id+ has that draft stage, else nil. A draft
+      # stage prints in place of the publisher.
+      def draft_stage_abbr(id)
+        abbr = id.typed_stage&.abbr&.first
+        abbr if %w[prEN FprEN].include?(abbr)
+      end
+
       # CEN Identifiers::Base: simple key-value model
       # Format: {PUBLISHER} NUMBER[-PART]:YEAR
       def render_cen_base(id)
@@ -148,10 +156,10 @@ module Pubid
           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
+        # If we have adopted, render it (contains all info)
+        if id.adopted
+          result += " #{id.adopted}"
+          # Don't add our own number/parts/year - they're in adopted
         else
           # Only render our own fields if no adoption
           # Type - use space for Guide, slash for TR/TS
@@ -181,77 +189,64 @@ module Pubid
         result
       end
 
-      # AdoptedEuropeanNorm: "EN ISO 8601:2019"
+      # AdoptedEuropeanNorm: "EN ISO 8601:2019", "CEN/CLC ISO/IEC 17000",
+      # "prEN ISO 1234:2020" (a draft stage prints in place of "EN")
       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
+        publishers = ([id.publisher] + Array(id.copublishers)).compact
+          .map { |p| p.render(context: @context) }
+        draft = draft_stage_abbr(id)
+        publishers[0] = draft if draft
+        result = publishers.join("/")
+        result += " #{id.adopted}" if id.adopted
         result
       end
 
       # Amendment: "EN 196-3:2005/A1:2008"
       def render_amendment(id)
-        result = if id.base
-                   "#{id.base}/A#{id.amendment_number}"
-                 else
-                   "/A#{id.amendment_number}"
-                 end
-        result += ":#{id.amendment_year}" if id.amendment_year
-        result
+        "#{id.base}/#{supplement_token(id)}"
       end
 
-      # Corrigendum: "EN 60038/AC1:2012"
+      # Corrigendum: "EN 60038/AC1:2012", "EN 61375-2-3:2015/AC:2016-11"
       def render_corrigendum(id)
-        if id.base
-          result = id.base.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
+        "#{id.base}/#{supplement_token(id)}"
       end
 
-      # ConsolidatedIdentifier: "EN 196-3:2005+A1:2008"
+      # ConsolidatedIdentifier: "EN 196-3:2005+A1:2008". The first member is
+      # the base document; the others are supplements with no base.
       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
+        base, *supplements = id.identifiers
+        base.to_s + supplements.map do |sub_id|
+          if sub_id.is_a?(Identifiers::Amendment) ||
+              sub_id.is_a?(Identifiers::Corrigendum)
+            "+#{supplement_token(sub_id)}"
           else
-            # Other identifiers (should not happen in typical bundles) render with +
+            # Other identifiers (should not happen in typical bundles)
             "+#{sub_id}"
           end
-        end.compact.join
+        end.join
+      end
+
+      # The supplement without its base: "A1:2008", "AC1:2012",
+      # "AC:2016-11" (an unnumbered corrigendum).
+      def supplement_token(id)
+        prefix = id.is_a?(Identifiers::Corrigendum) ? "AC" : "A"
+        result = "#{prefix}#{id.number}"
+        return result unless id.year
+
+        result += ":#{id.year}"
+        result += "-#{id.month}" if id.respond_to?(:month) && id.month
+        result
       end
 
       # Fragment: "EN 60038 AMD1 FRAG2"
       def render_fragment(id)
-        "#{id.base} FRAG#{id.fragment_number}"
+        "#{id.base} FRAG#{id.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}"
+        if id.adopted
+          "ENV #{id.adopted}"
         else
           render_single(id)
         end

data/lib/pubid/cen_cenelec/single_identifier.rb

@@ -7,7 +7,7 @@ module Pubid
     # concrete type is `is_a?` it.
     class SingleIdentifier < Pubid::CenCenelec::Identifier
       attribute :publisher, Components::Publisher, default: -> {
-        Components::Publisher.new(body: "EN")
+        self.class.default_publisher
       }
 
       # Generate URN for this identifier
@@ -18,6 +18,24 @@ module Pubid
         nil
       end
 
+      # The `publisher` default: the type token for a publisher-type
+      # ("CWA 14050", "HD 1215", "CR 954", "ES 59008", "ENV 1613"), else EN.
+      # `to_hash` leaves out a value equal to its default, so the publisher
+      # of those five is not written: `_type` already names it.
+      def self.default_publisher
+        short = type.is_a?(Hash) ? type[:short] : nil
+        body = CenCenelec::PUBLISHER_TYPES.include?(short) ? short : "EN"
+        Components::Publisher.new(body: body)
+      end
+
+      # The `type` default of a typed leaf. It is a Components::Type, like
+      # the value the parser sets for "CEN/TR", so a document with no type
+      # token deserializes the same way it parses. The default used to be the
+      # bare Symbol `type[:key]`, and from_hash raised on it.
+      def self.default_type
+        Components::Type.new(abbr: type[:short])
+      end
+
       def to_s(lang: :en, lang_single: false, **opts)
         render(format: :human, lang: lang, lang_single: lang_single, **opts)
       end
@@ -30,7 +48,7 @@ module Pubid
         return num_cmp unless num_cmp.zero?
 
         # Then by part
-        part_cmp = (part || Components::Code.new(value: "0")).to_s <=> (other.part || Components::Code.new(value: "0")).to_s
+        part_cmp = (part || "0").to_s <=> (other.part || "0").to_s
         return part_cmp unless part_cmp.zero?
 
         # Then by date

data/lib/pubid/cen_cenelec/urn_generator.rb

@@ -4,14 +4,76 @@ module Pubid
   module CenCenelec
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        if identifier.is_a?(CenCenelec::SupplementIdentifier)
-          generate_supplement_urn
+        urn_for(identifier)
+      end
+
+      protected
+
+      # The URN of +id+, walking the wrapper structure:
+      #   EN 13250:2000/A1:2005    urn:cen:en:13250:2000:amd:1:2005
+      #   EN 285:2015+A1:2021      urn:cen:en:285:2015:plus:amd:1:2021
+      #   EN 60038 AMD1 FRAG2      urn:cen:en:60038:amd:1:frag:2
+      #   CEN ISO/TS 21003-7:2019  urn:cen:cen:iso:ts:21003-7:2019
+      #   ENV ISO 11079:1999       urn:cen:env:iso:11079:1999
+      #   prEN ISO 1234:2020       urn:cen:en:iso:1234:2020:stage.proposal
+      # The "plus" marker keeps a consolidated identifier apart from the
+      # standalone amendment with the same number and year.
+      def urn_for(id)
+        case id
+        when nil
+          "urn:cen"
+        when Identifiers::Amendment, Identifiers::Corrigendum,
+             Identifiers::Fragment
+          [urn_for(id.base), *supplement_segments(id)].join(":")
+        when Identifiers::ConsolidatedIdentifier
+          base, *supplements = id.identifiers
+          [urn_for(base), *supplements.flat_map do |s|
+            ["plus", *supplement_segments(s)]
+          end].join(":")
         else
-          generate_base_urn
+          if adoption?(id)
+            # The publisher, then the adopted document's MR string with its
+            # dot and underscore separators as colons, then a draft stage as
+            # the base URN writes it.
+            body = [id.mr_publisher, id.adopted&.to_mr_string]
+              .compact.reject(&:empty?).join(".").tr("._", "::")
+            ["urn:cen:#{body}", *stage_segment(id)].join(":")
+          else
+            self.class.new(id).generate_base_urn
+          end
         end
       end
 
-      protected
+      # "EN ISO 8601:2019" or "ENV ISO 11079:1999": the document identity is
+      # on the adopted ISO/IEC identifier, not on this one.
+      def adoption?(id)
+        id.is_a?(Identifiers::AdoptedEuropeanNorm) ||
+          (id.is_a?(Identifiers::EuropeanPrestandard) && id.adopted)
+      end
+
+      # ["stage.proposal"] for a draft stage, [] for a published document.
+      def stage_segment(id)
+        code = id.typed_stage&.stage_code
+        return [] if code.nil? || code.to_s == "published"
+
+        ["stage.#{code}"]
+      end
+
+      # The segments that a supplement adds to its base: type, number (none
+      # for an unnumbered "/AC"), then the date.
+      def supplement_segments(id)
+        segments = case id
+                   when Identifiers::Amendment
+                     ["amd", id.number, id.year]
+                   when Identifiers::Corrigendum
+                     ["cor", id.number, id.supplement_date]
+                   when Identifiers::Fragment
+                     ["frag", id.number]
+                   else
+                     []
+                   end
+        segments.map(&:to_s).reject(&:empty?)
+      end
 
       def generate_base_urn
         parts = ["urn", "cen"]
@@ -75,46 +137,6 @@ module Pubid
         parts.join(":")
       end
 
-      def generate_supplement_urn
-        parts = ["urn", "cen"]
-
-        base_id = maybe(:base)
-        if base_id
-          base_gen = self.class.new(base_id)
-          base_urn = base_gen.generate_base_urn
-
-          base_part = base_urn.sub(/^urn:cen:/, "")
-          base_parts = base_part.split(":")
-
-          parts.concat(base_parts)
-
-          typed_stage = maybe(:typed_stage)
-          if typed_stage
-            supp_type = typed_stage.type_code.to_s
-            parts << supp_type if supp_type
-          end
-
-          amendment_number = maybe(:amendment_number)
-          if amendment_number
-            parts << amendment_number.to_s
-          elsif identifier.number
-            number = identifier.number.to_s
-            parts << number
-          end
-
-          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)
-          end
-        else
-          parts << "unknown"
-        end
-
-        parts.join(":")
-      end
-
       def type_component
         typed_stage = maybe(:typed_stage)
         return nil unless typed_stage