pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/etsi/identifiers/supplement_identifier.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      # Identifier class for ETSI supplements (Amendment, Corrigendum)
+      class SupplementIdentifier < Identifier
+        attribute :base, Pubid::Etsi::Identifier
+        attribute :number, :integer
+
+        # Compact serialization: a supplement carries only its own ordinal
+        # `number` (A1 -> 1) and the nested base standard under the compact key
+        # `base`. type/code/version/date are delegated to `base` (methods below)
+        # and NOT re-emitted here, so the old redundant duplication is gone.
+        # This block is inherited unchanged by Amendment/Corrigendum.
+        key_value do
+          map "_type",  to: :_type
+          map "number", to: :number
+          map "base",   with: { to: :base_to_kv, from: :base_from_kv }
+        end
+
+        # Serialize the base via its own to_hash so it collapses to the compact
+        # EtsiStandard shape.
+        def base_to_kv(model, doc)
+          return unless model.base
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new(
+              "base", model.base.to_hash
+            ),
+          )
+        end
+
+        # Re-dispatch through the flavor base so `_type` resolves to the
+        # concrete EtsiStandard; a bare polymorphic cast would rebuild a plain
+        # Identifier and lose the subclass (and its custom mappings). Mirrors JCGM.
+        def base_from_kv(model, value)
+          return unless value
+
+          model.base = Pubid::Etsi::Identifier.from_hash(value)
+        end
+
+        # Inherit attributes from base
+        def type
+          base.type
+        end
+
+        def code
+          base.code
+        end
+
+        def version
+          base.version
+        end
+
+        def date
+          base.date
+        end
+
+        # Render via renderer
+
+        # Recursively collect supplement notations from the supplement chain
+        def collect_supplement_notations(current_supplement, notations)
+          if current_supplement.is_a?(SupplementIdentifier)
+            # Add this supplement's notation at the beginning (because supplements wrap from outside in)
+            notations.unshift("/#{current_supplement.supplement_notation}")
+            # Continue collecting from the base if it's also a supplement
+            if current_supplement.base.is_a?(SupplementIdentifier)
+              collect_supplement_notations(current_supplement.base, notations)
+            else
+              notations
+            end
+          else
+            notations
+          end
+        end
+
+        # Find the actual base ETSI standard (not supplements)
+        def find_actual_base(current_base)
+          if current_base.is_a?(SupplementIdentifier)
+            find_actual_base(current_base.base)
+          else
+            current_base
+          end
+        end
+
+        def supplement_notation
+          raise NotImplementedError
+        end
+
+        # Make Renderers::MrString recurse into `base` instead of slugging the
+        # supplement flat. Without this the flat path reads the supplement's own
+        # `number` — its ordinal, 1 — and the base document is dropped entirely,
+        # so every "/C1" corrigendum published in one month shared the slug
+        # `etsi.1.<date>`. `to_slug` is an output FILENAME, so that is an
+        # overwrite. Same fix as ITU's AnnexOfRecommendation (see CLAUDE.md).
+        def mr_supplement_suffix
+          [supplement_notation.to_s.downcase, number].compact.join(".")
+        end
+
+        def ==(other)
+          return false unless other.is_a?(SupplementIdentifier)
+          return false unless other.class == self.class
+
+          base == other.base && number == other.number
+        end
+
+        # Include supplement notation in serialization
+        def base_hash
+          hash = super
+          # ETSI supplements need the type (e.g., "ETS", "TR") from the base document
+          if base.class.attributes.key?(:type) && base.type
+            hash[:type] =
+              base.type
+          end
+          hash[:supplement_notation] = supplement_notation
+          hash[:supplement_type] = self.class.name.split("::").last.downcase
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/pubid/etsi/identifiers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+      autoload :EtsiStandard, "#{__dir__}/identifiers/etsi_standard"
+      autoload :SupplementIdentifier,
+               "#{__dir__}/identifiers/supplement_identifier"
+    end
+  end
+end

