pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

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

@@ -5,14 +5,44 @@ 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
 
-        def to_s
-          identifiers_string || ""
+        # 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(**opts)
+          return "" unless ids&.any?
+
+          result = 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(",")
+
+          annotate_plain_render(result, **opts)
+        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,22 +9,27 @@ 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}"
+        def to_s(**opts)
+          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
 
-          result
+          # Opaque /slug variant if present
+          result += "/#{variant}" if variant
+
+          annotate_plain_render(result, **opts)
         end
       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(**opts)
+          annotate_plain_render("#{base}/Cor#{number}:#{year}", **opts)
         end
       end
     end

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

@@ -9,31 +9,31 @@ 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
+        def to_s(**opts)
           parts = ["CIE"]
 
           # S prefix
           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
           result += "/IEC #{iec_identifier}" if iec_identifier
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

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

@@ -12,24 +12,25 @@ module Pubid
       #   CIE S 014-4/E2007 - part with dash + language
       #   CIE S 008/E:2001 (ISO 8995-1:2002(E)) - language with colon year
       class Identical < SingleIdentifier
+        include CodeAttributes # flat number/part/iteration/part_separator + #code_string
+
         attribute :s_prefix, :boolean, default: -> { false }
-        attribute :code, Components::Code
         attribute :language, Components::Language
         attribute :iso_reference, :string # The ISO identifier in parentheses
 
-        def to_s
+        def to_s(**opts)
           parts = ["CIE"]
 
           # S prefix
           parts << "S" if s_prefix
 
           # Code
-          parts << code.to_s if code
+          parts << code_string if number
 
           result = parts.join(" ")
 
           # Language + Year combined for slash formats before ISO reference
-          if language && (language.format == "slash_colon" || (language.format == "slash" && year && date_separator != "slash"))
+          if language && (language.format == "slash_colon" || (language.format == "slash" && year && style != "slash"))
             # Render /E:YYYY or /EYYYY (language with year, no separate date separator)
             result += if language.format == "slash_colon"
                         "/#{language.code}:#{year}" # /E:2001
@@ -39,13 +40,12 @@ module Pubid
           elsif language && language.format == "slash"
             # Language without year: /E
             result += "/#{language.code}"
-          elsif year && date_separator == "slash"
+          elsif year && style == "slash"
             # Legacy slash-year format without language: /1998
             result += "/#{year}"
           elsif year
-            # Standard date with separator (colon or dash)
-            separator = date_separator == "colon" ? ":" : "-"
-            result += "#{separator}#{year}"
+            # Standard date with separator derived from style
+            result += "#{date_sep_char}#{year}"
           end
 
           # Language (parenthetical) after date
@@ -56,7 +56,7 @@ module Pubid
           # ISO reference in parentheses
           result += " (ISO #{iso_reference})" if iso_reference
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

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

@@ -8,13 +8,14 @@ module Pubid
       # Joint published identifier for CIE
       # Handles CIE ISO, CIE IEC, CIE ISO/CIE patterns
       class JointPublished < SingleIdentifier
+        include CodeAttributes # flat number/part/iteration/part_separator + #code_string
+
         attribute :copublisher, :string       # "ISO", "IEC", or "ISO/CIE"
-        attribute :code, Components::Code
         attribute :language, Components::Language
         attribute :doc_type, :string          # "TR" for Technical Report
         attribute :stage, :string             # "DIS" for draft stage
 
-        def to_s
+        def to_s(**opts)
           parts = ["CIE", copublisher]
 
           # Document type (TR)
@@ -24,27 +25,26 @@ module Pubid
           parts << stage if stage
 
           # Code (number-part) - special handling for IEC dot separator
-          if code
-            code_str = code.to_s
+          if number
+            code_str = code_string
             # For IEC copublisher, if code has a part, use dot not slash/dash
-            if copublisher == "IEC" && code.part
-              code_str = "#{code.number}.#{code.part}"
+            if copublisher == "IEC" && part
+              code_str = "#{number}.#{part}"
             end
             parts << code_str
           end
 
           result = parts.join(" ")
 
