pubid 2.0.0.pre.alpha.29 → 2.0.0.pre.alpha.30

data/lib/pubid/cen_cenelec/builder.rb

@@ -18,6 +18,13 @@ module Pubid
           return build_fragment_identifier(data)
         end
 
+        # "TR" is a CEN or CLC technical report ("CEN/TR", "CLC/TR") — the
+        # EN publisher never carries it (pubid ruling 2026-10-13).
+        if data[:type].to_s == "TR" && %w[EN].include?(data[:publisher].to_s)
+          raise Pubid::Errors::ParseError,
+                "\"EN\" cannot be \"TR\": a technical report is \"CEN/TR\" or \"CLC/TR\""
+        end
+
         # Every base document (an adopted norm, an ENV adoption, a plain
         # identifier) goes through the same supplement wrapping. The adopted
         # branches used to return early, so "CEN ISO/TS 21003-7:2008/A1:2010"
@@ -171,6 +178,9 @@ module Pubid
         when :part
           value[:part].to_s if value.is_a?(Hash)
 
+        when :version
+          value.to_s unless value.to_s.empty?
+
         when :year, :date
           # Check if month is present in the data and include it
           month_val = @data[:month]&.to_s

data/lib/pubid/cen_cenelec/identifier.rb

@@ -19,6 +19,8 @@ module Pubid
       attribute :number, :string
       attribute :part, :string
       attribute :subpart, :string
+      # The ETSI-style version suffix ("EN 302 326-2 V2.2.1")
+      attribute :version, :string
 
       # A published European Norm holds no type, stage or typed stage, so a
       # nil one means "published", not "any stage": `EN 1325` is not

data/lib/pubid/cen_cenelec/renderer.rb

@@ -110,12 +110,15 @@ module Pubid
           parts << "Guide"
         end
 
-        # Number with part (which may be multi-level like "5-1-1")
+        # Number with part (which may be multi-level like "5-1-1") and the
+        # ETSI-style version suffix ("EN 302 326-2 V2.2.1")
         if id.number
           number_str = id.number
           if id.part
             number_str += "-#{id.part}"
           end
+          # the version capture carries its own leading space
+          number_str += id.version if id.version
           parts << number_str
         end
 

data/lib/pubid/evs/builder.rb

@@ -2,10 +2,11 @@
 
 module Pubid
   module Evs
-    # Builds an EVS national adoption from the composed parse tree: the
-    # structured :adopted subtree (produced by the embedded CEN grammar) goes
-    # straight to the CEN/CENELEC builder as data — no string
-    # re-serialization anywhere.
+    # Builds an EVS identifier from the composed parse tree. The structured
+    # :adopted subtree (produced by the embedded CEN grammar) goes straight
+    # to the CEN/CENELEC builder as data — no string re-serialization
+    # anywhere; the ISO/IEC and plain-Estonian shapes carry their captures
+    # directly.
     class Builder < Pubid::Builder::Base
       def self.build(parsed_data)
         new.build(parsed_data)
@@ -14,12 +15,79 @@ module Pubid
       def build(data)
         data = flatten_array(data) if data.is_a?(Array)
 
-        adopted = Pubid::CenCenelec::Builder.build(data[:adopted])
+        identifier =
+          if data[:adopted]
+            adopted_data = data[:adopted]
+            # The adopted TS face carries no TS marker ("EVS-EN
+            # 16798-1:2019"; pubid ruling 2026-10-13) — the TS-ness of an
+            # EN adoption is metadata, not identity, so the type capture
+            # strips before the CEN builder routes on it.
+            if adopted_data[:type].to_s == "TS" && adopted_data[:publisher].to_s == "EN"
+              adopted_data = adopted_data.reject { |k, _| k == :type }
+            end
+            Identifiers::NationalAdoption.new(
+              base: Pubid::CenCenelec::Builder.build(adopted_data),
+              **shared(data),
+            )
+          elsif data[:intl]
+            intl = data[:intl]
+            Identifiers::InternationalAdoption.new(
+              intl_org: extract(intl[:intl_org]),
+              number: extract(intl[:number]),
+              part: extract(intl[:part]),
+              year: extract(intl[:year]),
+              **shared(data),
+            )
+          else
+            plain = data[:plain]
+            Identifiers::EstonianStandard.new(
+              number: extract(plain[:number]),
+              year: extract(plain[:year]),
+              evs_type: extract(plain[:evs_type]),
+              **shared(data),
+            )
+          end
 
