pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -1,4 +1,6 @@
+require_relative "../identifier"
 # frozen_string_literal: true
+require_relative "../components/vap_suffix"
 
 module Pubid
   module Iec
@@ -7,33 +9,10 @@ module Pubid
       # Single Responsibility: Wraps another identifier with VAP type suffix
       # Examples: "IEC 61666:2010+AMD1:2021 CSV"
       class VapIdentifier < Identifier
-        attribute :base, Identifier, polymorphic: true
-        # One or more VAP codes (e.g. ["CSV"] or ["EXV", "CMV"]). Plain strings.
-        attribute :vap, :string, collection: true
+        attribute :base_identifier, Identifier, polymorphic: true
+        attribute :vap_suffix, Components::VapSuffix
         attribute :edition, ::Pubid::Components::Edition, default: -> {}
 
-        # number/date/publisher/stage are delegated to base, so
-        # serialize the wrapped identifier under "base" plus the vap array; the
-        # common fields live inside "base", not at the top level.
-        include Pubid::Iec::DelegatedFieldSuppression
-
-        key_value do
-          map "base", with: { to: :base_to_kv, from: :base_from_kv }
-          map "vap", to: :vap, render_default: false
-        end
-
-        def base_to_kv(model, doc)
-          base = model.base
-          return unless base
-
-          doc.add_child(Lutaml::KeyValue::DataModel::Element.new("base",
-                                                                 base.to_hash))
-        end
-
-        def base_from_kv(model, value)
-          model.base = ::Pubid::Iec::Identifier.from_hash(value) if value
-        end
-
         # VAP types mapping
         TYPE_MAP = {
           "CSV" => "Consolidated version (with Supplements)",
@@ -42,33 +21,55 @@ module Pubid
           "SER" => "Serial version",
         }.freeze
 
-        # Delegate common attributes to base
+        def to_s(lang: :en, lang_single: false, with_edition: false)
+          parts = []
+
+          # Render base identifier WITHOUT edition (edition goes at VAP level)
+          parts << base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                        with_edition: false)
+
+          # Add VAP suffix with space
+          if vap_suffix
+            parts << " #{vap_suffix}"
+          end
+
+          # Add edition after VAP suffix if present
+          parts << " #{edition}" if edition&.number
+
+          parts.compact.join
+        end
+
+        # Delegate common attributes to base_identifier
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
 
         def copublishers
-          base&.copublishers
+          base_identifier&.copublishers
         end
 
         def code
-          base&.code
+          base_identifier&.code
         end
 
         def number
-          base&.number
+          base_identifier&.number
         end
 
         def date
-          base&.date
+          base_identifier&.date
+        end
+
+        def type
+          :vap
         end
 
         def stage
-          base&.stage
+          base_identifier&.stage
         end
 
         def typed_stage
-          base&.typed_stage
+          base_identifier&.typed_stage
         end
       end
     end

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

@@ -1,4 +1,5 @@
-# frozen_string_literal: true
+require_relative "base"
+require_relative "../../components/typed_stage"
 
 module Pubid
   module Iec
