pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/etsi/parser.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Etsi
+    class Parser < Parslet::Parser
+      # 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
+      rule(:identifier) do
+        etsi_prefix >>
+          type >> space >>
+          number >> minor.maybe >> parts >>
+          supplements.maybe >>
+          space >> version_or_edition >>
+          space >> date_part
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/etsi/scheme.rb

@@ -0,0 +1,42 @@
+require "lutaml/model"
+# frozen_string_literal: true
+
+module Pubid
+  module Etsi
+    class Scheme < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :number, :string
+      attribute :part, :string, collection: true, default: -> { [] }
+      attribute :version, :string, default: -> {}
+      attribute :edition, :string, default: -> {}
+      attribute :date, :string
+      attribute :amendment, :string, default: -> {}
+      attribute :corrigendum, :string, default: -> {}
+
+      def to_s
+        result = "ETSI #{type} #{number}"
+
+        # Add parts
+        part.each do |p|
+          result += "-#{p}"
+        end
+
+        # Add amendment or corrigendum
+        result += "/A#{amendment}" if amendment
+        result += "/C#{corrigendum}" if corrigendum
+
+        # Add version or edition
+        if version
+          result += " V#{version}"
+        elsif edition
+          result += " ed.#{edition}"
+        end
+
+        # Add date (only if present)
+        result += " (#{date})" if 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.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Etsi
+    autoload :Builder, "#{__dir__}/etsi/builder"
+    autoload :Components, "#{__dir__}/etsi/components"
+    autoload :Identifier, "#{__dir__}/etsi/identifier"
+    autoload :Identifiers, "#{__dir__}/etsi/identifiers"
+    autoload :Parser, "#{__dir__}/etsi/parser"
+    autoload :Scheme, "#{__dir__}/etsi/scheme"
+    autoload :UrnGenerator, "#{__dir__}/etsi/urn_generator"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    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/data_class_exporter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Strategy for flavors using Lutaml::Model::Serializable as their Scheme
+    # (ETSI, Plateau). These have identifier classes in the Identifiers module
+    # that may not have def self.type.
+    class DataClassExporter < FlavorExporter
+      def export
+        klasses = resolve_identifier_classes_from_module
+        return nil if klasses.empty?
+
+        fixture_data = fixture_examples
+
+        identifier_types = klasses.map do |klass|
+          info = extract_type_info(klass)
+          type_key = info[:key]
+          examples = fixture_data[type_key] || fixture_data[type_key.to_s] || []
+
+          IdentifierTypeResult.new(
+            key: info[:key],
+            title: info[:title],
+            short: info[:short],
+            abbr: info[:abbr],
+            typed_stages: [],
+            examples: examples,
+          )
+        end
+
+        scheme = scheme_class
+        attrs = scheme&.methods&.include?(:attributes) ? scheme.attributes.keys.map(&:to_s) : []
+
+        FlavorResult.new(
+          flavor: flavor,
+          identifier_types: identifier_types,
+          attributes: attrs,
+        )
+      end
+
+      private
+
+      def resolve_identifier_classes_from_module
+        mod = scheme_module
+        return [] unless mod
+
+        idents_mod = mod.const_get(:Identifiers)
+        skip = %w[Base Supplement]
+
+        idents_mod.constants.filter_map do |c|
+          klass = begin; idents_mod.const_get(c); rescue NameError; next; end
+          next unless klass.is_a?(Class)
+          next if skip.include?(klass.name&.split("::")&.last)
+
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/pubid/export/exporter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Top-level orchestrator. Iterates flavors, selects the appropriate
+    # extraction strategy, and produces the combined result.
+    #
+    # Open/Closed: Adding a new flavor only requires registering it in
+    # FLAVOR_STRATEGIES; no existing code changes.
+    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
+      ].freeze
+
+      # Maps each flavor to its extraction strategy class.
+      # When a flavor follows a new pattern, add a new strategy class here.
+      FLAVOR_STRATEGIES = {
+        iso: :scheme,
+        iec: :scheme,
+        ieee: :ieee,
+        nist: :nist,
+        bsi: :registry,
+        itu: :itu,
+        cen_cenelec: :registry,
+        etsi: :data_class,
+        ansi: :scheme,
+        astm: :scheme,
+        ashrae: :scheme,
+        asme: :scheme,
+        ccsds: :scheme,
+        cie: :scheme,
+        csa: :scheme,
+        jis: :scheme,
+        jcgm: :scheme,
+        oiml: :scheme,
+        idf: :scheme,
+        api: :scheme,
+        amca: :scheme,
+        plateau: :data_class,
+        sae: :scheme,
+      }.freeze
+
+      STRATEGY_CLASSES = {
+        scheme: SchemeExporter,
+        registry: RegistryExporter,
+        data_class: DataClassExporter,
+        nist: NistExporter,
+        ieee: IeeeExporter,
+        itu: ItuExporter,
+      }.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|
+          strategy_name = FLAVOR_STRATEGIES[flavor]
+          strategy_class = STRATEGY_CLASSES[strategy_name]
+          next unless strategy_class
+
+          exporter = strategy_class.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