data/lib/pubid/etsi/parser.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Etsi
+    class Parser < ::Pubid::Parser::Grammar
+      # Basic elements
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match["A-Za-z"] }
+      rule(:alnum) { match["A-Za-z0-9"] }
+      rule(:letters) { letter.repeat(1) }
+      rule(:alnums) { alnum.repeat(1) }
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:dot) { str(".") }
+
+      # ETSI prefix
+      rule(:etsi_prefix) { str("ETSI") >> space }
+
+      # Type prefixes - all 15 types
+      rule(:type) do
+        (str("I-ETS") | str("TCRTR") | str("GTS") | str("ETR") |
+         str("ETS") | str("TBR") | str("NET") | str("EN") |
+         str("ES") | str("EG") | str("TS") | str("GR") |
+         str("GS") | str("SR") | str("TR")).as(:type)
+      end
+
+      # Number variants
+
+      # GSM with dotted number: "GSM 11.14", "GSM 02.01"
+      rule(:gsm_with_space_number) do
+        str("GSM").capture(:gsm_prefix) >> space >>
+          digits.capture(:main) >> dot >> digits.capture(:sub)
+      end
+
+      # Number with dot: 11.40, 02.01
+      rule(:dotted_number) do
+        digits.capture(:main) >> dot >> digits.capture(:sub)
+      end
+
+      # Complex format: ABC 123 or ABC-DEF 123 or IP6 031
+      rule(:complex_number) do
+        alnums.capture(:prefix1) >>
+          (dash >> alnums.capture(:prefix2)).maybe >>
+          space >>
+          digits.capture(:num)
+      end
+
+      # Simple format: just digits
+      rule(:simple_number) do
+        digits.capture(:num)
+      end
+
+      # Main number
+      rule(:number) do
+        (gsm_with_space_number | dotted_number | complex_number | simple_number).as(:number)
+      end
+
+      # Optional minor part
+      rule(:minor) do
+        space >> digits.as(:minor)
+      end
+
+      # Parts
+      rule(:part) do
+        dash >> alnums.as(:part)
+      end
+
+      rule(:parts) { part.repeat(0).as(:parts) }
+
+      # Version
+      rule(:version) do
+        str("V") >> match["0-9."].repeat(1).as(:version)
+      end
+
+      # Edition
+      rule(:edition) do
+        str("ed.") >> digits.as(:edition)
+      end
+
+      # Version or edition
+      rule(:version_or_edition) do
+        version | edition
+      end
+
+      # Published date
+      rule(:date_part) do
+        str("(") >>
+          digit.repeat(4, 4).as(:year) >>
+          dash >>
+          digit.repeat(2, 2).as(:month) >>
+          str(")")
+      end
+
+      # Individual supplements
+      rule(:amendment) do
+        str("/A") >> digits.as(:number)
+      end
+
+      rule(:corrigendum) do
+        str("/C") >> digits.as(:number)
+      end
+
+      # Single supplement (AMD or COR)
+      rule(:single_supplement) do
+        amendment.as(:amendment) | corrigendum.as(:corrigendum)
+      end
+
+      # Multiple supplements
+      rule(:supplements) do
+        single_supplement.repeat(1).as(:supplements)
+      end
+
+      # Main identifier
+      #
+      # The mandatory core is `etsi_prefix type number` (+ optional
+      # minor/parts/supplements), mirroring ISO. The version/edition and date
+      # suffixes are optional so a partial reference (e.g. "ETSI GS ZSM 012")
+      # parses with version/date left nil. Each `.maybe` guards its own leading
+      # space so no trailing space is demanded when the suffix is absent.
+      rule(:identifier) do
+        etsi_prefix >>
+          type >> space >>
+          number >> minor.maybe >> parts >>
+          supplements.maybe >>
+          (space >> version_or_edition).maybe >>
+          (space >> date_part).maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/etsi/renderer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # Human-readable renderer for ETSI identifiers.
+    #
+    # Produces strings like:
+    #   "ETSI EN 301 419 V1.1.1 (2020-01)"
+    #   "ETSI TS 102 606-1/A1 V1.1.1 (2021-06)"
+    #   "ETSI GS NFV 002 ed.1 (2013-10)"
+    #
+    # The renderer is registered as the `:human` format in the ETSI format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::SupplementIdentifier
+          render_supplement(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        result = "#{id.publisher} #{id.type} #{id.code}"
+        # version/date are optional on partial references; append each only when
+        # present so a partial id renders without a stray " V… ()" suffix.
+        result += " #{id.version}" if id.version
+        result += " (#{id.date.render})" if id.date
+        result
+      end
+
+      def render_supplement(id)
+        supplement_notations = id.collect_supplement_notations(id, [])
+        actual_base = id.find_actual_base(id.base)
+        code_with_supplements = "#{actual_base.code}#{supplement_notations.join}"
+        result = "#{actual_base.publisher} #{actual_base.type} #{code_with_supplements}"
+        result += " #{actual_base.version}" if actual_base.version
+        result += " (#{actual_base.date.render})" if actual_base.date
+        result
+      end
+    end
+  end
+end

data/lib/pubid/etsi/urn_generator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.class.name&.include?("SupplementIdentifier")
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def urn_type_for_base
+        return "en" unless identifier.type
+
+        identifier.type.to_s.downcase
+      end
+
+      def urn_code
+        identifier.code&.to_s
+      end
+
+      def urn_version
+        identifier.version&.to_s&.downcase
+      end
+
+      def urn_date
+        return nil unless identifier.date
+
+        date = identifier.date
+        if date.month
+          "#{date.year}-#{format('%02d', date.month)}"
+        else
+          date.year.to_s
+        end
+      end
+
+      def generate_base_urn
+        parts = ["urn", "etsi"]
+        parts << urn_type_for_base
+        parts << urn_code if urn_code
+        parts << urn_version if urn_version
+        parts << urn_date if urn_date
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "etsi"]
+
+        if identifier.base
+          base_gen = self.class.new(identifier.base)
+          base_urn = base_gen.generate_base_urn
+
+          base_part = base_urn.sub(/^urn:etsi:/, "")
+          base_parts = base_part.split(":")
+
+          parts.concat(base_parts)
+        else
+          parts << urn_type_for_base if identifier.type
+          parts << urn_code if urn_code
+          parts << urn_version if urn_version
+          parts << urn_date if urn_date
+        end
+
+        parts << identifier.supplement_notation.to_s.downcase if identifier.supplement_notation
+
+        parts << identifier.number.to_s if identifier.number
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/etsi/urn_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    # Parses ETSI URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:etsi:{type}:{code}:{version}:{date}[:{supplement_notation}:{number}]
+    #
+    # type is the lowercase type abbreviation (en, ets, ts, tr, gs, sr).
+    # code is the identifier code with internal whitespace preserved.
+    # version is the lowercase Vx.y.z form.
+    # date is YYYY or YYYY-MM.
+    #
+    # Examples:
+    # - urn:etsi:en:300 100:v1.1.1:1998-04 → ETSI EN 300 100 V1.1.1 (1998-04)
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0).upcase
+        code = parts.fetch(1)
+        version = parts[2]
+        date = parts[3]
+
+        text = "ETSI #{type_token} #{code}"
+        text += " #{version.upcase}" if version
+        text += " (#{date})" if date
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/etsi.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Etsi
+    extend Pubid::PrefixesSupport
+
+    # Sole ETSI publisher token (see the parser's `etsi_prefix` rule). The
+    # document-type tokens (EN, TS, TR, ...) are sub-types that follow the ETSI
+    # prefix, not standalone routing tokens, so they are excluded.
+    PREFIXES = ["ETSI"].freeze
+
+    autoload :Builder, "#{__dir__}/etsi/builder"
+    autoload :Components, "#{__dir__}/etsi/components"
+    autoload :Identifier, "#{__dir__}/etsi/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/etsi/identifiers"
+    autoload :Parser, "#{__dir__}/etsi/parser"
+    autoload :Renderer, "#{__dir__}/etsi/renderer"
+    autoload :UrnGenerator, "#{__dir__}/etsi/urn_generator"
+    autoload :UrnParser, "#{__dir__}/etsi/urn_parser"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Etsi::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c < Pubid::Identifier }
+        # Exclude the flavor base itself by identity (Identifier is now an
+        # alias for Pubid::Etsi::Identifier, so name-based matching misses it).
+        .reject { |c| c == Identifier }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    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] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+Pubid::Registry.register(:etsi, Pubid::Etsi)

