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

data/lib/pubid/itu/identifiers/question.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # ITU Question — the study topics assigned to a study group.
-      #
-      # Two printed forms, both modelled by this one class:
-      #
-      #   * numeric (no series):  ITU-R 234-1/7:   ITU-R 237/3:
-      #     number(-part)/study-group, always with a trailing ":".
-      #   * letter-series:        ITU-R P.3/BL/7   ITU-R SM.1/30
-      #     series.number(/BL)?/study-group, optionally bracketed and/or with a
-      #     trailing ":" — e.g. ITU-R S.[4/BL/2]:
-      #
-      # The `/study-group`, the optional "/BL" segment, the surrounding
-      # brackets and the trailing ":" have no home on Components::Code, so they
-      # are carried here and reconstructed exactly by +render_base+.
-      class Question < Identifier
-        include StandardSerialization
-
-        attribute :study_group, :string
-        attribute :has_bl, :boolean, default: -> { false }
-        attribute :bracketed, :boolean, default: -> { false }
-        attribute :has_colon, :boolean, default: -> { false }
-
-        # Extra maps merged on top of the StandardSerialization block. The
-        # booleans emit only when true (false is stripped as the default), and
-        # study_group is a plain scalar.
-        key_value do
-          map "study_group", to: :study_group
-          map "has_bl", to: :has_bl
-          map "bracketed", to: :bracketed
-          map "has_colon", to: :has_colon
-        end
-
-        def render_base(**_opts)
-          result = "#{publisher}-#{sector}"
-          result += series ? " #{series}." : " "
-          result += "[" if bracketed
-          result += code.to_s
-          result += "/BL" if has_bl
-          result += "/#{study_group}"
-          result += "]" if bracketed
-          result += ":" if has_colon
-          result
-        end
-
-        def ==(other)
-          return false unless other.is_a?(Question)
-
-          sector == other.sector &&
-            series == other.series &&
-            code == other.code &&
-            study_group == other.study_group &&
-            has_bl == other.has_bl &&
-            bracketed == other.bracketed &&
-            has_colon == other.has_colon
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/identifiers/report.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # ITU Report — a publication series distinct from Recommendations.
-      # Format: Report ITU-{SECTOR} {SERIES}.{NUMBER}[-EDITION]
-      # Example: Report ITU-R BT.2020-1 (2000)
-      #
-      # Reports and Recommendations number INDEPENDENTLY, so the same
-      # series/number/edition is two different documents — "ITU-R BT.2020-1" is
-      # both Report BT.2020-1 (objective quality assessment, 2000) and
-      # Recommendation BT.2020-1 (UHDTV parameter values, 06/2014). ITU
-      # disambiguates them with the leading word, which is therefore part of
-      # the identifier: the marker reaches `to_s`, `to_urn` and `to_mr_string`,
-      # and the class-strict `Identifier#==` keeps the two unequal in both
-      # directions so `#matches?` can never resolve one to the other.
-      #
-      # Everything else is shaped exactly like a Recommendation
-      # (sector/series/code/date/version/language), including the flat
-      # serialization — only `_type` distinguishes the two hashes.
-      class Report < Identifier
-        include StandardSerialization
-
-        def render_base(**_opts)
-          "Report #{super}"
-        end
-
-        # The MR string doubles as an output filename, so the marker has to
-        # reach it too — otherwise a Report and its same-numbered
-        # Recommendation slug identically and one overwrites the other.
-        # "itu.r.report.bt-2020-1"
-        def mr_type
-          [super, "report"].compact.join(".")
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/identifiers/standard_serialization.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # Installs the compact flat `key_value` block shared by the "single
-      # document" leaf types (Recommendation, Handbook, SpecialPublication, and
-      # — extended with their own extra maps — Question and CombinedIdentifier).
-      #
-      # The block lives on the leaves rather than the shared Identifier because
-      # the delegating subtypes (Supplement/Annex) would otherwise inherit-and-
-      # merge it and re-emit their `base`'s fields (the ETSI lesson). The
-      # converter methods it references are defined once on Pubid::Itu::Identifier.
-      module StandardSerialization
-        def self.included(base)
-          base.key_value do
-            map "_type", to: :_type
-            map "sector",
-                with: { to: :sector_to_kv, from: :sector_from_kv }
-            map "series",
-                with: { to: :series_to_kv, from: :series_from_kv }
-            map "imp_marker",
-                with: { to: :imp_marker_to_kv, from: :imp_marker_from_kv }
-            map "number",
-                with: { to: :number_to_kv, from: :number_from_kv }
-            map "series_suffix",
-                with: { to: :series_suffix_to_kv, from: :series_suffix_from_kv }
-            map "series_suffix_spaced",
-                with: { to: :series_suffix_spaced_to_kv,
-                        from: :series_suffix_spaced_from_kv }
-            map "subseries",
-                with: { to: :subseries_to_kv, from: :subseries_from_kv }
-            map "parts",
-                with: { to: :parts_to_kv, from: :parts_from_kv }
-            map "qualifier",
-                with: { to: :qualifier_to_kv, from: :qualifier_from_kv }
-            map "qualifier_glued",
-                with: { to: :qualifier_glued_to_kv,
-                        from: :qualifier_glued_from_kv }
-            map "series_word", to: :series_word
-            map "series_dash", to: :series_dash
-            map "attachment", to: :attachment
-            map "range_end", to: :range_end
-            map "version", to: :version
-            map "year",
-                with: { to: :year_to_kv, from: :year_from_kv }
-            map "month",
-                with: { to: :month_to_kv, from: :month_from_kv }
-            map "language", to: :language
-            map "common_text_twin",
-                with: { to: :common_text_twin_to_kv,
-                        from: :common_text_twin_from_kv }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/urn_parser.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    # Parses ITU URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:itu:{sector}:{code}` where sector is the
-    # lowercase ITU sector letter (t for ITU-T, r for ITU-R, d for ITU-D)
-    # and code is the document code (e.g., "BO.1073-1").
-    #
-    # Examples:
-    # - urn:itu:t:BO.1073-1 → ITU-T BO.1073-1
-    # - urn:itu:r:BO.500    → ITU-R BO.500
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-        sector, code = parts
-
-        # UrnGenerator emits a "report" segment between the sector and the code
-        # for an ITU-R Report, which numbers independently of the
-        # Recommendation series (urn:itu:r:report:BT.2020-1).
-        if parts[1] == "report"
-          return flavor_parse("Report ITU-#{sector.upcase} #{parts[2]}")
-        end
-
-        flavor_parse("ITU-#{sector.upcase} #{code}")
-      end
-    end
-  end
-end

