pubid 1.15.19 → 2.0.0.pre.alpha.2

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
+        attribute :s_prefix, :boolean, default: -> { false }
+        attribute :code, Components::Code
+        attribute :iec_identifier, :string # IEC portion as string
+
+        def to_s
+          parts = ["CIE"]
+
+          # S prefix
+          parts << "S" if s_prefix
+
+          # Code
+          parts << code.to_s if code
+
+          result = parts.join(" ")
+
+          # Date
+          if year
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
+          end
+
+          # IEC portion with slash separator
+          result += "/IEC #{iec_identifier}" if iec_identifier
+
+          result
+        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
+        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
+          parts = ["CIE"]
+
+          # S prefix
+          parts << "S" if s_prefix
+
+          # Code
+          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 && 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
+                      else
+                        "/#{language.code}#{year}" # /E2007 (no colon)
+                      end
+          elsif language && language.format == "slash"
+            # Language without year: /E
+            result += "/#{language.code}"
+          elsif year && date_separator == "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}"
+          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
+
+          result
+        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
+        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
+          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 code
+            code_str = code.to_s
+            # For IEC copublisher, if code has a part, use dot not slash/dash
+            if copublisher == "IEC" && code.part
+              code_str = "#{code.number}.#{code.part}"
+            end
+            parts << code_str
+          end
+
+          result = parts.join(" ")
+
+          # Date - use the actual captured separator
+          if year
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{year}"
+          end
+
+          # Language (always parenthetical for joint published)
+          result += language.to_s if language
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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
+        attribute :s_prefix, :boolean, default: -> { false }
+        attribute :code, Components::Code
+        attribute :language, Components::Language
+        attribute :stage, :string # DIS, DS
+
+        def to_s
+          parts = ["CIE"]
+
+          # Stage (DIS/DS) before code if present
+          parts << stage if stage
+
+          # S prefix
+          parts << "S" if s_prefix
+
+          # Code
+          parts << code.to_s if code
+
+          # 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
+
+          # Date with separator (for non-slash-colon formats)
+          if year
+            separator = date_separator == "colon" ? ":" : "-"
+            result += "#{separator}#{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,45 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Cie
+    module Identifiers
+      # 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
+        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"]
+
+          # Stage if present (DIS/DS)
+          parts << stage if stage
+
+          # Build base number and supplement
+          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}"
+          end
+
+          # Add year with colon (supplements always use current style)
+          result += ":#{year}" if year
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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
+      class TutorialBundle < SingleIdentifier
+        attribute :bundle_number, :string
+
+        def to_s
+          "CIE Tutorials Bundle #{bundle_number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cie/identifiers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    module Identifiers
+      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 :Standard, "#{__dir__}/identifiers/standard"
+      autoload :Supplement, "#{__dir__}/identifiers/supplement"
+      autoload :TutorialBundle, "#{__dir__}/identifiers/tutorial_bundle"
+    end
+  end
+end

