pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/cie.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Cie
+    extend Pubid::PrefixesSupport
+
+    # Sole CIE publisher token (see the parser grammar).
+    PREFIXES = ["CIE"].freeze
+
+    module Components
+      autoload :Language, "#{__dir__}/cie/components/language"
+    end
+
+    autoload :Builder, "#{__dir__}/cie/builder"
+    autoload :Identifier, "#{__dir__}/cie/identifier"
+    autoload :Identifiers, "#{__dir__}/cie/identifiers"
+    autoload :Parser, "#{__dir__}/cie/parser"
+    autoload :SingleIdentifier, "#{__dir__}/cie/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/cie/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/cie/urn_generator"
+    autoload :UrnParser, "#{__dir__}/cie/urn_parser"
+
+    # Main entry point for CIE identifiers
+    # Delegates to Identifier.parse
+    def self.parse(input)
+      unless input.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if input.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(input)
+    end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # CIE identifier classes extend Lutaml::Model::Serializable via
+    # SingleIdentifier / SupplementIdentifier, without a self.type Hash.
+    # We discover by checking for subclasses of those base types.
+    # @return [Array<Class>] identifier classes
+    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 < SingleIdentifier || c < SupplementIdentifier) }
+    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: class name -> identifier class
+    # Since CIE lacks self.type, locate by class name suffix
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find do |t|
+        t.name.split("::").last.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "") == code.to_s.downcase ||
+          t.name.split("::").last.downcase == code.to_s.downcase
+      end
+    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 Ucie flavor with the registry
+Pubid::Registry.register(:cie, Pubid::Cie)

data/lib/pubid/components/adoption.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Adoption component — captures the metadata when one identifier adopts
+    # another. Originally surfaced as BSI's AdoptedInternationalStandard /
+    # AdoptedEuropeanNorm and CEN-CENELEC's AdoptedEuropeanNorm; the same
+    # shape applies to CSA adoptions and IEEE Adopted-Standard relationships.
+    #
+    # Shape (union across BSI, CEN-CENELEC, CSA, IEEE):
+    # - base:                     the adopted document (polymorphic Identifier).
+    # - adopter_publisher:        the publisher doing the adopting (BS, EN,
+    #                             CAN/, CSA, IEEE).
+    # - edition:                  edition of the adoption (BSI-only).
+    # - date:                     adoption date (replaces ad-hoc year attrs).
+    # - translation_lang:         translation language code (BSI-only).
+    # - translation_upper:        upper-case translation marker (BSI-only).
+    # - translation_suffix_type:  "version" or "Translation" (BSI-only).
+    # - reaffirmation_year:       "(R2004)" reaffirmation notation (BSI, CSA).
+    # - expert_commentary:        true when the adoption ships with commentary
+    #                             (BSI-only).
+    # - expert_commentary_topic:  topic of the commentary (BSI-only).
+    # - publisher_prefix:         CSA-specific dash-vs-space prefix.
+    #
+    # Render delegates to the base identifier; the adopter's renderer decides
+    # the prefix and any suffix notation (translation, reaffirmation,
+    # commentary) by calling adoption.render(context:).
+    class Adoption < Lutaml::Model::Serializable
+      attribute :base, ::Pubid::Identifier, polymorphic: true
+      attribute :adopter_publisher, ::Pubid::Components::Publisher
+      attribute :edition, :string
+      attribute :date, ::Pubid::Components::Date
+      attribute :translation_lang, :string
+      attribute :translation_upper, :string
+      attribute :translation_suffix_type, :string
+      attribute :reaffirmation_year, :string
+      attribute :expert_commentary, :boolean
+      attribute :expert_commentary_topic, :string
+      attribute :publisher_prefix, :string
+
+      IDENTITY_FIELDS = %i[
+        base adopter_publisher edition date translation_lang translation_upper
+        translation_suffix_type reaffirmation_year expert_commentary
+        expert_commentary_topic publisher_prefix
+      ].freeze
+
+      def present?
+        IDENTITY_FIELDS.any? { |f| present_value?(public_send(f)) }
+      end
+
+      def render(context: nil)
+        return "" unless base
+
+        body = base.to_s
+        body += translation_suffix if translation_lang
+        body += reaffirmation_suffix if reaffirmation_year
+        body += commentary_suffix if expert_commentary
+        body
+      end
+
+      def to_s(**opts)
+        render(context: opts[:context])
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        IDENTITY_FIELDS.all? { |f| public_send(f) == other.public_send(f) }
+      end
+
+      alias eql? ==
+
+      def hash
+        @hash ||= [self.class, *IDENTITY_FIELDS.map { |f| public_send(f) }].hash
+      end
+
+      private
+
+      def present_value?(value)
+        return false if value.nil?
+        return value if [true, false].include?(value)
+
+        value.is_a?(String) ? !value.empty? : !value.nil?
+      end
+
+      def translation_suffix
+        type = translation_suffix_type || "Translation"
+        lang = translation_lang&.upcase
+        " #{lang}#{type}"
+      end
+
+      def reaffirmation_suffix
+        " (R#{reaffirmation_year})"
+      end
+
+      def commentary_suffix
+        topic = expert_commentary_topic
+        topic ? " (Commentary: #{topic})" : " (Commentary)"
+      end
+    end
+  end
+end