data/lib/pubid/jcgm/identifiers/corrigendum.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jcgm
-    module Identifiers
-      # A JCGM corrigendum. Two surface forms are supported:
-      #
-      #   "JCGM 200:2008 Corrigendum"      — base guide + trailing " Corrigendum"
-      #                                       word, no iteration number
-      #   "JCGM 101:2008/Cor 1:2009"       — base guide + slash-separated
-      #                                       numbered corrigendum with date
-      #
-      # The first form is the JCGM-native convention. The second mirrors the
-      # ISO/IEC supplement syntax and is needed to round-trip identifiers like
-      # "JCGM 101:2008/Cor 1:2009" (corrigendum to GUM Supplement 1).
-      class Corrigendum < SupplementIdentifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :pubcorr,
-            stage_code: :published,
-            type_code: :corrigendum,
-            abbr: %w[Corrigendum Cor],
-            name: "Corrigendum",
-            harmonized_stages: %w[60.00 60.60],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :corrigendum, title: "Corrigendum", short: "Corr" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/jcgm/identifiers/meeting.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jcgm
-    module Identifiers
-      # A JCGM committee/meeting record, e.g. "JCGM 17th Meeting (2012)".
-      #
-      # `number` (Components::Code) holds the meeting ordinal as a clean integer
-      # value ("17"); `date` (Components::Date, year-only) holds the year.
-      class Meeting < SingleIdentifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :pubmeeting,
-            stage_code: :published,
-            type_code: :jcgm_meeting,
-            abbr: ["Meeting"],
-            name: "Meeting",
-            harmonized_stages: %w[60.00 60.60],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :jcgm_meeting, title: "Meeting" }
-        end
-
-        # Ordinal suffix as printed by the JCGM/BIPM data generator: a naive
-        # last-digit rule (1->st, 2->nd, 3->rd, else th) with NO 11/12/13 teens
-        # exception. The real records print "11st", "12nd", "13rd", so applying
-        # the standard-English teens exception would break round-trip.
-        def self.ordinal(number)
-          n = number.to_i
-          suffix = case n % 10
-                   when 1 then "st"
-                   when 2 then "nd"
-                   when 3 then "rd"
-                   else "th"
-                   end
-          "#{n}#{suffix}"
-        end
-
-        def ordinal
-          self.class.ordinal(number)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/jcgm/renderer.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jcgm
-    # Human-readable renderer for JCGM identifiers.
-    #
-    # Produces strings like:
-    #   "JCGM 100:2008"
-    #   "JCGM 100:2008/Amd 1:2023"
-    #   "JCGM GUM-6:2020"
-    #
-    # The renderer is registered as the `:human` format in the JCGM format
-    # registry and invoked via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        case @id
-        when Identifiers::Amendment then render_amendment(@id, context)
-        when Identifiers::Corrigendum then render_corrigendum(@id)
-        when Identifiers::GumGuide then render_gum_guide(@id, context)
-        when Identifiers::Meeting then render_meeting(@id)
-        else render_single(@id)
-        end
-      end
-
-      private
-
-      def render_corrigendum(id)
-        # Two surface forms:
-        #   "JCGM 200:2008 Corrigendum"  — number absent (word form)
-        #   "JCGM 101:2008/Cor 1:2009"   — number present (numbered form)
-        return "#{id.base}/Cor #{id.number}#{corrigendum_date_suffix(id)}" if id.number
-
-        "#{id.base} Corrigendum"
-      end
-
-      def corrigendum_date_suffix(id)
-        id.date ? ":#{id.date}" : ""
-      end
-
-      # Two surface forms:
-      #   "JCGM 17th Meeting (2012)"  — date present (published records)
-      #   "JCGM 17th Meeting"         — date absent (partial reference)
-      # The ordinal alone names the meeting, so the dateless form is a valid
-      # identifier and must stay re-parseable (the parser makes the " (YYYY)"
-      # group optional to match).
-      def render_meeting(id)
-        base = "JCGM #{id.ordinal} Meeting"
-        id.date ? "#{base} (#{id.date.year})" : base
-      end
-
-      def render_single(id)
-        parts = [id.publisher_portion]
-        parts << id.number_portion unless id.number_portion.empty?
-        result = parts.join(" ")
-        result += id.language_portion if id.languages&.any?
-        result
-      end
-
-      def render_amendment(id, context)
-        result = id.base.to_s if id.base
-        result += "/Amd"
-        result += " #{id.number}" if id.number
-        result += ":#{id.date}" if id.date
-        result
-      end
-
-      def render_gum_guide(id, context)
-        parts = []
-        parts << id.publisher.publisher if id.publisher
-        parts << "GUM-#{id.number}" if id.number
-
-        result = parts.join(" ")
-        result += ":#{id.date}" if id.date
-        result += gum_language_portion(id) if id.languages&.any?
-        result
-      end
-
-      def gum_language_portion(id)
-        return "" unless id.languages&.any?
-
-        codes = id.languages.map do |lang|
-          lang.original_code || lang.code
-        end
-
-        "(#{codes.join('/')})"
-      end
-    end
-  end
-end

