pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/iec/identifiers/white_paper.rb

@@ -0,0 +1,39 @@
+require_relative "base"
+require_relative "../../components/typed_stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # White Paper identifier class
+      # Single Responsibility: Represents IEC White Paper documents
+      class WhitePaper < Base
+        # White Papers have full phrase as type abbreviation
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :wp,
+            stage_code: :published,
+            type_code: :wp,
+            abbr: ["White Paper"],
+            name: "White Paper",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :wp, title: "White Paper", short: "White Paper" }
+        end
+
+        # Override publisher_portion to add White Paper
+        def publisher_portion
+          result = publisher.to_s
+
+          if typed_stage && typed_stage.abbreviation == "White Paper"
+            result += " White Paper"
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/identifiers/working_document.rb

@@ -0,0 +1,96 @@
+require_relative "base"
+# frozen_string_literal: true
+require_relative "../../components/stage"
+
+module Pubid
+  module Iec
+    module Identifiers
+      # Working Document identifier class
+      # Single Responsibility: Represents IEC Working Documents with TC attribution
+      # Also handles Working Programmes with PWI/PNW stage-first format
+      # Formats:
+      #   Working Programme: "PWI TR 100-36 ED1"
+      #   Working Document: "100/3705(F)/FDIS"
+      class WorkingDocument < Base
+        attribute :technical_committee, :string, default: -> {}
+        attribute :wd_number, :string, default: -> {}
+        attribute :wd_language, :string, default: -> {}
+        attribute :wd_stage, :string, default: -> {}
+        attribute :wp_stage, :string, default: -> {}
+        attribute :wp_type, :string, default: -> {}
+
+        # Working documents have no TYPED_STAGES - they use PROJECT_STAGES only
+        TYPED_STAGES = [].freeze
+
+        # Working document stages
+        PROJECT_STAGES = {}.freeze
+
+        def self.type
+          { key: :wd, title: "Working Document", short: "WD" }
+        end
+
+        # Return stage object for PWI/PNW stage
+        def stage
+          return nil unless wp_stage
+
+          # Map PWI/PNW to stage codes
+          stage_map = {
+            "PWI" => "pwi",
+            "PNW" => "pnw",
+          }
+          stage_code = stage_map[wp_stage]
+          return nil unless stage_code
+
+          @stage ||= ::Pubid::Components::Stage.new(stage_code: stage_code)
+        end
+
+        def to_s(_format = :short)
+          # Working Programme format: "PWI TR 100-36 ED1" or "IEC/PWI 60038"
+          if wp_stage
+            parts = []
+            # Include publisher if present (for IEC/PWI format)
+            if publisher
+              parts << publisher.body
+              if copublishers&.any?
+                parts << "/#{copublishers.map(&:body).join('/')}"
+              end
+              parts << "/"
+            end
+            parts << wp_stage
+            # Only add wp_type if it exists and is not empty/whitespace
+            if wp_type && !wp_type.strip.empty?
+              parts << " #{wp_type.strip}"
+            end
+
+            # Render full number with parts
+            if number
+              num_str = number.to_s
+              num_str += "-#{part}" if part && part.to_s != ""
+              num_str += "-#{subpart}" if subpart && subpart.to_s != ""
+              parts << " #{num_str}"
+            end
+
+            parts << " #{edition}" if edition&.number
+            return parts.join
+          end
+
+          # Working Document format: "100/3705(F)/FDIS"
+          parts = []
+
+          parts << technical_committee if technical_committee
+
+          # Number with optional language
+          if wd_number
+            num_part = wd_number.to_s
+            num_part += "(#{wd_language})" if wd_language
+            parts << num_part
+          end
+
+          parts << wd_stage if wd_stage
+
+          parts.join("/")
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iec/parser.rb

@@ -0,0 +1,417 @@
+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
+        # ISO/IEC Directives: "DIR", "DIR 1", "DIR 1 IEC SUP", "DIR 2 IEC", "DIR IEC SUP"
+        # Captured as a flat number (no part/subpart) so it round-trips to the input
+        # and class-matches the IEC index. Must come before the IECEE [A-Z]{2,4} branch,
+        # which would otherwise match "DIR" alone and leave the trailing tokens unconsumed.
+        (str("DIR") >> (space >> match('[A-Z\d]').repeat(1)).repeat) |
+          # 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