data/lib/pubid/components/code.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Document code/number component.
+    #
+    # Holds the structured fields that recur across flavors: the main +value+
+    # (always present), plus optional +prefix+ (series/type designator),
+    # +part+, +subpart+, and free-form +parts+. Subclasses own their
+    # composition rules — flavor-specific separators and orderings live in
+    # the subclass #to_s / #render override.
+    class Code < Lutaml::Model::Serializable
+      attribute :value, :string
+      attribute :prefix, :string
+      attribute :part, :string
+      attribute :subpart, :string
+      attribute :parts, :string, collection: true
+
+      def to_s
+        value.to_s
+      end
+
+      # Format-aware render seam. Default returns the bare value; subclasses
+      # override to compose flavor-specific shapes (e.g. ISO joins parts
+      # with "-", NIST joins subpart with ".").
+      def render(context: nil)
+        value.to_s
+      end
+
+      def hash
+        [value, prefix, part, subpart, parts].hash
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        value == other.value &&
+          prefix == other.prefix &&
+          part == other.part &&
+          subpart == other.subpart &&
+          parts == other.parts
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/pubid/components/date.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Publication date component
+    #
+    # Human render: "YYYY" or "YYYY-MM" or "YYYY-MM-DD"; or "--" when the
+    # date slot is present but explicitly undated (ISO/IEC undated-reference
+    # convention, e.g. "ISO 16634:--"). URN render: year only (RFC 5141-bis
+    # URN spec); flavors that drop the slot when undated gate that decision
+    # at the URN-generator level, not here.
+    class Date < Lutaml::Model::Serializable
+      attribute :year, :string
+      attribute :month, :string
+      attribute :day, :string
+      attribute :undated, :boolean, default: false
+
+      # True when the year is set to a non-empty value, OR the date is
+      # explicitly marked undated. An undated date is a meaningful
+      # publication-date slot (it is what renders as `:--` in ISO/IEC), so
+      # callers that gate rendering on "is there a date at all?" should
+      # treat undated as present.
+      def present?
+        return true if undated
+        !year.nil? && !year.to_s.empty?
+      end
+
+      def undated?
+        !!undated
+      end
+
+      def render(context: nil)
+        return "--" if undated? && (year.nil? || year.to_s.empty?)
+        return nil unless present?
+        return year.to_s if context&.urn?
+        return year.to_s unless month
+
+        result = "#{year}-#{pad2(month)}"
+        result += "-#{pad2(day)}" if day
+        result
+      end
+
+      def to_s(_context: nil, _include_month: false)
+        return "--" if undated? && (year.nil? || year.to_s.empty?)
+        return year.to_s unless month
+
+        result = "#{year}-#{pad2(month)}"
+        result += "-#{pad2(day)}" if day
+        result
+      end
+
+      private
+
+      def pad2(value)
+        value.to_s.rjust(2, "0")
+      end
+
+      def hash
+        @hash ||= [year, month, day, undated].compact.map(&:hash).hash
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        year == other.year && month == other.month && day == other.day &&
+          undated == other.undated
+      end
+    end
+  end
+end

data/lib/pubid/components/edition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Edition component (typically a year and number)
+    #
+    # Human render: "ED#{number}".
+    # URN render: "ed-#{number}" per RFC 5141-bis.
+    class Edition < Lutaml::Model::Serializable
+      attribute :year, :string
+      attribute :number, Lutaml::Model::Type::Value
+      attribute :original_text, :string
+
+      def to_s
+        number_value = number.is_a?(Components::Code) ? number.value : number
+        number_value ? "ED#{number_value}" : nil
+      end
+
+      def value
+        number.is_a?(Components::Code) ? number.value : number
+      end
+
+      def render(context: nil)
+        number_value = number.is_a?(Components::Code) ? number.value : number
+        return nil unless number_value
+
+        context&.urn? ? "ed-#{number_value}" : "ED#{number_value}"
+      end
+
+      def original_format
+        original_text
+      end
+    end
+  end
+end

