pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

data/lib/pubid/cen_cenelec.rb

@@ -21,118 +21,122 @@ module Pubid
     autoload :UrnParser, "#{__dir__}/cen_cenelec/urn_parser"
 
     # TYPED_STAGES_REGISTRY for native CEN types
+    # Covers the CEN PROJEX stage-code table per issue #251.
     TYPED_STAGES_REGISTRY = [
-      # European Norm (EN)
+      # === European Norm (EN) lifecycle ===
+      # Preliminary (pWI EN): proposal/WI stages
       Pubid::Components::TypedStage.new(
-        code: :puben,
-        stage_code: :published,
-        type_code: :en,
-        abbr: ["EN"],
-        name: "European Norm",
-        harmonized_stages: %w[60.00 60.60],
+        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
       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],
+        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],
+      ),
+      # Final Proposal (FprEN): enquiry stages
+      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.97 40.98 40.99],
+      ),
+      # Formal Vote (FV prEN): COCOR + FV dispatch
+      Pubid::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
+      Pubid::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],
+      ),
+      # Published (EN): ratification + publication milestones
+      Pubid::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],
+      ),
+      # Review (rvEN): 2-year review
+      Pubid::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)
+      Pubid::Components::TypedStage.new(
+        code: :racen, stage_code: :reactivation, type_code: :en,
+        abbr: ["racEN"], name: "Re-activated EN",
+        harmonized_stages: %w[96.60],
       ),
+      # Withdrawn (wdEN)
       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],
+        code: :wden, stage_code: :withdrawn, type_code: :en,
+        abbr: ["wdEN"], name: "Withdrawn EN",
+        harmonized_stages: %w[99.60],
       ),
 
