pubid 1.15.17 → 2.0.0.pre.alpha.1

data/lib/pubid/iec/parser.rb

@@ -0,0 +1,412 @@
+require "parslet"
+# frozen_string_literal: true
+require_relative "../parser/common_parse_rules"
+require_relative "../parser/common_parse_methods"
+require_relative "identifier"
+require_relative "supplement_identifier"
+
+module Pubid
+  module Iec
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      DASH_CHARS = ["-", "‑", "‐"].freeze
+
+      # We need to sort by length to match longest first because that's how Parslet works
+      TYPED_STAGES = Pubid::Iec::Scheme.typed_stages
+        .map(&:abbr).flatten.sort_by(&:length).reverse
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Iec::Scheme.supplement_typed_stages
+        .map(&:abbr).flatten.sort_by(&:length).reverse
+
+      root :identifier
+
+      rule(:identifier) do
+        working_programme_with_publisher |
+          working_programme |
+          working_document |
+          sheet_supplement_identifier |
+          sheet_identifier |
+          supplement_supplement_identifier |
+          standalone_supplement |
+          supplement_identifier |
+          joint_identifier |
+          identifier_copublishers
+      end
+
+      # Working Programme format: [PWI|PNW] [TR] number edition
+      # Examples: "PWI TR 100-36 ED1", "PWI 100-44 ED1", "PNW 65-915 ED1"
+      # TC-style names: "PWI TR SYCSMARTENERGY-1", "PWI SyCLVDC-1 ED1"
+      rule(:working_programme) do
+        (str("PWI") | str("PNW")).as(:wp_stage) >>
+          space >>
+          (
+            (str("TR") >> space) |
+            (str("TS") >> space) |
+            (str("SRD") >> space)
+          ).maybe.as(:wp_type) >>
+          wp_number >>
+          (space >> edition).maybe
+      end
+
+      # Working Programme with publisher prefix: IEC/PWI [TR] number edition
+      # Examples: "IEC/PWI 60038", "ISO/IEC/PWI TR 100-36 ED1"
+      rule(:working_programme_with_publisher) do
+        prefix_with_copublishers >> str("/") >>
+          (str("PWI") | str("PNW")).as(:wp_stage) >>
+          space >>
+          (
+            (str("TR") >> space) |
+            (str("TS") >> space) |
+            (str("SRD") >> space)
+          ).maybe.as(:wp_type) >>
+          wp_number >>
+          (space >> edition).maybe
+      end
+
+      # Working programme numbers can be digits or TC names
+      rule(:wp_number) do
+        # TC-style: SYCSMARTENERGY-1, SyCLVDC-125
+        (match("[A-Za-z]").repeat(1) >> match('[A-Za-z\d]').repeat >> (dash >> match('\d').repeat(1)).maybe).as(:number_with_part) |
+          # Regular numeric: 100-36
+          number_with_part
+      end
+
+      # Working Document format: TC/number/stage
+      # TC can be: slashes (CIS/D), hyphens (JTC1-SC41), simple (100, 86B, ACEA, SyCSmartEnergy)
+      # Examples: "CIS/D/468A/CC", "JTC1-SC41/251/FDIS", "100/3705(F)/FDIS", "86B/4347A/CC"
+      rule(:working_document) do
+        # TC patterns: digits (100), letters (ACEA), letters/letters (CIS/D), or complex (JTC1-SC41)
+        (
+          # Try specific patterns first
+          (str("JTC1-SC") >> match('\d').repeat(1)) | # JTC1-SC41
+          (match("[A-Z]").repeat(1) >> str("/") >> match("[A-Z]").repeat(1)) | # CIS/D
+          match('[A-Za-z\d]').repeat(1) # Simple: 100, 86B, ACEA, SyCSmartEnergy
+        ).as(:technical_committee) >>
+          str("/") >>
+          match('[A-Za-z\d]').repeat(1).as(:wd_number) >>
+          (str("(") >> match("[A-Z]").as(:wd_language) >> str(")")).maybe >>
+          (str("/") >> match("[A-Z]").repeat(1).as(:wd_stage)).maybe
+      end
+
+      # IEC 60038:2009
+      # ISO/IEC 17025:2017
+      # CISPR 11:2015 (special IEC publisher)
+      # IECQ 080000:2017 (special IEC publisher)
+      # IECEE (IEC System for Conformity Assessment)
+      # IECEx (IEC System for Certification to Standards)
+      # IEC CA (IEC Conformity Assessment)
+      # IECQ CS (IECQ Component Specifications)
+      # IECQ OD (IECQ Operational Documents)
+      rule(:prefix_sole_publisher) do
+        (
+          str("IECQ OD") |
+          str("IECQ CS") |
+          str("IEC CAB") |
+          str("IEC CA") |
+          str("IECRE") |
+          str("CISPR") |
+          str("IECEE") |
+          str("IECEx") |
+          str("IECQ") |
+          str("IEC") |
+          str("ISO")
+        ).as(:publisher)
+      end
+
+      # ISO/IEC or IEC
+      rule(:prefix_with_copublishers) do
+        prefix_sole_publisher >> space? >> copublishers.maybe
+      end
+
+      ORGANIZATIONS = %w[
+        IEC ISO IEEE CIW SAE CIE ASME ASTM OECD HL7 CEI UNDP
+      ].freeze
+      rule(:copublishers) do
+        (str("/") >> space? >> array_to_str(ORGANIZATIONS).as(:copublisher)).repeat.as(:copublishers)
+      end
+
+      rule(:number_with_part) do
+        (number >> part_and_subpart.maybe).as(:number_with_part)
+      end
+
+      # For TRF with organization prefix: "CISPR 14-1G" where CISPR is part of the number
+      rule(:trf_org_number) do
+        (str("CISPR") >> space).as(:trf_org) >> number_with_part
+      end
+
+      rule(:number) do
+        # Special case for VIM publication
+        str("VIM") |
+          # Special case for SYMBOL publication
+          str("SYMBOL") |
+          # IECEx TRF version notation: 62784v1a_ds, 62784v1A
+          (match('\d').repeat(1,
+                              6) >> str("v") >> match('\d').repeat(1) >> match("[a-zA-Z]").repeat >> (str("_") >> match("[a-zA-Z]").repeat).maybe) |
+          # IECEE letter-based numbers: AD-001, GD-2053, OD-1000, CAB-G01, 01-S
+          # Pattern: 2-4 letter prefix followed by optional dash and number
+          # The suffix uses [A-Z\d] but not space to properly separate from edition
+          (match("[A-Z]").repeat(2, 4) >> (
+            dash >> match('\d').repeat(1)
+          ).maybe >> match('[A-Z\d]').repeat) |
+          # Can be 5-6 digits for TRF: 60065, 610091
+          # Can have letter suffix: 60065N, 610091A
+          # Can have letter + underscore + letters: 61215F_SE
+          (match('\d').repeat(1, 6) >> (
+            match("[a-zA-Z]") >> (str("_") >> match("[a-zA-Z]").repeat).maybe
+          ).maybe)
+      end
+
+      rule(:date) do
+        # :2005-02 or optional for DB without date
+        (str(":") | dash) >>
+          (year_digits >>
+            (dash >> month_digits).maybe >>
+            (dash >> day_digits).maybe
+          ).as(:date)
+      end
+
+      rule(:part_and_subpart) do
+        # Parts can have:
+        # - Dashes: 60038-1
+        # - Complex: 29110-5-1-1
+        # - TRF ampersand: 60086-1&2A
+        # - TRF underscore: 60127-2-IA_I, 61215F_SE
+        # - TRF lowercase: 60127-2-iD_I
+        # - TRF commas: 60309-1,2G or 60335-1-14,15G
+
+        # the "space?" needed to handle potential spaces
+        (dash | str(",")) >> space? >>
+          # matches a part with special TRF characters including commas
+          match('[\w&_,]').repeat >>
+          # matches subparts
+          ((dash | str(",")) >> match('[\w&_,]').repeat).repeat.maybe
+      end
+
+      rule(:all_parts) do
+        str("(all parts)").as(:all_parts)
+      end
+
+      rule(:type_with_stage) do
+        # "DTR"
+        # "TS"
+        # "Guide"
+        # Also includes supplement stages like "CDCor" for standalone draft corrigenda
+        array_to_str(TYPED_STAGES + TYPED_STAGES_SUPPLEMENTS).as(:type_with_stage) >>
+          (match('\d').as(:stage_iteration) >> space).maybe
+      end
+
+      rule(:language) do
+        # IEC 60038:2009(en,fr)
+        # IEC 60038:2009(E/F)
+        str("(") >>
+          (
+            # parse 2-char language codes: ru,en,fr,de,ar,es
+            (match["a-z"].repeat(1) >> str(",").maybe) |
+            # parse single language codes: R/E/F
+            (match["EFARDS"] >> str("/").maybe)
+          ).repeat.as(:languages) >>
+          str(")")
+      end
+
+      EDITION_STRINGS = %w[Edition Ed. ED Ed].freeze
+      rule(:edition) do
+        # We ignore the case where there is "Ed" but no number
+        # Handle decimal editions like ED1.2
+        array_to_str(EDITION_STRINGS) >> space? >>
+          (digits >> (str(".") >> digits).maybe).maybe.as(:edition)
+      end
+
+      rule(:stage_iteration) do
+        # "IEC 11243.1"
+        str(".") >> match('\d').as(:stage_iteration)
+      end
+
+      # Sheet notation: /1:1994 (sheet 1 from year 1994)
+      # IEC 60695-2-1/1:1994
+      rule(:sheet_notation) do
+        str("/") >>
+          match('\d').repeat(1).as(:sheet_number) >>
+          str(":") >>
+          year_digits.as(:sheet_year)
+      end
+
+      # Sheet notation without year: /1 (sheet 1 without year)
+      # IEC 60695-2-1/1
+      rule(:sheet_notation_no_year) do
+        str("/") >>
+          match('\d').repeat(1).as(:sheet_number)
+      end
+
+      # Fragment notation: /FRAG2 or /FRAGC1 (fragment of amendment/corrigendum)
+      # IEC 60050-191/AMD2/FRAG2
+      # IEC 60050-191/COR1/FRAGC1
+      rule(:fragment_notation) do
+        str("/") >>
+          (str("FRAGC") | str("FRAG")).as(:fragment_type) >>
+          match('\d').repeat(1).as(:fragment_number)
+      end
+
+      # Sheet identifier: base identifier followed by /N:YEAR
+      # IEC 60695-2-1/1:1994 (sheet 1 from year 1994)
+      # IEC 60695-2-1/1 (sheet 1 without year)
+      rule(:sheet_identifier) do
+        identifier_copublishers_no_third.as(:base_identifier) >>
+          (sheet_notation | sheet_notation_no_year)
+      end
+
+      # Sheet identifier followed by supplement: base/sheet/supplement
+      # IEC 60695-2-1/1:1994/COR1:1995
+      rule(:sheet_supplement_identifier) do
+        identifier_copublishers_no_third.as(:base_identifier) >>
+          sheet_notation >>
+          str("/") >> supplement_type_with_stage >>
+          space? >> second_part >> third_part
+      end
+
+      # VAP suffix for consolidated/version types
+      # CSV = Consolidated version (with Supplements)
+      # CMV = Commented Version
+      # RLV = Redline Version (shows changes)
+      # SER = Serial version
+      # EXV = Example version
+      # PAC = Package
+      # PRV = Preview version
+      rule(:vap_suffix) do
+        space >> (
+          str("CSV") |
+          str("CMV") |
+          str("RLV") |
+          str("SER") |
+          str("EXV") |
+          str("PAC") |
+          str("PRV")
+        ).as(:vap_suffix)
+      end
+
+      # Database suffix: " DB"
+      # IEC 60617:2012 DB
+      rule(:database_suffix) do
+        space >> str("DB").as(:database)
+      end
+
+      # Consolidated amendments: +AMD1:2016+AMD2:2019
+      # Also supports without dates: +AMD1+AMD2
+      # Creates ConsolidatedIdentifier with array of amendments
+      rule(:consolidated_supplement) do
+        str("+") >>
+          (str("AMD") | str("COR")).as(:supplement_type) >>
+          match('\d').repeat(1).as(:supplement_number) >>
+          (str(":") >> year_digits.as(:supplement_year)).maybe
+      end
+
+      rule(:consolidated_supplements) do
+        consolidated_supplement.repeat(1).as(:consolidated_supplements)
+      end
+
+      rule(:second_part) do
+        # Try TRF organization number first, fallback to regular number
+        (trf_org_number | number_with_part) >>
+          stage_iteration.maybe >>
+          (space? >> date).maybe >>
+          consolidated_supplements.maybe >>
+          (vap_suffix | database_suffix).maybe
+      end
+
+      rule(:third_part_edition) do
+        space? >> edition.maybe
+      end
+
+      rule(:third_part) do
+        # End of the identifier, we can have language, edition, fragment, or all parts
+        third_part_edition >> language.maybe >> fragment_notation.maybe >> all_parts.maybe
+      end
+
+      # prefix sole or copublishers with type and stage
+      # IEC/TR 60038
+      # ISO/IEC TS 20594-1
+      # IEC/FDIS 60038
+      rule(:identifier_copublishers) do
+        identifier_copublishers_no_third >> third_part
+      end
+
+      rule(:guide_prefix) do
+        str("Guide") | str("GUIDE")
+      end
+
+      rule(:identifier_copublishers_no_third) do
+        # Guide IEC 51:1999
+        (guide_prefix.as(:type_with_stage_fr) >> space).maybe >>
+          prefix_with_copublishers.maybe >> space? >> str("/").maybe >>
+          type_with_stage.maybe >>
+          space.maybe >>
+          second_part >> third_part_edition
+      end
+
+      # For joint identifiers (ISO/IEC)
+      # ISO/IEC 17025:2017 handles copublisher in copublishers rule
+      # We handle this in identifier_copublishers already
+      rule(:joint_identifier) do
+        identifier_copublishers_no_third.as(:base_identifier) >>
+          space? >> str("|") >> space? >>
+          scope { iso_identifier }.as(:joint_identifier)
+      end
+
+      rule(:iso_identifier) do
+        Iso::Parser.new.identifier
+      end
+
+      rule(:supplement_type_with_stage) do
+        # "DAM"
+        # "Amd"
+        # "FRAG" (fragments of amendments)
+        # "FRAGC" (fragments of corrigenda)
+        (array_to_str(TYPED_STAGES_SUPPLEMENTS) | str("FRAGC") | str("FRAG")).as(:type_with_stage)
+      end
+
+      # Standalone draft supplement (no base identifier)
+      # IEC/FDAM 60038-1
+      # IEC/FDCOR 12345
+      rule(:standalone_supplement) do
+        prefix_with_copublishers >> str("/") >>
+          supplement_type_with_stage >>
+          space >> second_part >> third_part
+      end
+
+      # IEC 60038:2009/Amd 1:2011
+      rule(:supplement_identifier_no_third) do
+        identifier_copublishers_no_third.as(:base_identifier) >>
+          str("/") >> supplement_type_with_stage >>
+          space? >> second_part
+      end
+
+      rule(:supplement_identifier) do
+        supplement_identifier_no_third >> third_part
+      end
+
+      # IEC 60038:2009/Amd 1:2011/Cor 1:2012
+      rule(:supplement_supplement_identifier) do
+        supplement_identifier_no_third.as(:base_identifier) >>
+          str("/") >> supplement_type_with_stage >>
+          space? >> second_part >> third_part
+      end
+
+      rule(:dash) do
+        DASH_CHARS.map { |char| str(char) }.reduce(:|)
+      end
+
+      IEV_SHORTHAND = /\AIEV(?=\z|[\s-])/
+
+      # Preprocess input to normalize tab-separated editions and other formats
+      def parse(input)
+        # Normalize tab-separated editions: "IECEE AD-001\tED1.6" -> "IECEE AD-001 ED1.6"
+        normalized = input.gsub("\t", " ")
+        # Normalize comma-separated editions: "IEC CAB-G01:2025-02, Ed. 2.1" -> "IEC CAB-G01:2025-02 Ed. 2.1"
+        normalized = normalized.gsub(/,\s+Ed\./, " Ed.")
+        # Expand IEV shorthand: "IEV" / "IEV-351" -> "IEC 60050" / "IEC 60050-351"
+        normalized = normalized.sub(IEV_SHORTHAND, "IEC 60050")
+        super(normalized)
+      end
+    end
+  end
+end