-        Identifiers::NationalAdoption.new(
-          base: adopted,
-          separator: data[:evs_separator] || "-",
-        )
+        attach_supplements(identifier, data)
+      end
+
+      private
+
+      def shared(data)
+        {
+          separator: extract(data[:evs_separator]) || "-",
+          draft_prefix: data[:draft_prefix] ? true : false,
+          language: extract(data[:language]),
+        }
+      end
+
+      def attach_supplements(identifier, data)
+        if data[:na]
+          identifier.na_separator = supplement_separator(data[:na])
+          identifier.na_year = extract(data[:na][:na_year])
+        end
+        if data[:evs_amd]
+          identifier.amd_separator = supplement_separator(data[:evs_amd])
+          identifier.amd_kind = extract(data[:evs_amd][:amd_kind])
+          identifier.amd_number = extract(data[:evs_amd][:amd_number])
+          identifier.amd_year = extract(data[:evs_amd][:amd_year])
+        end
+        if data[:evs_cor]
+          identifier.cor_separator = supplement_separator(data[:evs_cor])
+          identifier.cor_kind = extract(data[:evs_cor][:cor_kind])
+          identifier.cor_number = extract(data[:evs_cor][:cor_number])
+          identifier.cor_year = extract(data[:evs_cor][:cor_year])
+        end
+        identifier
+      end
+
+      def supplement_separator(supp)
+        %i[supp_plus supp_slash supp_space]
+          .map { |k| extract(supp[k]) }.compact.first
+      end
+
+      def extract(value)
+        value.is_a?(Hash) ? value[:value] : value
       end
     end
   end

data/lib/pubid/evs/identifier.rb

@@ -2,19 +2,41 @@
 
 module Pubid
   module Evs
-    # An EVS national adoption wraps a CEN identifier the same way BSI's
-    # AdoptedEuropeanNorm does — polymorphic `base` so the
-    # wrapped object stays a real Pubid::CenCenelec identifier.
+    # An EVS identifier: the national prefix ("EVS" / "prEVS") over a CEN
+    # adoption, an ISO/IEC adoption, or a plain Estonian standard, plus the
+    # EVS-list supplements and the language code.
     #
-    # Examples:
-    #   "EVS-EN 18216:2026"           (base: EN 18216:2026)
-    #   "EVS-EN ISO 14001:2026"       (base: EN ISO 14001:2026)
-    #   "EVS-EN ISO/IEC 27017:2026"   (base: EN ISO/IEC 27017:2026)
+    #   "EVS-EN 18216:2026"            (base: EN 18216:2026)
     #   "EVS-EN ISO 9001:2015/A1:2024" (base: EN ISO 9001:2015/A1:2024)
+    #   "EVS-ISO 9001:2015"            (intl_org: ISO)
+    #   "EVS-IEC 62368-1:2020"         (intl_org: IEC)
+    #   "EVS 921:2019", "EVS-TS 1:2019"
+    #
+    # Shared supplements (pubid#517-list): the national annex ("+NA:2010" /
+    # "/NA"), the AMD and COR spellings, and the trailing language code
+    # (" et" / " en" / " et-en"). The supplement separators are semantic
+    # ("+X" a full standard plus the supplement, "/X" the supplement only)
+    # and are preserved as captured.
     class Identifier < ::Pubid::Identifier
       attribute :base, ::Pubid::Identifier, polymorphic: true
       # "-" or " " — preserves the printed separator ("EVS-EN" vs "EVS EN")
       attribute :separator, :string, default: -> { "-" }
