pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Conference identifier for CIE
+      # Handles x-prefix conference proceedings
+      # Example: CIE x038:2013, CIE x038:2013 Amendment 1
+      class Conference < SingleIdentifier
+        # :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(**opts)
+          result = "CIE x#{number}"
+
+          # Date with separator
+          if 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
+
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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.
+      # 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
+
+        # Uniform supplement interface (shared with Supplement).
+        def supplement_type
+          :corrigendum
+        end
+
+        def supplement_year
+          year
+        end
+
+        def to_s(**opts)
+          annotate_plain_render("#{base}/Cor#{number}:#{year}", **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Dual published identifier for CIE
+      # 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 :iec_identifier, :string # IEC portion as string
+
+        def to_s(**opts)
+          parts = ["CIE"]
+
+          # S prefix
+          parts << "S" if s_prefix
+
+          # Code
+          parts << code_string if number
+
+          result = parts.join(" ")
+
+          # Date
+          if year
+            result += "#{date_sep_char}#{year}"
+          end
+
+          # IEC portion with slash separator
+          result += "/IEC #{iec_identifier}" if iec_identifier
+
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # Identical identifier for CIE
+      # Represents CIE identifiers with ISO reference
+      # Examples:
+      #   CIE S 006.1/1998 (ISO 16508:1999) - iteration with dot
+      #   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 :language, Components::Language
+        attribute :iso_reference, :string # The ISO identifier in parentheses
+
+        def to_s(**opts)
+          parts = ["CIE"]
+
+          # S prefix
+          parts << "S" if s_prefix
+
+          # 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 && 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
+                      else
+                        "/#{language.code}#{year}" # /E2007 (no colon)
+                      end
+          elsif language && language.format == "slash"
+            # Language without year: /E
+            result += "/#{language.code}"
+          elsif year && style == "slash"
+            # Legacy slash-year format without language: /1998
+            result += "/#{year}"
+          elsif year
+            # Standard date with separator derived from style
+            result += "#{date_sep_char}#{year}"
+          end
+
+          # Language (parenthetical) after date
+          if language && language.format != "slash" && language.format != "slash_colon"
+            result += language.to_s
+          end
+
+          # ISO reference in parentheses
+          result += " (ISO #{iso_reference})" if iso_reference
+
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # 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 :language, Components::Language
+        attribute :doc_type, :string          # "TR" for Technical Report
+        attribute :stage, :string             # "DIS" for draft stage
+
+        def to_s(**opts)
+          parts = ["CIE", copublisher]
+
+          # Document type (TR)
+          parts << doc_type if doc_type
+
+          # Stage (DIS)
+          parts << stage if stage
+
+          # Code (number-part) - special handling for IEC dot separator
+          if number
+            code_str = code_string
+            # For IEC copublisher, if code has a part, use dot not slash/dash
+            if copublisher == "IEC" && part
+              code_str = "#{number}.#{part}"
+            end
+            parts << code_str
+          end
+
+          result = parts.join(" ")
+
+          # Date - separator derived from style
+          if year
+            result += "#{date_sep_char}#{year}"
+          end
+
+          # Language (always parenthetical for joint published)
+          result += language.to_s if language
+
+          annotate_plain_render(result, **opts)
+        end
+      end
+    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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # 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 :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
+          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
+
+            # Code
+            parts << code_string if number
+          end
+
+          # Build initial result from parts
+          result = parts.join(" ")
+
+          # Language (slash format without year) - appended before date
+          if language && language.format == "slash"
+            result += "/#{language.code}"
+          end
+
+          # Language (slash_colon format with year) - language/colon/year as unit
+          if language && language.format == "slash_colon"
+            result += "/#{language.code}:#{year}"
+            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}"
+          end
+
+          # Language (parenthetical formats) - comes after date
+          if language && !["slash", "slash_colon"].include?(language.format)
+            result += language.to_s
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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.
+      # 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
+          parts = ["CIE"]
+          parts << b.stage if b.respond_to?(:stage) && b.stage
+
+          core = "#{b.number}-SP#{number}"
+          core += ".#{part}" if part
+          parts << core
+          result = parts.join(" ")
+
+          # Language with slash (before year), e.g. "/E"
+          if b.language && b.language.format == "slash_colon"
+            result += "/#{b.language.code}"
+          end
+
+          # Supplements always use the current (colon) style.
+          result += ":#{b.year}" if b.year
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # 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
+
+        def to_s(**opts)
+          annotate_plain_render("CIE Tutorials Bundle #{number}", **opts)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/identifiers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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"
+    end
+  end
+end