pubid 1.15.18 → 2.0.0.pre.alpha.1

data/lib/pubid/iso/components.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Components
+      # ISO-specific components
+    end
+  end
+end
+
+require_relative "components/code"
+require_relative "components/publisher"

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

data/lib/pubid/iso/identifier.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    class Identifier < ::Pubid::Identifier
+      # Override base types with ISO-specific ones
+      attribute :publisher, ::Pubid::Iso::Components::Publisher
+      attribute :copublishers, ::Pubid::Iso::Components::Publisher,
+                collection: true
+      attribute :number, ::Pubid::Iso::Components::Code
+      attribute :part, ::Pubid::Iso::Components::Code
+      attribute :subpart, ::Pubid::Iso::Components::Code
+
+      # Polymorphic type map for lutaml::Model key_value serialization
+      # Maps polymorphic_name → class name for deserialization
+      # Validated by spec to stay in sync with Scheme.identifiers
+      ISO_TYPE_MAP = {
+        "pubid:iso:international-standard" => "Pubid::Iso::Identifiers::InternationalStandard",
+        "pubid:iso:international-standardized-profile" => "Pubid::Iso::Identifiers::InternationalStandardizedProfile",
+        "pubid:iso:international-workshop-agreement" => "Pubid::Iso::Identifiers::InternationalWorkshopAgreement",
+        "pubid:iso:technical-report" => "Pubid::Iso::Identifiers::TechnicalReport",
+        "pubid:iso:technical-specification" => "Pubid::Iso::Identifiers::TechnicalSpecification",
+        "pubid:iso:pas" => "Pubid::Iso::Identifiers::Pas",
+        "pubid:iso:guide" => "Pubid::Iso::Identifiers::Guide",
+        "pubid:iso:recommendation" => "Pubid::Iso::Identifiers::Recommendation",
+        "pubid:iso:amendment" => "Pubid::Iso::Identifiers::Amendment",
+        "pubid:iso:corrigendum" => "Pubid::Iso::Identifiers::Corrigendum",
+        "pubid:iso:supplement" => "Pubid::Iso::Identifiers::Supplement",
+        "pubid:iso:addendum" => "Pubid::Iso::Identifiers::Addendum",
+        "pubid:iso:extract" => "Pubid::Iso::Identifiers::Extract",
+        "pubid:iso:directives" => "Pubid::Iso::Identifiers::Directives",
+        "pubid:iso:directives-supplement" => "Pubid::Iso::Identifiers::DirectivesSupplement",
+        "pubid:iso:data" => "Pubid::Iso::Identifiers::Data",
+        "pubid:iso:tc-document" => "Pubid::Iso::Identifiers::TcDocument",
+        "pubid:iso:technology-trends-assessments" => "Pubid::Iso::Identifiers::TechnologyTrendsAssessments",
+      }.freeze
+
+      # Build type map from Scheme.identifiers for validation
+      def self.build_type_map
+        Scheme.identifiers.to_h do |klass|
+          [klass.polymorphic_name, klass.name]
+        end
+      end
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ISO_TYPE_MAP
+      end
+
+      def self.parse(string, format: :auto)
+        format = Pubid::FormatDetector.detect(string) if format == :auto
+
+        case format
+        when :urn
+          Pubid::Iso::UrnParser.parse(string)
+        when :mr_string
+          Pubid::Parsers::MrString.parse(string)
+        else
+          parsed = Pubid::Iso::Parser.new.parse(string)
+          if parsed.nil? || parsed.empty?
+            raise Pubid::Iso::Parser::ParseError,
+                  "Invalid identifier format"
+          end
+
+          Pubid::Iso::Builder.new(Pubid::Iso::Scheme).build(parsed)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/addendum.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Addendum < SupplementIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        # Override URN supplement type to use generic "sup" instead of "add"
+        # This matches the ISO URN specification where addendums use "sup"
+        def urn_supplement_type
+          "sup"
+        end
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwi_add,
+            abbr: ["PWI Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :proposal,
+            name: "Proposed Work Item for Addendum",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :np_add,
+            abbr: ["NP Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :proposal,
+            name: "New Work Item Proposal for Addendum",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awi_add,
+            abbr: ["AWI Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :preliminary,
+            name: "Approved Work Item for Addendum",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wd_add,
+            abbr: ["WD Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :working_draft,
+            name: "Working Draft for Addendum",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :committee_draft_add,
+            abbr: ["CD Add"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :add,
+            stage_code: :cd,
+            name: "Committee Draft for Addendum",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dad,
+            abbr: ["DAD", "DAdd", "D ADD", "Dad"],
+            short_abbr: "DAD",
+            long_abbr: "DAdd",
+            type_code: :add,
+            stage_code: :dad,
+            name: "Draft Addendum",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdad,
+            abbr: ["FDAD", "FDAdd", "FD ADD", "FDad"],
+            short_abbr: "FDAD",
+            long_abbr: "FDAdd",
+            type_code: :add,
+            stage_code: :fdad,
+            name: "Final Draft Addendum",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :published,
+            abbr: ["Add", "ADD", "Add.", "Addendum"],
+            short_abbr: "ADD",
+            long_abbr: "Add",
+            type_code: :add,
+            stage_code: :published,
+            name: "Addendum",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :add, title: "Addendum", short: "ADD" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/amendment.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Amendment < SupplementIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwi_amd,
+            abbr: ["PWI Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :proposal,
+            name: "Proposed Work Item for Amendment",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :np_amd,
+            abbr: ["NP Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :proposal,
+            name: "New Work Item Proposal for Amendment",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awi_amd,
+            abbr: ["AWI Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :preliminary,
+            name: "Approved Work Item for Amendment",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wd_amd,
+            abbr: ["WD Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :working_draft,
+            name: "Working Draft for Amendment",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :committee_draft_amd,
+            abbr: ["CD Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :cd,
+            name: "Committee Draft for Amendment",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pdam,
+            abbr: ["PDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :cd,
+            name: "Proposed Draft Amendment (Legacy)",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :damd,
+            abbr: ["DAM", "DAmd"],
+            short_abbr: "DAM",
+            long_abbr: "DAmd",
+            type_code: :amd,
+            stage_code: :damd,
+            name: "Draft Amendment",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdamd,
+            abbr: ["FDAM", "FDAmd"],
+            short_abbr: "FDAM",
+            long_abbr: "FDAmd",
+            type_code: :amd,
+            stage_code: :fdamd,
+            name: "Final Draft Amendment",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fpdam,
+            abbr: ["FPDAM"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :fdamd,
+            name: "Final Proposed Draft Amendment (Legacy)",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prf_amd,
+            abbr: ["PRF Amd"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :amd,
+            stage_code: :prf,
+            name: "Proof Amendment",
+            harmonized_stages: %w[50.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :published,
+            abbr: ["Amd", "AMD", "Amd."],
+            short_abbr: "AMD",
+            long_abbr: "Amd",
+            type_code: :amd,
+            stage_code: :published,
+            name: "Amendment",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amd, title: "Amendment", short: "AMD" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Iso
+    module Identifiers
+      # Base class for ISO identifiers
+      class Base < ::Pubid::Identifier
+        # Inherit most attributes from parent
+        # ISO-specific attributes
+        attribute :stage_iteration, ::Pubid::Iso::Components::Code
+
+        # ISO rendering context singleton
+        def self.rendering_context
+          @rendering_context ||= Pubid::Rendering::RenderingContext.iso
+        end
+
+        # Render identifier using OOP approach - each component renders itself
+        #
+        # @param lang [Symbol] language for rendering (:en or :fr)
+        # @param lang_single [Boolean] use single char language format
+        # @param with_edition [Boolean] include edition in output
+        # @return [String] formatted identifier string
+        def to_s(lang: :en, lang_single: false, with_edition: false)
+          # Create rendering context with language settings
+          context = Pubid::Rendering::RenderingContext.new(
+            stage_separator: "/",
+            stage_separator_with_copublisher: " ",
+            type_separator: "/",
+            type_separator_with_prefix: " ",
+            default_type_abbr: "IS",
+            lang: lang,
+            lang_single: lang_single,
+          )
+
+          # Compose the identifier from component renderings
+          render_from_components(context: context, with_edition: with_edition)
+        end
+
+        private
+
+        # Compose identifier string by having each component render itself
+        #
+        # @param context [RenderingContext] rendering context for flavor rules
+        # @param with_edition [Boolean] include edition in output
+        # @return [String] composed identifier string
+        def render_from_components(context:, with_edition: false)
+          parts = []
+          parts << publisher.to_s
+
+          # Stage renders itself with context-aware separators
+          if stage
+            has_copub = publisher&.has_copublisher?
+            parts << stage.to_s(context: context, has_copublisher: has_copub)
+          end
+
+          # Type renders itself with context-aware separators and default handling
+          if type
+            has_prefix = stage || publisher&.has_copublisher?
+            type_render = type.to_s(context: context, has_prefix: has_prefix)
+            parts << type_render if type_render != ""
+          end
+
+          # Number renders itself
+          parts << " #{number.value}" if number&.value
+
+          # Parts render themselves
+          parts << "-#{part.value}" if part&.value
+          parts << "-#{subpart.value}" if subpart&.value
+
+          # Stage iteration renders itself
+          parts << ".#{stage_iteration.value}" if stage_iteration&.value
+
+          # Date renders itself with context
+          parts << date.to_s(context: context) if date&.year
+
+          # Edition renders itself
+          parts << " #{edition}" if with_edition && edition&.number
+
+          # Languages render themselves
+          if languages&.any?
+            parts << "(#{languages.map do |l|
+              l.to_s(lang_single: context.lang_single)
+            end.join('/')})"
+          end
+
+          parts.join
+        end
+
+        public
+
+        # V1 API compatibility - tests expect .copublishers returning array of Publisher objects
+        def copublishers
+          return [] unless publisher.copublisher&.any?
+
+          publisher.copublisher.map do |cp|
+            ::Pubid::Components::Publisher.new(body: cp)
+          end
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Base)
+
+          publisher == other.publisher &&
+            type == other.type &&
+            number == other.number &&
+            part == other.part &&
+            date == other.date &&
+            stage == other.stage
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Corrigendum < SupplementIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwi_cor,
+            abbr: ["PWI Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :proposal,
+            name: "Proposed Work Item for Corrigendum",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npcor,
+            abbr: ["NP Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :proposal,
+            name: "New Work Item Proposal for Corrigendum",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awicor,
+            abbr: ["AWI Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :preliminary,
+            name: "Approved Work Item for Corrigendum",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdcor,
+            abbr: ["WD Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :working_draft,
+            name: "Working Draft for Corrigendum",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdcor,
+            abbr: ["CD Cor", "pDCOR"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :cd,
+            name: "Committee Draft for Corrigendum",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dcor,
+            abbr: ["DCor", "DCOR"],
+            short_abbr: "DCOR",
+            long_abbr: "DCor",
+            type_code: :cor,
+            stage_code: :dcor,
+            name: "Draft Corrigendum",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdcor,
+            abbr: ["FDCor", "FDCOR", "FCOR"],
+            short_abbr: "FDCOR",
+            long_abbr: "FDCor",
+            type_code: :cor,
+            stage_code: :fdcor,
+            name: "Final Draft Corrigendum",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prfcor,
+            abbr: ["PRF Cor"],
+            short_abbr: nil,
+            long_abbr: nil,
+            type_code: :cor,
+            stage_code: :prf,
+            name: "Proof Corrigendum",
+            harmonized_stages: %w[50.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubcor,
+            abbr: ["Cor", "COR", "Cor."],
+            short_abbr: "COR",
+            long_abbr: "Cor",
+            type_code: :cor,
+            stage_code: :published,
+            name: "Corrigendum",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :cor, title: "Corrigendum", short: "COR" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/identifiers/data.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # Data Identifier
+      class Data < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :npdata,
+            stage_code: :np,
+            type_code: :data,
+            abbr: ["NP DATA"],
+            name: "New Work Item Proposal for Data",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awidata,
+            stage_code: :awi,
+            type_code: :data,
+            abbr: ["AWI DATA"],
+            name: "Approved Work Item for Data",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wddata,
+            stage_code: :wd,
+            type_code: :data,
+            abbr: ["WD DATA"],
+            name: "Working Draft for Data",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cddata,
+            stage_code: :cd,
+            type_code: :data,
+            abbr: ["CD DATA"],
+            name: "Committee Draft for Data",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :ddata,
+            stage_code: :ddata,
+            type_code: :data,
+            abbr: ["D DATA"],
+            name: "Draft Data",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :prfdata,
+            stage_code: :prf,
+            type_code: :data,
+            abbr: ["PRF DATA"],
+            name: "Proof Data",
+            harmonized_stages: %w[60.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubdata,
+            stage_code: :published,
+            type_code: :data,
+            abbr: ["DATA"],
+            name: "Data",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :data, title: "Data", short: "PAS" }
+        end
+      end
+    end
+  end
+end