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

data/lib/pubid/bsi/urn_parser.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Bsi
-    # Parses BSI URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:bsi:{publisher}:{number}:{year}[:{supp_type}:{supp_number}:{supp_year}]
-    #
-    # publisher is the lowercase publisher (e.g., "bs", "pd"). supplement
-    # triples (`amd`/`cor`/`add`) follow the base identifier.
-    #
-    # Examples:
-    # - urn:bsi:bs:9001:2015                → BS 9001:2015
-    # - urn:bsi:bs:9001:2015:amd:1:2020     → BS 9001:2015/A1:2020
-    class UrnParser < Pubid::UrnParser::Base
-      SUPPLEMENT_ABBR = {
-        "amd" => "Amd",
-        "cor" => "Cor",
-        "add" => "Add",
-      }.freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        publisher_token, number, year, *supplement_parts = parts
-        publisher = publisher_token.upcase
-        text = "#{publisher} #{number}"
-        text += ":#{year}" if year
-        text += build_supplements(supplement_parts)
-        flavor_parse(text)
-      end
-
-      private
-
-      def build_supplements(parts)
-        return "" if parts.empty?
-
-        chunks = parts.each_slice(3).to_a
-        chunks.map { |type, num, supp_year| render_supplement(type, num, supp_year) }.join
-      end
-
-      def render_supplement(type, num, supp_year)
-        label = SUPPLEMENT_ABBR.fetch(type.downcase) { type.capitalize }
-        suffix = num ? " #{num}" : ""
-        suffix += ":#{supp_year}" if supp_year
-        "/#{label}#{suffix}"
-      end
-    end
-  end
-end

data/lib/pubid/calconnect/builder.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Calconnect
-    # Builds a CalConnect identifier object from a Parslet parse tree. There is
-    # a single concrete type (Identifiers::Standard), so no type dispatch.
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        Identifiers::Standard.new(
-          series: data[:series]&.to_s,
-          number: data[:number].to_s,
-          date: build_date(data),
-        )
-      end
-
-      private
-
-      # Publication date as a Pubid::Components::Date, or nil for a partial
-      # reference that omits the trailing ":YYYY" (relaton matches such refs by
-      # excluding the date). Digits are kept as strings verbatim (already
-      # zero-padded in the source, e.g. "07"/"23"); month/day are nil for the
-      # common year-only form.
-      def build_date(data)
-        return nil if data[:year].nil?
-
-        ::Pubid::Components::Date.new(
-          year: data[:year].to_s,
-          month: data[:month]&.to_s,
-          day: data[:day]&.to_s,
-        )
-      end
-    end
-  end
-end