data/lib/pubid/iec/rendering_style.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iec
+    # Base class for rendering styles using Strategy pattern
+    # Each identifier stores its own rendering_style which knows how to render it
+    class RenderingStyle
+      attr_reader :with_language_code, :stage_format_long, :with_date
+
+      def initialize(with_language_code:, stage_format_long:, with_date:)
+        @with_language_code = with_language_code
+        @stage_format_long = stage_format_long
+        @with_date = with_date
+      end
+
+      # Render the identifier according to this style
+      def render(identifier, with_edition: false)
+        parts = []
+
+        # Publisher portion
+        parts << identifier.publisher_portion(
+          lang: :en,
+          stage_format_long: stage_format_long,
+        )
+
+        # Number portion
+        parts << identifier.number_portion(
+          lang_single: single_char_language?,
+          with_date: with_date,
+        )
+
+        # Edition portion (if requested)
+        if with_edition && identifier.edition && (identifier.edition.number || identifier.edition.original_text)
+          parts << identifier.edition_portion(lang: :en)
+        end
+
+        result = parts.compact.join(" ")
+
+        # Language portion (if applicable)
+        if identifier.languages&.any? && with_language_code != :none
+          result << identifier.language_portion(lang_single: single_char_language?)
+        end
+
+        result
+      end
+
+      def single_char_language?
+        with_language_code == :single
+      end
+
+      def self.from_format(format)
+        case format
+        when :ref_num_short
+          RefNumShort.new
+        when :ref_num_long
+          RefNumLong.new
+        when :ref_dated
+          RefDated.new
+        when :ref_dated_long
+          RefDatedLong.new
+        when :ref_undated
+          RefUndated.new
+        when :ref_undated_long
+          RefUndatedLong.new
+        else
+          RefDatedLong.new # Default
+        end
+      end
+    end
+
+    # Instance reference number: 1-letter language code + short form + dated
+    class RefNumShort < RenderingStyle
+      def initialize
+        super(with_language_code: :single, stage_format_long: false, with_date: true)
+      end
+    end
+
+    # Instance reference number long: 2-letter language code + long form + dated
+    class RefNumLong < RenderingStyle
+      def initialize
+        super(with_language_code: :iso, stage_format_long: true, with_date: true)
+      end
+    end
+
+    # Reference dated: no language code + short form + dated
+    class RefDated < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: false, with_date: true)
+      end
+    end
+
+    # Reference dated long: no language code + long form + dated
+    class RefDatedLong < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: true, with_date: true)
+      end
+    end
+
+    # Reference undated: no language code + short form + undated
+    class RefUndated < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: false, with_date: false)
+      end
+    end
+
+    # Reference undated long: no language code + long form + undated
+    class RefUndatedLong < RenderingStyle
+      def initialize
+        super(with_language_code: :none, stage_format_long: true, with_date: false)
+      end
+    end
+  end
+end

