pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

data/lib/pubid/easc/renderer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Human-readable renderer for EASC identifiers.
+    #
+    # Produces strings like:
+    #   "ПМГ 03-2025"
+    #   "ПМГ В 31-2001"      (defense variant)
+    #   "РМГ 151-2025"
+    #
+    # Always renders in Cyrillic — the canonical form used on
+    # mgscatalog.by. Latin transliterations (PMG, RMG, V) parse but
+    # render to Cyrillic.
+    class Renderer < ::Pubid::Renderers::Base
+      CYRILLIC_SERIES = {
+        "PMG" => "ПМГ",
+        "RMG" => "РМГ",
+      }.freeze
+
+      CYRILLIC_VARIANT = "В".freeze
+
+      def render(context: nil, **_opts)
+        id = @id
+
+        if id.is_a?(Identifiers::Pmg) || id.is_a?(Identifiers::Rmg)
+          return render_standard(id)
+        end
+
+        raise ArgumentError, "Unknown EASC identifier class: #{id.class}"
+      end
+
+      private
+
+      def render_standard(id)
+        rendered = +"#{cyrillic_series(id.series)}"
+        rendered << " #{CYRILLIC_VARIANT}" if id.variant == "V"
+        rendered << " #{id.number}"
+        rendered << "-#{id.year}" if id.year
+        rendered
+      end
+
+      def cyrillic_series(series)
+        CYRILLIC_SERIES.fetch(series, series)
+      end
+    end
+  end
+end

data/lib/pubid/easc/urn_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Generates URN strings for EASC identifiers.
+    #
+    # Format:
+    #   urn:easc:<series>[:<variant>]:<number>[:<year>]
+    #
+    # Examples:
+    #   urn:easc:pmg:3:2025
+    #   urn:easc:pmg:v:31:2001
+    #   urn:easc:rmg:151:2025
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        unless identifier.is_a?(Identifiers::Pmg) ||
+               identifier.is_a?(Identifiers::Rmg)
+          raise ArgumentError,
+                "Unknown EASC identifier class: #{identifier.class}"
+        end
+
+        parts = ["urn:easc", series_lower]
+        parts << variant_lower if identifier.variant
+        parts << identifier.number.to_s
+        parts << identifier.year.to_s if identifier.year
+        parts.join(":")
+      end
+
+      private
+
+      def series_lower
+        identifier.series.to_s.downcase
+      end
+
+      def variant_lower
+        identifier.variant.to_s.downcase
+      end
+    end
+  end
+end

data/lib/pubid/easc/urn_parser.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Parses EASC URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:easc:<series>[:<variant>]:<number>[:<year>]
+    #
+    # Examples:
+    #   urn:easc:pmg:3:2025           → ПМГ 3-2025
+    #   urn:easc:pmg:v:31:2001        → ПМГ В 31-2001
+    #   urn:easc:rmg:151:2025         → РМГ 151-2025
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:easc:".freeze
+      VARIANT_SEGMENT = /\Av\z/i.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        series = parts.fetch(0)
+        rest = parts.drop(1)
+
+        variant = nil
+        if rest.first&.match?(VARIANT_SEGMENT)
+          variant = "V"
+          rest = rest.drop(1)
+        end
+        number = rest[0]
+        year = rest[1]
+
+        klass = Easc.identifier_klass_for_series(series) || Identifier
+        klass.new(series: series.upcase, variant: variant,
+                  number: number, year: year)
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid EASC URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+
+      def split_parts(body)
+        parts = body.split(":")
+        raise Pubid::UrnParser::Errors::ParseError,
+              "EASC URN missing series: #{body.inspect}" if parts.empty?
+
+        parts
+      end
+    end
+  end
+end

