pubid 1.15.19 → 2.0.0.pre.alpha.1

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Standards and Specifications (S series).
+      # Examples: IHO S-44 5.0.0, IHO S-100 Part 4a 1.0.0, IHO S-65 Ap. A 1.0.0.
+      class Standard < Base
+        def self.type
+          { key: :standard, title: "Standards and Specifications", short: "S" }
+        end
+
+        def type
+          self.class.type
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifiers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      autoload :Base,           "#{__dir__}/identifiers/base"
+      autoload :Bibliographic,  "#{__dir__}/identifiers/bibliographic"
+      autoload :CircularLetter, "#{__dir__}/identifiers/circular_letter"
+      autoload :Miscellaneous,  "#{__dir__}/identifiers/miscellaneous"
+      autoload :Publication,    "#{__dir__}/identifiers/publication"
+      autoload :Standard,       "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/iho/parser.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iho
+    # Parser class for IHO identifiers
+    class Parser < Parslet::Parser
+      rule(:space)  { str(" ") }
+      rule(:dash)   { str("-") }
+      rule(:dot)    { str(".") }
+      rule(:digits) { match("[0-9]").repeat(1) }
+
+      rule(:series) do
+        (str("S") | str("P") | str("M") | str("B") | str("C")).as(:type)
+      end
+
+      rule(:number_suffix) do
+        (str(":") >> digits) | (str("/") >> digits) | (dash >> digits) | match("[A-Z]")
+      end
+
+      rule(:code) do
+        (digits >> number_suffix.maybe).as(:code)
+      end
+
+      rule(:appendix) do
+        space >> (str("Appendix") | str("Ap.")) >> space >>
+          (
+            (match("[A-Z]") >> dash >> digits) |
+            digits |
+            match("[A-Z]")
+          ).as(:appendix)
+      end
+
+      rule(:part) do
+        space >> str("Part") >> space >>
+          (
+            (digits >> match("[a-zA-Z]").repeat).as(:part) |
+            match("[A-Z]").as(:part)
+          )
+      end
+
+      rule(:annex) do
+        space >> str("Annex") >> space >> match("[A-Z]").as(:annex)
+      end
+
+      rule(:supplement) do
+        space >> str("Suppl") >> space >> digits.as(:supplement)
+      end
+
+      rule(:version) do
+        space >> (digits >> dot >> digits >> dot >> digits).as(:version)
+      end
+
+      rule(:identifier) do
+        (str("IHO") >> space).maybe >>
+          series >> dash >> code >>
+          appendix.maybe >> part.maybe >> annex.maybe >> supplement.maybe >> version.maybe
+      end
+
+      root :identifier
+
+      def self.parse(string)
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/iho/scheme.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Scheme registry for IHO identifier types.
+    class Scheme < Pubid::Scheme
+      IDENTIFIERS = [
+        Identifiers::Standard,
+        Identifiers::Publication,
+        Identifiers::Miscellaneous,
+        Identifiers::Bibliographic,
+        Identifiers::CircularLetter,
+      ].freeze
+
+      def initialize
+        @identifiers = IDENTIFIERS
+      end
+
+      # Look up an identifier class by its IHO series letter (S/P/M/B/C).
+      # @param letter [String]
+      # @return [Class<Identifiers::Base>]
+      # @raise [KeyError] if the letter is not a known IHO series
+      def self.identifier_klass_for_type_letter(letter)
+        @by_letter ||= IDENTIFIERS.to_h { |klass| [klass.type[:short], klass] }
+        @by_letter.fetch(letter.to_s)
+      end
+    end
+  end
+end

data/lib/pubid/iho/urn_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Generates URN strings for IHO identifiers.
+    #
+    # Format: urn:iho:{type-letter-lowercase}:{code}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version}]
+    # Example: urn:iho:s:44:5.0.0 for "IHO S-44 5.0.0".
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        parts = ["urn", "iho"]
+        parts << identifier.type[:short].to_s.downcase
+        parts << identifier.code.to_s
+        parts << "ap.#{identifier.appendix}"     if identifier.appendix
+        parts << "part.#{identifier.part}"       if identifier.part
+        parts << "annex.#{identifier.annex}"     if identifier.annex
+        parts << "suppl.#{identifier.supplement}" if identifier.supplement
+        parts << identifier.version.to_s if identifier.version
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/iho.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    autoload :Builder,      "#{__dir__}/iho/builder"
+    autoload :Identifier,   "#{__dir__}/iho/identifier"
+    autoload :Identifiers,  "#{__dir__}/iho/identifiers"
+    autoload :Parser,       "#{__dir__}/iho/parser"
+    autoload :Scheme,       "#{__dir__}/iho/scheme"
+    autoload :UrnGenerator, "#{__dir__}/iho/urn_generator"
+
+    # Parse an IHO identifier string into an identifier object
+    # @param identifier [String] The IHO identifier string to parse
+    # @return [Pubid::Iho::Identifiers::Base] The appropriate identifier object
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+  end
+end
+
+Pubid::Registry.register(:iho, Pubid::Iho)