data/lib/pubid/calconnect/identifier.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Calconnect
-    # Base class for every CalConnect identifier AND the flavor's parse entry
-    # point — mirrors Pubid::Jis::Identifier. Concrete identifiers under
-    # Pubid::Calconnect::Identifiers descend from this class, so a parsed
-    # CalConnect id is an instance of Pubid::Calconnect::Identifier and
-    # relaton-index can pass this class as `pubid_class` for from_hash/to_hash.
-    class Identifier < ::Pubid::Identifier
-      # `number` is a CalConnect-specific plain string (preserves leading zeros
-      # like "0514" and the sub-part separator, "0812-1"/"0707.1"), so it
-      # overrides the inherited Components::Code type. The publication date uses
-      # the shared Pubid::Components::Date (inherited attribute): `year` is
-      # always present, `month`/`day` only for the rare full-date form
-      # ("CC/WD 51017:2024-07-23").
-      attribute :series, :string # Optional series letter/token (A, WD, DIR, …)
-      attribute :number, :string
-      attribute :date, ::Pubid::Components::Date
-
-      # Polymorphic type map for lutaml::Model key_value (de)serialization,
-      # mapping the concrete class's polymorphic_name to its class name so a
-      # stored hash rebuilds the correct identifier type via from_hash.
-      CALCONNECT_TYPE_MAP = {
-        "pubid:calconnect:standard" => "Pubid::Calconnect::Identifiers::Standard",
-      }.freeze
-
-      # The date serializes FLAT as year/month/day string keys (nils omitted),
-      # mirroring lib/pubid/iso/identifier.rb — not as a nested "date" object —
-      # so the index row stays a shallow hash and round-trips exactly.
-      key_value do
-        map "_type", to: :_type, polymorphic_map: CALCONNECT_TYPE_MAP
-        map "series", to: :series
-        map "number", to: :number
-        map "year", with: { to: :year_to_kv, from: :year_from_kv }
-        map "month", with: { to: :month_to_kv, from: :month_from_kv }
-        map "day", with: { to: :day_to_kv, from: :day_from_kv }
-      end
-
-      # Publisher is always "CC". 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 = "CC"
-
-      attr_reader :with_publisher
-
-      # Render the publication date, e.g. "2018" or "2024-07-23". Shared by the
-      # renderer and the URN generator so they always agree.
-      # Pubid::Components::Date#to_s yields the year alone, or the zero-padded
-      # "YYYY-MM-DD" when month/day are present.
-      def date_string
-        date&.to_s
-      end
-
-      # Basic string representation. Delegates to the human renderer. The
-      # printed CalConnect id carries the "CC" publisher token by default; pass
-      # with_publisher: false to drop it (and the series slash).
-      def to_s(**opts)
-        render(format: :human, **opts)
-      end
-
-      # Capture the with_publisher flag on EVERY render call (default true), so
-      # it can never leak across calls. The base `render` only forwards
-      # `:with_edition` to the renderer, so the flag is threaded via this
-      # per-call instance write (the renderer reads `id.with_publisher`).
-      def render(format: :human, with_publisher: true, **opts)
-        @with_publisher = with_publisher
-        super(format: format, **opts)
-      end
-
-      # --- date serialized flat as year/month/day (mirrors ISO) ---
-      def year_to_kv(model, doc)
-        emit_date_part(doc, "year", model.date&.year)
-      end
-
-      def month_to_kv(model, doc)
-        emit_date_part(doc, "month", model.date&.month)
-      end
-
-      def day_to_kv(model, doc)
-        emit_date_part(doc, "day", model.date&.day)
-      end
-
-      def year_from_kv(model, value) = date_for(model).year = value.to_s
-      def month_from_kv(model, value) = date_for(model).month = value.to_s
-      def day_from_kv(model, value) = date_for(model).day = value.to_s
-
-      def emit_date_part(doc, key, val)
-        return if val.nil? || val.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
-      end
-
-      def date_for(model)
-        model.date ||= ::Pubid::Components::Date.new
-      end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
-      # CALCONNECT_TYPE_MAP remains as the key_value polymorphic_map.
-
-      # Parse a CalConnect identifier string into an identifier object.
-      # @param identifier [String] The CalConnect 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
-
-        Builder.build(Parser.parse(identifier))
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Calconnect
-    module Identifiers
-      # The sole CalConnect document type. Its polymorphic_name resolves
-      # automatically to "pubid:calconnect:standard".
-      class Standard < Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :pubcc,
-            stage_code: :published,
-            type_code: :cc,
-            abbr: ["CC"],
-            name: "CalConnect Standard",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :cc,
-            web: :standard,
-            title: "CalConnect Standard",
-            short: "CC" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/calconnect/identifiers.rb

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

data/lib/pubid/calconnect/parser.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Calconnect
-    # Parslet grammar for CalConnect identifiers.
-    #
-    # Shape: CC[/<series>] <number>:<date>
-    #   CC 18011:2018
-    #   CC/DIR 10006:2019
-    #   CC/Adv 0707.1:2007        (dot sub-part)
-    #   CC/A 0812-1:2008          (dash sub-part)
-    #   CC/WD 51017:2024-07-23    (full ISO date)
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-
-      # Publisher token
-      rule(:publisher) { str("CC") }
-
-      # Series token — an open [A-Za-z]+ set (A, WD, R, S, CD, DIR, Adv, FDS, …)
-      rule(:series) { match["A-Za-z"].repeat(1).as(:series) }
-
-      # Number — digits, preserving leading zeros, with at most one dot- or
-      # dash-delimited sub-part ("0707.1", "0812-1"). Kept as a string.
-      rule(:number) do
-        (digits >> ((str(".") | str("-")) >> digits).maybe).as(:number)
-      end
-
-      # Date after the colon: a year, optionally a full "YYYY-MM-DD". The colon
-      # hard-delimits number from date, and month+day only appear together, so
-      # the split is unambiguous.
-      rule(:date) do
-        digits.as(:year) >>
-          (str("-") >> digits.as(:month) >> str("-") >> digits.as(:day)).maybe
-      end
-
-      rule(:identifier) do
-        publisher >>
-          (str("/") >> series).maybe >>
-          str(" ") >>
-          number >>
-          (str(":") >> date).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/calconnect/renderer.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Calconnect
-    # Human-readable renderer for CalConnect identifiers.
-    #
-    # Produces the canonical printed form, e.g.:
-    #   "CC 18011:2018"
-    #   "CC/DIR 10006:2019"
-    #   "CC/WD 51017:2024-07-23"
-    #   "DIR 10006:2019"          (only when with_publisher: false)
-    #
-    # Registered as the `:human` format in the CalConnect format registry and
-    # invoked via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      PUBLISHER = "CC"
-
-      def render(**_opts)
-        id = @id
-        prefix = if with_publisher?(id)
-                   id.series ? "#{PUBLISHER}/#{id.series} " : "#{PUBLISHER} "
-                 else
-                   id.series ? "#{id.series} " : ""
-                 end
-        date = id.date_string
-        "#{prefix}#{id.number}#{":#{date}" if date}"
-      end
-
-      private
-
-      def with_publisher?(id)
-        id.respond_to?(:with_publisher) && id.with_publisher != false
-      end
-    end
-  end
-end

