pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    module Identifiers
+      # The EVS national adoption of a European Standard.
+      # Example: "EVS-EN 18216:2026"
+      class NationalAdoption < ::Pubid::Evs::Identifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        def self.type
+          { key: :evs_en, title: "EVS National Adoption of a European Standard" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    module Identifiers
+      autoload :NationalAdoption, "#{__dir__}/identifiers/national_adoption"
+    end
+  end
+end

data/lib/pubid/evs/parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Evs
+    # Grammar for the printed EVS national-adoption reference, composed with
+    # the CEN/CENELEC parser as an embedded atom (the same pattern ISO uses
+    # for IDF joint identifiers, and IEEE for AIEE/IRE/NESC):
+    #
+    #   "EVS" ("-" | " ") <CEN identifier>
+    #
+    # The adopted portion is parsed by the real CEN grammar — publisher,
+    # adopted org, number, parts, year, supplements, edition — and captured
+    # as a structured :adopted subtree for the CEN builder.
+    #
+    #   "EVS-EN 18216:2026"            → {evs_separator, adopted: {publisher, number, year}}
+    #   "EVS-EN ISO 9001:2015/A1:2024" → {evs_separator, adopted: {publisher, adopted_string, supplements}}
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:root) do
+        str("EVS") >>
+          (str("-") | str(" ")).as(:evs_separator) >>
+          ::Pubid::CenCenelec::Parser.new.identifier.as(:adopted)
+      end
+    end
+  end
+end

data/lib/pubid/evs/renderer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+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"
+    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}"
+      end
+
+      private
+
+      def separator
+        @id.separator || "-"
+      end
+
+      def adopted
+        @id.adopted_identifier.to_s
+      end
+    end
+  end
+end

data/lib/pubid/evs/urn_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # URNs mirror the CEN adoption namespace with the national-body prefix:
+    #
+    #   "EVS-EN 18216:2026"            → urn:evs:en:18216:2026
+    #   "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
+    #
+    # 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.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      CEN_NAMESPACE = "urn:cen:"
+      EVS_NAMESPACE = "urn:evs:"
+
+      def generate
+        adopted_urn = identifier.adopted_identifier.to_urn
+        unless adopted_urn.start_with?(CEN_NAMESPACE)
+          raise Errors::ParseError,
+                "expected adopted CEN URN, got #{adopted_urn.inspect}"
+        end
+
+        adopted_urn.sub(/\A#{Regexp.escape(CEN_NAMESPACE)}/o, EVS_NAMESPACE)
+      end
+    end
+  end
+end

data/lib/pubid/evs/urn_parser.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+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.
+    #
+    #   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
+    class UrnParser < Pubid::UrnParser::Base
+      ORGS = {
+        "iso" => "ISO",
+        "iso-iec" => "ISO/IEC",
+        "iec" => "IEC",
+        "cispr" => "CISPR",
+      }.freeze
+
+      # UrnGenerator emits "urn:evs:" (national-body namespace).
+      def flavor_name
+        "evs"
+      end
+
+      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}"
+        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}"
+          end
+          text << " #{org}"
+        end
+
+        number = parts.shift
+        year = parts.shift
+        unless number
+          raise Errors::ParseError, 
+                "missing number in #{urn.inspect}"
+        end
+
+        text << " #{number}"
+        text << ":#{year}" if year
+
+        append_supplement(text, parts, urn) unless parts.empty?
+
+        adopted = Pubid::CenCenelec.parse(text)
+        ::Pubid::Evs::Identifiers::NationalAdoption.new(
+          adopted_identifier: adopted,
+        )
+      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}"
+        end
+
+        text << (kind == "amd" ? "/A#{iteration}" : "/AC#{iteration}")
+        text << ":#{year}" if year
+        text
+      end
+    end
+  end
+end