data/lib/pubid/jcgm/urn_parser.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jcgm
-    # Parses JCGM URNs back into identifiers.
-    #
-    # Identifiers are rebuilt **directly from the URN segments** rather than
-    # rendered to a human-readable string and re-parsed (the BIPM UrnParser
-    # pattern). Round-tripping through the grammar flattened the segments into
-    # one string and silently lost everything the string form could not carry:
-    # a GUM guide (`urn:jcgm:gum.6:2020`) raised, and the language and
-    # supplement segments were dropped, so a corrigendum read back as the
-    # standard it amends — a different document, with no error.
-    #
-    # Shapes emitted by UrnGenerator, and read back here:
-    #   urn:jcgm:200:2008                        → JCGM 200:2008
-    #   urn:jcgm:100:2008:en                     → JCGM 100:2008(E)
-    #   urn:jcgm:200:2012:en,fr                  → JCGM 200:2012(E/F)
-    #   urn:jcgm:GUM                             → JCGM GUM
-    #   urn:jcgm:gum.6:2020                      → JCGM GUM-6:2020
-    #   urn:jcgm:200:2008:corrigendum            → JCGM 200:2008 Corrigendum
-    #   urn:jcgm:101:2008:corrigendum:1:2009     → JCGM 101:2008/Cor 1:2009
-    #   urn:jcgm:100:2008:amendment:1:2023       → JCGM 100:2008/Amd 1:2023
-    #   urn:jcgm:meeting:17:2012                 → JCGM 17th Meeting (2012)
-    #   urn:jcgm:meeting:11                      → JCGM 11st Meeting
-    #
-    # KNOWN GAP, on the generator side and unchanged here: a full date is
-    # rendered as its year alone (`JCGM GUM-1:2022-11-28` →
-    # `urn:jcgm:gum.1:2022`), so a URN cannot restore the month and day.
-    # Widening it would change already-published URNs.
-    class UrnParser < Pubid::UrnParser::Base
-      MEETING_MARKER = "meeting"
-
-      # The GUM-guide number is written "gum.<n>" by UrnGenerator.
-      GUM_PREFIX = "gum."
-
-      # The supplement marker UrnGenerator writes is the typed stage's
-      # `type_code`; the abbreviation is what `Jcgm.locate_stage` matches on.
-      SUPPLEMENT_ABBRS = {
-        "corrigendum" => "Cor",
-        "amendment" => "Amd",
-      }.freeze
-
-      MEETING_ABBR = "Meeting"
-
-      # Mirrors `year_digits` in the shared parser rules.
-      YEAR_PATTERN = /\A(?:19|20)\d{2}\z/
-
-      # A language segment is one or more comma-joined ISO codes.
-      LANGUAGES_PATTERN = /\A[a-z]{2}(?:,[a-z]{2})*\z/
-
-      # Language codes back to the single-letter form the identifier prints;
-      # the builder maps the other way when parsing "(E)" / "(E/F)".
-      LANGUAGE_LETTERS = Pubid::Builder::Base::LANG_CHAR_MAP.invert.freeze
-
-      def parse_urn(urn)
-        parts = split_parts(strip_namespace(urn))
-        return parse_meeting_urn(parts) if parts.first == MEETING_MARKER
-
-        parse_document_urn(parts)
-      end
-
-      private
-
-      # urn:jcgm:meeting:<number>[:<year>] -> Identifiers::Meeting
-      #
-      # The reconstruction must agree with a parsed identifier attribute for
-      # attribute, so `typed_stage` comes from the same registry lookup
-      # `Builder#locate_typed_stage` uses. (The attribute default now agrees
-      # too — it no longer sets `original_abbr` — so this mirrors the builder
-      # for clarity rather than out of necessity.)
-      def parse_meeting_urn(parts)
-        _, number, year = parts
-
-        Identifiers::Meeting.new(
-          number: meeting_number(number),
-          date: urn_date(year),
-          typed_stage: Jcgm.locate_stage(MEETING_ABBR),
-        )
-      end
-
-      # A guide, a GUM guide, or a supplement wrapping one of those. The
-      # supplement marker splits the segments: everything before it describes
-      # the base document, everything after is the supplement's own number and
-      # date.
-      def parse_document_urn(parts)
-        marker_at = parts.index { |segment| SUPPLEMENT_ABBRS.key?(segment) }
-        return build_document(parts) unless marker_at
-
-        build_supplement(
-          parts[marker_at],
-          build_document(parts[0...marker_at]),
-          parts[(marker_at + 1)..] || [],
-        )
-      end
-
-      # The class comes from the same registry the builder uses, so a URN and a
-      # parsed reference resolve to one class and one typed_stage.
-      def build_supplement(marker, base, tail)
-        typed_stage = Jcgm.locate_stage(SUPPLEMENT_ABBRS.fetch(marker))
-        number, year = tail
-
-        Jcgm.locate_type(typed_stage.type_code).new(
-          base: base,
-          number: (number.nil? || number.empty? ? nil : number.to_s),
-          date: urn_date(year),
-          typed_stage: typed_stage,
-        )
-      end
-
-      # <number>[:<year>][:<languages>] — the number segment carries the
-      # "gum." prefix for a GUM guide, which is what selects the class.
-      #
-      # Guide and GumGuide deliberately take their `typed_stage` from the
-      # attribute default: the grammar emits no type token for them, so
-      # `Builder#build` fills it from `published_typed_stage` too, and both
-      # paths agree.
-      def build_document(parts)
-        number, *rest = parts
-        require_number!(number)
-        gum = number.start_with?(GUM_PREFIX)
-
-        (gum ? Identifiers::GumGuide : Identifiers::Guide).new(
-          number: (gum ? number.delete_prefix(GUM_PREFIX) : number).to_s,
-          date: urn_date(segment_matching(rest, YEAR_PATTERN)),
-          languages: urn_languages(segment_matching(rest, LANGUAGES_PATTERN)),
-        )
-      end
-
-      def require_number!(segment)
-        return unless segment.nil? || segment.empty?
-
-        raise Pubid::UrnParser::Errors::ParseError,
-              "JCGM URN has no document number"
-      end
-
-      def segment_matching(segments, pattern)
-        segments.find { |segment| segment.match?(pattern) }
-      end
-
-      # The ordinal, normalized the way `Identifiers::Meeting.ordinal` does it
-      # (`number.to_i`), so "011" reads back as "11" and a missing or
-      # non-numeric segment as "0" — the behaviour of the previous
-      # render-and-re-parse implementation.
-      def meeting_number(segment)
-        segment.to_i.to_s
-      end
-
-      # nil for an absent year; a Date for a well-formed one. The grammar
-      # accepts only a 19xx/20xx year, so anything else is a malformed URN and
-      # must still be rejected now that no re-parse validates it.
-      def urn_date(segment)
-        return nil if segment.nil? || segment.empty?
-
-        unless segment.match?(YEAR_PATTERN)
-          raise Pubid::UrnParser::Errors::ParseError,
-                "Invalid year in JCGM URN: #{segment.inspect}"
-        end
-
-        Pubid::Components::Date.new(year: segment)
-      end
-
-      # "en" -> (E), "en,fr" -> (E/F). `original_code` is what the renderer
-      # prints, so it is restored from the code rather than left nil.
-      def urn_languages(segment)
-        return nil if segment.nil? || segment.empty?
-
-        segment.split(",").map do |code|
-          Pubid::Components::Language.new(
-            code: code,
-            original_code: LANGUAGE_LETTERS.fetch(code, code),
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pubid/jis/identifiers/corrigendum.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jis
-    module Identifiers
-      # Corrigendum identifier type
-      # Format: {base}/CORRIGENDUM {number}:{year}
-      # Example: JIS B 3700-11:1996/CORRIGENDUM 1:2002
-      class Corrigendum < SupplementIdentifier
-        def supplement_notation
-          "CORRIGENDUM #{number}:#{year_with_reaffirmation}"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/jis/renderer.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jis
-    # Human-readable renderer for JIS identifiers.
-    #
-    # Produces strings like:
-    #   "JIS A 0001:1999"
-    #   "JIS TR Z 8301:2019"
-    #   "JIS B 3700-11:1996/CORRIGENDUM 1:2002"
-    #   "JIS K 2151:2004/EXPL"
-    #
-    # The renderer is registered as the `:human` format in the JIS format
-    # registry and invoked via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      PUBLISHER = "JIS"
-
-      def render(context: nil, **opts)
-        id = @id
-
-        case id
-        when SupplementIdentifier
-          render_supplement(id)
-        when SingleIdentifier
-          render_single(id)
-        else
-          render_base(id)
-        end
-      end
-
-      private
-
-      def with_publisher?(id)
-        id.with_publisher != false
-      end
-
-      def render_base(id)
-        result = "#{PUBLISHER} #{id.code}"
-        result += ":#{id.year_with_reaffirmation}" if id.year
-        result += "(#{id.language})" if id.language
-        result += "（規格群）" if id.all_parts?
-        result + id.symbol_suffix
-      end
-
-      def render_single(id)
-        with_pub = with_publisher?(id)
-        parts = []
-        parts << PUBLISHER if with_pub
-        parts << id.type_prefix if id.class.method_defined?(:type_prefix) && id.type_prefix
-        result = parts.join(" ")
-        result += " " if result.length.positive?
-        result += id.code.to_s
-        result += ":#{id.year_with_reaffirmation}" if id.year
-        result += "(#{id.language})" if id.language
-        result += "（規格群）" if id.all_parts?
-        result += id.symbol_suffix
-        result
-      end
-
-      def render_supplement(id)
-        with_pub = with_publisher?(id)
-        result = id.base.to_s(with_publisher: with_pub)
-        result += "/#{id.supplement_notation}"
-        result += id.symbol_suffix
-        result
-      end
-    end
-  end
-end

data/lib/pubid/jis/urn_parser.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Jis
-    # Parses JIS URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:jis:{code}:{year}` where code is the
-    # classification letter + number (e.g., "X 0201").
-    #
-    # Examples:
-    # - urn:jis:X 0201:1997 → JIS X 0201:1997
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-        code, year = parts
-        text = "JIS #{code}"
-        text += ":#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end