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

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

@@ -12,8 +12,9 @@ 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
 
@@ -24,12 +25,12 @@ module Pubid
           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

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

@@ -8,8 +8,9 @@ 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
@@ -24,21 +25,20 @@ 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)

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

@@ -0,0 +1,39 @@
+# 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
+          if conference
+            "CIE x#{conference}-#{number}"
+          else
+            "CIE #{number} #{page}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,8 +8,12 @@ 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
 
@@ -19,11 +23,16 @@ module Pubid
           # 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 +48,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
@@ -52,6 +66,18 @@ module Pubid
 
           result
         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
       end
     end
   end

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

@@ -5,38 +5,40 @@ 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
+        # +number+ (the "-SPN" ordinal) is inherited from SupplementIdentifier.
+        attribute :part, :string # "1" in "SP1.1", "4" in "SP1.4"
+
+        # Uniform supplement interface (shared with Corrigendum).
+        def supplement_type
+          :supplement
+        end
+
+        def supplement_year
+          base&.year
+        end
 
         def to_s
+          b = base
           parts = ["CIE"]
+          parts << b.stage if b.respond_to?(:stage) && b.stage
 
-          # Stage if present (DIS/DS)
-          parts << stage if stage
-
-          # Build base number and supplement
+          core = "#{b.number}-SP#{number}"
+          core += ".#{part}" if part
+          parts << core
           result = parts.join(" ")
-          result += " #{base_number}-SP#{supplement_number}"
-
-          # Add part if present (e.g., ".4" in "SP1.4")
-          result += ".#{supplement_part}" if supplement_part
 
-          # Add language with slash if present (before year)
-          if language && language.format == "slash_colon"
-            result += "/#{language.code}"
+          # Language with slash (before year), e.g. "/E"
+          if b.language && b.language.format == "slash_colon"
+            result += "/#{b.language.code}"
           end
 
-          # Add year with colon (supplements always use current style)
-          result += ":#{year}" if year
-
+          # Supplements always use the current (colon) style.
+          result += ":#{b.year}" if b.year
           result
         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}"
+          "CIE Tutorials Bundle #{number}"
         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

@@ -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

data/lib/pubid/cie/single_identifier.rb

@@ -24,7 +24,46 @@ module Pubid
       attribute :publisher, :string, default: -> { "CIE" }
 
       attribute :year, :string
-      attribute :date_separator, :string # "dash" or "colon"
+      # The number<->year separator character, derived from +style+ (the sole
+      # separator field; there is no date_separator attribute):
+      #   current -> ":"   legacy -> "-"   slash -> "/"
+      def date_sep_char
+        { "legacy" => "-", "slash" => "/" }.fetch(style, ":")
+      end
+
+      # Partial-reference matching: CIE keeps the publication year in its own
+      # `year` string attribute (the separator lives in `style`), not a `Date`
+      # component, so the base's `:year`->`:date` remap would nil the unused
+      # inherited `date` and leave `year` intact. Call super (preserving the
+      # nested-identifier recursion), then nil `year` directly so a year-less
+      # CIE ref is a year wildcard under `matches?(ignore: [:year])`.
+      #
+      # Known limit: `style` (which also encodes the era: current<->colon,
+      # legacy<->dash) is intentionally NOT wildcarded, so bare `CIE 015`
+      # (always current) matches a colon-dated full but not a legacy dash-dated
+      # (pre-2001) one. Partial-ref scope targets modern colon forms.
+      def exclude(*args)
+        result = super
+        result.year = nil if args.include?(:year) || args.include?(:date)
+        result
+      end
+
+      # CIE stores its publication year in its own `year` string attribute
+      # (not a Components::Date), and uses a single-Language component with
+      # multiple formats. Override the lossless MR template so `CIE S 017/E:2011`
+      # round-trips as `CIE.S.017.E.2011` rather than losing the type letter,
+      # language, and year (issue #142). Subclasses add the `s_prefix` and
+      # `language` attributes that this template reads.
+      def mr_year
+        year&.to_s
+      end
+
+      def mr_languages
+        return nil unless respond_to?(:language) && language
+
+        # Lowercase + filename-safe: drop the leading `/` (path-unsafe).
+        language.code.to_s.downcase
+      end
     end
   end
 end