data/lib/pubid/export/auditor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pubid
+  module Export
+    # Compares library-generated metadata against website publisher data.
+    # Reports gaps: missing types, extra types, stage mismatches.
+    #
+    # Open/Closed: New audit dimensions can be added as new methods.
+    class Auditor
+      attr_reader :generated, :website
+
+      # @param generated_path [String] Path to website-data.json
+      # @param website_path [String] Path to publishers.ts (not parsed; uses key matching)
+      def initialize(generated_data)
+        @generated = generated_data
+      end
+
+      def self.from_file(path)
+        data = JSON.parse(File.read(path))
+        new(data)
+      end
+
+      def audit(website_publishers)
+        results = {}
+
+        generated.each do |flavor, gen_data|
+          website_data = website_publishers[flavor]
+          results[flavor] = audit_flavor(flavor, gen_data, website_data)
+        end
+
+        # Also check for website flavors not in generated data
+        website_publishers.each_key do |flavor|
+          next if results.key?(flavor)
+
+          results[flavor] = { missing_from_library: true }
+        end
+
+        results
+      end
+
+      def summary(audit_results)
+        lines = []
+        total_missing = 0
+        total_extra = 0
+
+        audit_results.each do |flavor, result|
+          next if result.empty?
+
+          missing = result[:missing_types] || []
+          extra = result[:extra_types] || []
+
+          if !missing.empty? || !extra.empty?
+            lines << "#{flavor}:"
+            lines.concat(missing.map do |t|
+              "  MISSING from website: #{t[:key]} (#{t[:title]})"
+            end)
+            lines.concat(extra.map do |t|
+              "  EXTRA in website (not in library): #{t}"
+            end)
+            total_missing += missing.size
+            total_extra += extra.size
+          end
+        end
+
+        lines.unshift("Audit Summary: #{total_missing} missing, #{total_extra} extra")
+        lines.join("\n")
+      end
+
+      private
+
+      def audit_flavor(_flavor, gen_data, website_data)
+        result = {}
+        return result unless website_data
+
+        gen_keys = (gen_data["identifier_types"] || []).map { |t| t["key"] }
+        web_keys = (website_data["doc_types"] || []).map { |t| t["key"] }
+
+        result[:missing_types] = gen_data["identifier_types"].reject do |t|
+          web_keys.include?(t["key"])
+        end
+        result[:extra_types] = web_keys.reject { |k| gen_keys.include?(k) }
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/export/exporter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Top-level orchestrator. Iterates flavors and delegates to FlavorExporter.
+    #
+    # Open/Closed: Adding a new flavor only requires adding it to FLAVORS;
+    # no existing code changes.
+    class Exporter
+      FLAVORS = %i[
+        iso iec ieee nist bsi itu cen_cenelec etsi ansi astm ashrae asme
+        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.
+      # @return [Hash{String => Hash}]
+      def self.export_all
+        require "pubid"
+
+        FLAVORS.each_with_object({}) do |flavor, result|
+          exporter = FlavorExporter.new(flavor)
+          flavor_result = exporter.export
+          next unless flavor_result
+
+          result[flavor.to_s] = flavor_result.to_hash
+        rescue StandardError => e
+          warn "Export warning (#{flavor}): #{e.message}"
+        end
+      end
+    end
+  end
+end