data/lib/pubid/cie/parser.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Cie
+    # Parser for CIE identifiers
+    # Handles dual-style system (legacy vs current)
+    class Parser < Parslet::Parser
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:dash) { str("-") }
+      rule(:colon) { str(":") }
+      rule(:dot) { str(".") }
+      rule(:slash) { str("/") }
+      rule(:comma) { str(",") }
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:upper) { match("[A-Z]") }
+      rule(:lower) { match("[a-z]") }
+
+      # Year (4 digits: 1900-2099)
+      rule(:year_digits) do
+        (str("19") | str("20")) >> digit.repeat(2, 2)
+      end
+
+      # Date with separator detection (CRITICAL for style)
+      # Legacy: dash "-" (pre-2001)
+      # Current: colon ":" (2001+)
+      rule(:legacy_date) do
+        (dash >> year_digits.as(:year)).as(:legacy_date)
+      end
+
+      rule(:current_date) do
+        (colon >> year_digits.as(:year)).as(:current_date)
+      end
+
+      rule(:date) do
+        current_date | legacy_date
+      end
+
+      # Legacy format: NUMBER-YEAR (e.g., 001-1980)
+      # This is BEFORE 2001, using dash as year separator (NOT part)
+      # Can optionally have trailing language like "(RU-2020)"
+      rule(:legacy_code_with_year) do
+        str("CIE") >> space >> digits.as(:number) >> dash >> year_digits.as(:year) >>
+          (language_paren_year | str("")).as(:trailing_lang)
+      end
+
+      # Code patterns
+      # Pattern 1: "006.1" - iteration (leading zero + dot)
+      rule(:code_with_iteration) do
+        digits.as(:number) >> dot >> digits.as(:iteration)
+      end
+
+      # Pattern 1b: "19/2.1" - part with slash THEN iteration with dot (complex)
+      rule(:code_with_part_and_iteration_slash) do
+        digits.as(:number) >> slash >> digits.as(:part) >> dot >> digits.as(:iteration)
+      end
+
+      # Pattern 1c: "19-2.1" - part with dash THEN iteration with dot (complex)
+      rule(:code_with_part_and_iteration_dash) do
+        digits.as(:number) >> dash >> digits.as(:part) >> dot >> digits.as(:iteration) >>
+          dash.absent? # Don't consume date dash
+      end
+
+      # Pattern 2: "170-1" - part with dash (current style)
+      # NOTE: Part must be 1-3 digits, and NOT followed by a 4-digit year
+      rule(:code_with_part_dash) do
+        digits.as(:number) >> dash >> match("[0-9]").repeat(1, 3).as(:part) >>
+          str("").as(:dash_sep) >> # Marker for dash separator
+          # Negative lookahead: don't consume if followed by 4-digit year
+          (str("19") | str("20")).absent? >>
+          (dot | dash).absent? # Don't consume dot or date dash
+      end
+
+      # Pattern 3: "170/1" - part with slash (legacy style)
+      rule(:code_with_part_slash) do
+        digits.as(:number) >> slash >> digits.as(:part) >>
+          str("").as(:slash_sep) >> # Marker for slash separator
+          dot.absent? # Don't consume iteration dot
+      end
+
+      # Pattern 4: Simple number
+      rule(:code_simple) do
+        digits.as(:number)
+      end
+
+      # Code rule (longest match first - complex patterns before simple)
+      rule(:code) do
+        code_with_part_and_iteration_slash |
+          code_with_part_and_iteration_dash |
+          code_with_iteration |
+          code_with_part_slash |
+          code_with_part_dash |
+          code_simple
+      end
+
+      # Language patterns
+      # Format 1: /E, /F, /G (slash-prefix, legacy)
+      rule(:language_slash) do
+        (slash >> upper.as(:lang_code)).as(:language_slash)
+      end
+
+      # Format 2: (DE), (ES), (CN), (en), (E), (F), (G)
+      rule(:language_paren) do
+        (str("(") >> match("[A-Za-z]").repeat(1,
+                                              3).as(:lang_code) >> str(")")).as(:language_paren)
+      end
+
+      # Format 3: (RU-2021) - with translation year
+      # NOTE: The space before parenthesis is OPTIONAL (e.g., "2003 (RU-2021)" or "2003(RU-2021)")
+      rule(:language_paren_year) do
+        (space.maybe >> str("(") >> upper.repeat(2).as(:lang_code) >>
+        dash >> year_digits.as(:trans_year) >> str(")")).as(:language_paren_year)
+      end
+
+      rule(:language) do
+        language_paren_year | language_paren | language_slash
+      end
+
+      # S prefix (optional "Standard" marker)
+      rule(:s_prefix) do
+        str("S") >> space
+      end
+
+      # Conference x-prefix
+      rule(:x_prefix) do
+        str("x")
+      end
+
+      # Stage codes (DIS, DS, FDIS, etc.)
+      rule(:stage_code) do
+        (str("FDIS") | str("DIS") | str("DS")) >> space
+      end
+
+      # Document type (TR for Technical Report)
+      rule(:doc_type) do
+        str("TR") # Don't consume trailing space
+      end
+
+      # DIS stage with supplement pattern (e.g., DIS 025-SP1/E:2019)
+      rule(:dis_with_supplement) do
+        str("CIE") >> space >>
+          stage_code.as(:stage) >>
+          s_prefix.maybe.as(:s_prefix) >>
+          digits.as(:base_number) >>
+          dash >> str("SP") >> digits.as(:supplement_number) >>
+          (dot >> digits.as(:supplement_part)).maybe >>
+          slash >> upper.as(:lang_code) >> colon.as(:lang_colon) >> year_digits.as(:year)
+      end
+
+      # Standard identifier (most common) - language can come AFTER date
+      rule(:standard_identifier) do
+        str("CIE") >> space >>
+          stage_code.maybe.as(:stage) >>
+          s_prefix.maybe.as(:s_prefix) >>
+          code >>
+          # Language can come BEFORE date, AFTER date, or both
+          (
+            (language >> date).as(:lang_before) |
+            (date >> language.maybe).as(:date_then_lang) |
+            date
+          )
+      end
+
+      # Standard identifier without ISO reference but with language-year (CIE S 014-4/E:2007)
+      rule(:standard_with_language_year) do
+        str("CIE") >> space >>
+          stage_code.maybe.as(:stage) >>
+          s_prefix.maybe.as(:s_prefix) >>
+          code >>
+          slash >> upper.as(:lang_code) >> colon.as(:lang_colon) >> year_digits.as(:year)
+      end
+
+      # Conference identifier (x-prefix)
+      rule(:conference_identifier) do
+        str("CIE") >> space >>
+          x_prefix.as(:conference) >>
+          digits.as(:conf_number) >>
+          date >>
+          # Optional amendment
+          (space >> str("Amendment") >> space >> digits.as(:amd_number)).maybe
+      end
+
+      # Joint published with ISO
+      rule(:joint_with_iso) do
+        str("CIE") >> space >>
+          str("ISO").as(:copublisher) >> # Match and mark once
+          (slash >> str("CIE")).absent? >> # Make sure it's not "ISO/CIE"
+          space >>
+          (doc_type >> space).maybe.as(:doc_type) >> # Consume space here
+          stage_code.maybe.as(:stage) >>
+          digits.as(:number) >>
+          (dash >> digits.as(:part)).maybe >>
+          ((colon >> year_digits.as(:year)) | (dash >> year_digits.as(:year))).maybe >>
+          language.maybe
+      end
+
+      # Joint with ISO/CIE (special case)
+      rule(:joint_with_iso_cie) do
+        str("CIE") >> space >>
+          str("ISO/CIE").as(:copublisher) >> # Match and mark once
+          space >>
+          (doc_type >> space).maybe.as(:doc_type) >> # Consume space here
+          digits.as(:number) >>
+          (colon >> year_digits.as(:year)).maybe >>
+          language.maybe
+      end
+
+      # Joint published with IEC
+      rule(:joint_with_iec) do
+        str("CIE") >> space >>
+          str("IEC").as(:copublisher) >> # Match and mark once
+          space >>
+          digits.as(:number) >>
+          dot >> digits.as(:part) >> # IEC always uses dot
+          dash >> year_digits.as(:year)
+      end
+
+      # Identical with ISO (parenthetical reference)
+      # Patterns:
+      # "CIE S 006.1/1998 (ISO 16508:1999)" - iteration with dot
+      # "CIE S 014-4/E2007" - part with dash + language without colon (needs colon insertion)
+      # "CIE S 008/E:2001 (ISO 8995-1:2002(E))" - language with colon year
+      rule(:identical_with_iso) do
+        str("CIE") >> space >>
+          s_prefix.maybe.as(:s_prefix) >>
+          digits.as(:number) >>
+          # Can have iteration (.1) OR part (-4)
+          (
+            (dot >> digits.as(:iteration)) |
+            (dash >> digits.as(:part))
+          ).maybe >>
+          # Slash handling - three mutually exclusive patterns:
+          (slash >>
+            (
+              # /E:2001 - language code WITH colon year
+              (upper.as(:lang_code) >> colon.as(:lang_colon) >> year_digits.as(:year)) |
+              # /E2007 - language code WITHOUT colon + year (needs colon insertion)
+              (upper.as(:lang_code) >> year_digits.as(:year)) |
+              # /1998 - just legacy slash-year (no language)
+              year_digits.as(:slash_year)
+            )
+          ).maybe >>
+          # ISO reference - handle nested parentheses for language codes
+          space >> str("(ISO") >> space >>
+          # Match ISO identifier: digits, colons, dashes, slashes, dots
+          # Plus optional language code in parentheses like (E), (F)
+          (
+            match("[0-9A-Z:/.\\-]").repeat(1) >> # Main ISO identifier
+            (str("(") >> match("[A-Z]").repeat(1) >> str(")")).maybe # Optional (E), (F), etc.
+          ).as(:iso_reference) >>
+          str(")")
+      end
+
+      # Dual published with IEC (slash separator between full identifiers)
+      # Pattern: "CIE S 009:2002/IEC 62471:2006"
+      rule(:dual_with_iec) do
+        str("CIE") >> space >>
+          s_prefix.maybe.as(:s_prefix) >>
+          digits.as(:number) >>
+          colon >> year_digits.as(:year) >>
+          slash >> str("IEC") >> space >>
+          match("[^)\\n]").repeat(1).as(:iec_identifier)
+      end
+
+      # Supplement identifier (-SPN notation)
+      rule(:supplement_identifier) do
+        str("CIE") >> space >>
+          digits.as(:base_number) >>
+          dash >> str("SP") >> digits.as(:supplement_number) >>
+          (dot >> digits.as(:supplement_part)).maybe >>
+          colon >> year_digits.as(:year)
+      end
+
+      # Corrigendum identifier (/CorN notation)
+      rule(:corrigendum_identifier) do
+        # Parse base identifier first (could be supplement or standard)
+        str("CIE") >> space >>
+          digits.as(:base_number) >>
+          # Could have supplement notation before corrigendum
+          (dash >> str("SP") >> digits.as(:base_supplement) >>
+           (dot >> digits.as(:base_supplement_part)).maybe).maybe >>
+          colon >> year_digits.as(:base_year) >>
+          # Corrigendum portion
+          slash >> str("Cor") >> digits.as(:cor_number) >>
+          colon >> year_digits.as(:cor_year)
+      end
+
+      # Bundle identifier (comma-separated list)
+      rule(:bundle_identifier) do
+        str("CIE") >> space >>
+          digits.as(:first_number) >>
+          dash >> str("SP") >> digits >> dot >> digits >>
+          colon >> year_digits >>
+          (comma >> digits.as(:next_number) >>
+           dash >> str("SP") >> digits >> dot >> digits >>
+           colon >> year_digits).repeat(1).as(:bundle_items)
+      end
+
+      # Tutorial Bundle
+      rule(:tutorial_bundle) do
+        str("CIE Tutorials Bundle") >> space >> digits.as(:bundle_number)
+      end
+
+      # Main identifier rule (longest/most specific first)
+      root(:identifier)
+
+      rule(:identifier) do
+        tutorial_bundle |
+          bundle_identifier |
+          joint_with_iso_cie |
+          joint_with_iso |
+          joint_with_iec |
+          identical_with_iso |
+          dis_with_supplement |
+          dual_with_iec |
+          corrigendum_identifier |
+          supplement_identifier |
+          standard_with_language_year |
+          legacy_code_with_year | # Before standard to catch 001-1980 pattern
+          conference_identifier |
+          standard_identifier
+      end
+
+      # Class method for parsing with preprocessing
+      def self.parse(string)
+        # Minimal preprocessing for data quality
+        cleaned = string.strip
+
+        # Remove comments (text after #)
+        cleaned = cleaned.gsub(/\s*#.*$/, "")
+
+        # Normalize spaces
+        cleaned = cleaned.gsub(/\s+/, " ")
+
+        # Insert missing colon before year in language patterns like /E2007 -> /E:2007
+        # This is a data quality fix - correct format always has colon
+        cleaned = cleaned.gsub(%r{/(E|F|G|DE|ES|CN|RU|FR)(\d{4})}, '/\1:\2')
+
+        new.parse(cleaned)
+      end
+    end
+  end
+end