@@ -19,10 +20,19 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :wp,
-            web: :white_paper, title: "White Paper", short: "White Paper" }
+          { 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

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

@@ -1,4 +1,6 @@
+require_relative "base"
 # frozen_string_literal: true
+require_relative "../../components/stage"
 
 module Pubid
   module Iec
@@ -24,37 +26,69 @@ module Pubid
         PROJECT_STAGES = {}.freeze
 
         def self.type
-          { key: :wd,
-            web: :working_document, title: "Working Document", short: "WD" }
+          { key: :wd, title: "Working Document", short: "WD" }
         end
 
-        # A working document prints its committee, number, language and stage —
-        # `1/2457(F)/FDIS` — and none of those is the `number` the shared token
-        # table looks for, so it had no annotatable token. `wd_stage` is the
-        # printed stage token ("FDIS"); the derived `#stage` reader covers only
-        # the PWI/PNW work-programme form and is nil here.
-        def annotation_tokens
-          super + [
-            [:technical_committee, "docnumber"],
-            [:wd_number, "docnumber"],
-            [:wd_language, "language"],
-            [:wd_stage, "stage"],
-            [:wp_stage, "stage"],
-            [:wp_type, "doctype"],
-          ]
-        end
-
-        # Return stage object for the PWI/PNW work-programme stage.
-        #
-        # This used to build a bare Stage from a hand-written abbreviation map,
-        # so the stage carried no harmonized code and "pnw" existed as a stage
-        # code nowhere else in the registry. It now resolves through the shared
-        # registry, so PWI carries 00.* and PNW carries 10.20 — which is what
-        # the URN generator reads.
+        # Return stage object for PWI/PNW stage
         def stage
           return nil unless wp_stage
 
-          @stage ||= Pubid::Iec.locate_stage(wp_stage)&.to_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

data/lib/pubid/iec/parser.rb

@@ -1,24 +1,29 @@
 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 < ::Pubid::Parser::Grammar
+    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.all_typed_stages
+      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
-      TYPED_STAGES_SUPPLEMENTS = TYPED_STAGES
 
       root :identifier
 
       rule(:identifier) do
-        working_programme |
-          technical_group |
+        working_programme_with_publisher |
+          working_programme |
           working_document |
           sheet_supplement_identifier |
           sheet_identifier |
@@ -29,42 +34,6 @@ module Pubid
           identifier_copublishers
       end
 
-      # Technical Group identifier — names a committee rather than a document.
-      # Examples: "IEC TC 1", "ISO/IEC JTC 1", "ISO/IEC JTC 1/SC 7",
-      #           "IEC SC 100A", "CISPR", "CIS/A".
-      rule(:technical_group) do
-        technical_group_with_publisher | technical_group_bare
-      end
-
-      rule(:technical_group_with_publisher) do
-        prefix_sole_publisher >> copublishers.maybe >> space >>
-          tc_body.as(:technical_committee) >>
-          (str("/") >> space? >> sc_body).as(:subcommittee).maybe
-      end
-
-      rule(:technical_group_bare) do
-        # CISPR / CIS-letter forms and bare TYPE NUMBER forms both default
-        # publisher to "IEC" via the Base class default.
-        tc_body.as(:technical_committee) >>
-          (str("/") >> space? >> sc_body).as(:subcommittee).maybe
-      end
-
-      # Committee body forms accepted by the parser. Order matters: longer
-      # or more specific patterns first so they win the ordered choice.
-      rule(:tc_body) do
-        str("CISPR") |
-          (str("CIS") >> str("/") >> match("[A-Z]")) |
-          (tc_type >> space >> digits >> match("[A-Z]").maybe)
-      end
-
-      rule(:sc_body) do
-        str("SC") >> space >> digits >> match("[A-Z]").maybe
-      end
-
-      rule(:tc_type) do
-        str("JTC") | str("JPC") | str("TC") | str("SC") | str("PC")
-      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"
@@ -80,6 +49,21 @@ module Pubid
           (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
@@ -152,13 +136,8 @@ module Pubid
       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 VIM publication
+        str("VIM") |
           # Special case for SYMBOL publication
           str("SYMBOL") |
           # IECEx TRF version notation: 62784v1a_ds, 62784v1A
@@ -179,16 +158,12 @@ module Pubid
       end
 
       rule(:date) do
-        # :2005-02 or :-- (undated reference — ISO/IEC undated-reference form,
-        # e.g. IEC 60050:--, also accepted as the em-dash variant IEC 60050:—)
+        # :2005-02 or optional for DB without date
         (str(":") | dash) >>
-          (
-            (str("--") | str("—")).as(:undated_marker) |
-              (year_digits >>
-                (dash >> month_digits).maybe >>
-                (dash >> day_digits).maybe
-              ).as(:date)
-          )
+          (year_digits >>
+            (dash >> month_digits).maybe >>
+            (dash >> day_digits).maybe
+          ).as(:date)
       end
 
       rule(:part_and_subpart) do
@@ -276,14 +251,14 @@ module Pubid
       # 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_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_copublishers_no_third.as(:base_identifier) >>
           sheet_notation >>
           str("/") >> supplement_type_with_stage >>
           space? >> second_part >> third_part
@@ -297,22 +272,16 @@ module Pubid
       # EXV = Example version
       # PAC = Package
       # PRV = Preview version
-      # Internal helper (no `.as`): a single VAP code. The capture key stays
-      # :vap_suffix below; this rule just lets the suffix be one or more codes.
-      rule(:vap_code) do
-        str("CSV") |
+      rule(:vap_suffix) do
+        space >> (
+          str("CSV") |
           str("CMV") |
           str("RLV") |
           str("SER") |
           str("EXV") |
           str("PAC") |
           str("PRV")
-      end
-
-      # One or more VAP codes joined by "-", captured whole, e.g. "CSV" or
-      # "EXV-CMV"; the builder splits it into the VapIdentifier `vap` array.
-      rule(:vap_suffix) do
-        space >> (vap_code >> (str("-") >> vap_code).repeat).as(:vap_suffix)
+        ).as(:vap_suffix)
       end
 
       # Database suffix: " DB"
@@ -378,13 +347,13 @@ module Pubid
       # 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_copublishers_no_third.as(:base_identifier) >>
           space? >> str("|") >> space? >>
           scope { iso_identifier }.as(:joint_identifier)
       end
 
       rule(:iso_identifier) do
-        Pubid::Iso.joint_grammar_atom(:identifier)
+        Iso::Parser.new.identifier
       end
 
       rule(:supplement_type_with_stage) do
@@ -406,7 +375,7 @@ module Pubid
 
       # IEC 60038:2009/Amd 1:2011
       rule(:supplement_identifier_no_third) do
-        identifier_copublishers_no_third.as(:base) >>
+        identifier_copublishers_no_third.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
           space? >> second_part
       end
@@ -417,7 +386,7 @@ module Pubid
 
       # IEC 60038:2009/Amd 1:2011/Cor 1:2012
       rule(:supplement_supplement_identifier) do
-        supplement_identifier_no_third.as(:base) >>
+        supplement_identifier_no_third.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
           space? >> second_part >> third_part
       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

@@ -1,19 +1,25 @@
+require_relative "identifier"
 # frozen_string_literal: true
+require_relative "../components/typed_stage"
+require_relative "urn_generator"
 
 module Pubid
   module Iec
     class SingleIdentifier < Identifier
-      # Default to the class's published typed_stage so an omitted "stage" key
-      # reconstructs the published state on from_hash.
-      attribute :typed_stage, ::Pubid::Components::TypedStage,
-                default: -> { self.class.published_typed_stage }
+      attribute :typed_stage, Components::TypedStage
 
       # Generate URN for this identifier
       #
       # @return [String] URN representation
 
-      def to_s(**opts)
-        render(format: :human, **opts)
+      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)
@@ -28,14 +34,16 @@ module Pubid
                        publisher.body
                      end
 
-        # IEC house style separates the publisher from the typed-stage
-        # abbreviation with a SPACE, for every type and whether or not there
-        # are copublishers: "IEC CD 60038", "IEC PNW 1000-1:2023". The slash
-        # stays the copublisher separator only. The slash input spelling
-        # ("IEC/CD 60038") is still accepted by the parser; only rendering
-        # normalises. See issue #360 item 2.
-        abbr = typed_stage&.abbreviation.to_s
-        pub_string += " #{abbr}" unless abbr.empty?
+        # 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
@@ -46,7 +54,7 @@ module Pubid
           (part ? "-#{part}" : ""),
           (subpart ? "-#{subpart}" : ""),
           (stage_iteration ? ".#{stage_iteration}" : ""),
-          (date ? ":#{date.render}" : ""),
+          (date ? ":#{date.year}" : ""),
         ].join
       end