pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iso/builder.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    class Builder < Pubid::Builder::Base
+      def initialize
+        # No state needed: lookups are delegated to the Pubid::Iso module.
+      end
+
+      # Override the base implementation to avoid relying on @scheme.
+      # @param typed_stage_string [String, nil]
+      # @return [Pubid::Components::TypedStage, nil]
+      def locate_typed_stage(typed_stage_string)
+        Pubid::Iso.locate_stage(typed_stage_string.to_s)
+      end
+
+      def locate_identifier_klass(parsed_hash)
+        # If there is a joint_identifier, we need to use a CombinedIdentifier
+        # which takes `base` and `additional_identifiers`
+        if parsed_hash[:joint_identifier]
+          return CombinedIdentifier
+        end
+
+        # If there are supplements, we need to use a BundledIdentifier
+        # which takes `base_document` and `supplements`
+        if parsed_hash[:supplements]
+          return BundledIdentifier
+        end
+
+        # TC documents are identified by the presence of tc_type
+        if parsed_hash[:tc_type]
+          return Identifiers::TcDocument
+        end
+
+        # An explicit document type (e.g. from a URN's `:tr:`/`:ts:` token) pins
+        # the class regardless of the stage. The stage and type are separate URN
+        # fields, but the stage is later folded into `:type_with_stage` (e.g.
+        # "WDA" for 90.93), which would otherwise mis-resolve the class to the
+        # stage's owning type (IS). Consume the hint here, before assign_attributes.
+        if (doc_type = parsed_hash.delete(:document_type))
+          type_stage = locate_typed_stage(doc_type)
+          return Pubid::Iso.locate_type(type_stage.type_code) if type_stage
+        end
+
+        # Check the `:type_with_stage` to determine the identifier class
+        # 1. :type_with_stage will be nil if:
+        # a) It is an IS.
+        # b) It is a Directive Supplements. The "SUP" keyword may be entirely missing, and hence nil. If the base type_with_stage is a directive, then if the type_with_stage is blank, it is a directive supplement.
+
+        if parsed_hash[:type_with_stage].nil? && parsed_hash[:base] && parsed_hash[:base][:type_with_stage] == "DIR"
+          # Directive Supplement without "SUP" keyword
+          parsed_hash[:type_with_stage] = "SUP"
+        end
+
+        typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
+
+        Pubid::Iso.locate_type(typed_stage.type_code)
+      end
+
+      def build(parsed_hash)
+        # For ISO/R legacy format, split into publisher and type
+        if parsed_hash[:iso_r_prefix]
+          parsed_hash[:publisher] = "ISO"
+          parsed_hash[:type_with_stage] = "R"
+          parsed_hash.delete(:iso_r_prefix)
+        end
+
+        # For NSB-prefixed identifiers (FprISO, WD/ISO), set stage
+        if parsed_hash[:nsb_stage]
+          nsb_stage = parsed_hash.delete(:nsb_stage)
+          # Map NSB stage to typed stage
+          case nsb_stage
+          when "Fpr"
+            parsed_hash[:type_with_stage] = "PRF"
+          when "WD"
+            parsed_hash[:type_with_stage] = "WD"
+          end
+        end
+
+        # Instantiate the identifier based on the typed stage
+        identifier = locate_identifier_klass(parsed_hash).new
+
+        # For French GUIDE entries: "Guide ISO/CEI 37:1995"
+        if type_with_stage_fr = parsed_hash.delete(:type_with_stage_fr)
+          parsed_hash[:type_with_stage] = type_with_stage_fr
+        end
+
+        # For DirectivesSupplement, rename :publisher to :supplement_publisher
+        if identifier.is_a?(Identifiers::DirectivesSupplement) && parsed_hash[:publisher]
+          parsed_hash[:supplement_publisher] = parsed_hash.delete(:publisher)
+        end
+
+        # Merge copublishers into publisher object
+        if parsed_hash[:publisher] && parsed_hash[:copublishers]
+          copublisher_strings = parsed_hash[:copublishers].map do |cp|
+            cp[:copublisher]
+          end
+          parsed_hash[:publisher] = {
+            publisher: parsed_hash[:publisher],
+            copublisher: copublisher_strings,
+          }
+        end
+
+        assign_attributes(identifier, parsed_hash)
+
+        # If typed_stage, stage, or type are still nil after building,
+        # set them to the default International Standard values
+        if identifier.typed_stage.nil?
+          default_typed_stage = Pubid::Iso.locate_stage("")
+          identifier.typed_stage = default_typed_stage
+          identifier.stage = default_typed_stage.to_stage
+          identifier.type = default_typed_stage.to_type
+        end
+
+        identifier
+      end
+
+      def handle_key(identifier, key, value)
+        if key == :joint_identifier
+          identifier.additional_identifiers ||= []
+          identifier.additional_identifiers << value
+          true
+        else
+          false
+        end
+      end
+
+      # ISO normalizes em/en dashes, slashes, and spaces to hyphens so that
+      # "4037/1979", "4037-1979", and "ISO/IEC DIR 1 IEC" all split cleanly.
+      def normalize_number_with_part(value)
+        value.to_s
+             .tr("#{Parser::DASH_CHARS.join}/", "-")
+             .gsub(" ", "-")
+      end
+
+      # LEGACY: "ISO 4037-1979" used a hyphen where the modern form is
+      # "ISO 4037:1979". When the part looks like a 4-digit year in a
+      # plausible range, treat it as a date instead of a part number.
+      def extract_legacy_year(number, part, code_class)
+        return nil unless part&.match?(/^\d{4}$/)
+
+        year_value = part.to_i
+        return nil unless year_value.between?(1900, 2099)
+
+        {
+          number: code_class.new(value: number),
+          date: ::Pubid::Components::Date.new(year: part),
+        }
+      end
+
+      def cast(type, value)
+        case type
+        when :base
+          # If it has a base identifier, we need to build a supplement
+          # We assume that the base identifier is already a valid Identifier object
+          build(value)
+
+          # If there is a base, and it has a joint_identifier, we need to use a CombinedIdentifier.
+
+        when :publisher, :directives_supplement_body, :supplement_publisher
+          # value can be either a string OR a hash with publisher + copublisher
+          if value.is_a?(Hash)
+            Pubid::Iso::Components::Publisher.new(
+              publisher: value[:publisher],
+              copublisher: value[:copublisher],
+            )
+          else
+            # Default copublisher to [] (not nil) so a bare-string publisher
+            # (e.g. a TC document, which skips the copublisher merge) matches
+            # the [] convention used by copublisher-merged parses and by
+            # Identifier.create. Otherwise equality fails on [] vs nil.
+            Pubid::Iso::Components::Publisher.new(publisher: value, 
+                                                  copublisher: [])
+          end
+
+        when :copublishers
+          # Copublishers already merged into publisher
+          # Create array of Publisher objects for identifier.copublishers attribute
+          if value.nil? || value.empty?
+            nil
+          else
+            value.map do |copublisher|
+              Pubid::Iso::Components::Publisher.new(publisher: copublisher[:copublisher])
+            end
+          end
+
+        when :year
+          # For TC documents, parser returns :year but identifier uses :date
+          # Return as date for assignment
+          { date: Pubid::Components::Date.new(year: value.to_s) }
+
+        when :number_with_part
+          # "1234" (no part)
+          # or "1234-1" ('1' is part)
+          # or "1234-1-2" ('1' is part, '2' is subpart)
+          # or "29110-5-1-1" ('5' is part, '1-1' is subpart)
+          # or "105/F" ('F' is part)
+          # or "5843/6" ('6' is part)
+          # LEGACY: "4037-1979" (number-year, year should become date)
+          parse_number_with_part(value, code_class: Pubid::Iso::Components::Code)
+
+        when :directives_type
+          # nothing to do here, just return nil
+          nil
+
+        when :type_with_stage
+          # "WD"
+          # "PAS"
+          # "CD TR"
+          original_value = value.to_s # Store the original parsed value
+          iteration = original_value.match(/(\d+)$/)
+          normalized_value = original_value.sub(iteration.to_s, "")
+          typed_stage = locate_typed_stage(normalized_value || "")
+
+          # Create a copy with the original abbreviation preserved
+          typed_stage_with_original = typed_stage.dup
+          typed_stage_with_original.original_abbr = original_value.strip
+
+          ##
+          # Always use TypedStage in an Identifier or separate Type and Stage.
+          {
+            stage: typed_stage_with_original.to_stage,
+            type: typed_stage_with_original.to_type,
+            typed_stage: typed_stage_with_original,
+          }
+        when :stage_iteration
+          # "1" or "2"
+          Pubid::Components::Iteration.new(number: value.to_s)
+
+        when :date
+          parse_date(value)
+
+        when :undated_marker
+          # ISO/IEC undated reference (e.g. "ISO 16634:--") — explicit
+          # publication-date slot with no year; round-trips via date.render.
+          { date: Pubid::Components::Date.new(undated: true) }
+
+        when :edition
+          # value can be "Ed.2", "Ed 2", "ED1", "Edition 13", or just "Ed"
+          original_text = value.to_s
+          # Extract just the digit(s) for the number field
+          number_string = original_text.match(/\d+/)&.to_s
+          number_code = number_string ? Pubid::Iso::Components::Code.new(value: number_string) : nil
+          Pubid::Components::Edition.new(number: number_code,
+                                         original_text: original_text)
+
+        when :languages
+          parse_languages(value)
+
+        when :all_parts
+          # Set all_parts boolean attribute directly on identifier
+          true
+
+        # ISO 4214:2022 | IDF/RM 254:2022
+        when :joint_identifier
+          case value[:publisher]
+          when "IDF"
+            Pubid::Idf.build_from_parse(value)
+          end
+
+        when :subgroup
+          # Handle JTC 1 subgroup in directives (ISO/IEC JTC 1 DIR)
+          # Store as a component for potential use in rendering
+          Pubid::Iso::Components::Code.new(value: value.to_s)
+
+        when :supplements
+          # Handle bundled supplements (+ operator)
+          # Each supplement is a hash that needs to be built
+          value.map { |supplement_hash| build(supplement_hash[:supplement]) }
+
+        when :base_document
+          # For bundled identifiers, build the base document
+          build(value)
+
+        # TC Document attributes
+        when :tc_type, :sc_type, :wg_type
+          # TC, SC, WG types are code components
+          Pubid::Iso::Components::Code.new(value: value.to_s)
+
+        when :tc_number, :sc_number, :wg_number
+          # TC, SC, WG numbers are code components
+          Pubid::Iso::Components::Code.new(value: value.to_s)
+
+        when :year
+          # For TC documents with year, convert to Date
+          Pubid::Components::Date.new(year: value.to_s)
+
+        when :number
+          # For TC documents, number is the document number (N number)
+          # For regular identifiers, this is handled in :number_with_part
+          if value.is_a?(Parslet::Slice) || value.is_a?(String) ||
+              value.is_a?(Integer)
+            Pubid::Iso::Components::Code.new(value: value.to_s)
+          else
+            value
+          end
+
+        when :stage
+          # Raw stage code from URN parser (e.g., "10.00", "50.00")
+          # Convert to type_with_stage format for builder
+          # Look up the typed stage from stage code
+          typed_stage = Pubid::Iso.locate_stage_by_stage_code(value.to_s)
+          if typed_stage
+            typed_stage.abbr.is_a?(Array) ? typed_stage.abbr.first : typed_stage.abbr
+          else
+            # Fallback: return the raw stage code (shouldn't happen with valid data)
+            value.to_s
+          end
+
+        else
+          raise ArgumentError, "Unknown parameter type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/bundled_identifier.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # Identifier that represents a bundled identifier with base document and supplements
+    # E.g., "ISO/IEC DIR 1 + IEC SUP:2016-05" or "ISO/IEC DIR 1:2022 + IEC SUP:2022"
+    class BundledIdentifier < Identifier
+      attribute :base_document, Identifier, polymorphic: true
+      attribute :supplements, ::Pubid::Identifier, polymorphic: true,
+                                                   collection: true
+      attribute :type, :string, default: -> { "bundled_identifier" }
+
+      # Serialize the bundle structure. The inherited common-field maps read the
+      # delegated base_document values; suppress them (base_document carries
+      # them) and serialize base_document + the supplements collection instead,
+      # routing each through from_hash on load.
+      key_value do
+        # Serialized key is "base" (consistent with supplements); the attribute
+        # stays base_document.
+        map "base",
+            with: { to: :base_document_to_kv, from: :base_document_from_kv }
+        map "supplements",
+            with: { to: :supplements_to_kv, from: :supplements_from_kv }
+      end
+
+      def base_document_to_kv(model, doc)
+        return unless model.base_document
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(
+                        "base", model.base_document.to_hash
+                      ))
+      end
+
+      def base_document_from_kv(model, value)
+        model.base_document = ::Pubid::Iso::Identifier.from_hash(value) if value
+      end
+
+      def supplements_to_kv(model, doc)
+        return unless model.supplements&.any?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(
+                        "supplements", model.supplements.map(&:to_hash)
+                      ))
+      end
+
+      def supplements_from_kv(model, value)
+        model.supplements = Array(value).map do |h|
+          ::Pubid::Iso::Identifier.from_hash(h)
+        end
+      end
+
+      # The delegated common fields are carried by base_document; don't duplicate
+      # them at the bundle level.
+      def number_to_kv(_model, _doc); end
+      def part_to_kv(_model, _doc); end
+      def subpart_to_kv(_model, _doc); end
+      def year_to_kv(_model, _doc); end
+      def month_to_kv(_model, _doc); end
+      def day_to_kv(_model, _doc); end
+      def publisher_to_kv(_model, _doc); end
+      def copublishers_to_kv(_model, _doc); end
+      def stage_to_kv(_model, _doc); end
+
+      # Delegate key attributes to base_document for easier access in tests
+      def publisher
+        base_document&.publisher
+      end
+
+      def number
+        base_document&.number
+      end
+
+      def part
+        base_document&.part
+      end
+
+      def date
+        base_document&.date
+      end
+
+      def typed_stage
+        base_document&.typed_stage
+      end
+
+      def copublishers
+        base_document&.copublishers
+      end
+
+      # See the note on Pubid::BundledIdentifier#to_s: `**opts` carries flags
+      # this list does not name, `annotated:` above all.
+      def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
+stage_format_long: nil, with_date: nil, **opts)
+        parts = [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, **opts)]
+
+        # Add each supplement with "+" separator
+        supplements.each do |supplement|
+          supplement_str = supplement.to_supplement_s(lang: lang, lang_single: lang_single,
+                                                      with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date, **opts)
+          parts << "+ #{supplement_str}"
+        end
+
+        parts.join(" ")
+      end
+
+      # Generate URN for bundled identifier
+      # Format: urn:iso:doc:{base_urn}:{supplement_urn_parts}
+      # Example: urn:iso:doc:iso-iec:dir:1:2022:iec:sup:2022
+      def to_urn
+        # Start with base document URN (remove "urn:" prefix if exists)
+        base_urn = base_document.to_urn
+        base_parts = base_urn.split(":").drop(1) # Drop "urn" prefix
+
+        # Build URN parts starting with "urn"
+        urn_parts = ["urn"]
+
+        # Add base URN parts
+        urn_parts.concat(base_parts)
+
+        # Add each supplement's URN contribution
+        supplements.each do |supplement|
+          sup_urn = supplement.to_urn
+          if supplement.is_a?(Identifiers::DirectivesSupplement)
+          # DirectivesSupplement has special URN format
+          # Extract parts after "urn:iso:doc:"
+          else
+            # For other supplement types, add their URN parts
+            # Extract relevant parts and add them
+          end
+          sup_parts = sup_urn.split(":").drop(3)
+          urn_parts.concat(sup_parts)
+        end
+
+        urn_parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/iso/combined_identifier.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # Identifier that represents a supplement to a base identifier.
+    class CombinedIdentifier < Identifier
+      attribute :base, Identifier, polymorphic: true
+      attribute :additional_identifiers, ::Pubid::Identifier,
+                polymorphic: true, collection: true
+      attribute :type, :string, default: -> { "combined_identifier" }
+
+      # `**opts` carries render flags this list does not name (`annotated:`),
+      # which the closed signature used to reject outright.
+      def to_s(lang: :en, lang_single: false, **opts)
+        [
+          base.to_s(lang: lang, lang_single: lang_single, **opts),
+          additional_identifiers.map do |id|
+            id.to_s(lang: lang, lang_single: lang_single, **opts)
+          end,
+        ].flatten.join(" | ")
+      end
+    end
+  end
+end