-          # Date - use the actual captured separator
+          # Date - separator derived from style
           if year
-            separator = date_separator == "colon" ? ":" : "-"
-            result += "#{separator}#{year}"
+            result += "#{date_sep_char}#{year}"
           end
 
           # Language (always parenthetical for joint published)
           result += language.to_s if language
 
-          result
+          annotate_plain_render(result, **opts)
         end
       end
     end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Proceedings paper identifier for CIE conference papers.
+      #
+      # Two surface forms share this type:
+      #   x-prefixed (attached to a conference): "CIE x043-OP01"
+      #   standalone (with a page range):        "CIE OP02 1-5"
+      #
+      # The paper itself is the document, so its identity (code + running
+      # number, e.g. "OP01") is stored flat as +number+ for BOTH forms. This
+      # gives every proceedings row a non-empty relaton-index binary-search key
+      # (see index_number_spec). The x-form's parent conference lives in
+      # +conference+; the standalone form's +page+ range is its locality.
+      # No-default values so absent keys drop from to_hash (round-trip).
+      class Proceedings < SingleIdentifier
+        # The paper identity "OP01" / "P03". :string overrides the base
+        # ::Pubid::Identifier Components::Code type.
+        attribute :number, :string
+        # The parent conference "043" (x-form only; nil for standalone).
+        attribute :conference, :string
+        # Page range "1-5" (standalone form only).
+        attribute :page, :string
+
+        def to_s(**opts)
+          result = if conference
+                     "CIE x#{conference}-#{number}"
+                   else
+                     "CIE #{number} #{page}"
+                   end
+
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -8,22 +8,52 @@ module Pubid
       # Standard identifier for CIE
       # Handles both legacy (pre-2001) and current (2001+) styles
       class Standard < SingleIdentifier
+        include CodeAttributes # flat number/part/iteration/part_separator + #code_string
+
         attribute :s_prefix, :boolean, default: -> { false }
-        attribute :code, Components::Code
+        # D-series marker (CIE D001-2006). Boolean default false so it is
+        # canonicalized away for every non-D standard (round-trip contract).
+        attribute :d_prefix, :boolean, default: -> { false }
         attribute :language, Components::Language
         attribute :stage, :string # DIS, DS
 
-        def to_s
+        def to_s(**opts)
+          annotate_plain_render(render_plain, **opts)
+        end
+
+        # CIE Standard distinguishes S-prefixed standards (`CIE S 017`) from
+        # plain (`CIE 015`), D-prefixed (`CIE D001`), and DIS-staged. The
+        # generic mr_type looks at typed_stage, which CIE doesn't use, so
+        # without this override the `S`/`D`/stage marker would be lost in MR.
+        def mr_type
+          return stage.downcase if stage
+          return "d" if d_prefix
+          return "s" if s_prefix
+
+          nil
+        end
+
+        private
+
+        # The plain composition, extracted verbatim from `to_s`. It has two
+        # early returns (the slash_colon language form and the legacy
+        # bare slash-year form), and `to_s` needs a single exit to wrap.
+        def render_plain
           parts = ["CIE"]
 
           # Stage (DIS/DS) before code if present
           parts << stage if stage
 
-          # S prefix
-          parts << "S" if s_prefix
+          if d_prefix
+            # D-series: the D is attached to the code (no space): CIE D001
+            parts << "D#{code_string}"
+          else
+            # S prefix
+            parts << "S" if s_prefix
 
-          # Code
-          parts << code.to_s if code
+            # Code
+            parts << code_string if number
+          end
 
           # Build initial result from parts
           result = parts.join(" ")
@@ -39,10 +69,15 @@ module Pubid
             return result # Year already added
           end
 
+          # Bare slash-year (legacy, no language): CIE S 007/1998
+          if year && style == "slash"
+            result += "/#{year}"
+            return result
+          end
+
           # Date with separator (for non-slash-colon formats)
           if year
-            separator = date_separator == "colon" ? ":" : "-"
-            result += "#{separator}#{year}"
+            result += "#{date_sep_char}#{year}"
           end
 
           # Language (parenthetical formats) - comes after date

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