data/lib/pubid/components/iteration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Stage iteration component — the numeric suffix on a stage (e.g., "WD.2").
+    #
+    # Renders as the bare number; the caller decides the separator (".")
+    # because URN, MR, and human formats position iteration differently
+    # relative to the stage abbreviation.
+    class Iteration < Lutaml::Model::Serializable
+      attribute :number, :string
+
+      def to_s
+        number.to_s
+      end
+
+      def render(context: nil)
+        number.to_s
+      end
+
+      def hash
+        @hash ||= number.hash
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        number == other.number
+      end
+    end
+  end
+end

data/lib/pubid/components/language.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Language component (typically a language code)
+    #
+    # Human render: language code, optionally single-char.
+    # URN render: lowercase ISO 639-1 code (RFC 5141-bis).
+    class Language < Lutaml::Model::Serializable
+      CHAR_MAP = {
+        "R" => "ru",
+        "F" => "fr",
+        "E" => "en",
+        "A" => "ar",
+        "S" => "es",
+        "D" => "de",
+      }.freeze
+
+      attribute :code, :string, values: CHAR_MAP.values
+      attribute :original_code, :string
+
+      def to_s(lang_single: false)
+        if !lang_single && original_code&.length == 1
+          code
+        elsif original_code
+          original_code
+        else
+          lang_single ? CHAR_MAP.key(code) : code
+        end
+      end
+
+      def render(context: nil, **opts)
+        return code&.downcase if context&.urn?
+
+        to_s(**opts)
+      end
+    end
+  end
+end

data/lib/pubid/components/locality.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Components
+    # Locality marker (e.g. "all parts")
+    #
+    # Renders the human-readable phrase "(all parts)" and a URN
+    # suffix that completes the locality segment.
+    class Locality < Lutaml::Model::Serializable
+      attribute :value, :string
+
+      def render(context: nil)
+        return "all" if context&.urn?
+
+        "(all parts)"
+      end
+    end
+  end
+end

data/lib/pubid/components/publisher.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Publisher ISO, IEC, etc.
+    #
+    # Human render: the publisher body (e.g. "ISO").
+    # URN render: lowercase body (e.g. "iso") per RFC 5141-bis.
+    class Publisher < Lutaml::Model::Serializable
+      attribute :body, :string
+
+      def to_s
+        body
+      end
+
+      def render(context: nil)
+        return body&.downcase if context&.urn?
+
+        body
+      end
+
+      def copublished?
+        false
+      end
+
+      def hash
+        @hash ||= body.hash
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        body == other.body
+      end
+    end
+  end
+end

