pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/cie/parser.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Cie
+    # Parser for CIE identifiers
+    # Handles dual-style system (legacy vs current)
+    class Parser < ::Pubid::Parser::Grammar
+      # 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, TS for Technical Specification)
+      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)
+      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.
+          # 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)
+      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 >>
+          # Optional techstreet opaque /slug variant
+          variant_slug.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 |
+          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
+      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

data/lib/pubid/cie/single_identifier.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Base class for single CIE identifiers (standards, conferences, etc.)
+    # Single Responsibility: Provide common attributes for base documents
+    #
+    # Single identifiers are base documents that can exist independently,
+    # as opposed to supplement identifiers (amendments, corrigenda) which
+    # modify a base identifier.
+    #
+    # Classes inheriting from SingleIdentifier:
+    # - Standard (common CIE publications)
+    # - Conference (conference proceedings)
+    # - Bundle (bundles of multiple identifiers)
+    # - JointPublished (co-published with ISO/IEC)
+    # - DualPublished (dual published with IEC)
+    # - 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, ":")
+      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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Base class for CIE supplement identifiers (Supplement, Corrigendum).
+    #
+    # 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.
+    #
+    # Concrete subtypes: Supplement (-SPN), Corrigendum (/CorN).
+    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
+    end
+  end
+end

data/lib/pubid/cie/urn_generator.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "cie"]
+
+        special_type = special_identifier_type_component
+        parts << special_type if special_type
+
+        if maybe(:s_prefix)
+          parts << "s"
+        end
+
+        parts << publisher_component
+
+        if identifier.respond_to?(:code_string) && identifier.code_string
+          parts << identifier.code_string
+        end
+
+        year = extract_year
+        parts << year.to_s if year
+
+        language = maybe(:language)
+        if language
+          if language&.code
+            parts << language.code.to_s.downcase
+            if language&.format
+              parts << language.format.to_s.downcase
+            end
+          else
+            parts << language.to_s.downcase
+          end
+        end
+
+        stage = maybe(:stage)
+        parts << stage.to_s.downcase if stage
+
+        # 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
+
+        iso_reference = maybe(:iso_reference)
+        parts << "iso.#{iso_reference}" if iso_reference
+
+        doc_type = maybe(:doc_type)
+        parts << "doctype.#{doc_type}" if doc_type
+
+        if identifier.respond_to?(:ids) && identifier.ids&.any?
+          parts << "bundle.#{identifier}"
+        end
+
+        if identifier.is_a?(Cie::Identifiers::TutorialBundle) &&
+           identifier.number
+          parts << "tut-bundle.#{identifier.number}"
+        end
+
+        languages = maybe(:languages)
+        if languages&.any?
+          lang_codes = languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      private
+
+      def extract_year
+        year = maybe(:year)
+        return year if year
+
+        date = identifier.date
+        if date
+          return date.year
+        end
+
+        nil
+      end
+
+      def special_identifier_type_component
+        return nil unless identifier.class
+
+        class_name = identifier.class.name.to_s
+        case class_name
+        when /DualPublished/
+          "dual-pub"
+        when /Identical/
+          "identical"
+        when /JointPublished/
+          "joint-pub"
+        when /Bundle$/
+          "bundle"
+        when /TutorialBundle/
+          "tut-bundle"
+        end
+      end
+
+      def publisher_component
+        pub = "cie"
+
+        if identifier.publisher
+          p = identifier.publisher.to_s
+          pub = p.to_s.downcase
+        end
+
+        copublisher = maybe(:copublisher)
+        if copublisher
+          cp = copublisher.to_s
+          pub = "#{pub}-#{cp.to_s.downcase}"
+        else
+          copubs = maybe(:copublishers)
+          if copubs&.any?
+            cp = copubs.map(&:to_s)
+            pub = "#{pub}-#{cp.join('-').downcase}"
+          end
+        end
+
+        pub
+      end
+    end
+  end
+end

data/lib/pubid/cie/urn_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    # Parses CIE URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:cie:cie:{code}:{year}:sep.colon
+    #
+    # The trailing `sep.colon` token records the code/year separator used
+    # in the human-readable form (`:`). The leading `cie` after the
+    # namespace is the lowercase publisher.
+    #
+    # Examples:
+    # - urn:cie:cie:015:2018:sep.colon → CIE 015:2018
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject { |p| p.start_with?("sep.") }
+
+        _publisher, code, year = parts
+        text = "CIE #{code}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end