data/lib/pubid/easc.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    extend Pubid::PrefixesSupport
+
+    # Leading identifier tokens that an EASC document id can start with.
+    # Both Cyrillic (canonical — ПМГ, РМГ) and Latin transliterations
+    # (PMG, RMG) are accepted; the canonical render is Cyrillic per
+    # mgscatalog.by convention.
+    PREFIXES = ["ПМГ", "РМГ", "PMG", "RMG"].freeze
+
+    autoload :Builder,      "#{__dir__}/easc/builder"
+    autoload :Identifier,   "#{__dir__}/easc/identifier"
+    autoload :Identifiers,  "#{__dir__}/easc/identifiers"
+    autoload :Parser,       "#{__dir__}/easc/parser"
+    autoload :Renderer,     "#{__dir__}/easc/renderer"
+    autoload :UrnGenerator, "#{__dir__}/easc/urn_generator"
+    autoload :UrnParser,    "#{__dir__}/easc/urn_parser"
+
+    # @param identifier [String]
+    # @return [Pubid::Easc::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry.
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Easc::Renderer)
+
+    # Auto-discover identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    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 }
+        .reject { |c| c == Identifier }
+    end
+
+    # Lookup: series (ПМГ / РМГ / PMG / RMG) → identifier class
+    # @param series [String, Symbol]
+    # @return [Class<Identifier>, nil]
+    def self.identifier_klass_for_series(series)
+      @by_series ||= identifier_types.to_h do |klass|
+        [klass.type[:series].to_s, klass]
+      end
+      @by_series[series.to_s] || @by_series[series.to_s.upcase]
+    end
+  end
+end
+
+Pubid::Registry.register(:easc, Pubid::Easc)

data/lib/pubid/ecma/builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Turns the Parslet parse tree into a concrete identifier object. The class
+    # is chosen by which number key the parser captured.
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        if data[:tr_number]
+          Identifiers::TechnicalReport.new(number: data[:tr_number].to_s)
+        elsif data[:mem_number]
+          Identifiers::Memento.new(number: data[:mem_number].to_s)
+        else
+          build_standard(data)
+        end
+      end
+
+      private
+
+      def build_standard(data)
+        attrs = { number: data[:number].to_s }
+        attrs[:part] = data[:part].to_s if data[:part]
+        Identifiers::Standard.new(**attrs)
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifier.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Base class for every ECMA identifier AND the flavor's parse entry point —
+    # mirrors Pubid::Jis::Identifier. Concrete identifiers under
+    # Pubid::Ecma::Identifiers descend from this class, so a parsed ECMA id is
+    # an instance of Pubid::Ecma::Identifier. ECMA has no supplement layer.
+    class Identifier < ::Pubid::Identifier
+      # The document number as a string (preserves any leading zeros). `part`
+      # is only present for standards that split into parts (e.g. ECMA-418-1).
+      attribute :number, :string
+      attribute :part, :string
+      # Edition is separate metadata (the index stores {:id, :ed} and the YAML
+      # has edition.content); it is NOT part of the printed identifier string.
+      # Modelled as an optional string (decimal editions like "5.1" occur) that
+      # serializes in `to_hash` — so relaton preserves `:ed:` — but is omitted
+      # from `to_s`. No default, so it drops from the hash when unset.
+      attribute :edition, :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.
+      ECMA_TYPE_MAP = {
+        "pubid:ecma:standard" => "Pubid::Ecma::Identifiers::Standard",
+        "pubid:ecma:technical-report" =>
+          "Pubid::Ecma::Identifiers::TechnicalReport",
+        "pubid:ecma:memento" => "Pubid::Ecma::Identifiers::Memento",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ECMA_TYPE_MAP
+        map "number", to: :number
+        map "part", to: :part
+        map "edition", to: :edition
+      end
+
+      # Publisher is always "ECMA". A plain constant (not a `publisher` method)
+      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
+      # would otherwise fail serialization type validation.
+      PUBLISHER = "ECMA"
+
+      # Whether the last `to_s` should include the "ECMA" publisher token.
+      attr_reader :with_publisher
+
+      # Basic string representation. Delegates to renderer. `with_publisher:
+      # false` drops the ECMA token (e.g. "-411", "TR/84").
+      def to_s(with_publisher: true, **opts)
+        @with_publisher = with_publisher
+        render(format: :human, **opts)
+      end
+
+      # Type token that precedes the number ("TR"/"MEM"), or nil for standards.
+      # Overridden by each concrete identifier class.
+      def type_prefix
+        nil
+      end
+
+      # Parse an ECMA identifier string into an identifier object.
+      # @param identifier [String] The ECMA identifier string to parse
+      # @return [Identifier] The appropriate identifier object
+      # @raise [ArgumentError] If the input exceeds MAX_INPUT_LENGTH
+      # @raise [RuntimeError] If parsing fails
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ECMA identifier '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifiers/memento.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      # Memento identifier type.
+      # Format: ECMA MEM/<year>. Example: ECMA MEM/1970
+      class Memento < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :mem,
+            stage_code: :published,
+            type_code: :ecma,
+            abbr: ["MEM"],
+            name: "Memento",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :mem, web: :memento, title: "Memento", short: "MEM" }
+        end
+
+        def type_prefix
+          "MEM"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      # Default ECMA identifier type (no type token).
+      # Examples: ECMA-411, ECMA-418-1
+      class Standard < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :standard,
+            stage_code: :published,
+            type_code: :ecma,
+            abbr: ["ECMA"],
+            name: "Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :standard, web: :standard, title: "Standard", short: "ECMA" }
+        end
+
+        # No type token for standards.
+        def type_prefix
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifiers/technical_report.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      # Technical Report identifier type.
+      # Format: ECMA TR/<number>. Example: ECMA TR/101
+      class TechnicalReport < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :tr,
+            stage_code: :published,
+            type_code: :ecma,
+            abbr: ["TR"],
+            name: "Technical Report",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :tr, web: :technical_report, title: "Technical Report",
+            short: "TR" }
+        end
+
+        def type_prefix
+          "TR"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ecma/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    module Identifiers
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :Memento, "#{__dir__}/identifiers/memento"
+    end
+  end
+end