-      # Technical Specification (TS)
+      # === Technical Specification (TS) ===
       Pubid::Components::TypedStage.new(
-        code: :pubts,
-        stage_code: :published,
-        type_code: :ts,
-        abbr: ["TS"],
-        name: "Technical Specification",
+        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",
+        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)
+      # === Technical Report (TR) ===
       Pubid::Components::TypedStage.new(
-        code: :pubtr,
-        stage_code: :published,
-        type_code: :tr,
-        abbr: ["TR"],
-        name: "Technical Report",
+        code: :pubtr, stage_code: :published, type_code: :tr,
+        abbr: ["TR"], name: "Technical Report",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # CEN Workshop Agreement (CWA)
+      # === CEN Workshop Agreement (CWA) ===
       Pubid::Components::TypedStage.new(
-        code: :pubcwa,
-        stage_code: :published,
-        type_code: :cwa,
-        abbr: ["CWA"],
-        name: "CEN Workshop Agreement",
+        code: :pubcwa, stage_code: :published, type_code: :cwa,
+        abbr: ["CWA"], name: "CEN Workshop Agreement",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # Guide
+      # === Guide ===
       Pubid::Components::TypedStage.new(
-        code: :pubguide,
-        stage_code: :published,
-        type_code: :guide,
-        abbr: ["Guide"],
-        name: "Guide",
+        code: :pubguide, stage_code: :published, type_code: :guide,
+        abbr: ["Guide"], name: "Guide",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # Harmonization Document (HD)
+      # === Harmonization Document (HD) ===
       Pubid::Components::TypedStage.new(
-        code: :pubhd,
-        stage_code: :published,
-        type_code: :hd,
-        abbr: ["HD"],
-        name: "Harmonization Document",
+        code: :pubhd, stage_code: :published, type_code: :hd,
+        abbr: ["HD"], name: "Harmonization Document",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # European Specification (ES)
+      # === European Specification (ES) ===
       Pubid::Components::TypedStage.new(
-        code: :pubes,
-        stage_code: :published,
-        type_code: :es,
-        abbr: ["ES"],
-        name: "European Specification",
+        code: :pubes, stage_code: :published, type_code: :es,
+        abbr: ["ES"], name: "European Specification",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # CEN Report (CR)
+      # === CEN Report (CR) ===
       Pubid::Components::TypedStage.new(
-        code: :pubcr,
-        stage_code: :published,
-        type_code: :cr,
-        abbr: ["CR"],
-        name: "CEN Report",
+        code: :pubcr, stage_code: :published, type_code: :cr,
+        abbr: ["CR"], name: "CEN Report",
         harmonized_stages: %w[60.00 60.60],
       ),
 
-      # European Prestandard (ENV)
+      # === European Prestandard (ENV) ===
       Pubid::Components::TypedStage.new(
-        code: :pubenv,
-        stage_code: :published,
-        type_code: :env,
-        abbr: ["ENV"],
-        name: "European Prestandard",
+        code: :pubenv, stage_code: :published, type_code: :env,
+        abbr: ["ENV"], name: "European Prestandard",
         harmonized_stages: %w[60.00 60.60],
       ),
     ].freeze

data/lib/pubid/cie/builder.rb

@@ -14,12 +14,20 @@ module Pubid
         # Determine identifier class based on parsed content
         identifier_class = determine_class(parsed_hash)
 
+        # Supplement / Corrigendum wrap a nested base.
+        if identifier_class == Cie::Identifiers::Corrigendum
+          return build_corrigendum(parsed_hash)
+        end
+        if identifier_class == Cie::Identifiers::Supplement
+          return build_supplement(parsed_hash)
+        end
+
         # Extract attributes with style detection
         attributes = extract_attributes(parsed_hash)
 
-        # For Bundle identifier, store original string
+        # For Bundle, parse each comma-separated member and hoist a shared base.
         if parsed_hash[:bundle_items] && original_string
-          attributes[:identifiers_string] = original_string
+          attributes.merge!(build_bundle(original_string))
         end
 
         # Construct identifier
@@ -28,6 +36,85 @@ module Pubid
 
       private
 
+      # Build a Bundle's attributes from its printed form. Parse each member,
+      # then — since a CIE bundle is the parts of one supplement of one standard
+      # — hoist the shared base and keep only the differing supplement
+      # number/part in each doc. If the members don't share a base (not seen in
+      # practice, but the grammar allows it), keep each doc's own base instead.
+      def build_bundle(original_string)
+        members = split_bundle_members(original_string)
+        shared = common_base(members)
+        return { ids: members } unless shared
+
+        ids = members.map do |m|
+          Cie::Identifiers::Supplement.new(number: m.number, part: m.part)
+        end
+        { base: shared, ids: ids }
+      end
+
+      # The publisher prefix is written once, so only the first item carries
+      # "CIE "; prepend it to the rest before parsing each member.
+      def split_bundle_members(original_string)
+        original_string.split(",").each_with_index.map do |item, i|
+          ref = i.zero? ? item.strip : "CIE #{item.strip}"
+          Cie::Identifier.parse(ref)
+        end
+      end
+
+      # The base shared by every member, or nil if they differ (or any is
+      # base-less). Compared by canonical hash so structural equality holds.
+      def common_base(members)
+        bases = members.map(&:base)
+        return nil if bases.any?(&:nil?)
+
+        first = bases.first.to_hash
+        bases.all? { |b| b.to_hash == first } ? bases.first : nil
+      end
+
+      # Supplement: nest the base Standard (the stage/year/language belong to
+      # the base), keep only the -SPN number/part on the wrapper.
+      def build_supplement(parsed_hash)
+        a = extract_attributes(parsed_hash)
+        base = Cie::Identifiers::Standard.new(
+          number: a[:base_number],
+          stage: a[:stage],
+          s_prefix: a.fetch(:s_prefix, false),
+          language: a[:language],
+          year: a[:year],
+          style: "current", # supplements always use the colon style
+        )
+        Cie::Identifiers::Supplement.new(
+          base: base,
+          number: a[:supplement_number],
+          part: a[:supplement_part],
+        )
+      end
+
+      # Corrigendum: nest the base (a Standard, or a Supplement when the base
+      # itself carries -SPN), keep only the /CorN number/year on the wrapper.
+      def build_corrigendum(parsed_hash)
+        a = extract_attributes(parsed_hash)
+        base_std = Cie::Identifiers::Standard.new(
+          number: a[:base_number],
+          year: a[:base_year],
+          style: "current",
+        )
+        base = if a[:base_supplement]
+                 Cie::Identifiers::Supplement.new(
+                   base: base_std,
+                   number: a[:base_supplement],
+                   part: a[:base_supplement_part],
+                 )
+               else
+                 base_std
+               end
+        Cie::Identifiers::Corrigendum.new(
+          base: base,
+          number: a[:cor_number],
+          year: a[:cor_year],
+        )
+      end
+
       # Determine which identifier class to use
       def determine_class(parsed_hash)
         # Tutorial Bundle (special text format)
@@ -50,6 +137,11 @@ module Pubid
           return Cie::Identifiers::Supplement
         end
 
+        # Proceedings paper (x-prefixed or standalone)
+        if parsed_hash[:paper_code]
+          return Cie::Identifiers::Proceedings
+        end
+
         # Conference (x-prefix)
         if parsed_hash[:conference]
           return Cie::Identifiers::Conference
@@ -179,47 +271,69 @@ module Pubid
           date_sep = "slash" # Special format for identical identifiers
         end
 
-        # Detect style from date separator
-        style = if date_sep == "colon"
-                  "current"
-                else
-                  (date_sep == "dash" ? "legacy" : detect_style_fallback(parsed_hash))
+        # Style is the sole separator field (no date_separator):
+        #   colon -> current (":")   dash -> legacy ("-")   slash -> slash ("/")
+        style = case date_sep
+                when "colon" then "current"
+                when "dash" then "legacy"
+                when "slash" then "slash"
+                else detect_style_fallback(parsed_hash)
                 end
         attributes[:style] = style
 
-        # Set year and separator if present
+        # Set year if present
         attributes[:year] = year_value if year_value
-        attributes[:date_separator] = date_sep if date_sep
 
-        # Extract code
+        # Extract code (flat number/part/iteration/part_separator on the
+        # identifier; the code's style is the identifier's own `style`).
         if parsed_hash[:number]
-          code_attrs = { number: extract_value(parsed_hash[:number]),
-                         style: style }
+          attributes[:number] = extract_value(parsed_hash[:number])
           if parsed_hash[:part]
-            code_attrs[:part] =
-              extract_value(parsed_hash[:part])
+            attributes[:part] = extract_value(parsed_hash[:part])
           end
           if parsed_hash[:iteration]
-            code_attrs[:iteration] =
-              extract_value(parsed_hash[:iteration])
+            attributes[:iteration] = extract_value(parsed_hash[:iteration])
           end
 
           # Detect part separator from parser markers
           if parsed_hash[:slash_sep]
-            code_attrs[:part_separator] = "slash"
+            attributes[:part_separator] = "slash"
           elsif parsed_hash[:dash_sep]
-            code_attrs[:part_separator] = "dash"
+            attributes[:part_separator] = "dash"
           end
-
-          attributes[:code] = Components::Code.new(**code_attrs)
         end
 
         # Conference number (separate from regular code)
         if parsed_hash[:conf_number]
-          attributes[:conference_number] =
+          attributes[:number] =
             extract_value(parsed_hash[:conf_number])
         end
 
+        # Proceedings paper: the paper itself is the document, so its identity
+        # (code + running number, e.g. "OP01") is the flat +number+ for both
+        # surface forms. The x-form's parent conference goes to
+        # +conference+; the standalone form keeps its +page+ range.
+        if parsed_hash[:paper_code]
+          attributes[:number] =
+            "#{extract_value(parsed_hash[:paper_code])}" \
+            "#{extract_value(parsed_hash[:paper_number])}"
+          if parsed_hash[:conf_number]
+            attributes[:conference] =
+              extract_value(parsed_hash[:conf_number])
+          end
+        end
+        if parsed_hash[:page_range]
+          attributes[:page] = extract_value(parsed_hash[:page_range])
+        end
+
+        # Conference /slug variant (opaque, verbatim)
+        if parsed_hash[:variant]
+          attributes[:variant] = extract_value(parsed_hash[:variant])
+        end
+
+        # D-series marker
+        attributes[:d_prefix] = true if parsed_hash[:d_prefix]
+
         # Extract language (direct lang_code for slash_colon format)
         lang_code = nil
         lang_format = nil
@@ -325,10 +439,11 @@ module Pubid
             extract_value(parsed_hash[:amd_number])
         end
 
-        # Extract bundle data
+        # Tutorial bundle: the ordinal is the bundle's own `number` (also its
+        # relaton-index key). A comma-list bundle instead keys via its `ids`
+        # members through #root, so it needs no stored number.
         if parsed_hash[:bundle_number]
-          attributes[:bundle_number] =
-            extract_value(parsed_hash[:bundle_number])
+          attributes[:number] = extract_value(parsed_hash[:bundle_number])
         end
 
         # Extract trailing language from legacy_code_with_year

data/lib/pubid/cie/identifier.rb

@@ -5,10 +5,14 @@ module Pubid
     # 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).
+    # to_urn, exclude, hash, eql?) while allowing CIE-specific attributes.
+    #
+    # +style+ is the sole number<->year separator field (there is no separate
+    # date_separator): "current" -> ":", "legacy" -> "-", "slash" -> "/".
+    # It defaults to "current" (the dominant value), so canonicalize_hash drops
+    # it from the majority of rows and from_hash restores it.
     class Identifier < ::Pubid::Identifier
-      attribute :style, :string # "legacy" or "current"
+      attribute :style, :string, default: -> { "current" }
 
       def self.parse(input)
         if input.length > Pubid::MAX_INPUT_LENGTH

data/lib/pubid/cie/identifiers/bundle.rb

@@ -5,14 +5,42 @@ require "lutaml/model"
 module Pubid
   module Cie
     module Identifiers
-      # Bundle identifier for CIE
-      # Handles comma-separated supplement lists
+      # Bundle identifier for CIE: a comma-separated list of sibling documents,
+      # each a full CIE identifier (typically a Supplement).
       # Example: CIE 198-SP1.1:2011,198-SP1.2:2011,198-SP1.3:2011,198-SP1.4:2011
+      #
+      # A CIE bundle is the parts of one supplement of one standard, so its
+      # members share a base document. That shared +base+ is hoisted to the
+      # bundle and the +ids+ carry only what differs (supplement number/part);
+      # #root walks +base+ to the origin standard for the relaton-index key.
+      # (Defensive: if members ever don't share a base, each id keeps its own
+      # and +base+ is nil — see Builder#build_bundle.)
       class Bundle < SingleIdentifier
-        attribute :identifiers_string, :string # Store as string for now
+        attribute :base, Identifier, polymorphic: true
+        attribute :ids, Identifier, polymorphic: true, collection: true
 
+        # The origin document: the shared base's root, else the first member's.
+        def root
+          (base || ids&.first)&.root || self
+        end
+
+        # The printed form writes the publisher once: the first member keeps its
+        # "CIE " prefix, the rest are bare. A base-less member is re-based onto
+        # the bundle's shared base for rendering.
         def to_s
-          identifiers_string || ""
+          return "" unless ids&.any?
+
+          ids.each_with_index.map do |id, i|
+            member = id.base ? id : rebased(id)
+            i.zero? ? member.to_s : member.to_s.delete_prefix("CIE ")
+          end.join(",")
+        end
+
+        private
+
+        # Attach the bundle's shared base to a base-less member for rendering.
+        def rebased(id)
+          Supplement.new(base: base, number: id.number, part: id.part)
         end
       end
     end

data/lib/pubid/cie/identifiers/code_attributes.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Shared document-code attributes + rendering for the CIE identifier
+      # types that carry a code (Standard, Identical, JointPublished,
+      # DualPublished).
+      #
+      # The code fields live *flat* on the identifier (no nested
+      # Components::Code), so the serialized hash stays compact:
+      #   {style:, year:, ..., number: "018", iteration: "2"}
+      # rather than nesting them under a code: {number:, iteration:, style:}.
+      #
+      # +code.style+ is intentionally gone: it always equalled the identifier's
+      # own +style+ (the builder set both from one value), so #code_string reads
+      # the identifier's +style+ directly for the part-separator fallback.
+      module CodeAttributes
+        def self.included(base)
+          base.class_eval do
+            attribute :number, :string        # "018", "170", "11664"
+            attribute :part, :string          # "1", "2", "4"
+            attribute :iteration, :string     # "2" in "018.2"
+            attribute :part_separator, :string # "slash" | "dash" (original sep)
+          end
+        end
+
+        # Render the code portion: "018.2", "170-1", "19/2.1", "11664-1".
+        # Uses +part_separator+ when set, otherwise falls back to the
+        # identifier's +style+ (legacy -> "/", current -> "-").
+        def code_string
+          return nil unless number
+
+          result = number.dup
+          if part && iteration
+            result += "/#{part}.#{iteration}"
+          elsif iteration
+            result += ".#{iteration}"
+          elsif part
+            separator = case part_separator
+                        when "slash" then "/"
+                        when "dash" then "-"
+                        else style == "current" ? "-" : "/"
+                        end
+            result += "#{separator}#{part}"
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/identifiers/conference.rb

@@ -9,21 +9,26 @@ module Pubid
       # Handles x-prefix conference proceedings
       # Example: CIE x038:2013, CIE x038:2013 Amendment 1
       class Conference < SingleIdentifier
-        attribute :conference_number, :string
+        # :string overrides the base ::Pubid::Identifier Components::Code type.
+        attribute :number, :string
         attribute :amendment_number, :string
+        # Techstreet opaque /slug variant (no default -> round-trips cleanly)
+        attribute :variant, :string
 
         def to_s
-          result = "CIE x#{conference_number}"
+          result = "CIE x#{number}"
 
           # Date with separator
           if year
-            separator = date_separator == "colon" ? ":" : "-"
-            result += "#{separator}#{year}"
+            result += "#{date_sep_char}#{year}"
           end
 
           # Amendment if present
           result += " Amendment #{amendment_number}" if amendment_number
 
+          # Opaque /slug variant if present
+          result += "/#{variant}" if variant
+
           result
         end
       end

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

@@ -5,34 +5,28 @@ require "lutaml/model"
 module Pubid
   module Cie
     module Identifiers
-      # Corrigendum identifier for CIE
-      # Handles /CorN notation with recursive base parsing
+      # Corrigendum identifier for CIE (/CorN notation).
+      # Wraps a nested base — a Standard, or a Supplement when the
+      # corrigendum applies to a supplement (CIE 198-SP1.4:2011/Cor1:2013).
+      # The "/CorN:year" is a clean trailing suffix on the base's rendering.
       # Examples: CIE 232:2019/Cor1:2020, CIE 198-SP1.4:2011/Cor1:2013
       class Corrigendum < SupplementIdentifier
-        attribute :base_number, :string
-        attribute :base_year, :string
-        attribute :base_supplement, :string       # If base is a supplement
-        attribute :base_supplement_part, :string  # Part of supplement
-        attribute :cor_number, :string
-        attribute :cor_year, :string
+        # +number+ (the "/CorN" ordinal) is inherited from SupplementIdentifier.
+        # The corrigendum's own year — SupplementIdentifier descends from the
+        # base Identifier (not SingleIdentifier), so there is no inherited year.
+        attribute :year, :string
 
-        def to_s
-          # Build base identifier string
-          result = "CIE #{base_number}"
-
-          # Add supplement notation if base is a supplement
-          if base_supplement
-            result += "-SP#{base_supplement}"
-            result += ".#{base_supplement_part}" if base_supplement_part
-          end
-
-          # Add base year with colon
-          result += ":#{base_year}" if base_year
+        # Uniform supplement interface (shared with Supplement).
+        def supplement_type
+          :corrigendum
+        end
 
-          # Add corrigendum with slash and colon
-          result += "/Cor#{cor_number}:#{cor_year}"
+        def supplement_year
+          year
+        end
 
-          result
+        def to_s
+          "#{base}/Cor#{number}:#{year}"
         end
       end
     end

data/lib/pubid/cie/identifiers/dual_published.rb

@@ -9,8 +9,9 @@ module Pubid
       # Represents CIE/IEC dual published standards
       # Example: CIE S 009:2002/IEC 62471:2006
       class DualPublished < SingleIdentifier
+        include CodeAttributes # flat number/part/iteration/part_separator + #code_string
+
         attribute :s_prefix, :boolean, default: -> { false }
-        attribute :code, Components::Code
         attribute :iec_identifier, :string # IEC portion as string
 
         def to_s
@@ -20,14 +21,13 @@ module Pubid
           parts << "S" if s_prefix
 
           # Code
-          parts << code.to_s if code
+          parts << code_string if number
 
           result = parts.join(" ")
 
           # Date
           if year
-            separator = date_separator == "colon" ? ":" : "-"
-            result += "#{separator}#{year}"
+            result += "#{date_sep_char}#{year}"
           end
 
           # IEC portion with slash separator