data/lib/pubid/iec/scheme.rb

@@ -0,0 +1,71 @@
+require_relative "identifiers/international_standard"
+# frozen_string_literal: true
+require_relative "identifiers/technical_specification"
+require_relative "identifiers/technical_report"
+require_relative "identifiers/publicly_available_specification"
+require_relative "identifiers/guide"
+require_relative "identifiers/amendment"
+require_relative "identifiers/corrigendum"
+require_relative "identifiers/fragment_identifier"
+
+module Pubid
+  module Iec
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::InternationalStandard,
+            Identifiers::TechnicalSpecification,
+            Identifiers::TechnicalReport,
+            Identifiers::PubliclyAvailableSpecification,
+            Identifiers::Guide,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Amendment,
+            Identifiers::Corrigendum,
+            Identifiers::FragmentIdentifier,
+          ]
+        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/iec/single_identifier.rb

@@ -0,0 +1,80 @@
+require_relative "identifier"
+# frozen_string_literal: true
+require_relative "../components/typed_stage"
+require_relative "urn_generator"
+
+module Pubid
+  module Iec
+    class SingleIdentifier < Identifier
+      attribute :typed_stage, Components::TypedStage
+
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      def to_s(lang: :en, lang_single: false, with_edition: false)
+        [].tap do |parts|
+          parts << publisher_portion(lang: lang)
+          parts << number_portion(lang_single: lang_single)
+          parts << edition_portion(lang: lang) if with_edition
+        end.compact.join(" ").tap do |s|
+          s << language_portion(lang_single: lang_single) if languages&.any?
+        end
+      end
+
+      def publisher_portion(lang: :en)
+        # IEC identifiers can have copublishers (e.g., IEC/IEEE, ISO/IEC)
+
+        # Build publisher string
+        pub_string = if copublishers&.any?
+                       # Has copublishers: "IEC/IEEE" or "ISO/IEC"
+                       ([publisher] + copublishers).map(&:body).join("/")
+                     else
+                       # No copublishers: just "IEC"
+                       publisher.body
+                     end
+
+        # Add type abbreviation if present
+        if typed_stage && !typed_stage.abbreviation.empty?
+          abbr = typed_stage.abbreviation
+          # For copublishers or empty abbr, use space; otherwise use slash
+          pub_string += if copublishers&.any? || abbr == ""
+                          (abbr == "" ? "" : " #{abbr}")
+                        else
+                          "/#{abbr}"
+                        end
+        end
+
+        pub_string
+      end
+
+      def number_portion(lang_single: false)
+        [
+          (number ? number.to_s : ""),
+          (part ? "-#{part}" : ""),
+          (subpart ? "-#{subpart}" : ""),
+          (stage_iteration ? ".#{stage_iteration}" : ""),
+          (date ? ":#{date.year}" : ""),
+        ].join
+      end
+
+      def language_portion(lang_single: false)
+        return "" unless languages&.any?
+
+        [
+          "(",
+          languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def edition_portion(lang: :en)
+        return nil unless edition&.number
+
+        "ED#{edition.number}"
+      end
+    end
+  end
+end