data/lib/pubid/ecma/parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ecma
+    # Parslet grammar for ECMA identifiers.
+    #
+    # Four printed forms (see HANDOFFS/ecma.md):
+    #   ECMA-411          standard
+    #   ECMA-418-1        standard with part
+    #   ECMA TR/101       technical report
+    #   ECMA MEM/1970     memento
+    #
+    # Each branch captures its number under a distinct key so the builder can
+    # pick the identifier class without a separate type token. Numbers are kept
+    # as strings to preserve any leading zeros.
+    class Parser < Parslet::Parser
+      rule(:digits) { match["0-9"].repeat(1) }
+
+      rule(:prefix) { str("ECMA") }
+
+      rule(:tr) { str(" TR/") >> digits.as(:tr_number) }
+
+      rule(:mem) { str(" MEM/") >> digits.as(:mem_number) }
+
+      rule(:standard) do
+        str("-") >> digits.as(:number) >>
+          (str("-") >> digits.as(:part)).maybe
+      end
+
+      rule(:identifier) { prefix >> (tr | mem | standard) }
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/ecma/renderer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Human-readable renderer for ECMA identifiers.
+    #
+    # Produces strings like:
+    #   "ECMA-411"        standard
+    #   "ECMA-418-1"      standard with part
+    #   "ECMA TR/101"     technical report
+    #   "ECMA MEM/1970"   memento
+    #
+    # With `with_publisher: false` the leading ECMA token is dropped, yielding
+    # "-411" / "TR/101" / "MEM/1970". The edition is never rendered — it is
+    # separate metadata carried only in `to_hash`.
+    class Renderer < ::Pubid::Renderers::Base
+      PUBLISHER = "ECMA"
+
+      def render(context: nil, **opts)
+        id = @id
+        # Standard joins the publisher directly ("ECMA-411"); TR/MEM separate it
+        # with a space ("ECMA TR/101"). type_prefix is nil only for standards.
+        sep = id.type_prefix.nil? ? "" : " "
+        core = id.type_prefix.nil? ? standard_core(id) : typed_core(id)
+        with_publisher?(id) ? "#{PUBLISHER}#{sep}#{core}" : core
+      end
+
+      private
+
+      # Standard: "-<number>[-<part>]".
+      def standard_core(id)
+        core = "-#{id.number}"
+        id.part ? "#{core}-#{id.part}" : core
+      end
+
+      # Technical Report / Memento: "<TYPE>/<number>".
+      def typed_core(id)
+        "#{id.type_prefix}/#{id.number}"
+      end
+
+      def with_publisher?(id)
+        id.with_publisher != false
+      end
+    end
+  end
+end