+      attribute :draft_prefix, :boolean, default: -> { false }
+      attribute :language, :string
+
+      # National annex: separator ("+"/"/") and optional year
+      attribute :na_separator, :string
+      attribute :na_year, :string
+      # AMD amendment spelling
+      attribute :amd_separator, :string
+      attribute :amd_kind, :string
+      attribute :amd_number, :string
+      attribute :amd_year, :string
+      # COR corrigendum spelling
+      attribute :cor_separator, :string
+      attribute :cor_kind, :string
+      attribute :cor_number, :string
+      attribute :cor_year, :string
 
       def to_s(**opts)
         render(format: :human, **opts)

data/lib/pubid/evs/identifiers/estonian_standard.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    module Identifiers
+      # A plain Estonian standard: "EVS 921:2019", optionally carrying the
+      # TS/TR type ("EVS-TS 1:2019").
+      class EstonianStandard < ::Pubid::Evs::Identifier
+        attribute :number, :string
+        attribute :year, :string
+        attribute :evs_type, :string
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifiers/international_adoption.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    module Identifiers
+      # The EVS adoption of an ISO or IEC standard directly (not via CEN).
+      # Examples: "EVS-ISO 9001:2015", "EVS-IEC 62368-1:2020"
+      class InternationalAdoption < ::Pubid::Evs::Identifier
+        attribute :intl_org, :string
+        attribute :number, :string
+        attribute :part, :string
+        attribute :year, :string
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifiers.rb

@@ -4,6 +4,8 @@ module Pubid
   module Evs
     module Identifiers
       autoload :NationalAdoption, "#{__dir__}/identifiers/national_adoption"
+      autoload :InternationalAdoption, "#{__dir__}/identifiers/international_adoption"
+      autoload :EstonianStandard, "#{__dir__}/identifiers/estonian_standard"
     end
   end
 end

data/lib/pubid/evs/renderer.rb

@@ -4,26 +4,59 @@ module Pubid
   module Evs
     # Human-readable renderer for EVS identifiers.
     #
-    # Produces strings like:
     #   "EVS-EN 18216:2026"
-    #   "EVS-EN ISO 14001:2026"
-    #   "EVS-EN ISO/IEC 27017:2026"
     #   "EVS-EN ISO 9001:2015/A1:2024"
+    #   "EVS-ISO 9001:2015"
+    #   "EVS-IEC 62368-1:2020"
+    #   "EVS 921:2019"
+    #   "EVS-TS 1:2019"
+    #   "prEVS-EN 100:2026"
+    #   "EVS-EN 1993-1-1:2005+NA:2010 et"
     class Renderer < ::Pubid::Renderers::Base
       def render(context: nil, **_opts)
-        # The adopted identifier renders with its own "EN …" prefix, so the
-        # national prefix composes as "EVS" + separator + adopted.
-        "EVS#{separator}#{adopted}"
+        result = +""
+        result << "pr" if @id.draft_prefix
+        result << "EVS#{@id.separator}"
+        result << body
+        result << supplement(@id.amd_separator, @id.amd_kind, @id.amd_number, @id.amd_year)
+        result << supplement(@id.cor_separator, @id.cor_kind || "COR", @id.cor_number, @id.cor_year)
+        result << supplement(@id.na_separator, "NA", nil, @id.na_year)
+        result << " #{@id.language}" if @id.language
+        result
       end
 
       private
 
-      def separator
-        @id.separator || "-"
+      # The adopted CEN identifier renders with its own "EN …" prefix; the
+      # ISO/IEC and plain shapes compose from their captures.
+      def body
+        case @id
+        when Pubid::Evs::Identifiers::NationalAdoption
+          @id.base.to_s
+        when Pubid::Evs::Identifiers::InternationalAdoption
+          org = "#{@id.intl_org} #{@id.number}"
+          org << "-#{@id.part}" if @id.part
+          org << ":#{@id.year}" if @id.year
+          org
+        else
+          plain = +""
+          plain << "#{@id.evs_type} " if @id.evs_type
+          plain << @id.number.to_s
+          plain << ":#{@id.year}" if @id.year
+          plain
+        end
       end
 
