pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/bundled_identifier.rb

@@ -0,0 +1,126 @@
+require_relative "identifier"
+# frozen_string_literal: true
+
+module Pubid
+  # Identifier that represents a combined bundle of documents using the + operator.
+  # Examples:
+  #   EN 10077-1:2006+AC:2009+AC2:2009
+  #   ISO/IEC DIR 1 + IEC SUP:2016-05
+  #   ISO 8601:2019+Amd 1:2024+Cor 1:2025
+  #
+  # Semantic: Base document combined with amendments/corrigenda that are applied together
+  # This is different from:
+  #   / operator (SupplementIdentifier) - supplement of a document
+  #   | operator (CombinedIdentifier) - dual-published by multiple organizations
+  class BundledIdentifier < Identifier
+    attribute :base_document, Identifier, polymorphic: true
+    attribute :supplements, Identifier, polymorphic: true, collection: true
+    attribute :type, :string, default: -> { "bundled_identifier" }
+
+    # Delegate common attributes to base_document for easier access
+    def publisher
+      base_document&.publisher
+    end
+
+    def copublishers
+      base_document&.copublishers
+    end
+
+    def number
+      base_document&.number
+    end
+
+    def date
+      base_document&.date
+    end
+
+    def type
+      base_document&.type
+    end
+
+    def stage
+      base_document&.stage
+    end
+
+    def typed_stage
+      base_document&.typed_stage
+    end
+
+    def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
+stage_format_long: nil, with_date: nil)
+      result = base_document.to_s(lang: lang, lang_single: lang_single,
+                                  with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)
+
+      supplements.each do |supplement|
+        # ISO DirectivesSupplement always uses " + " (space before)
+        # CEN-style supplements (AC, A) without base_identifier use "+" (no space before)
+        # Other ISO supplements with base_identifier use " + " (space before)
+        if supplement.class.name&.include?("DirectivesSupplement") ||
+            (supplement.class.attributes.key?(:base_identifier) && !supplement.base_identifier.nil?)
+          result += " + #{supplement.to_s(lang: lang, lang_single: lang_single,
+                                          with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
+        else
+          result += "+#{supplement.to_s(lang: lang, lang_single: lang_single,
+                                        with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date)}"
+        end
+      end
+
+      result
+    end
+
+    # Generate URN for bundled identifier
+    # Flattens all components into a single URN
+    #
+    # Example: "ISO/IEC DIR 1:2022 + IEC SUP:2022"
+    #          → "urn:iso:doc:iso-iec:dir:1:2022:iec:sup:2022"
+    def to_urn
+      # Start with base document URN components
+      parts = base_document.to_urn.split(":")
+
+      # Add each supplement's components
+      supplements.each do |supplement|
+        # For DirectivesSupplement: add organization and "sup" (not "dir-sup")
+        if supplement.class.name&.include?("DirectivesSupplement")
+          # Add organization (e.g., "IEC")
+          if supplement.class.attributes.key?(:supplement_publisher) && supplement.supplement_publisher
+            parts << supplement.supplement_publisher.body.downcase
+          end
+
+          # Always add "sup" for DirectivesSupplement (not "dir-sup")
+          parts << "sup"
+
+          # Add year
+          parts << supplement.date.year.to_s if supplement.date
+        else
+          # For other supplements: use typed_stage type_code
+          if supplement.typed_stage
+            type_code = supplement.typed_stage.type_code
+            parts << type_code.to_s unless type_code == :is
+          end
+
+          # Add supplement date
+          if supplement.date
+            parts << supplement.date.year.to_s
+          end
+
+          # Add supplement number if present
+          if supplement.number
+            parts << "v#{supplement.number.value}"
+          end
+        end
+      end
+
+      parts.join(":")
+    end
+
+    # Support comparison for sorting
+    def <=>(other)
+      return nil unless other.is_a?(BundledIdentifier)
+
+      base_comparison = base_document.to_s <=> other.base_document.to_s
+      return base_comparison unless base_comparison.zero?
+
+      supplements.map(&:to_s).sort <=> other.supplements.map(&:to_s).sort
+    end
+  end
+end

data/lib/pubid/ccsds/builder.rb