data/lib/pubid/ecma/urn_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Emits `urn:ecma:<tag>:<number>[:part-<part>]` where the tag is bare for
+    # standards, "tr" for technical reports and "mem" for mementos:
+    #   ECMA-411      -> urn:ecma:411
+    #   ECMA-418-1    -> urn:ecma:418:part-1
+    #   ECMA TR/101   -> urn:ecma:tr:101
+    #   ECMA MEM/1970 -> urn:ecma:mem:1970
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "ecma"]
+
+        tag = identifier.type_prefix&.downcase
+        parts << tag if tag
+
+        parts << identifier.number.to_s
+        parts << "part-#{identifier.part}" if identifier.part
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/ecma/urn_parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    # Parses ECMA URNs back into identifiers, inverting {UrnGenerator}.
+    #
+    # Examples:
+    #   urn:ecma:411        -> ECMA-411
+    #   urn:ecma:418:part-1 -> ECMA-418-1
+    #   urn:ecma:tr:101     -> ECMA TR/101
+    #   urn:ecma:mem:1970   -> ECMA MEM/1970
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        tag = %w[tr mem].include?(parts.first) ? parts.shift : nil
+        number = parts.shift
+        part = if parts.first&.start_with?("part-")
+                 parts.shift.sub("part-", "")
+               end
+        flavor_parse(reconstruct(tag, number, part))
+      end
+
+      private
+
+      # Rebuild the printed identifier string from the URN fields.
+      def reconstruct(tag, number, part)
+        case tag
+        when "tr" then "ECMA TR/#{number}"
+        when "mem" then "ECMA MEM/#{number}"
+        else part ? "ECMA-#{number}-#{part}" : "ECMA-#{number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ecma.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ecma
+    extend Pubid::PrefixesSupport
+
+    # Sole ECMA publisher token (see the parser's `prefix` rule). Document types
+    # (TR/MEM) follow the ECMA prefix as type tokens and are excluded.
+    PREFIXES = ["ECMA"].freeze
+
+    autoload :Builder, "#{__dir__}/ecma/builder"
+    autoload :Identifier, "#{__dir__}/ecma/identifier"
+    autoload :Identifiers, "#{__dir__}/ecma/identifiers"
+    autoload :Parser, "#{__dir__}/ecma/parser"
+    autoload :Renderer, "#{__dir__}/ecma/renderer"
+    autoload :UrnGenerator, "#{__dir__}/ecma/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ecma/urn_parser"
+
+    # Parse an ECMA 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: Ecma::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 ECMA flavor with the registry
+Pubid::Registry.register(:ecma, Pubid::Ecma)

data/lib/pubid/etsi/builder.rb

@@ -95,19 +95,23 @@ module Pubid
       end
 
       def build_version(data)
-        # Handle both version and edition
+        # Handle both version and edition. A partial reference omits both, in
+        # which case version is left nil (not defaulted) so exclude/matches?
+        # treat it as a wildcard.
         if data[:version]
           Components::Version.new(version: data[:version].to_s,
                                   is_edition: false)
         elsif data[:edition]
           Components::Version.new(version: data[:edition].to_s,
                                   is_edition: true)
-        else
-          Components::Version.new(version: "1.0.0", is_edition: false)
         end
       end
 
       def build_date(data)
+        # A partial reference omits the date; leave it nil rather than building
+        # an empty Date, so the canonical to_hash drops it entirely.
+        return nil unless data[:year]
+
         Pubid::Components::Date.new(
           year: data[:year].to_s,
           month: data[:month].to_s,

data/lib/pubid/etsi/identifier.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Pubid::Etsi::Identifier is the ETSI base class (a real Pubid::Identifier
-# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
-# live in identifiers/base.rb. This file just ensures it is loaded.
-require_relative "identifiers/base"
+# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.