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

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

@@ -5,28 +5,34 @@ require "lutaml/model"
 module Pubid
   module Cie
     module Identifiers
-      # 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.
+      # Corrigendum identifier for CIE
+      # Handles /CorN notation with recursive base parsing
       # Examples: CIE 232:2019/Cor1:2020, CIE 198-SP1.4:2011/Cor1:2013
       class Corrigendum < SupplementIdentifier
-        # +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
+        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
 
-        # Uniform supplement interface (shared with Supplement).
-        def supplement_type
-          :corrigendum
-        end
+        def to_s
+          # Build base identifier string
+          result = "CIE #{base_number}"
 
-        def supplement_year
-          year
-        end
+          # 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
+
+          # Add corrigendum with slash and colon
+          result += "/Cor#{cor_number}:#{cor_year}"
 
-        def to_s(**opts)
-          annotate_plain_render("#{base}/Cor#{number}:#{year}", **opts)
+          result
         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(**opts)
+        def to_s
           parts = ["CIE"]
 
           # S prefix
           parts << "S" if s_prefix
 
           # Code
-          parts << code_string if number
+          parts << code.to_s if code
 
           result = parts.join(" ")
 
           # Date
           if year
-            result += "#{date_sep_char}#{year}"
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
           end
 
           # IEC portion with slash separator
           result += "/IEC #{iec_identifier}" if iec_identifier
 
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end

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

@@ -12,25 +12,24 @@ 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(**opts)
+        def to_s
           parts = ["CIE"]
 
           # S prefix
           parts << "S" if s_prefix
 
           # Code
-          parts << code_string if number
+          parts << code.to_s if code
 
           result = parts.join(" ")
 
           # Language + Year combined for slash formats before ISO reference
-          if language && (language.format == "slash_colon" || (language.format == "slash" && year && style != "slash"))
+          if language && (language.format == "slash_colon" || (language.format == "slash" && year && date_separator != "slash"))
             # Render /E:YYYY or /EYYYY (language with year, no separate date separator)
             result += if language.format == "slash_colon"
                         "/#{language.code}:#{year}" # /E:2001
@@ -40,12 +39,13 @@ module Pubid
           elsif language && language.format == "slash"
             # Language without year: /E
             result += "/#{language.code}"
-          elsif year && style == "slash"
+          elsif year && date_separator == "slash"
             # Legacy slash-year format without language: /1998
             result += "/#{year}"
           elsif year
-            # Standard date with separator derived from style
-            result += "#{date_sep_char}#{year}"
+            # Standard date with separator (colon or dash)
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
           end
 
           # Language (parenthetical) after date
@@ -56,7 +56,7 @@ module Pubid
           # ISO reference in parentheses
           result += " (ISO #{iso_reference})" if iso_reference
 
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end

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

@@ -8,14 +8,13 @@ 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(**opts)
+        def to_s
           parts = ["CIE", copublisher]
 
           # Document type (TR)
@@ -25,26 +24,27 @@ module Pubid
           parts << stage if stage
 
           # Code (number-part) - special handling for IEC dot separator
-          if number
-            code_str = code_string
+          if code
+            code_str = code.to_s
             # For IEC copublisher, if code has a part, use dot not slash/dash
-            if copublisher == "IEC" && part
-              code_str = "#{number}.#{part}"
+            if copublisher == "IEC" && code.part
+              code_str = "#{code.number}.#{code.part}"
             end
             parts << code_str
           end
 
           result = parts.join(" ")
 
-          # Date - separator derived from style
+          # Date - use the actual captured separator
           if year
-            result += "#{date_sep_char}#{year}"
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
           end
 
           # Language (always parenthetical for joint published)
           result += language.to_s if language
 
-          annotate_plain_render(result, **opts)
+          result
         end
       end
     end

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

@@ -8,52 +8,22 @@ 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 }
-        # 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 :code, Components::Code
         attribute :language, Components::Language
         attribute :stage, :string # DIS, DS
 
-        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
+        def to_s
           parts = ["CIE"]
 
           # Stage (DIS/DS) before code if present
           parts << stage if stage
 
-          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
+          # S prefix
+          parts << "S" if s_prefix
 
-            # Code
-            parts << code_string if number
-          end
+          # Code
+          parts << code.to_s if code
 
           # Build initial result from parts
           result = parts.join(" ")
@@ -69,15 +39,10 @@ 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
-            result += "#{date_sep_char}#{year}"
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
           end
 
           # Language (parenthetical formats) - comes after date

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

@@ -5,41 +5,39 @@ require "lutaml/model"
 module Pubid
   module Cie
     module Identifiers
