pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/calconnect.rb

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        # Check if corrigenda are present - if so, build Corrigendum objects
+        if data[:corrigenda] && !data[:corrigenda].empty?
+          return build_corrigendum(data)
+        end
+
+        # Build base identifier
+        build_base(data)
+      end
+
+      private
+
+      def build_base(data)
+        Identifiers::Base.new(
+          number: data[:number].to_s,
+          part: data[:part]&.to_s,
+          type: data[:type]&.to_s,
+          edition: data[:edition]&.to_s,
+          suffix: data[:suffix]&.to_s,
+          language: data[:language]&.to_s,
+        )
+      end
+
+      def build_corrigendum(data)
+        # Extract corrigenda numbers
+        corr_array = data[:corrigenda]
+        corr_array = [corr_array] unless corr_array.is_a?(Array)
+        corr_numbers = corr_array.map { |c| c[:cor_number].to_s }
+
+        # Build base identifier (without corrigenda)
+        base_data = data.dup
+        base_data.delete(:corrigenda)
+        base = build_base(base_data)
+
+        # Build Corrigendum object for each corrigendum number. The corrigendum
+        # sequence is stored in the inherited `number` attribute (mirroring ISO).
+        # Note: CCSDS uses "Cor. 1" format (single corrigendum per identifier)
+        # If multiple corrigenda exist, we build the last one wrapping the base
+        corr_numbers.reduce(base) do |current_base, cor_num|
+          Identifiers::Corrigendum.new(
+            base: current_base,
+            number: cor_num,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/identifier.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    # Abstract root for every CCSDS identifier AND the flavor's parse entry
+    # point — mirrors Pubid::Iso::Identifier / Pubid::Jis::Identifier. Concrete
+    # identifiers (Identifiers::Base, Identifiers::Corrigendum) descend from this
+    # class, so a parsed CCSDS id is an instance of Pubid::Ccsds::Identifier and
+    # relaton-index can pass this class as `pubid_class` for from_hash/to_hash.
+    #
+    # Keeping the root abstract (it is never itself a serialized type, so it is
+    # absent from CCSDS_TYPE_MAP) is what breaks the polymorphic recursion a
+    # supplement's `base` would otherwise hit if it pointed at a
+    # concrete type that is also its own superclass.
+    class Identifier < ::Pubid::Identifier
+      # CCSDS stores every code component as a plain string (the Builder passes
+      # strings, never Components::Code/Edition objects), so override the
+      # inherited Components::Code/Edition attribute types with :string. This
+      # both matches the runtime values and yields a lean, round-trippable
+      # key_value (`to_hash`) serialization instead of nested component hashes.
+      # `type` (single book-color letter B/G/M/R/Y/O), `suffix`, and `language`
+      # are likewise CCSDS-specific plain strings.
+      attribute :number, :string
+      attribute :part, :string
+      attribute :edition, :string
+      attribute :type, :string
+      attribute :suffix, :string
+      attribute :language, :string
+
+      # Polymorphic type map for lutaml::Model key_value (de)serialization,
+      # mapping each concrete class's polymorphic_name to its class name.
+      CCSDS_TYPE_MAP = {
+        "pubid:ccsds:base" => "Pubid::Ccsds::Identifiers::Base",
+        "pubid:ccsds:corrigendum" => "Pubid::Ccsds::Identifiers::Corrigendum",
+      }.freeze
+
+      # The shared Pubid::Identifier no longer auto-maps attributes, so the
+      # flavor's root declares the full key_value mapping; subclasses
+      # (SupplementIdentifier/Corrigendum) merge their own blocks on top. Every
+      # value is a plain string, so a direct `to:` map round-trips.
+      key_value do
+        map "_type", to: :_type, polymorphic_map: CCSDS_TYPE_MAP
+        map "number", to: :number
+        map "part", to: :part
+        map "edition", to: :edition
+        map "type", to: :type
+        map "suffix", to: :suffix
+        map "language", to: :language
+      end
+
+      def publisher
+        "CCSDS"
+      end
+
+      # Parse a CCSDS identifier string into the appropriate identifier object.
+      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
+
+        # Apply legacy update_codes normalization first
+        normalized = Core::UpdateCodes.apply(identifier, :ccsds)
+        parsed = Pubid::Ccsds::Parser.parse(normalized)
+        Pubid::Ccsds::Builder.build(parsed)
+      end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # CCSDS_TYPE_MAP remains as the key_value polymorphic_map.
+    end
+  end
+end

data/lib/pubid/ccsds/identifiers/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    module Identifiers
+      # CCSDS base identifier (a published standard).
+      #
+      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX][ - LANGUAGE Translated]
+      # Examples: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S, CCSDS 551.1-O-2 - Russian Translated
+      #
+      # Attributes, the key_value mapping and from_hash dispatch live on the
+      # abstract root Pubid::Ccsds::Identifier; this concrete type only carries
+      # its typed stage and rendering.
+      class Base < Pubid::Ccsds::Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: [""],
+            stage_code: "published",
+            type_code: "base",
+          ),
+        ].freeze
+
+        def self.type
+          { key: :base, web: :base, title: "Base Standard", short: nil }
+        end
+
+        # Composes its string by hand rather than going through `render`, so
+        # the annotation hook has to be applied on the way out.
+        def to_s(**opts)
+          result = "#{publisher} #{number}"
+          result += ".#{part}" if part
+          result += "-#{type}" if type
+          result += "-#{edition}" if edition
+          result += "-#{suffix}" if suffix
+          result += " - #{language} Translated" if language
+          annotate_plain_render(result, **opts)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/identifiers/base_BASE_88929.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../../serializable"
+require_relative "../urn_generator"
+
+module Pubid
+  module Ccsds
+    module Identifiers
+      # CCSDS identifier
+      # Format: CCSDS NUMBER.PART-TYPE-EDITION[-SUFFIX]
+      # Example: CCSDS 120.0-G-4, CCSDS 100.0-G-1-S
+      class Base < Lutaml::Model::Serializable
+        include Pubid::Serializable
+
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+        def to_urn
+          UrnGenerator.new(self).generate
+        end
+
+        # Include CCSDS-specific attributes in serialization
+        def base_hash
+          hash = super
+          # CCSDS uses plain strings for type, edition, suffix
+          hash[:type] = type if type
+          hash[:suffix] = suffix if suffix
+          hash[:language] = language if language
+          hash
+        end
+
+        attribute :number, :string
+        attribute :part, :string
+        attribute :type, :string # B, G, M, R, Y, O, etc.
+        attribute :edition, :string
+        attribute :suffix, :string # Optional suffix like -S
+        attribute :language, :string # Language metadata (e.g., "French", "Russian")
+
+        def publisher
+          "CCSDS"
+        end
+
+        def to_s
+          result = "#{publisher} #{number}"
+          result += ".#{part}" if part
+          result += "-#{type}" if type
+          result += "-#{edition}" if edition
+          result += "-#{suffix}" if suffix
+
+          # Add language metadata
+          result += " - #{language} Translated" if language
+
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Base)
+
+          number == other.number &&
+            part == other.part &&
+            type == other.type &&
+            edition == other.edition &&
+            suffix == other.suffix &&
+            language == other.language
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    module Identifiers
+      class Corrigendum < SupplementIdentifier
+        # CCSDS Corrigendum typed stage
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: ["Cor", "Corr"],
+            stage_code: "published",
+            type_code: "cor",
+          ),
+        ].freeze
+
+        # Type information for this identifier class
+        #
+        # @return [Hash] Type information with key, title, and short form
+        def self.type
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "Cor" }
+        end
+
+        # The corrigendum sequence number is stored in the inherited `number`
+        # attribute (mirroring ISO), so it serializes via Base's key_value as
+        # { _type, number: '1', base: {...} } with no corrigendum-specific map.
+        def to_s(**opts)
+          base_str = base.to_s
+          annotate_plain_render("#{base_str} Cor. #{number}", **opts)
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Corrigendum)
+
+          base == other.base && number == other.number
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/identifiers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
+    end
+  end
+end