-      def adopted
-        @id.base.to_s
+      # The separator is semantic ("+X" a full standard plus the
+      # supplement, "/X" the supplement only, " AMD" the space spelling)
+      # and prints as captured.
+      def supplement(separator, kind, number, year)
+        return "" unless separator
+
+        face = +"#{separator}#{kind}"
+        face << number.to_s if number
+        face << ":#{year}" if year
+        face
       end
     end
   end

data/lib/pubid/evs/urn_generator.rb

@@ -8,22 +8,62 @@ module Pubid
     #   "EVS-EN ISO 14001:2026"        → urn:evs:en:iso:14001:2026
     #   "EVS-EN ISO/IEC 27017:2026"    → urn:evs:en:iso-iec:27017:2026
     #   "EVS-EN ISO 9001:2015/A1:2024" → urn:evs:en:iso:9001:2015:amd:1:2024
+    #   "EVS-ISO 9001:2015"            → urn:evs:iso:9001:2015
+    #   "EVS-IEC 62368-1:2020"         → urn:evs:iec:62368-1:2020
+    #   "EVS 921:2019"                 → urn:evs:921:2019
+    #   "EVS-TS 1:2019"                → urn:evs:ts:1:2019
     #
     # Generation delegates to the adopted CEN identifier's URN and swaps the
     # `urn:cen:` namespace for `urn:evs:`, so the two stay consistent by
-    # construction.
+    # construction; the ISO/IEC and plain shapes compose from their captures.
     class UrnGenerator < Pubid::UrnGenerator::Base
       CEN_NAMESPACE = "urn:cen:"
       EVS_NAMESPACE = "urn:evs:"
 
       def generate
-        adopted_urn = identifier.base.to_urn
-        unless adopted_urn.start_with?(CEN_NAMESPACE)
-          raise Errors::ParseError,
-                "expected adopted CEN URN, got #{adopted_urn.inspect}"
+        segments = +""
+        segments << "pr:" if identifier.draft_prefix
+
+        segments << if identifier.is_a?(Identifiers::NationalAdoption)
+                      adopted_urn = identifier.base.to_urn
+                      unless adopted_urn.start_with?(CEN_NAMESPACE)
+                        raise Errors::ParseError,
+                              "expected adopted CEN URN, got #{adopted_urn.inspect}"
+                      end
+                      adopted_urn.delete_prefix(CEN_NAMESPACE)
+                    else
+                      body = +""
+                      if identifier.is_a?(Identifiers::InternationalAdoption)
+                        body << "#{identifier.intl_org.downcase}:"
+                        body << identifier.number.to_s
+                        body << "-#{identifier.part}" if identifier.part
+                      else
+                        body << "#{identifier.evs_type.downcase}:" if identifier.evs_type
+                        body << identifier.number.to_s
+                      end
+                      body << ":#{identifier.year}" if identifier.year
+                      body
+                    end
+
+        segments << ":na" << ":#{identifier.na_year}" if identifier.na_separator && identifier.na_year
+        segments << ":na" if identifier.na_separator && !identifier.na_year
+        if identifier.amd_separator
+          # the consolidation marker mirrors the cen vocabulary: "+A1" is
+          # "plus:amd:1", the slash and space spellings carry no marker
+          segments << ":plus" if identifier.amd_separator == "+"
+          segments << ":amd"
+          segments << ":#{identifier.amd_number}" if identifier.amd_number
+          segments << ":#{identifier.amd_year}" if identifier.amd_year
+        end
+        if identifier.cor_separator
+          segments << ":plus" if identifier.cor_separator == "+"
+          segments << ":cor"
+          segments << ":#{identifier.cor_number}" if identifier.cor_number
+          segments << ":#{identifier.cor_year}" if identifier.cor_year
         end
+        segments << ":#{identifier.language}" if identifier.language
 