data/lib/pubid/components/relationship.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Relationship component — captures how one identifier relates to others.
+    #
+    # Originally modeled as IEEE's Components::Relationship; promoted to the
+    # shared namespace because the same relationship vocabulary applies to
+    # ISO, IEC, and other flavors that need to express "revises", "amends",
+    # "incorporates", "adopts", etc.
+    #
+    # Shape:
+    # - relationship_type: one of the VALID_TYPES constants below.
+    # - related_identifiers: array of identifier objects the relationship
+    #   points at (e.g., the standards being revised).
+    # - intermediate_amendments: optional array of identifiers that amended
+    #   the related identifier between its original publication and the
+    #   current revision (renders as "... as amended by ...").
+    # - approved_amendments_flag: when true and no intermediate_amendments
+    #   are listed, renders "... and its approved amendments".
+    class Relationship < Lutaml::Model::Serializable
+      REVISION_OF = "revision_of"
+      AMENDMENT_TO = "amendment_to"
+      CORRIGENDUM_TO = "corrigendum_to"
+      INCORPORATES = "incorporates"
+      INCORPORATING = "incorporating"
+      ADOPTION_OF = "adoption_of"
+      SUPPLEMENT_TO = "supplement_to"
+      DRAFT_AMENDMENT_TO = "draft_amendment_to"
+      DRAFT_REVISION_OF = "draft_revision_of"
+      REAFFIRMATION_OF = "reaffirmation_of"
+      REDESIGNATION_OF = "redesignation_of"
+      SUPERSEDES = "supersedes"
+      PREVIOUSLY_DESIGNATED_AS = "previously_designated_as"
+      INCLUDES = "includes"
+
+      VALID_TYPES = [
+        REVISION_OF,
+        AMENDMENT_TO,
+        CORRIGENDUM_TO,
+        INCORPORATES,
+        INCORPORATING,
+        ADOPTION_OF,
+        SUPPLEMENT_TO,
+        DRAFT_AMENDMENT_TO,
+        DRAFT_REVISION_OF,
+        REAFFIRMATION_OF,
+        REDESIGNATION_OF,
+        SUPERSEDES,
+        PREVIOUSLY_DESIGNATED_AS,
+        INCLUDES,
+      ].freeze
+
+      attribute :relationship_type, :string
+
+      attr_accessor :related_identifiers, :intermediate_amendments,
+                    :approved_amendments_flag
+
+      PREFIXES = {
+        REVISION_OF => "Revision of",
+        AMENDMENT_TO => "Amendment to",
+        CORRIGENDUM_TO => "Corrigendum to",
+        INCORPORATES => "incorporates",
+        ADOPTION_OF => "Adoption of",
+        SUPPLEMENT_TO => "Supplement to",
+        DRAFT_AMENDMENT_TO => "Draft Amendment to",
+        DRAFT_REVISION_OF => "Draft Revision of",
+        REAFFIRMATION_OF => "Reaffirmation of",
+        REDESIGNATION_OF => "Redesignation of",
+        SUPERSEDES => "Supersedes",
+        PREVIOUSLY_DESIGNATED_AS => "Previously designated as",
+        INCLUDES => "Includes",
+      }.freeze
+
+      def initialize(**args)
+        @related_identifiers = args.delete(:related_identifiers)
+        @intermediate_amendments = args.delete(:intermediate_amendments)
+        @approved_amendments_flag = args.delete(:approved_amendments_flag)
+        super
+        normalize_incorporating!
+        validate_relationship_type if relationship_type
+      end
+
+      def normalize_incorporating!
+        return unless relationship_type == INCORPORATING
+
+        self.relationship_type = INCORPORATES
+      end
+
+      def validate_relationship_type
+        return if VALID_TYPES.include?(relationship_type)
+
+        raise ArgumentError,
+              "Invalid relationship type: #{relationship_type}. " \
+              "Valid types: #{VALID_TYPES.join(', ')}"
+      end
+
+      def to_s
+        return "" if related_identifiers.nil? || related_identifiers.empty?
+
+        prefix = format_relationship_prefix
+        ids = format_identifier_list(related_identifiers)
+        return "#{prefix} #{ids}" unless intermediate_clause?
+
+        "#{prefix} #{ids} #{intermediate_clause}"
+      end
+
+      def render(context: nil)
+        to_s
+      end
+
+      private
+
+      def intermediate_clause?
+        (intermediate_amendments && !intermediate_amendments.empty?) ||
+          approved_amendments_flag
+      end
+
+      def intermediate_clause
+        if intermediate_amendments && !intermediate_amendments.empty?
+          "as amended by #{format_identifier_list(intermediate_amendments)}"
+        else
+          "and its approved amendments"
+        end
+      end
+
+      def format_relationship_prefix
+        PREFIXES.fetch(relationship_type, relationship_type)
+      end
+
+      # Format a list of identifiers using proper English grammar:
+      # - Single: "IEEE Std X"
+      # - Two: "IEEE Std X and IEEE Std Y"
+      # - Three+: "IEEE Std X, IEEE Std Y, and IEEE Std Z" (Oxford comma)
+      def format_identifier_list(identifiers)
+        return "" if identifiers.nil? || identifiers.empty?
+
+        case identifiers.length
+        when 1
+          identifiers.first.to_s
+        when 2
+          "#{identifiers.first} and #{identifiers.last}"
+        else
+          "#{identifiers[0..-2].join(', ')}, and #{identifiers.last}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/components/stage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Components
+    # Stage component (a set of defined stages)
+    #
+    # Human render: abbreviation with flavor-specific separator.
+    # URN render: stage abbreviation alone (no separator).
+    class Stage < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :stage_code, :string
+      attribute :harmonized_stages, :string, collection: true
+      attribute :abbr, :string
+
+      def to_s(context: nil, has_copublisher: false)
+        return "" unless abbr
+
+        if context
+          sep = context.stage_separator_for(has_copublisher:)
+          sep == "" ? abbr : "#{sep}#{abbr}"
+        else
+          has_copublisher ? " #{abbr}" : "/#{abbr}"
+        end
+      end
+
+      def render(context: nil)
+        return abbr.to_s if context&.urn?
+
+        abbr.to_s
+      end
+
+      def hash
+        @hash ||= [stage_code, abbr].compact.map(&:hash).hash
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        stage_code == other.stage_code && abbr == other.abbr
+      end
+    end
+  end
+end