data/lib/pubid/ccsds/parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ccsds
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+      rule(:alnum) { match["A-Za-z0-9"] }
+      rule(:alnums) { alnum.repeat(1) }
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:dot) { str(".") }
+
+      # CCSDS prefix
+      rule(:ccsds_prefix) { str("CCSDS") >> space }
+
+      # Number (can be alphanumeric like A02)
+      rule(:number) { alnums.as(:number) }
+
+      # Part (can be multi-digit like .21 or alphanumeric like .1)
+      rule(:part) { dot >> alnums.as(:part) }
+
+      # Type (all possible type letters)
+      rule(:type) { dash >> match["A-Z"].as(:type) }
+
+      # Edition (can have dots like 4.1, and a trailing draft letter like 1.99h)
+      rule(:edition) do
+        dash >> (match["0-9."].repeat(1) >> match["A-Za-z"].maybe).as(:edition)
+      end
+
+      # Suffix (like -S)
+      rule(:suffix) { dash >> match["A-Z"].as(:suffix) }
+
+      # Corrigendum
+      rule(:corrigendum) do
+        space >> str("Cor.") >> space >> digits.as(:cor_number)
+      end
+
+      rule(:corrigenda) { corrigendum.repeat(0).as(:corrigenda) }
+
+      # Language metadata (e.g., " - French Translated", " - Russian Translated")
+      rule(:language_metadata) do
+        space >> dash >> space >>
+          (
+            (str("French") | str("Russian") | str("English") |
+             str("German") | str("Spanish") | str("Italian") |
+             str("Portuguese") | str("Chinese") | str("Japanese")).as(:language) >>
+            (space >> str("Translated")).maybe
+          )
+      end
+
+      # Main identifier
+      rule(:identifier) do
+        ccsds_prefix >>
+          number >>
+          part.maybe >>
+          type.maybe >>
+          edition.maybe >>
+          suffix.maybe >>
+          corrigenda >>
+          language_metadata.maybe
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/single_identifier.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    # Qualified as ::Pubid::Identifier to avoid resolving to the local
+    # Pubid::Ccsds::Identifier module, which is a parser entry point
+    # (`self.parse`) — not the base class.
+    class SingleIdentifier < ::Pubid::Identifier
+      attribute :publisher, Components::Publisher, default: -> {
+        Components::Publisher.new(body: "CCSDS")
+      }
+      attribute :series, Components::Code
+      attribute :number, Components::Code
+      attribute :part, Components::Code
+      attribute :book_color, Components::Code
+      attribute :edition, Components::Edition
+      attribute :retired, :boolean, default: -> { false }
+      attribute :language, Components::Language
+      attribute :type, Components::Type
+      attribute :typed_stage, Components::TypedStage
+
+      def to_s(lang: :en, lang_single: false, **opts)
+        result = ""
+
+        # Publisher
+        result += publisher.body if publisher
+
+        # Space after publisher
+        result += " "
+
+        # Series (optional single letter before number)
+        result += series.value if series
+
+        # Number with part (using dot notation)
+        result += number.value
+        result += ".#{part.value}" if part
+
+        # Book color (required) - no space before dash
+        result += "-#{book_color.value}" if book_color
+
+        # Edition (optional)
+        result += "-#{edition.number}" if edition
+
+        # Retired marker (optional)
+        result += "-S" if retired
+
+        # Language (optional)
+        result += " - #{language.code} Translated" if language
+
+        annotate_plain_render(result, **opts)
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(SingleIdentifier)
+
+        # Compare by number first
+        num_cmp = number.value.to_i <=> other.number.value.to_i
+        return num_cmp unless num_cmp.zero?
+
+        # Then by part
+        part_cmp = (part ? part.value.to_i : 0) <=> (other.part ? other.part.value.to_i : 0)
+        return part_cmp unless part_cmp.zero?
+
+        # Then by edition
+        if edition && other.edition
+          edition.number.to_s <=> other.edition.number.to_s
+        elsif edition
+          1
+        elsif other.edition
+          -1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/supplement_identifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    # Base class for CCSDS supplements (corrigenda, amendments, etc.).
+    # Descends from the abstract root (not the concrete Base) and points
+    # `base` at the root, so the polymorphic attribute never
+    # resolves to its own superclass — which is what prevents lutaml from
+    # recursing forever while building a supplement from a hash.
+    class SupplementIdentifier < Identifier
+      attribute :base, Identifier, polymorphic: true
+
+      # Serialize the supplemented identifier under "base" (matches ISO/JIS).
+      # The key stays `base` for the attribute/getter, which
+      # relaton-index's get_id_number relies on. A supplement's own code
+      # attributes (number/part/edition/...) stay nil — they live inside
+      # `base` — so the merged root key_value omits them here, keeping the
+      # serialization lean and non-duplicated.
+      key_value do
+        map "base", to: :base
+      end
+
+      def <=>(other)
+        return nil unless other.is_a?(SupplementIdentifier)
+
+        # Compare base identifiers first
+        if base && other.base
+          base_cmp = base <=> other.base
+          return base_cmp unless base_cmp.zero?
+        end
+
+        # Subclasses should implement more specific comparison
+        0
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/urn_generator.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(SupplementIdentifier)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def generate_base_urn
+        parts = ["urn", "ccsds"]
+
+        identifier_parts = []
+
+        series = maybe(:series)
+        if series
+          s = series.to_s
+          identifier_parts << s if s && !s.empty?
+        end
+
+        if identifier.number
+          number = identifier.number.to_s
+          identifier_parts << number if number && !number.empty?
+        end
+
+        part = maybe(:part)
+        if part
+          p = part.to_s
+          identifier_parts << ".#{p}" if p && !p.empty?
+        end
+
+        book_color = maybe(:book_color)
+        if book_color
+          bc = book_color.to_s
+          identifier_parts << "-#{bc}" if bc && !bc.empty?
+        elsif identifier.type
+          t = identifier.type.to_s
+          identifier_parts << "-#{t}" if t && !t.empty?
+        end
+
+        edition = maybe(:edition)
+        if edition
+          e = if edition.is_a?(Pubid::Components::Edition)
+                edition.number
+              else
+                edition.to_s
+              end
+          identifier_parts << "-#{e}" if e && !e.to_s.empty?
+        end
+
+        retired = maybe(:retired)
+        if retired
+          identifier_parts << "-S"
+        else
+          suffix = maybe(:suffix)
+          if suffix
+            s = suffix.to_s
+            identifier_parts << "-#{s}" if s && !s.empty?
+          end
+        end
+
+        parts << identifier_parts.join unless identifier_parts.empty?
+
+        language = maybe(:language)
+        if language
+          lang_code = if language&.code
+                        language.code
+                      elsif language.is_a?(String)
+                        language
+                      else
+                        language.to_s
+                      end
+          lang_code = lang_code.gsub(/ Translated$/, "").downcase if lang_code
+          parts << lang_code if lang_code && !lang_code.empty?
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "ccsds"]
+
+        current = identifier
+        supplement_chain = []
+
+        while current.is_a?(SupplementIdentifier)
+          supplement_chain.unshift(current)
+          current = current.base
+        end
+
+        base_gen = self.class.new(current)
+        base_urn = base_gen.generate_base_urn
+
+        base_part = base_urn.sub(/^urn:ccsds:/, "")
+        parts << base_part
+
+        supplement_chain.each do |supp|
+          if supp.number && !supp.number.to_s.empty?
+            parts << "cor.#{supp.number}"
+          elsif supp.typed_stage
+            parts << supp.typed_stage.type_code.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end