-        adopted_urn.sub(/\A#{Regexp.escape(CEN_NAMESPACE)}/o, EVS_NAMESPACE)
+        "#{EVS_NAMESPACE}#{segments}"
       end
     end
   end

data/lib/pubid/evs/urn_parser.rb

@@ -3,14 +3,19 @@
 module Pubid
   module Evs
     # Parses `urn:evs:…` URNs back into identifiers, following the same
-    # pattern as Pubid::CenCenelec::UrnParser: reassemble the adopted
-    # identifier's human text and delegate to the real grammar so every
-    # structural check happens in parsers, not in this class.
+    # pattern as Pubid::CenCenelec::UrnParser: reassemble the identifier's
+    # human text and delegate to the real grammar so every structural check
+    # happens in parsers, not in this class.
     #
     #   urn:evs:en:18216:2026                → EVS-EN 18216:2026
     #   urn:evs:en:iso:14001:2026            → EVS-EN ISO 14001:2026
     #   urn:evs:en:iso-iec:27017:2026        → EVS-EN ISO/IEC 27017:2026
     #   urn:evs:en:iso:9001:2015:amd:1:2024  → EVS-EN ISO 9001:2015/A1:2024
+    #   urn:evs:iso:9001:2015                → EVS-ISO 9001:2015
+    #   urn:evs:921:2019                     → EVS 921:2019
+    #   urn:evs:ts:1:2019                    → EVS-TS 1:2019
+    #   urn:evs:pr:en:100:2026               → prEVS-EN 100:2026
+    #   urn:evs:en:1993-1-1:2005:na:2010:et  → EVS-EN 1993-1-1:2005+NA:2010 et
     class UrnParser < Pubid::UrnParser::Base
       ORGS = {
         "iso" => "ISO",
@@ -19,6 +24,8 @@ module Pubid
         "cispr" => "CISPR",
       }.freeze
 
+      TYPES = { "ts" => "TS", "tr" => "TR" }.freeze
+
       # UrnGenerator emits "urn:evs:" (national-body namespace).
       def flavor_name
         "evs"
@@ -27,54 +34,104 @@ module Pubid
       def parse_urn(urn)
         parts = split_parts(strip_namespace(urn))
 
-        type = parts.shift
-        unless /\Aen\z/i.match?(type)
-          raise Errors::ParseError, "unsupported type in #{urn.inspect}"
+        draft = parts.first == "pr"
+        parts.shift if draft
+
+        # The trailing language code and the EVS-level national annex peel
+        # before the body dispatch — both are EVS-level, never cen segments.
+        language = parts.last&.match?(/\A(et-en|et|en)\z/) && parts.length > 1 ? parts.pop : nil
+        na_year = nil
+        na_present = false
+        if (na_i = parts.index("na"))
+          parts.delete_at(na_i)
+          na_present = true
+          na_year = parts[na_i]&.match?(/\A\d{4}\z/) ? parts.delete_at(na_i) : nil
         end
 
-        text = +"EN"
-        org_parts = []
-        org_parts << parts.shift while parts.first&.match?(/\A[a-z][a-z-]*\z/)
-        if org_parts.any?
-          org = ORGS.fetch(org_parts.join("-")) do
-            raise Errors::ParseError, "unknown adopted org in #{urn.inspect}"
+        head = parts.shift
+        text = +"EVS"
+
+        case head
+        when /\Aen\z/i
+          # the adopted CEN identifier: "en [org] number[:year] [supplements]"
+          text << "-EN"
+          org_parts = []
+          org_parts << parts.shift while parts.first&.match?(/\A[a-z][a-z-]*\z/)
+          if org_parts.any?
+            org = ORGS.fetch(org_parts.join("-")) do
+              raise Errors::ParseError, "unknown adopted org in #{urn.inspect}"
+            end
+            text << " #{org}"
           end
-          text << " #{org}"
-        end
+          number = parts.shift
+          raise Errors::ParseError, "missing number in #{urn.inspect}" unless number
 
-        number = parts.shift
-        year = parts.shift
-        unless number
-          raise Errors::ParseError, 
-                "missing number in #{urn.inspect}"
+          text << " #{number}"
+          year = parts.shift
+          text << ":#{year}" if year
+          text << adopted_supplement(parts, urn)
+        when "ts", "tr"
+          number = parts.shift
+          year = parts.shift
+          text << "-#{TYPES.fetch(head)} #{number}"
+          text << ":#{year}" if year
+        when "iso", "iec", "cispr"
+          # a direct ISO/IEC adoption: "iso:9001[:part]:year"
+          org = ORGS.fetch(head)
+          number = parts.shift
+          part = parts.shift if parts.first&.match?(/\A\d+\z/) && !parts.first&.match?(/\A\d{4}\z/) && parts.length > 1
+          year = parts.shift
+          text << "-#{org} #{number}"
+          text << "-#{part}" if part
+          text << ":#{year}" if year
+        when /\A\d/
+          number = head
+          year = parts.shift
+          text << " #{number}"
+          text << ":#{year}" if year
+        else
+          raise Errors::ParseError, "unsupported shape in #{urn.inspect}"
         end
 
-        text << " #{number}"
-        text << ":#{year}" if year
+        raise Errors::ParseError, "trailing segments in #{urn.inspect}" unless parts.empty?
 
-        append_supplement(text, parts, urn) unless parts.empty?
+        if na_present
+          text << "+NA"
+          text << ":#{na_year}" if na_year
+        end
+        text << " #{language}" if language
 
-        adopted = Pubid::CenCenelec.parse(text)
-        ::Pubid::Evs::Identifiers::NationalAdoption.new(
-          base: adopted,
-        )
+        built = Pubid::Evs.parse(text)
+        built.draft_prefix = draft
+        built
       end
 
       private
 
-      # Appends the trailing `amd|cor : iteration [: year]` in human form.
-      def append_supplement(text, parts, urn)
-        year = parts.last&.match?(/\A\d{4}\z/) ? parts.pop : nil
-        kind = parts.shift
-        iteration = parts.shift
-        unless %w[amd cor].include?(kind) && iteration && parts.empty?
-          raise Errors::ParseError, "malformed supplement in #{urn.inspect}"
+      # The adopted CEN spine consumes its own supplements; their urn
+      # segments carry the consolidation marker ("plus" = "+A1", its absence
+      # = "/A1") — cen_cenelec/urn_generator.rb's supplement_segments.
+      def adopted_supplement(parts, urn)
+        faces = +""
+        while %w[plus slash amd cor frag].include?(parts.first)
+          if %w[plus slash].include?(parts.first)
+            sep = parts.shift == "plus" ? "+" : "/"
+            kind = parts.shift
+          else
+            sep = "/"
+            kind = parts.shift
+          end
+          num = parts.first&.match?(/\A\d{1,3}\z/) ? parts.shift : nil
+          yr = parts.first&.match?(/\A\d{4}\z/) ? parts.shift : nil
+          faces << case kind
+                   when "amd" then "#{sep}A#{num}#{":#{yr}" if yr}"
+                   when "cor" then "#{sep}AC#{num}#{":#{yr}" if yr}"
+                   else " FRAG#{num}"
+                   end
         end
-
-        text << (kind == "amd" ? "/A#{iteration}" : "/AC#{iteration}")
-        text << ":#{year}" if year
-        text
+        faces
       end
+
     end
   end
 end

data/lib/pubid/evs.rb

@@ -33,8 +33,19 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
-      parsed = Pubid::Parg::Backend.parse(:evs, identifier)
-      Builder.new.build(parsed)
+      # The trailing language code (" et" / " en" / " et-en") extracts
+      # before the grammar runs — the CEN adopted_string is greedy over
+      # plain text and would swallow it.
+      language = identifier[/ (et-en|et|en)\z/, 1]
+      body = language ? identifier.sub(/ #{Regexp.escape(language)}\z/, "") : identifier
+
+      parsed = Pubid::Parg::Backend.parse(:evs, body)
+      built = Builder.new.build(parsed)
+      # An "(all parts)" parse wraps the identifier — the language belongs
+      # to the inner EVS identifier, not the flavor-less wrapper.
+      target = built.is_a?(Pubid::AllPartsIdentifier) ? built.identifiers.first : built
+      target.language = language
+      built
     end
 
     # Build an EVS identifier from a parse-tree hash.