pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/export/flavor_exporter.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Pubid
+  module Export
+    # Unified metadata extractor for all flavors.
+    #
+    # Uses the self-describing type interface (identifier_types, all_typed_stages,
+    # locate_type, locate_stage) on each flavor module. No Scheme dependency (Scheme class removed).
+    #
+    # Open/Closed: Adding a new flavor requires only adding it to Exporter::FLAVORS.
+    # Single Responsibility: Extracts metadata from flavor modules into value objects.
+    # Single Source of Truth: Each identifier class IS the type definition.
+    class FlavorExporter
+      attr_reader :flavor
+
+      # Wrapper classes to discover per flavor (overlay patterns that wrap base identifiers)
+      WRAPPER_CLASSES = {
+        iec: %i[VapIdentifier],
+        bsi: %i[ValueAddedPublication],
+      }.freeze
+
+      def initialize(flavor)
+        @flavor = flavor
+      end
+
+      def export
+        mod = flavor_module
+        return nil unless mod
+
+        klasses = resolve_identifier_classes(mod)
+        return nil if klasses.empty?
+
+        fixture_data = fixture_examples
+        seen_keys = Set.new
+
+        identifier_types = klasses.filter_map do |klass|
+          info = extract_type_info(klass)
+          next if seen_keys.include?(info[:key])
+
+          seen_keys << info[:key]
+
+          stages = extract_typed_stages(klass)
+          examples = match_examples(fixture_data, info[:key]&.to_s, klass)
+
+          IdentifierTypeResult.new(
+            key: info[:key],
+            title: info[:title],
+            short: info[:short],
+            abbr: info[:abbr],
+            typed_stages: stages,
+            examples: examples,
+          )
+        end
+
+        FlavorResult.new(
+          flavor: flavor,
+          identifier_types: identifier_types,
+          wrapper_types: extract_wrapper_types,
+          attributes: extract_attributes(klasses.first),
+        )
+      end
+
+      protected
+
+      # Resolve identifier classes from the flavor module.
+      # Primary: use the module's self-describing identifier_types method.
+      # Fallback: scan the Identifiers namespace directly for Pubid::Identifier
+      # subclasses (handles ETSI, ITU, and other non-standard patterns).
+      def resolve_identifier_classes(mod)
+        klasses = mod.identifier_types
+        return klasses if klasses && !klasses.empty?
+
+        discover_from_namespace(mod)
+      end
+
+      # Scan Identifiers namespace for all Pubid::Identifier subclasses,
+      # excluding structural base classes.
+      def discover_from_namespace(mod)
+        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)
+
+        ident = mod.const_get(:Identifier)
+        ident if ident.is_a?(Class) && ident < Pubid::Identifier
+      end
+
+      # Recursively collect all Pubid::Identifier subclasses from a module,
+      # descending into submodules (e.g., IEEE's Nesc namespace).
+      def collect_identifier_classes(mod)
+        result = []
+        mod.constants.each do |c|
+          const = begin; mod.const_get(c); rescue NameError; next; end
+          if const.is_a?(Module) && !const.is_a?(Class)
+            result.concat(collect_identifier_classes(const))
+          elsif const.is_a?(Class) && const < Pubid::Identifier
+            result << const
+          end
+        end
+        result
+      end
+
+      # Map flavor symbol to the flavor module.
+      def flavor_module
+        @flavor_module ||= begin
+          mod_name = flavor.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+          Pubid.const_get(mod_name)
+        rescue NameError
+          nil
+        end
+      end
+
+      def extract_type_info(klass)
+        type_info = safe_type(klass)
+        metadata = safe_metadata(klass)
+
+        key = type_info&.dig(:web) || type_info&.dig(:key)
+        title = type_info&.dig(:title) || metadata&.title
+        short = type_info&.dig(:short) || metadata&.short
+        abbr = metadata&.abbr || []
+
+        unless key
+          class_name = klass.name&.split("::")&.last
+          key = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
+          title ||= class_name&.gsub(/([A-Z])/, ' \1')&.strip
+        end
+
+        { key: key&.to_s, title: title, short: short, abbr: abbr }
+      end
+
+      def extract_typed_stages(klass)
+        return [] unless klass.const_defined?(:TYPED_STAGES)
+
+        klass.const_get(:TYPED_STAGES)
+      rescue NameError
+        []
+      end
+
+      # Fixture example extraction
+      def fixture_examples
+        gem_root = File.expand_path("../../..", __dir__)
+        base = File.join(gem_root, "spec", "fixtures", flavor.to_s, "identifiers",
+                         "pass")
+        return {} unless Dir.exist?(base)
+
+        examples = {}
+        Dir.glob(File.join(base, "*.txt")).each do |path|
+          type_key = File.basename(path, ".txt")
+          identifiers = parse_fixture_file(path)
+          examples[type_key] = identifiers if identifiers.any?
+        end
+        examples
+      end
+
+      def parse_fixture_file(path)
+        identifiers = []
+        File.readlines(path, chomp: true).each do |line|
+          next if line.start_with?("#") || line.strip.empty?
+
+          if line.start_with?("!")
+            parts = line.split("!")
+            input = parts[2]&.strip
+            identifiers << input if input && !input.empty?
+          else
+            identifiers << line.strip
+          end
+        end
+        identifiers.uniq.first(10)
+      end
+
+      def match_examples(fixture_data, type_key, klass)
+        return [] unless type_key
+
+        # Try direct type key match first
+        examples = fixture_data[type_key] ||
+          fixture_data[type_key.gsub("_", "")] ||
+          []
+
+        return examples if examples.any?
+
+        # Try class name match
+        class_name = klass.name&.split("::")&.last
+        snake_name = class_name&.gsub(/([A-Z])/, '_\1')&.downcase&.sub(/^_/, "")
+        if snake_name && fixture_data.key?(snake_name)
+          fixture_data[snake_name]
+        else
+          []
+        end
+      end
+
+      def extract_attributes(klass)
+        klass.model_attributes.keys.map(&:to_s)
+      rescue NoMethodError
+        []
+      end
+
+      def extract_wrapper_types
+        names = WRAPPER_CLASSES[flavor]
+        return [] unless names
+
+        mod = flavor_module
+        return [] unless mod
+
+        identifiers_mod = mod.const_get(:Identifiers)
+        names.filter_map do |name|
+          klass = identifiers_mod.const_get(name)
+          info = extract_type_info(klass)
+          IdentifierTypeResult.new(
+            key: info[:key],
+            title: info[:title],
+            short: info[:short],
+            abbr: info[:abbr],
+            typed_stages: [],
+            examples: [],
+          )
+        rescue NameError
+          nil
+        end
+      end
+
+      private
+
+      def safe_type(klass)
+        klass.type
+      rescue NoMethodError, NotImplementedError
+        nil
+      end
+
+      def safe_metadata(klass)
+        klass.metadata
+      rescue NoMethodError
+        nil
+      end
+    end
+  end
+end