-      # 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.
+      # Supplement identifier for CIE
+      # Handles -SPN and -SPN.P notation with recursive base parsing
       # Examples: CIE 121-SP1:2009, CIE 198-SP1.4:2011, CIE DIS 025-SP1/E:2019
       class Supplement < SupplementIdentifier
-        # +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(**opts)
-          b = base
+        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"]
-          parts << b.stage if b.respond_to?(:stage) && b.stage
 
-          core = "#{b.number}-SP#{number}"
-          core += ".#{part}" if part
-          parts << core
+          # Stage if present (DIS/DS)
+          parts << stage if stage
+
+          # Build base number and supplement
           result = parts.join(" ")
+          result += " #{base_number}-SP#{supplement_number}"
 
-          # Language with slash (before year), e.g. "/E"
-          if b.language && b.language.format == "slash_colon"
-            result += "/#{b.language.code}"
+          # 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}"
           end
 
-          # Supplements always use the current (colon) style.
-          result += ":#{b.year}" if b.year
-          annotate_plain_render(result, **opts)
+          # Add year with colon (supplements always use current style)
+          result += ":#{year}" if year
+
+          result
         end
       end
     end

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

@@ -8,15 +8,11 @@ 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
-        # :string overrides the base ::Pubid::Identifier Components::Code type.
-        attribute :number, :string
+        attribute :bundle_number, :string
 
-        def to_s(**opts)
-          annotate_plain_render("CIE Tutorials Bundle #{number}", **opts)
+        def to_s
+          "CIE Tutorials Bundle #{bundle_number}"
         end
       end
     end

data/lib/pubid/cie/identifiers.rb

@@ -3,14 +3,12 @@
 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 < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       # Basic building blocks
       rule(:space) { str(" ") }
       rule(:space?) { space.maybe }
@@ -135,50 +135,9 @@ module Pubid
         (str("FDIS") | str("DIS") | str("DS")) >> space
       end
 
-      # Document type (TR for Technical Report, TS for Technical Specification)
+      # Document type (TR for Technical Report)
       rule(:doc_type) do
-        (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)
+        str("TR") # Don't consume trailing space
       end
 
       # DIS stage with supplement pattern (e.g., DIS 025-SP1/E:2019)
@@ -198,14 +157,12 @@ module Pubid
           stage_code.maybe.as(:stage) >>
           s_prefix.maybe.as(:s_prefix) >>
           code >>
-          # 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 can come BEFORE date, AFTER date, or both
           (
             (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)
@@ -224,9 +181,7 @@ module Pubid
           digits.as(:conf_number) >>
           date >>
           # Optional amendment
-          (space >> str("Amendment") >> space >> digits.as(:amd_number)).maybe >>
-          # Optional techstreet opaque /slug variant
-          variant_slug.maybe
+          (space >> str("Amendment") >> space >> digits.as(:amd_number)).maybe
       end
 
       # Joint published with ISO
@@ -365,10 +320,6 @@ 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/scheme.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Standard,
+            Identifiers::Conference,
+            Identifiers::Bundle,
+            Identifiers::DualPublished,
+            Identifiers::Identical,
+            Identifiers::JointPublished,
+            Identifiers::Supplement,
+            Identifiers::TutorialBundle,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Corrigendum,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def supplement_typed_stages
+          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "" if abbr.nil?
+
+          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/single_identifier.rb

@@ -18,52 +18,13 @@ module Pubid
     # - Identical (identical to ISO publications)
     # - TutorialBundle (tutorial bundles)
     class SingleIdentifier < Identifier
-      # Stored as a plain string (always "CIE") so it round-trips through
-      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
-      # serialize a String against the Components::Publisher attribute and raise.
-      attribute :publisher, :string, default: -> { "CIE" }
-
-      attribute :year, :string
-      # 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, ":")
+      # CIE uses a fixed publisher string
+      def publisher
+        "CIE"
       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
+      attribute :year, :string
+      attribute :date_separator, :string # "dash" or "colon"
     end
   end
 end

data/lib/pubid/cie/supplement_identifier.rb

@@ -2,38 +2,25 @@
 
 module Pubid
   module Cie
-    # Base class for CIE supplement identifiers (Supplement, Corrigendum).
+    # Base class for CIE supplement identifiers
+    # Single Responsibility: Provide common attributes for supplement documents
     #
-    # 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.
+    # Supplement identifiers modify or extend base identifiers.
+    # Unlike ISO/IEC, CIE supplements store base information as flat
+    # string attributes rather than recursive Identifier objects.
     #
-    # Concrete subtypes: Supplement (-SPN), Corrigendum (/CorN).
+    # 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.)
     class SupplementIdentifier < Identifier
-      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
+      # Common attribute for all CIE identifiers
+      # Values: "current" (colon date separator) or "legacy" (dash date separator)
+      attribute :style, :string
     end
   end
 end