data/lib/pubid/evs.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  module Evs
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed EVS reference can start with, drawn from the
+    # reference PDFs in metanorma/mn-samples-evs-private. Longest first so
+    # prefix routing picks the most specific claim. Deliberately EXCLUDES the
+    # bare adopted forms ("EN …" alone routes to Pubid::CenCenelec).
+    PREFIXES = [
+      "EVS-EN ISO/IEC", "EVS-EN ISO", "EVS-EN",
+      "EVS EN ISO/IEC", "EVS EN ISO", "EVS EN",
+      "EVS"
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/evs/builder"
+    autoload :Identifier, "#{__dir__}/evs/identifier"
+    autoload :Identifiers, "#{__dir__}/evs/identifiers"
+    autoload :Parser, "#{__dir__}/evs/parser"
+    autoload :Renderer, "#{__dir__}/evs/renderer"
+    autoload :UrnGenerator, "#{__dir__}/evs/urn_generator"
+    autoload :UrnParser, "#{__dir__}/evs/urn_parser"
+
+    def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      parsed = Parser.new.parse(identifier)
+      Builder.new.build(parsed)
+    end
+
+    # Build an EVS identifier from a parse-tree hash.
+    # @param hash [Hash] parse tree
+    # @return [Pubid::Evs::Identifier]
+    def self.build_from_parse(hash)
+      Builder.new.build(hash)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human.
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Evs::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants.filter_map do |c|
+        begin
+          Identifiers.const_get(c)
+        rescue NameError
+          nil
+        end
+      end
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # EVS identifiers have no typed stages.
+    # @return [Array<Pubid::Components::TypedStage>]
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param _abbr [String, Symbol]
+    # @return [nil] EVS identifiers have no typed stages
+    def self.locate_stage(_abbr)
+      nil
+    end
+  end
+end
+
+# Register EVS flavor with the registry
+Pubid::Registry.register(:evs, Pubid::Evs)

data/lib/pubid/export/exporter.rb

@@ -9,7 +9,8 @@ module Pubid
     class Exporter
       FLAVORS = %i[
         iso iec ieee nist bsi itu cen_cenelec etsi ansi astm ashrae asme
-        ccsds cie csa jis jcgm oiml idf api amca plateau sae
+        ccsds cie csa ecma jis jcgm oiml idf api amca plateau sae ogc ietf tgpp w3c xsf
+        bipm iana oasis calconnect
       ].freeze
 
       # Export all flavors to a hash suitable for JSON serialization.

data/lib/pubid/export/flavor_exporter.rb

@@ -78,10 +78,25 @@ module Pubid
       # Scan Identifiers namespace for all Pubid::Identifier subclasses,
       # excluding structural base classes.
       def discover_from_namespace(mod)
-        return [] unless mod.const_defined?(:Identifiers)
+        if mod.const_defined?(:Identifiers)
+          classes = collect_identifier_classes(mod.const_get(:Identifiers))
+          return classes unless classes.empty?
+        end
+
+        # Single-class flavors (e.g. SAE) expose no concrete types under
+        # Identifiers — the flavor's own Identifier class IS the sole document
+        # type (previously discovered via the removed Identifiers::Base alias).
+        Array(single_class_flavor_type(mod))
+      end
+
+      # The flavor's own `Identifier` class when it is a concrete
+      # Pubid::Identifier subclass, else nil (used as the sole type for
+      # single-class flavors with an empty Identifiers namespace).
+      def single_class_flavor_type(mod)
+        return unless mod.const_defined?(:Identifier)
 
-        idents_mod = mod.const_get(:Identifiers)
-        collect_identifier_classes(idents_mod)
+        ident = mod.const_get(:Identifier)
+        ident if ident.is_a?(Class) && ident < Pubid::Identifier
       end
 
       # Recursively collect all Pubid::Identifier subclasses from a module,

data/lib/pubid/export.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Export
     autoload :IdentifierTypeResult, "#{__dir__}/export/result"

data/lib/pubid/format_detector.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module FormatDetector
     URN_PATTERN = /\Aurn:/i

data/lib/pubid/gb/builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    # Builds a Pubid::Gb::Identifier from a parse tree.
+    #
+    # The parser captures the publisher code verbatim (which may already
+    # include the "/T" or "/Z" suffix). The builder normalizes: if the
+    # suffix is in the publisher_code string, it's split out into the
+    # separate +mandate+ attribute so the renderer can recompose either
+    # the inline or split form.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        publisher_code, mandate = split_mandate(data[:publisher_code].to_s)
+
+        mandate ||= data[:mandate]&.to_s
+
+        Identifiers::Standard.new(
+          publisher_code: publisher_code,
+          mandate: mandate,
+          number: data[:number].to_s,
+          part: data[:part]&.to_s,
+          date: data[:year] ? ::Pubid::Components::Date.new(year: data[:year].to_s) : nil,
+          all_parts: !data[:all_parts].to_s.empty?,
+        )
+      end
+
+      private
+
+      # If the publisher code carries an inline /T or /Z suffix, split it off
+      # and return the cleaned code + extracted mandate.
+      def split_mandate(code)
+        if code =~ %r{\A(.*?)/(T|Z)\z}
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        else
+          [code, nil]
+        end
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifier.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    # Base class for every Chinese Standard identifier AND the flavor's
+    # parse/create entry point. Concrete types under Pubid::Gb::Identifiers
+    # descend from this class, so a parsed GB id is always an instance of
+    # Pubid::Gb::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # The issuing body code as printed, e.g. "GB", "JB", "T/GZAEPI".
+      # Always non-empty for a valid identifier.
+      attribute :publisher_code, :string
+
+      # Mandate category: "T" (recommended), "Z" (guideline), or nil
+      # (mandatory). Carried after the "/" in the printed form.
+      attribute :mandate, :string
+
+      # Document number (digits, possibly dotted with part). Required.
+      # Examples: "20223", "5606.1", "001".
+      attribute :number, :string
+
+      # Optional part. Captured separately from #number when the input
+      # uses the dotted form (e.g. "5606.1" => number "5606", part "1").
+      attribute :part, :string
+
+      # All-parts flag — true for "GB/T 5606 (all parts)" forms.
+      attribute :all_parts, :boolean, default: -> { false }
+
+      # Polymorphic type map for lutaml key_value (de)serialization.
+      GB_TYPE_MAP = {
+        "pubid:gb:standard" => "Pubid::Gb::Identifiers::Standard",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: GB_TYPE_MAP
+        map "publisher_code", to: :publisher_code
+        map "mandate", to: :mandate
+        map "number", to: :number
+        map "part", to: :part
+        map "all_parts", to: :all_parts, render_default: false
+      end
+
+      PUBLISHER = "CN"
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      # Parse a Chinese Standard identifier string.
+      # @param identifier [String]
+      # @return [Pubid::Gb::Identifier]
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifiers/standard.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    module Identifiers
+      # The default Chinese Standard identifier type. The class name yields
+      # the polymorphic _type tag "pubid:gb:standard".
+      #
+      # Examples:
+      #   GB/T 20223-2006
+      #   GB/T 5606.1-2004
+      #   GB/T 5606 (all parts)
+      #   JB/T 13368-2018
+      #   T/GZAEPI 001—2018
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubgb,
+            stage_code: :published,
+            type_code: :gb,
+            abbr: ["GB"],
+            name: "Chinese Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :gb, web: :chinese_standard, title: "Chinese Standard",
+            short: "GB" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/gb/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/gb/parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Gb
+    # Parslet grammar for Chinese Standard identifiers.
+    #
+    # Accepts the canonical printed form
+    #
+    #   {PUBLISHER}[/{TYPE}] {NUMBER}[.{PART}][-|—{YEAR}] [(all parts)]
+    #
+    # PUBLISHER is one of the leading tokens from PREFIXES (GB, GB/T, JB,
+    # T/GZAEPI, ...). TYPE is T (recommended), Z (guideline), or omitted.
+    # YEAR is 4 digits, separated by either ASCII dash or em-dash (Chinese
+    # typography uses the em-dash form).
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space)  { str(" ") }
+      rule(:dot)    { str(".") }
+      rule(:dash)   { str("-") | str("—") }
+      rule(:digits) { match("[0-9]").repeat(1) }
+
+      # Publisher token: national/industry codes (1-3 letters, optionally
+      # followed by /T or /Z) OR social-group form "T/{ACRONYM}".
+      rule(:publisher_code) do
+        # Social-group form: "T/" then 2+ uppercase letters/digits.
+        (str("T/") >> match("[A-Z0-9]").repeat(1)).as(:publisher_code) |
+          # Standard form: 1-3 letters, optional slash-T-or-Z.
+          (match("[A-Z]").repeat(1, 3) >>
+            (str("/T") | str("/Z")).maybe).as(:publisher_code)
+      end
+
+      # Mandate category captured separately when the publisher token didn't
+      # already include it. Allows "GB/T" (inline) and "GB" + " T" (separate)
+      # to both parse.
+      rule(:mandate_suffix) do
+        (str("/") >> (str("T") | str("Z")).as(:mandate)).maybe
+      end
+
+      rule(:number) { digits.as(:number) }
+      rule(:part)   { dot >> digits.as(:part) }
+      rule(:year)   { (dash >> match("[0-9]").repeat(4, 4).as(:year)).maybe }
+      rule(:all_parts_flag) do
+        (space >> str("(") >> str("all parts") >> str(")")).as(:all_parts)
+      end
+
+      rule(:identifier) do
+        publisher_code >>
+          space >>
+          number >>
+          part.maybe >>
+          year >>
+          all_parts_flag.maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/gb/renderer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gb
+    # Human-readable renderer for Chinese Standard identifiers.
+    #
+    # Produces the canonical printed form:
+    #   "GB/T 20223-2006"
+    #   "GB/T 5606.1-2004"
+    #   "GB/T 5606 (all parts)"
+    #   "T/GZAEPI 001—2018"     (social-group form, em-dash year)
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        parts = [publisher_portion, " #{number_portion}"]
+        parts << " (all parts)" if @id.all_parts
+        parts.join
+      end
+
+      private
+
+      def publisher_portion
+        code = @id.publisher_code.to_s
+        code += "/#{@id.mandate}" if @id.mandate && !@id.publisher_code.include?("/")
+        code
+      end
+
+      def number_portion
+        result = @id.number.to_s
+        result += ".#{@id.part}" if @id.part
+        result += "-#{@id.year}" if @id.year
+        result
+      end
+    end
+  end
+end