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

data/lib/pubid/errors.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  # Every failure pubid raises.
-  #
-  # The three classes below have three different superclasses, chosen so that
-  # code written against the old contract keeps working: relaton-cli rescues
-  # `Parslet::ParseFailed`, and the input guards have always raised
-  # `ArgumentError`. What unifies them is the marker module
-  # {Pubid::Errors::Error}, which every one of them includes, so a caller that
-  # wants "pubid could not do this" writes one rescue:
-  #
-  #   begin
-  #     Pubid::Iso.parse(reference)
-  #   rescue Pubid::Errors::Error => e
-  #     warn e.message
-  #   end
-  #
-  # A URN failure deliberately does not inherit `Parslet::ParseFailed`: no
-  # grammar runs, so there is no parse failure to report.
-  module Errors
-    # Marker module included by every pubid error. Rescue this to catch all
-    # of them, whatever their superclass.
-    module Error; end
-
-    # A printed identifier could not be turned into an identifier object.
-    #
-    # Raised for a grammar rejection, and also for the few flavors that reject
-    # an input before the grammar runs (a CSA comment line, a bad ISBN check
-    # digit). Those synthetic failures carry no parslet cause, so
-    # {#parse_failure_cause} is nillable — check it before calling
-    # `ascii_tree` on it.
-    #
-    # v1's `Pubid::Core::Errors::ParseError` flattened the cause into the
-    # message and threw the object away. This one keeps it.
-    class ParseError < ::Parslet::ParseFailed
-      include Error
-
-      # The string that could not be parsed, when it is known.
-      # @return [String, nil]
-      attr_reader :input
-
-      # The flavor whose grammar rejected the input, lowercased ("iso").
-      #
-      # This is the flavor that actually ran, which is not always the one the
-      # caller named: `Pubid::Iso.parse("ITU-T G.711")` routes through the
-      # MR-string parser into ITU, and reports "itu".
-      # @return [String, nil]
-      attr_reader :flavor
-
-      # @param message [String]
-      # @param parse_failure_cause [Parslet::Cause, nil] parslet's structured
-      #   cause, nil for a failure raised without running a grammar
-      # @param input [String, nil]
-      # @param flavor [String, nil]
-      def initialize(message, parse_failure_cause = nil, input: nil,
-                     flavor: nil)
-        super(message, parse_failure_cause)
-        @input = input
-        @flavor = flavor
-      end
-    end
-
-    # A URN could not be turned into an identifier object.
-    class UrnParseError < ::StandardError
-      include Error
-    end
-
-    # The input was not a String, or was longer than {Pubid::MAX_INPUT_LENGTH}.
-    #
-    # Inherits `ArgumentError` because that is what the guards have always
-    # raised, and because the input is wrong in kind rather than unparseable.
-    class InvalidInputError < ::ArgumentError
-      include Error
-    end
-  end
-end

data/lib/pubid/etsi/renderer.rb

@@ -1,48 +0,0 @@
-# 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_parser.rb

@@ -1,34 +0,0 @@
-# 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/gb/builder.rb

@@ -1,45 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gb
-    module Identifiers
-      autoload :Standard, "#{__dir__}/identifiers/standard"
-    end
-  end
-end

data/lib/pubid/gb/parser.rb

@@ -1,63 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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

data/lib/pubid/gb.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  # Chinese Standard (GB) flavor.
-  #
-  # Covers national (GB), sector/industry (DB, QB, ZB, HB, JB, NY, YY, HJ,
-  # CJ, JG, MH, SL, DL, TB, TD, ...) and social-group (T/{ORG}) standards
-  # issued under the Chinese standards system. The mandate category is
-  # carried after a slash: T (recommended), Z (guideline), or omitted
-  # (mandatory).
-  module Gb
-    extend Pubid::PrefixesSupport
-
-    # Leading tokens a printed Chinese Standard identifier may start with.
-    # Used by relaton to route reference strings to this flavor. National
-    # "GB" comes first so PrefixesSupport's longest-match wins.
-    PREFIXES = %w[
-      GB GB/T GB/Z
-      DB DB/T DB/Z
-      QB QB/T
-      ZB ZB/T
-      HB HB/T
-      JB JB/T
-      NY NY/T
-      YY YY/T
-      HJ HJ/T
-      CJ CJ/T
-      JG JG/T
-      MH MH/T
-      SL SL/T
-      DL DL/T
-      TB TB/T
-      TD TD/T
-      T/
-    ].freeze
-
-    autoload :Builder, "#{__dir__}/gb/builder"
-    autoload :Identifier, "#{__dir__}/gb/identifier"
-    autoload :Identifiers, "#{__dir__}/gb/identifiers"
-    autoload :Parser, "#{__dir__}/gb/parser"
-    autoload :Renderer, "#{__dir__}/gb/renderer"
-
-    # Parse a Chinese Standard identifier string.
-    # @param identifier [String] e.g. "GB/T 20223-2006"
-    # @return [Pubid::Gb::Identifier]
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Gb::Renderer)
-
-    # Auto-discover concrete identifier types.
-    # @return [Array<Class>]
-    def self.identifier_types
-      @identifier_types ||= Identifiers.constants
-        .filter_map do |c| 
-        
-        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
-
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
-      end
-    end
-
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find do |s| 
-        s.abbr.any? do |a|
-          a.to_s.upcase == abbr_str
-        end
-      end
-    end
-  end
-end
-
-Pubid::Registry.register(:gb, Pubid::Gb)