data/lib/pubid/calconnect/urn_generator.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Calconnect
-    # Emits CalConnect URNs of the form
-    #   urn:calconnect[:<series>]:<number>:<date>
-    # e.g. "urn:calconnect:DIR:10006:2019", "urn:calconnect:18011:2018",
-    # "urn:calconnect:WD:51017:2024-07-23".
-    #
-    # The series keeps its printed case (JIS keeps its code case likewise) so a
-    # URN reconstructs the human form losslessly — mirror in urn_parser.rb.
-    #
-    # NOTE: a *partial* (date-less) reference has NO round-trippable URN form.
-    # Both `series` and `date` are optional, and UrnParser reads the trailing
-    # segments positionally, so a date-less URN like "urn:calconnect:11001"
-    # (or "urn:calconnect:DIR:10006") is ambiguous with a series-less dated URN
-    # and does not parse back. Partial refs are matched by pubid `#exclude`,
-    # not by URN, so this generator simply omits the missing segment rather
-    # than emitting an empty ":" — callers must not rely on URN round-trip for
-    # a partial id.
-    class UrnGenerator < Pubid::UrnGenerator::Base
-      def generate
-        # series and date_string are nil for a series-less or partial
-        # (date-less) id; compact drops them so no empty ":" segment appears.
-        parts = [
-          "urn", "calconnect",
-          identifier.series, identifier.number.to_s, identifier.date_string
-        ]
-        parts.compact.join(":")
-      end
-    end
-  end
-end

data/lib/pubid/calconnect/urn_parser.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Calconnect
-    # Parses CalConnect URNs back into identifiers.
-    #
-    # UrnGenerator emits: urn:calconnect[:<series>]:<number>:<date>
-    #   urn:calconnect:18011:2018            → CC 18011:2018
-    #   urn:calconnect:DIR:10006:2019        → CC/DIR 10006:2019
-    #   urn:calconnect:WD:51017:2024-07-23   → CC/WD 51017:2024-07-23
-    #
-    # The date segment (year or full "YYYY-MM-DD") never contains a colon, so
-    # it is a single trailing part; the number precedes it, and an optional
-    # series precedes the number.
-    #
-    # This positional pop assumes a *dated* URN (the form UrnGenerator emits for
-    # a full id). A partial (date-less) reference has no round-trippable URN —
-    # see UrnGenerator — so this parser is only guaranteed for URNs produced
-    # from a full id; a date-less URN misaligns the pops and will not parse.
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        parts = split_parts(strip_namespace(urn))
-        date = parts.pop
-        number = parts.pop
-        series = parts.pop
-
-        text = +"CC"
-        text << "/#{series}" if series
-        text << " #{number}:#{date}"
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/calconnect.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  # CalConnect (The Calendaring and Scheduling Consortium) flavor.
-  #
-  # Parses/renders the "CC …" numbering, e.g. "CC 18011:2018",
-  # "CC/DIR 10006:2019", "CC/Adv 0707.1:2007". Modeled on Pubid::Jis: a single
-  # flat identifier type (Identifiers::Standard) with no supplement layer.
-  module Calconnect
-    extend Pubid::PrefixesSupport
-
-    # Sole CalConnect publisher/leading token. Series letters (A, WD, R, S, CD,
-    # DIR, Adv, FDS) follow "CC/" and never lead a reference, so they are
-    # excluded per the PrefixesSupport inclusion policy.
-    PREFIXES = ["CC"].freeze
-
-    autoload :Builder, "#{__dir__}/calconnect/builder"
-    autoload :Identifier, "#{__dir__}/calconnect/identifier"
-    autoload :Identifiers, "#{__dir__}/calconnect/identifiers"
-    autoload :Parser, "#{__dir__}/calconnect/parser"
-    autoload :Renderer, "#{__dir__}/calconnect/renderer"
-    autoload :UrnGenerator, "#{__dir__}/calconnect/urn_generator"
-    autoload :UrnParser, "#{__dir__}/calconnect/urn_parser"
-
-    # Parse a CalConnect 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: Calconnect::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 CalConnect flavor with the registry
-Pubid::Registry.register(:calconnect, Pubid::Calconnect)

data/lib/pubid/ccsds/urn_parser.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ccsds
-    # Parses CCSDS URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:ccsds:{code}` where the code is the full
-    # identifier suffix after "CCSDS " (e.g., "120.0-G-4").
-    #
-    # Examples:
-    # - urn:ccsds:120.0-G-4  → CCSDS 120.0-G-4
-    # - urn:ccsds:100.0-G-1-S → CCSDS 100.0-G-1-S
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        flavor_parse("CCSDS #{body}")
-      end
-    end
-  end
-end