@@ -0,0 +1,56 @@
+# 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_i }
+
+        # 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
+        # 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_identifier: current_base,
+            cor_number: cor_num,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ccsds/identifier.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    module Identifier
+      def self.parse(identifier)
+        # Apply legacy update_codes normalization first
+        normalized = Core::UpdateCodes.apply(identifier, :ccsds)
+        parsed = Pubid::Ccsds::Parser.parse(normalized)
+        Pubid::Ccsds::Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse CCSDS identifier '#{identifier}': #{e.message}"
+      end
+
+      # Factory that builds a CCSDS identifier from a hash of primitives.
+      #
+      # Accepts the field shape used by relaton-data-ccsds index entries:
+      # `:publisher`, `:number`, `:series`, `:part`, `:book_color`,
+      # `:retired`, `:edition`, plus the parsed-shape fields `:type`,
+      # `:suffix`, `:language`. CCSDS 2.x maps these as:
+      #
+      #   * `:series` + `:number`  → combined number ("A" + "20" → "A20")
+      #   * `:book_color`          → `:type`            (B/G/M/R/Y/O)
+      #   * `:publisher`           → ignored (hardcoded "CCSDS")
+      #   * `:retired`             → ignored (no 2.x field)
+      #
+      # Supplement subclasses (currently just Corrigendum, via `type: :cor`)
+      # raise ArgumentError until `base:` kwarg is wired through.
+      def self.create(type: nil, **opts)
+        if type
+          type_sym = type.to_sym
+          base_type_key = Identifiers::Base.type[:key].to_sym
+
+          if type_sym != base_type_key
+            supplement = supplement_klass_for(type_sym)
+            if supplement
+              # TODO(create-shim): supplement subclasses (Corrigendum)
+              # require a base_identifier. Wire `base:` kwarg through once
+              # a caller needs it.
+              raise ArgumentError, "#{supplement} requires a " \
+                                   "base_identifier; Identifier.create " \
+                                   "cannot build supplements yet"
+            end
+
+            # Not a class-dispatch key — treat as book_color data
+            # (e.g. `type: "G"` for Green Book) and merge back into opts.
+            opts = opts.merge(type: type)
+          end
+        end
+
+        Identifiers::Base.new(**coerce_create_attrs(opts))
+      end
+
+      def self.supplement_klass_for(type_sym)
+        Scheme.supplement_identifiers.find do |k|
+          k.type[:key].to_sym == type_sym
+        end
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {}
+
+        if opts[:number]
+          num = opts[:number].to_s
+          attrs[:number] =
+            opts[:series] ? "#{opts[:series]}#{num}" : num
+        end
+
+        attrs[:type] = opts[:book_color].to_s if opts[:book_color]
+        # Allow caller to pass :type as data when no :book_color given
+        # (parsed identifiers expose it via Base#type attribute).
+        attrs[:type] = opts[:type].to_s if opts[:type] && !attrs[:type]
+
+        %i[part edition suffix language].each do |k|
+          v = opts[k]
+          attrs[k] = v.to_s unless v.nil?
+        end
+
+        attrs
+      end
+      private_class_method :supplement_klass_for, :coerce_create_attrs
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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
+        # CCSDS uses a simple architecture without typed stages
+        # TYPED_STAGES includes default stage for base identifiers
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: [""],
+            stage_code: "published",
+            type_code: "base",
+          ),
+        ].freeze
+
+        # Type information for this identifier class
+        #
+        # @return [Hash] Type information with key, title, and short form
+        def self.type
+          { key: :base, title: "Base Standard", short: nil }
+        end
+
+        # Return a copy of this identifier with the named attributes
+        # nil'd. Mirrors the {Pubid::Identifier#exclude} convenience.
+        # CCSDS Base extends Lutaml::Model::Serializable directly (not
+        # Pubid::Identifier), so the method is defined here too.
+        def exclude(*args)
+          attrs = self.class.attributes.each_with_object({}) do |(name, _), h|
+            h[name] = args.include?(name) ? nil : send(name)
+          end
+          self.class.new(attrs)
+        end
+
+        # Generate URN for this identifier
+        #
+        # @return [String] URN representation
+
+        # 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/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,39 @@
+# 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, title: "Corrigendum", short: "Cor" }
+        end
+
+        attribute :cor_number, :integer
+
+        def to_s
+          base_str = base_identifier.to_s
+          "#{base_str} Cor. #{cor_number}"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Corrigendum)
+
+          base_identifier == other.base_identifier &&
+            cor_number == other.cor_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,71 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ccsds
+    class Parser < Parslet::Parser
+      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)
+      rule(:edition) { dash >> match["0-9."].repeat(1).as(:edition) }
+
+      # 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/scheme.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ccsds
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Base,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Corrigendum,
+          ]
+        end
+
+        def typed_stages
+          identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def supplement_typed_stages
+          supplement_identifiers.flat_map { |klass| klass::TYPED_STAGES }
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          abbr = "" if abbr.nil?
+
+          typed_stage = (typed_stages + supplement_typed_stages).detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          identifier_klass = (identifiers + supplement_identifiers).detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      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)
+        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
+
+        result
+      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