data/lib/pubid/cie/supplement_identifier.rb

@@ -2,25 +2,38 @@
 
 module Pubid
   module Cie
-    # Base class for CIE supplement identifiers
-    # Single Responsibility: Provide common attributes for supplement documents
+    # Base class for CIE supplement identifiers (Supplement, Corrigendum).
     #
-    # Supplement identifiers modify or extend base identifiers.
-    # Unlike ISO/IEC, CIE supplements store base information as flat
-    # string attributes rather than recursive Identifier objects.
+    # Like ISO/IEC/BSI/JCGM, a CIE supplement wraps its base document as a
+    # nested full identifier (+base+, a Pubid::Cie::Identifier),
+    # rather than flat base_number/base_year strings. This lets CIE supplements
+    # participate in the shared base_document / drop_supplements / matches?
+    # vocabulary relaton uses to match a citation to its base standard.
     #
-    # Classes inheriting from SupplementIdentifier:
-    # - Corrigendum (corrigenda with /CorN notation)
-    # - Supplement (supplements with -SPN notation)
-    #
-    # Architecture Note:
-    # CIE uses a different architectural approach than ISO/IEC:
-    # - ISO/IEC: Recursive base_identifier objects
-    # - CIE: Flat string attributes (base_number, base_year, etc.)
+    # Concrete subtypes: Supplement (-SPN), Corrigendum (/CorN).
     class SupplementIdentifier < Identifier
-      # Common attribute for all CIE identifiers
-      # Values: "current" (colon date separator) or "legacy" (dash date separator)
-      attribute :style, :string
+      attribute :base, Identifier, polymorphic: true
+      # The supplement's/corrigendum's own ordinal ("1" in -SP1 / Cor1).
+      # :string overrides the base ::Pubid::Identifier Components::Code type.
+      # (Not the index key — relaton keys on #root.number, the base standard's.)
+      attribute :number, :string
+
+      # Uniform, class-agnostic supplement interface (shared by Supplement and
+      # Corrigendum) so callers never special-case corrigenda. +supplement_type+
+      # and +supplement_year+ are defined per subclass.
+      def supplement_number
+        number
+      end
+
+      # The underlying standard, with supplement layer(s) peeled recursively.
+      def base_document
+        base&.base_document || self
+      end
+
+      # Dropping one supplement layer yields the wrapped base identifier.
+      def drop_supplements
+        base || self
+      end
     end
   end
 end

data/lib/pubid/cie/urn_generator.rb

@@ -15,8 +15,8 @@ module Pubid
 
         parts << publisher_component
 
-        if identifier.code
-          parts << identifier.code.to_s
+        if identifier.respond_to?(:code_string) && identifier.code_string
+          parts << identifier.code_string
         end
 
         year = extract_year
@@ -37,8 +37,8 @@ module Pubid
         stage = maybe(:stage)
         parts << stage.to_s.downcase if stage
 
-        date_separator = maybe(:date_separator)
-        parts << "sep.#{date_separator}" if date_separator
+        # style is the sole separator field; record it for dated identifiers
+        parts << "sep.#{maybe(:style)}" if year
 
         iec_identifier = maybe(:iec_identifier)
         parts << "iec.#{iec_identifier}" if iec_identifier
@@ -49,11 +49,14 @@ module Pubid
         doc_type = maybe(:doc_type)
         parts << "doctype.#{doc_type}" if doc_type
 
-        identifiers_string = maybe(:identifiers_string)
-        parts << "bundle.#{identifiers_string}" if identifiers_string
+        if identifier.respond_to?(:ids) && identifier.ids&.any?
+          parts << "bundle.#{identifier}"
+        end
 
-        bundle_number = maybe(:bundle_number)
-        parts << "tut-bundle.#{bundle_number}" if bundle_number
+        if identifier.is_a?(Cie::Identifiers::TutorialBundle) &&
+           identifier.number
+          parts << "tut-bundle.#{identifier.number}"
+        end
 
         languages = maybe(:languages)
         if languages&.any?