data/lib/pubid/gost/builder.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    # Builds a GOST identifier object from the Parslet parse tree.
-    class Builder
-      NUMBER_YEAR_SPLIT = /\A(.+?)\s*[-—–]\s*(\d{2}|\d{4})\z/.freeze
-
-      # Cyrillic → Latin copublisher normalization. Compound forms
-      # (with /) are included.
-      COPUBLISHER_MAP = {
-        "ИСО" => "ISO", "МЭК" => "IEC", "ЕН" => "EN",
-        "ИСО/МЭК" => "ISO/IEC", "МЭК/ИСО" => "IEC/ISO",
-        "ИСО/ТУ" => "ISO/TS", "ИСО/ТО" => "ISO/TR",
-        "МЭК/ТУ" => "IEC/TS", "МЭК/ТО" => "IEC/TR",
-        "ИСО/МЭК/ТУ" => "ISO/IEC/TS",
-      }.freeze
-
-      # Cyrillic → Latin subtype normalization.
-      SUBTYPE_MAP = {
-        "МФС" => "ISP",
-        "ТУ" => "TS", "ТО" => "TR",
-      }.freeze
-
-      def build(parsed)
-        base = build_base(parsed)
-        with_foreign_adoption(base, parsed)
-      end
-
-      def self.build(parsed)
-        new.build(parsed)
-      end
-
-      private
-
-      def build_base(parsed)
-        russian = parsed[:scope_r] ? true : false
-        copublisher, subtype = split_prefix(stringify(parsed[:prefix_text]))
-        number, year = split_number_year(stringify(parsed[:raw]))
-
-        klass = russian ? Identifiers::NationalStandard : Identifiers::InterstateStandard
-        klass.new(**{
-          copublisher: copublisher,
-          subtype: subtype,
-          number: number,
-          year: year,
-        }.compact)
-      end
-
-      # Apply the slash (IdenticalAdoption) and/or parens (Harmonized)
-      # wrappers around the base standard. Both can apply simultaneously.
-      def with_foreign_adoption(base, parsed)
-        wrapper = wrap_identical_adoption(base, parsed)
-        wrap_harmonized(wrapper, parsed)
-      end
-
-      def wrap_identical_adoption(base, parsed)
-        adopted_raw = stringify(parsed[:adopted_raw])
-        return base unless adopted_raw
-
-        adopted = parse_foreign(adopted_raw)
-        Identifiers::IdenticalAdoption.new(base: base, adopted: adopted)
-      end
-
-      def wrap_harmonized(base, parsed)
-        reference_raw = stringify(parsed[:adopted_reference_raw])
-        return base unless reference_raw
-
-        items = reference_raw.split(",").map(&:strip).map { |s| normalize_foreign(s) }
-        adopted = items.map { |item| adopt_identifier(item) }
-
-        Identifiers::Harmonized.new(base: base, adopted_identifiers: adopted)
-      end
-
-      # Parse a single foreign identifier, falling back to a
-      # ForeignReference that preserves the raw surface form when no
-      # registered flavor recognizes it (e.g. OECD, UNECE STANDARD).
-      def adopt_identifier(raw)
-        parse_foreign(raw) || Identifiers::ForeignReference.new(raw: raw)
-      end
-
-      def split_prefix(text)
-        return [nil, nil] unless text
-
-        tokens = text.strip.split(/\s+/)
-        copublisher_raw = tokens.first
-        subtype_raw = tokens.size > 1 ? tokens.drop(1).join(" ") : nil
-
-        [normalize_copublisher(copublisher_raw), normalize_subtype(subtype_raw)]
-      end
-
-      def normalize_copublisher(raw)
-        return nil unless raw
-        COPUBLISHER_MAP.fetch(raw) { raw.upcase }
-      end
-
-      def normalize_subtype(raw)
-        return nil unless raw
-        SUBTYPE_MAP.fetch(raw) { raw }
-      end
-
-      # Normalize a leading Cyrillic publisher token (e.g. "ИСО") to its
-      # Latin equivalent so a foreign parser can recognize it. Longest
-      # keys first so "ИСО/МЭК" wins over "ИСО".
-      def normalize_foreign(raw)
-        COPUBLISHER_MAP.keys.sort_by(&:length).reverse.each do |cyr|
-          next unless raw.start_with?(cyr + " ") || raw.start_with?(cyr + "/")
-
-          return COPUBLISHER_MAP[cyr] + raw[cyr.length..]
-        end
-        raw
-      end
-
-      def split_number_year(raw)
-        return [raw, nil] unless raw
-
-        m = raw.match(NUMBER_YEAR_SPLIT)
-        return [raw, nil] unless m
-
-        [m[1], m[2]]
-      end
-
-      # Try every registered flavor (other than GOST itself) as a parser
-      # for a foreign adopted identifier. Returns the first successful
-      # parse, or nil if none recognize the string.
-      def parse_foreign(raw)
-        ::Pubid.eager_load_flavors!
-        ::Pubid::Registry.flavors.each_value do |mod|
-          next if mod == ::Pubid::Gost
-
-          begin
-            return mod.parse(raw)
-          rescue StandardError
-            next
-          end
-        end
-        nil
-      end
-
-      def stringify(value)
-        return nil if value.nil?
-
-        str = value.to_s
-        str.empty? ? nil : str
-      end
-    end
-  end
-end