pubid 1.15.19 → 2.0.0.pre.alpha.2

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Directives < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+        attribute :subgroup, ::Pubid::Components::Code
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pubguide,
+            stage_code: :published,
+            type_code: :dir,
+            abbr: ["DIR", "Directives Part", "Directives, Part", "Directives,",
+                   "Directives"],
+            short_abbr: "DIR",
+            long_abbr: "Directives, Part",
+            name: "Directives",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :dir, title: "Directives", short: "DIR" }
+        end
+
+        def to_s(**opts)
+          context = build_rendering_context(nil, format: :human, **opts)
+          Pubid::Renderers::DirectivesRenderer.new(self).render(context:,
+                                                                **opts.slice(:with_edition))
+        end
+
+        # Directives use a different URN scheme: urn:iso:doc instead of urn:iso:std
+        # Format: urn:iso:doc:{publisher}[:{subgroup}][:{subgroup_number}]:dir[:{number}][:{part}][:{year}]
+        def to_urn
+          parts = ["urn", "iso", "doc"]
+
+          copubs = copublishers || []
+          parts << ([publisher] + copubs).map(&:body).map(&:downcase).join("-")
+
+          if subgroup
+            subgroup_parts = subgroup.value.split
+            parts << subgroup_parts[0].downcase if subgroup_parts[0]
+            parts << subgroup_parts[1] if subgroup_parts[1]
+          end
+
+          parts << "dir"
+
+          parts << number.value if number
+          parts << part.value.downcase if part
+          parts << date.year if date
+
+          parts.join(":")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class DirectivesSupplement < SupplementIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+        attribute :supplement_publisher, ::Pubid::Components::Publisher
+
+        # Delegate base identifier attributes for easier access
+        def copublishers
+          base_identifier&.copublishers
+        end
+
+        def publisher
+          base_identifier&.publisher
+        end
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pubdirsup,
+            stage_code: :published,
+            type_code: :"dir-sup",
+            abbr: ["DIR SUP", "SUP", "Supplement"],
+            name: "Directives Supplement",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :"dir-sup", title: "Directives Supplement", short: "SUP" }
+        end
+
+        # def render_directives_supplement_identifier(identifier)
+        #   raise "Not a directives supplement identifier" unless identifier.is_a?(Identifiers::DirectivesSupplement)
+
+        #   render(identifier.base_identifier) +
+        #     " #{identifier.publisher.body}" +
+        #     " #{identifier.stage.abbr}" +
+        #     (identifier.date ? ":#{identifier.date.year}" : "")
+        # end
+
+        def to_s(lang: :en, lang_single: false, with_edition: false,
+format: nil, stage_format_long: nil, with_date: nil)
+          if base_identifier
+            # Full rendering with base identifier
+            [
+              base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                   with_edition: with_edition, format: format, stage_format_long: stage_format_long, with_date: with_date),
+              " #{supplement_publisher.body}",
+              " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
+              (date ? ":#{date.year}" : ""),
+              (edition ? " Edition #{edition.number.value}" : ""),
+            ].join
+          else
+            # Simplified rendering for bundled identifiers (just the supplement part)
+            to_supplement_s(lang: lang, lang_single: lang_single)
+          end
+        end
+
+        # Render just the supplement part (for use in bundled identifiers)
+        def to_supplement_s(lang: :en, lang_single: false, with_edition: false,
+format: nil, stage_format_long: nil, with_date: nil)
+          date_str = if date
+                       month_part = date.month ? "-#{date.month}" : ""
+                       ":#{date.year}#{month_part}"
+                     else
+                       ""
+                     end
+
+          [
+            supplement_publisher.body,
+            " SUP",
+            date_str,
+          ].join
+        end
+
+        # DirectivesSupplement use urn:iso:doc scheme (not urn:iso:std)
+        # Format: urn:iso:doc:{base_urn_parts}:jtc:X:sup[:{year}][:{edition}]
+        def to_urn
+          # If this is a standalone supplement (no base_identifier), build URN directly
+          unless base_identifier
+            parts = ["urn", "iso", "doc"]
+            parts << supplement_publisher.body.downcase if supplement_publisher
+            parts << "sup"
+            parts << date.year.to_s if date
+            parts << "ed-#{edition.number}" if edition&.number
+            return parts.join(":")
+          end
+
+          # Start with base identifier's URN parts (it will use urn:iso:doc scheme)
+          base_urn = base_identifier.to_urn
+
+          # Handle JTC pattern specially
+          if supplement_publisher&.body&.match?(/^JTC\s+(\d+)$/i)
+            # Extract JTC number: "JTC 1" -> ["jtc", "1"]
+            jtc_parts = supplement_publisher.body.downcase.split
+            # Insert JTC parts before "sup"
+            parts = base_urn.split(":")
+            parts.concat(jtc_parts) # Add "jtc" and "1"
+            parts << "sup"
+          else
+            # Normal supplement
+            parts = [base_urn, "sup"]
+            parts << supplement_publisher.body.downcase if supplement_publisher
+          end
+
+          # Year (if present)
+          parts << date.year.to_s if date
+
+          # Edition (if present)
+          parts << "ed-#{edition.number}" if edition&.number
+
+          parts.join(":")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Extract < SupplementIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pubext,
+            stage_code: :published,
+            type_code: :ext,
+            abbr: ["Ext"],
+            name: "Extract",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :ext, title: "Extract", short: "Ext" }
+        end
+
+        # def self.get_renderer_class
+        #   Renderer::TechnologyTrendsAssessments
+        # end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Guide < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwiis,
+            stage_code: :pwi,
+            type_code: :guide,
+            abbr: ["PWI Guide"],
+            name: "Proposed Work Item for International Standard",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npguide,
+            stage_code: :np,
+            type_code: :guide,
+            abbr: ["NP Guide", "NP GUIDE"],
+            name: "New Work Item Proposal for Guide",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98 10.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :awiguide,
+            stage_code: :awi,
+            type_code: :guide,
+            abbr: ["AWI Guide", "AWI GUIDE"],
+            name: "Approved Work Item for Guide",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :wdguide,
+            stage_code: :wd,
+            type_code: :guide,
+            abbr: ["WD Guide", "WD GUIDE"],
+            name: "Working Draft for Guide",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :cdguide,
+            stage_code: :cd,
+            type_code: :guide,
+            abbr: ["CD Guide", "CD GUIDE"],
+            name: "Committee Draft for Guide",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :dguide,
+            stage_code: :dguide,
+            type_code: :guide,
+            abbr: ["DGuide", "DGUIDE"],
+            name: "Draft Guide",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdguide,
+            stage_code: :fdguide,
+            type_code: :guide,
+            abbr: ["FDGuide", "FD Guide", "FD GUIDE"],
+            name: "Final Draft Guide",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prfguide,
+            stage_code: :prf,
+            type_code: :guide,
+            abbr: ["PRF Guide", "PRF GUIDE"],
+            name: "Proof Guide",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pubguide,
+            stage_code: :published,
+            type_code: :guide,
+            abbr: ["Guide", "GUIDE"],
+            name: "Published Guide",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :guide, title: "Guide", short: "GUIDE" }
+        end
+
+        def to_s(**opts)
+          context = build_rendering_context(nil, format: :human, **opts)
+          Pubid::Renderers::GuideRenderer.new(self).render(context:,
+                                                           **opts.slice(:with_edition))
+        end
+      end
+    end
+  end
+end