pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/w3c.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module W3c
-    extend Pubid::PrefixesSupport
-
-    # Sole W3C publisher token (see the parser's `prefix` rule). Document-type
-    # tokens (WD/NOTE/REC/…) follow the "W3C " prefix and are excluded.
-    PREFIXES = ["W3C"].freeze
-
-    autoload :Builder, "#{__dir__}/w3c/builder"
-    autoload :Identifier, "#{__dir__}/w3c/identifier"
-    autoload :Identifiers, "#{__dir__}/w3c/identifiers"
-    autoload :Parser, "#{__dir__}/w3c/parser"
-    autoload :Renderer, "#{__dir__}/w3c/renderer"
-    autoload :UrnGenerator, "#{__dir__}/w3c/urn_generator"
-    autoload :UrnParser, "#{__dir__}/w3c/urn_parser"
-
-    # Parse a W3C identifier string
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    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: W3c::Renderer)
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    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.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    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
-
-# Register W3C flavor with the registry
-Pubid::Registry.register(:w3c, Pubid::W3c)

data/lib/pubid/xsf/builder.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    # Builds an identifier object from the Parslet parse tree. XSF has a single
-    # concrete type, so the builder always produces an Identifiers::Xep.
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        Identifiers::Xep.new(number: data[:number].to_s)
-      end
-    end
-  end
-end

data/lib/pubid/xsf/identifier.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    # Base class for every XSF identifier AND the flavor's parse/create entry
-    # point — mirrors Pubid::Jis::Identifier. The single concrete type
-    # (Pubid::Xsf::Identifiers::Xep) descends from this class, so a parsed XSF
-    # id is an instance of Pubid::Xsf::Identifier.
-    class Identifier < ::Pubid::Identifier
-      # XEP number kept as a string to preserve the 4-digit zero padding
-      # ("0001", not 1). No default → it is dropped from the serialized hash
-      # only when nil, and always present for a real identifier.
-      attribute :number, :string
-
-      # Polymorphic type map for lutaml::Model key_value (de)serialization:
-      # maps each subclass's polymorphic_name to its class name so a stored
-      # hash rebuilds the correct identifier type via from_hash.
-      XSF_TYPE_MAP = {
-        "pubid:xsf:xep" => "Pubid::Xsf::Identifiers::Xep",
-      }.freeze
-
-      key_value do
-        map "_type", to: :_type, polymorphic_map: XSF_TYPE_MAP
-        map "number", to: :number
-      end
-
-      # Publisher name. A plain constant (not a `publisher` method) so it does
-      # not shadow the inherited lutaml `publisher` attribute, which would
-      # otherwise fail serialization type validation. XSF never prints its
-      # publisher name in an identifier — the leading token is "XEP".
-      PUBLISHER = "XSF"
-
-      attr_reader :with_publisher
-
-      # Basic string representation. Delegates to renderer; `with_publisher:
-      # false` yields the bare number.
-      def to_s(with_publisher: true, **opts)
-        @with_publisher = with_publisher
-        render(format: :human, **opts)
-      end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
-      # XSF_TYPE_MAP remains as the key_value polymorphic_map.
-
-      # Parse an XSF identifier string into an identifier object
-      # @param identifier [String] The XSF identifier string to parse
-      # @return [Identifier] The appropriate identifier object
-      # @raise [Pubid::Errors::InvalidInputError]
-      #   If the input exceeds the maximum length
-      # @raise [Pubid::Errors::ParseError] If parsing fails
-      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/xsf/identifiers/xep.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    module Identifiers
-      # XMPP Extension Protocol — the sole XSF identifier type.
-      # Format: "XEP NNNN" (e.g. XEP 0001, XEP 0218).
-      #
-      # `polymorphic_name` auto-derives "pubid:xsf:xep" from the class name,
-      # which is what serializes into the `_type` tag and drives from_hash
-      # dispatch (see XSF_TYPE_MAP on the base Identifier).
-      class Xep < Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :xep,
-            stage_code: :published,
-            type_code: :xep,
-            abbr: ["XEP"],
-            name: "XMPP Extension Protocol",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :xep,
-            web: :xep, title: "XMPP Extension Protocol", short: "XEP" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/xsf/identifiers.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    module Identifiers
-      autoload :Xep, "#{__dir__}/identifiers/xep"
-    end
-  end
-end

data/lib/pubid/xsf/parser.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Xsf
-    # Parslet grammar for XSF identifiers. One fixed shape: "XEP NNNN".
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-
-      # "XEP 0001" — publisher token, a single space, then the number kept as
-      # a string of digits (leading zeros preserved by the builder).
-      rule(:identifier) do
-        str("XEP") >> str(" ") >> digits.as(:number)
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/xsf/renderer.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    # Human-readable renderer for XSF identifiers.
-    #
-    # Produces strings like "XEP 0001". With `with_publisher: false` it emits
-    # just the bare number ("0001").
-    #
-    # Registered as the `:human` format in the XSF format registry and invoked
-    # via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      PUBLISHER = "XEP"
-
-      def render(context: nil, **opts)
-        id = @id
-        return id.number.to_s if id.with_publisher == false
-
-        "#{PUBLISHER} #{id.number}"
-      end
-    end
-  end
-end

data/lib/pubid/xsf/urn_generator.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    # Emits `urn:xsf:xep:<number>` (e.g. urn:xsf:xep:0001). The number keeps its
-    # zero padding so the URN round-trips back to the printed identifier.
-    class UrnGenerator < Pubid::UrnGenerator::Base
-      def generate
-        ["urn", "xsf", "xep", identifier.number.to_s].join(":")
-      end
-    end
-  end
-end

data/lib/pubid/xsf/urn_parser.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Xsf
-    # Parses XSF URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:xsf:xep:<number>` (e.g. urn:xsf:xep:0001).
-    # This inverts it by reconstructing the printed "XEP <number>" string and
-    # delegating to the flavor's text parser.
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        _type, number = split_parts(body)
-        flavor_parse("XEP #{number}")
-      end
-    end
-  end
-end

data/lib/pubid/xsf.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  # XSF (XMPP Standards Foundation) flavor. Its documents are XEPs — XMPP
-  # Extension Protocols — printed as "XEP NNNN" with a 4-digit zero-padded
-  # number (e.g. "XEP 0001"). The simplest full flavor: a single identifier
-  # type, one string attribute.
-  module Xsf
-    extend Pubid::PrefixesSupport
-
-    # Sole leading token an XSF identifier can start with (see the parser's
-    # `str("XEP")`). "XSF" is the publisher name but never appears in a printed
-    # identifier, so it is not a prefix.
-    PREFIXES = ["XEP"].freeze
-
-    autoload :Builder, "#{__dir__}/xsf/builder"
-    autoload :Identifier, "#{__dir__}/xsf/identifier"
-    autoload :Identifiers, "#{__dir__}/xsf/identifiers"
-    autoload :Parser, "#{__dir__}/xsf/parser"
-    autoload :Renderer, "#{__dir__}/xsf/renderer"
-    autoload :UrnGenerator, "#{__dir__}/xsf/urn_generator"
-    autoload :UrnParser, "#{__dir__}/xsf/urn_parser"
-
-    # Parse an XSF identifier string
-    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
-
-      Identifier.parse(identifier)
-    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: Xsf::Renderer)
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    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.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    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
-
-# Register XSF flavor with the registry
-Pubid::Registry.register(:xsf, Pubid::Xsf)