data/lib/pubid/cie.rb

@@ -8,7 +8,6 @@ module Pubid
     PREFIXES = ["CIE"].freeze
 
     module Components
-      autoload :Code, "#{__dir__}/cie/components/code"
       autoload :Language, "#{__dir__}/cie/components/language"
     end
 

data/lib/pubid/components/date.rb

@@ -6,19 +6,33 @@ module Pubid
   module Components
     # Publication date component
     #
-    # Human render: "YYYY" or "YYYY-MM" or "YYYY-MM-DD".
-    # URN render: year only (RFC 5141-bis URN spec).
+    # Human render: "YYYY" or "YYYY-MM" or "YYYY-MM-DD"; or "--" when the
+    # date slot is present but explicitly undated (ISO/IEC undated-reference
+    # convention, e.g. "ISO 16634:--"). URN render: year only (RFC 5141-bis
+    # URN spec); flavors that drop the slot when undated gate that decision
+    # at the URN-generator level, not here.
     class Date < Lutaml::Model::Serializable
       attribute :year, :string
       attribute :month, :string
       attribute :day, :string
+      attribute :undated, :boolean, default: false
 
-      # True when the year is set to a non-empty value.
+      # True when the year is set to a non-empty value, OR the date is
+      # explicitly marked undated. An undated date is a meaningful
+      # publication-date slot (it is what renders as `:--` in ISO/IEC), so
+      # callers that gate rendering on "is there a date at all?" should
+      # treat undated as present.
       def present?
+        return true if undated
         !year.nil? && !year.to_s.empty?
       end
 
+      def undated?
+        !!undated
+      end
+
       def render(context: nil)
+        return "--" if undated? && (year.nil? || year.to_s.empty?)
         return nil unless present?
         return year.to_s if context&.urn?
         return year.to_s unless month
@@ -29,6 +43,7 @@ module Pubid
       end
 
       def to_s(_context: nil, _include_month: false)
+        return "--" if undated? && (year.nil? || year.to_s.empty?)
         return year.to_s unless month
 
         result = "#{year}-#{pad2(month)}"
@@ -43,13 +58,14 @@ module Pubid
       end
 
       def hash
-        @hash ||= [year, month, day].compact.map(&:hash).hash
+        @hash ||= [year, month, day, undated].compact.map(&:hash).hash
       end
 
       def eql?(other)
         return false unless other.is_a?(self.class)
 
-        year == other.year && month == other.month && day == other.day
+        year == other.year && month == other.month && day == other.day &&
+          undated == other.undated
       end
     end
   end

data/lib/pubid/csa/builder.rb

@@ -53,7 +53,7 @@ module Pubid
         # Build base identifier (without package_portion)
         base_data = parsed_hash.dup
         base_data.delete(:package_portion)
-        package.base_identifier = build_single(base_data)
+        package.base = build_single(base_data)
 
         # Set package materials
         if parsed_hash[:package_portion]

data/lib/pubid/csa/composite_identifier.rb

@@ -16,12 +16,28 @@ module Pubid
     class CompositeIdentifier < Lutaml::Model::Serializable
       # The primary/base identifier
       # Use attr_accessor since it can be any identifier object
-      attr_accessor :base_identifier
+      attr_accessor :base
 
       # Subclasses MUST implement to_s to define how they render
       def to_s
         raise NotImplementedError, "Subclasses must implement to_s method"
       end
+
+      # CSA composites serialise through `to_s`, so MR mirrors that with
+      # ` ` → `.`, `:` → `.`, `/` → `-`, then lowercased (issue #142).
+      def to_mr_string
+        to_s.tr(" ", ".").tr(":", ".").tr("/", "-").downcase
+      end
+
+      def to_slug
+        to_mr_string
+      end
+
+      # CSA composites are not Pubid::Identifier objects, so they do not inherit
+      # #root. They are their own origin for matching purposes.
+      def root
+        self
+      end
     end
   end
 end