@@ -5,39 +5,41 @@ require "lutaml/model"
 module Pubid
   module Cie
     module Identifiers
-      # Supplement identifier for CIE
-      # Handles -SPN and -SPN.P notation with recursive base parsing
+      # Supplement identifier for CIE (-SPN / -SPN.P notation).
+      # Wraps a nested base (the base Standard); the "-SPN" is
+      # inserted after the base number, so to_s renders from the base's parts.
       # Examples: CIE 121-SP1:2009, CIE 198-SP1.4:2011, CIE DIS 025-SP1/E:2019
       class Supplement < SupplementIdentifier
-        attribute :base_number, :string
-        attribute :supplement_number, :string    # "1", "2"
-        attribute :supplement_part, :string      # "1" in "SP1.1", "4" in "SP1.4"
-        attribute :year, :string
-        attribute :stage, :string                # "DIS", "DS"
-        attribute :language, Components::Language
-
-        def to_s
-          parts = ["CIE"]
+        # +number+ (the "-SPN" ordinal) is inherited from SupplementIdentifier.
+        attribute :part, :string # "1" in "SP1.1", "4" in "SP1.4"
 
-          # Stage if present (DIS/DS)
-          parts << stage if stage
+        # Uniform supplement interface (shared with Corrigendum).
+        def supplement_type
+          :supplement
+        end
 
-          # Build base number and supplement
-          result = parts.join(" ")
-          result += " #{base_number}-SP#{supplement_number}"
+        def supplement_year
+          base&.year
+        end
 
-          # Add part if present (e.g., ".4" in "SP1.4")
-          result += ".#{supplement_part}" if supplement_part
+        def to_s(**opts)
+          b = base
+          parts = ["CIE"]
+          parts << b.stage if b.respond_to?(:stage) && b.stage
 
-          # Add language with slash if present (before year)
-          if language && language.format == "slash_colon"
-            result += "/#{language.code}"
-          end
+          core = "#{b.number}-SP#{number}"
+          core += ".#{part}" if part
+          parts << core
+          result = parts.join(" ")
 
-          # Add year with colon (supplements always use current style)
-          result += ":#{year}" if year
+          # Language with slash (before year), e.g. "/E"
+          if b.language && b.language.format == "slash_colon"
+            result += "/#{b.language.code}"
+          end
 
-          result
+          # Supplements always use the current (colon) style.
+          result += ":#{b.year}" if b.year
+          annotate_plain_render(result, **opts)
         end
       end
     end

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

@@ -8,11 +8,15 @@ module Pubid
       # Tutorial Bundle identifier for CIE
       # Special text-based identifier
       # Example: CIE Tutorials Bundle 1
+      #
+      # The ordinal ("1") is the bundle's own +number+ (also the relaton-index
+      # root key); there is no separate document, so no nested base.
       class TutorialBundle < SingleIdentifier
-        attribute :bundle_number, :string
+        # :string overrides the base ::Pubid::Identifier Components::Code type.
+        attribute :number, :string
 
-        def to_s
-          "CIE Tutorials Bundle #{bundle_number}"
+        def to_s(**opts)
+          annotate_plain_render("CIE Tutorials Bundle #{number}", **opts)
         end
       end
     end

data/lib/pubid/cie/identifiers.rb

@@ -3,12 +3,14 @@
 module Pubid
   module Cie
     module Identifiers
+      autoload :CodeAttributes, "#{__dir__}/identifiers/code_attributes"
       autoload :Bundle, "#{__dir__}/identifiers/bundle"
       autoload :Conference, "#{__dir__}/identifiers/conference"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :DualPublished, "#{__dir__}/identifiers/dual_published"
       autoload :Identical, "#{__dir__}/identifiers/identical"
       autoload :JointPublished, "#{__dir__}/identifiers/joint_published"
+      autoload :Proceedings, "#{__dir__}/identifiers/proceedings"
       autoload :Standard, "#{__dir__}/identifiers/standard"
       autoload :Supplement, "#{__dir__}/identifiers/supplement"
       autoload :TutorialBundle, "#{__dir__}/identifiers/tutorial_bundle"