data/lib/pubid/export/result.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    # Immutable value object representing extracted metadata for one identifier type.
+    # Encapsulates all data needed by the website for a single doc type entry.
+    class IdentifierTypeResult
+      attr_reader :key, :title, :short, :abbr, :typed_stages, :examples
+
+      def initialize(key:, title:, short: nil, abbr: [], typed_stages: [],
+examples: [])
+        @key = key.to_s
+        @title = title
+        @short = short
+        @abbr = Array(abbr).map(&:to_s)
+        @typed_stages = typed_stages.map do |ts|
+          TypedStageResult.from_typed_stage(ts)
+        end
+        @examples = examples
+        freeze
+      end
+
+      def to_h
+        {
+          key: @key,
+          title: @title,
+          short: @short,
+          abbr: @abbr,
+          typed_stages: @typed_stages.map(&:to_h),
+          examples: @examples,
+        }
+      end
+      alias to_hash to_h
+    end
+
+    # Immutable value object for a single typed stage.
+    class TypedStageResult
+      attr_reader :stage_code, :type_code, :abbr, :name, :harmonized_stages
+
+      def initialize(stage_code:, type_code:, abbr:, name:, harmonized_stages:)
+        @stage_code = stage_code.to_s
+        @type_code = type_code.to_s
+        @abbr = Array(abbr).map(&:to_s)
+        @name = name
+        @harmonized_stages = Array(harmonized_stages).map(&:to_s)
+        freeze
+      end
+
+      def self.from_typed_stage(ts)
+        new(
+          stage_code: ts.stage_code,
+          type_code: ts.type_code,
+          abbr: ts.abbr,
+          name: ts.is_a?(Pubid::Components::TypedStage) ? ts.name : nil,
+          harmonized_stages: ts.is_a?(Pubid::Components::TypedStage) ? ts.harmonized_stages : [],
+        )
+      end
+
+      def to_h
+        {
+          stage_code: @stage_code,
+          type_code: @type_code,
+          abbr: @abbr,
+          name: @name,
+          harmonized_stages: @harmonized_stages,
+        }
+      end
+    end
+
+    # Immutable value object for extracted flavor metadata.
+    class FlavorResult
+      attr_reader :flavor, :identifier_types, :wrapper_types, :attributes
+
+      def initialize(flavor:, identifier_types:, wrapper_types: [],
+attributes: [])
+        @flavor = flavor.to_s
+        @identifier_types = identifier_types
+        @wrapper_types = wrapper_types
+        @attributes = attributes
+        freeze
+      end
+
+      def to_h
+        h = {
+          identifier_types: @identifier_types.map(&:to_h),
+          attributes: @attributes,
+        }
+        unless @wrapper_types.empty?
+          h[:wrapper_types] =
+            @wrapper_types.map(&:to_h)
+        end
+        h
+      end
+      alias to_hash to_h
+    end
+  end
+end