data/lib/pubid/iso/components/code.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Components
+      # Code component for ISO identifiers.
+      #
+      # Inherits +value+ and +parts+ from the shared Code; overrides
+      # rendering to join parts with "-" (ISO convention). Equality and
+      # hash are inherited from the shared Code (compare all fields).
+      class Code < ::Pubid::Components::Code
+        def to_s
+          result = value.to_s
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result
+        end
+
+        def render(context: nil)
+          to_s
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/components/publisher.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Iso
+    module Components
+      # ISO Publisher with copublisher support
+      # Examples: ISO, ISO/IEC, ISO/IEC/IEEE
+      class Publisher < Lutaml::Model::Serializable
+        attribute :publisher, :string, default: -> { "ISO" }
+        attribute :copublisher, :string, collection: true
+
+        def body
+          publisher
+        end
+
+        def render(context: nil)
+          if context&.urn?
+            return publisher&.downcase
+          end
+
+          return publisher unless copublisher&.any?
+
+          publisher + copublisher.map { |cp| "/#{cp}" }.join
+        end
+
+        def to_s
+          result = publisher
+          result += copublisher.map { |cp| "/#{cp}" }.join if copublisher&.any?
+          result
+        end
+
+        def has_copublisher?
+          copublisher&.any?
+        end
+
+        def copublished?
+          copublisher&.any?
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Publisher)
+
+          # copublisher is a collection: parsing yields [] while building via
+          # .create (e.g. from an index hash) leaves it nil. Treat the empty
+          # collection and "no collection" as equal so both forms compare.
+          publisher == other.publisher &&
+            copublisher.to_a == other.copublisher.to_a
+        end
+
+        def hash
+          @hash ||= [publisher, copublisher.to_a].map(&:hash).hash
+        end
+
+        def eql?(other)
+          hash == other.hash && self == other
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/components.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Components
+      autoload :Code, "#{__dir__}/components/code"
+      autoload :Publisher, "#{__dir__}/components/publisher"
+    end
+  end
+end

data/lib/pubid/iso/format_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # Resolves format symbols to rendering options
+    class FormatResolver
+      FORMATS = {
+        ref_num_short: {
+          with_language_code: :single,      # 1-char: E, F, R, A, S, D
+          stage_format_long: false,         # Short: DAM, COR, FDAM
+          with_date: true,
+        },
+        ref_num_long: {
+          with_language_code: :iso,         # 2-char: en, fr, ru, ar, es, de
+          stage_format_long: true,          # Long: DAmd, Cor, FDAmd
+          with_date: true,
+        },
+        ref_dated: {
+          with_language_code: :none,
+          stage_format_long: false,
+          with_date: true,
+        },
+        ref_dated_long: {
+          with_language_code: :none,
+          stage_format_long: true,
+          with_date: true,
+        },
+        ref_undated: {
+          with_language_code: :none,
+          stage_format_long: false,
+          with_date: false,
+        },
+        ref_undated_long: {
+          with_language_code: :none,
+          stage_format_long: true,
+          with_date: false,
+        },
+      }.freeze
+
+      def self.resolve(format)
+        FORMATS[format] || raise(ArgumentError, "Unknown format: #{format}")
+      end
+    end
+  end
+end