data/lib/pubid/iso/builder.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    class Builder < Pubid::Builder::Base
+      def initialize(scheme)
+        @scheme = scheme
+      end
+
+      def locate_identifier_klass(parsed_hash)
+        # If there is a joint_identifier, we need to use a CombinedIdentifier
+        # which takes `base_identifier` 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
+
+        # 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_identifier] && parsed_hash[:base_identifier][: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])
+
+        @scheme.locate_identifier_klass_by_type_code(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 = @scheme.locate_typed_stage_by_abbr("")
+          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
+
+      def cast(type, value)
+        case type
+        when :base_identifier
+          # 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_identifier, 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
+            Pubid::Iso::Components::Publisher.new(publisher: value)
+          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)
+
+          # Split the number into parts
+          normalized_value = value.to_s.tr("#{Parser::DASH_CHARS.join}/", "-")
+
+          # for "1 IEC" ('IEC' is part) (in case of "ISO/IEC DIR 1 IEC")
+          normalized_value.gsub!(" ", "-")
+
+          parts = normalized_value.split("-").reject(&:empty?)
+          number = parts.shift # The first part is always the number
+          part = parts.shift&.strip # The second part is the part, if present
+          subpart = parts.any? ? parts.join("-") : nil # The remaining parts form the subpart, if present
+
+          # LEGACY FORMAT FIX: If "part" is a 4-digit year (1900-2099), move it to date field
+          # This handles legacy formats like "ISO 4037-1979" where hyphen was used instead of colon
+          if part&.match?(/^\d{4}$/)
+            year_value = part.to_i
+            # Only treat as year if in reasonable year range (excludes part numbers like "1751")
+            if year_value.between?(1900, 2099)
+              return {
+                number: Pubid::Iso::Components::Code.new(number: number),
+                date: Pubid::Components::Date.new(year: part),
+              }
+            end
+          end
+
+          part = convert_roman_to_integer(part)
+
+          code_hash = { number: Pubid::Iso::Components::Code.new(number: number) }
+
+          if part
+            code_hash[:part] = Pubid::Iso::Components::Code.new(number: part)
+          end
+
+          if subpart
+            code_hash[:subpart] =
+              Pubid::Iso::Components::Code.new(number: subpart)
+          end
+
+          code_hash
+
+        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::Iso::Components::Code.new(number: value.to_s)
+
+        when :date
+          parse_date(value)
+
+        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(number: 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"
+            require_relative "../idf/builder"
+            Idf::Builder.new.build(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(number: 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(number: value.to_s)
+
+        when :tc_number, :sc_number, :wg_number
+          # TC, SC, WG numbers are code components
+          Pubid::Iso::Components::Code.new(number: 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(number: 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 = Scheme.locate_typed_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,85 @@
+# 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" }
+
+      # 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
+
+      def to_s(lang: :en, lang_single: false, with_edition: false, format: nil,
+stage_format_long: nil, with_date: nil)
+        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)]
+
+        # 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)
+          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,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    # Identifier that represents a supplement to a base identifier.
+    class CombinedIdentifier < Identifier
+      attribute :base_identifier, Identifier, polymorphic: true
+      attribute :additional_identifiers, ::Pubid::Identifier,
+                polymorphic: true, collection: true
+      attribute :type, :string, default: -> { "combined_identifier" }
+
+      def to_s(lang: :en, lang_single: false)
+        [
+          base_identifier.to_s(lang: lang, lang_single: lang_single),
+          additional_identifiers.map do |id|
+            id.to_s(lang: lang, lang_single: lang_single)
+          end,
+        ].flatten.join(" | ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Iso
+    module Components
+      class Code < ::Pubid::Components::Code
+        attribute :number, :string
+        attribute :parts, :string, collection: true
+
+        def value
+          number || self[:value]
+        end
+
+        def render(context: nil)
+          result = value.to_s
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result
+        end
+
+        def to_s
+          result = value.to_s
+          result += parts.map { |p| "-#{p}" }.join if parts&.any?
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Code)
+
+          value == other.value && parts == other.parts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# 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)
+          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)
+
+          publisher == other.publisher && copublisher == other.copublisher
+        end
+
+        # Returns hash code for publisher component
+        # @return [Integer] hash code
+        # @note Memoized for performance
+        def hash
+          @hash ||= [publisher, copublisher].compact.map(&:hash).hash
+        end
+
+        # Checks equality using hash for consistency
+        # @param other [Object] object to compare with
+        # @return [Boolean] true if equal
+        def eql?(other)
+          hash == other.hash && self == other
+        end
+      end
+    end
+  end
+end