data/lib/pubid/cie/parser.rb

@@ -6,7 +6,7 @@ module Pubid
   module Cie
     # Parser for CIE identifiers
     # Handles dual-style system (legacy vs current)
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }
@@ -135,9 +135,50 @@ module Pubid
         (str("FDIS") | str("DIS") | str("DS")) >> space
       end
 
-      # Document type (TR for Technical Report)
+      # Document type (TR for Technical Report, TS for Technical Specification)
       rule(:doc_type) do
-        str("TR") # Don't consume trailing space
+        (str("TR") | str("TS")) # Don't consume trailing space
+      end
+
+      # Proceedings paper code: 1+ uppercase letters (OP, PO, PP, WP, IP, P, ...)
+      # Deliberately generic (open set); greedy letters then digits.
+      rule(:paper_code) do
+        match("[A-Z]").repeat(1).as(:paper_code)
+      end
+
+      # Techstreet opaque conference variant: /<lowercase-alnum slug>
+      # Charset kept lowercase-alnum so it can't collide with the uppercase
+      # /E, /Cor, /IEC tails or the self.parse language gsub.
+      rule(:variant_slug) do
+        slash >> match("[0-9a-z]").repeat(1).as(:variant)
+      end
+
+      # Conference proceedings paper (x-prefixed): CIE x043-OP01
+      rule(:conf_proceedings) do
+        str("CIE") >> space >> str("x") >> digits.as(:conf_number) >>
+          dash >> paper_code >> digits.as(:paper_number)
+      end
+
+      # Standalone proceedings paper: CIE OP02 1-5
+      rule(:standalone_proceedings) do
+        str("CIE") >> space >> paper_code >> digits.as(:paper_number) >>
+          space >> (digits >> dash >> digits).as(:page_range)
+      end
+
+      # D-series: CIE D001-2006 / CIE D002:2004
+      rule(:d_series_identifier) do
+        str("CIE") >> space >> str("D").as(:d_prefix) >> digits.as(:number) >> date
+      end
+
+      # Standard with bare slash-year (no language letter): CIE S 007/1998
+      # Uses a narrow number(+iteration) pattern rather than the full code rule
+      # so code_with_part_slash doesn't greedily consume the /year.
+      rule(:standard_with_slash_year) do
+        str("CIE") >> space >>
+          stage_code.maybe.as(:stage) >>
+          s_prefix.maybe.as(:s_prefix) >>
+          (digits.as(:number) >> (dot >> digits.as(:iteration)).maybe) >>
+          slash >> year_digits.as(:slash_year)
       end
 
       # DIS stage with supplement pattern (e.g., DIS 025-SP1/E:2019)
@@ -157,12 +198,14 @@ module Pubid
           stage_code.maybe.as(:stage) >>
           s_prefix.maybe.as(:s_prefix) >>
           code >>
-          # Language can come BEFORE date, AFTER date, or both
+          # Language can come BEFORE date, AFTER date, or both.
+          # The whole date group is optional so a bare "CIE 015" (no year)
+          # parses with year left nil (partial reference for relaton matching).
           (
             (language >> date).as(:lang_before) |
             (date >> language.maybe).as(:date_then_lang) |
             date
-          )
+          ).maybe
       end
 
       # Standard identifier without ISO reference but with language-year (CIE S 014-4/E:2007)
@@ -181,7 +224,9 @@ module Pubid
           digits.as(:conf_number) >>
           date >>
           # Optional amendment
-          (space >> str("Amendment") >> space >> digits.as(:amd_number)).maybe
+          (space >> str("Amendment") >> space >> digits.as(:amd_number)).maybe >>
+          # Optional techstreet opaque /slug variant
+          variant_slug.maybe
       end
 
       # Joint published with ISO
@@ -320,6 +365,10 @@ module Pubid
           corrigendum_identifier |
           supplement_identifier |
           standard_with_language_year |
+          standard_with_slash_year |
+          d_series_identifier |
+          conf_proceedings |
+          standalone_proceedings |
           legacy_code_with_year | # Before standard to catch 001-1980 pattern
           conference_identifier |
           standard_identifier