data/lib/pubid/export.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Export
+    autoload :IdentifierTypeResult, "#{__dir__}/export/result"
+    autoload :TypedStageResult, "#{__dir__}/export/result"
+    autoload :FlavorResult, "#{__dir__}/export/result"
+    autoload :FlavorExporter, "#{__dir__}/export/flavor_exporter"
+    autoload :Auditor, "#{__dir__}/export/auditor"
+    autoload :Exporter, "#{__dir__}/export/exporter"
+  end
+end

data/lib/pubid/format_detector.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module FormatDetector
+    URN_PATTERN = /\Aurn:/i
+    MR_STRING_PATTERN = /\A[A-Z]{2,}[.-]/
+
+    def self.detect(string)
+      case string
+      when URN_PATTERN then :urn
+      when MR_STRING_PATTERN then :mr_string
+      else :human
+      end
+    end
+  end
+end

data/lib/pubid/format_registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pubid
+  class FormatRegistry
+    attr_reader :formats
+
+    def initialize(parent: nil)
+      @formats = {}
+      @parent = parent
+    end
+
+    def register(format, renderer: nil, parser: nil)
+      @formats[format.to_sym] = { renderer:, parser: }
+    end
+
+    def renderer_for(format)
+      entry = @formats[format.to_sym]
+      return entry[:renderer] if entry && entry[:renderer]
+      return @parent.renderer_for(format) if @parent
+
+      nil
+    end
+
+    def parser_for(format)
+      entry = @formats[format.to_sym]
+      return entry[:parser] if entry && entry[:parser]
+      return @parent.parser_for(format) if @parent
+
+      nil
+    end
+
+    def registered_formats
+      formats = @formats.keys
+      formats |= @parent.registered_formats if @parent
+      formats
+    end
+
+    def has?(format)
+      @formats.key?(format.to_sym) || (@parent&.has?(format) || false)
+    end
+  end
+end

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