pubid 1.15.21 → 2.0.0.alpha.10

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # Data Identifier
+      class Data < SingleIdentifier
+
+        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,65 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Directives < SingleIdentifier
+        attribute :subgroup, ::Pubid::Components::Code
+
+        # Merges with Identifier's block (base attributes); only adds the
+        # Directives-specific subgroup so it survives to_hash/from_hash.
+        key_value do
+          map "subgroup", to: :subgroup
+        end
+
+        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,
+            web: :directives, 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,148 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class DirectivesSupplement < SupplementIdentifier
+        attribute :supplement_publisher, ::Pubid::Components::Publisher
+
+        # supplement_publisher (e.g. "IEC" in "ISO/IEC DIR 1 IEC SUP") is needed
+        # by to_s/to_urn; serialize its body under "publisher" (the supplement's
+        # own publisher; the base's publisher lives in the nested base). This
+        # overrides the inherited publisher map, whose delegated value is nil or
+        # the omitted ISO default here.
+        key_value do
+          map "publisher",
+              with: { to: :supplement_publisher_to_kv, from: :supplement_publisher_from_kv }
+        end
+
+        def supplement_publisher_to_kv(model, doc)
+          body = model.supplement_publisher&.body
+          return if body.nil? || body.to_s.empty?
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("publisher", body.to_s),
+          )
+        end
+
+        def supplement_publisher_from_kv(model, value)
+          model.supplement_publisher = ::Pubid::Components::Publisher.new(body: value.to_s)
+        end
+
+        # copublishers here is the base's (delegated), redundant with the nested
+        # base; don't duplicate it at the supplement level.
+        def copublishers_to_kv(_model, _doc); end
+
+        # Delegate base identifier attributes for easier access
+        def copublishers
+          base&.copublishers
+        end
+
+        def publisher
+          base&.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",
+            web: :directives_supplement, 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.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, **opts)
+          if base
+            # Full rendering with base identifier
+            [
+              base.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),
+              " #{supplement_publisher.render}",
+              " SUP", # Always render as "SUP" even though typed_stage.abbreviation is "DIR SUP"
+              (date ? ":#{date.render}" : ""),
+              (edition ? " Edition #{edition.value}" : ""),
+            ].join
+          else
+            # Simplified rendering for bundled identifiers (just the supplement part)
+            to_supplement_s(lang: lang, lang_single: lang_single, **opts)
+          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, **_opts)
+          date_str = if date
+                       month_part = date.month ? "-#{date.month}" : ""
+                       ":#{date.render}#{month_part}"
+                     else
+                       ""
+                     end
+
+          [
+            supplement_publisher.render,
+            " 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
+          urn_ctx = Rendering::RenderingContext.urn
+
+          # If this is a standalone supplement (no base), build URN directly
+          unless base
+            parts = ["urn", "iso", "doc"]
+            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
+            parts << "sup"
+            parts << date.render(context: urn_ctx) if date
+            parts << edition.render(context: urn_ctx) if edition&.number
+            return parts.join(":")
+          end
+
+          # Start with base identifier's URN parts (it will use urn:iso:doc scheme)
+          base_urn = base.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.render(context: urn_ctx).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.render(context: urn_ctx) if supplement_publisher
+          end
+
+          # Year (if present)
+          parts << date.render(context: urn_ctx) if date
+
+          # Edition (if present)
+          parts << edition.render(context: urn_ctx) 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
+
+        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,
+            web: :extract, 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,99 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      class Guide < SingleIdentifier
+
+        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

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # International Standard Identifier
+      class InternationalStandard < SingleIdentifier
+        include IdentifierMetadata
+
+        # Note: type attribute uses shared Components::Type from Pubid namespace
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :isdp,
+            stage_code: :dp,
+            type_code: :is,
+            abbr: ["DP"],
+            name: "Draft Proposal",
+            harmonized_stages: %w[],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pwiis,
+            stage_code: :pwi,
+            type_code: :is,
+            abbr: ["PWI"],
+            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: :isnp,
+            stage_code: :np,
+            type_code: :is,
+            abbr: ["NP", "NWIP"],
+            name: "New Work Item Proposal for International Standard",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awiis,
+            stage_code: :awi,
+            type_code: :is,
+            abbr: ["AWI"],
+            name: "Approved Work Item for International Standard",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdis,
+            stage_code: :wd,
+            type_code: :is,
+            abbr: ["WD"],
+            name: "Working Draft for International Standard",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wds,
+            stage_code: :wds,
+            type_code: :is,
+            abbr: ["WDS"],
+            name: "Working Draft Study",
+            harmonized_stages: %w[20.20 20.60],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :pcdis,
+            stage_code: :pcd,
+            type_code: :is,
+            abbr: ["preCD", "PreCD"],
+            name: "Pre-Committee Draft for International Standard",
+            harmonized_stages: %w[29.00 29.20 29.60 29.92 29.93 29.98 29.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdis,
+            stage_code: :cd,
+            type_code: :is,
+            abbr: ["CD"],
+            name: "Committee Draft for International Standard",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :dis,
+            stage_code: :dis,
+            type_code: :is,
+            abbr: ["DIS", "FPD"],
+            name: "Draft International Standard",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fcdis,
+            stage_code: :fcd,
+            type_code: :is,
+            abbr: ["FCD"],
+            name: "Final Committee Draft for International Standard",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :fdis,
+            stage_code: :fdis,
+            type_code: :is,
+            abbr: ["FDIS"],
+            name: "Final Draft International Standard",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :prfis,
+            stage_code: :prf,
+            type_code: :is,
+            abbr: ["PRF", "Fpr"],
+            name: "Proof International Standard",
+            harmonized_stages: %w[60.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :is,
+            stage_code: :published,
+            type_code: :is,
+            abbr: ["", "IS"],
+            name: "International Standard",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdr,
+            stage_code: :wdr,
+            type_code: :is,
+            abbr: ["WDR"],
+            name: "Proposed for Withdrawal",
+            harmonized_stages: %w[90.92],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wda,
+            stage_code: :wda,
+            type_code: :is,
+            abbr: ["WDA"],
+            name: "Withdrawal Approved",
+            harmonized_stages: %w[90.93],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdar,
+            stage_code: :wdar,
+            type_code: :is,
+            abbr: ["WDAR"],
+            name: "Withdrawal Archived",
+            harmonized_stages: %w[95.99],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :is,
+            web: :international_standard, title: "International Standard", short: nil }
+        end
+
+        # Define machine-readable metadata
+        define_metadata(
+          type_key: :is,
+          title: "International Standard",
+          short: "IS",
+          abbr: ["", "IS"],
+          base_class: "SingleIdentifier",
+          stage_codes: %i[dp pwi np awi wds wd pcd cd fcd dis
+                          fdis prf wdr wda wdar],
+          machine_codes: {
+            iso_stage: ["40.60", "60.60"],
+            harcoded: "IS",
+          },
+        )
+      end
+    end
+  end
+end
+
+# NOTE: Identifiers are now registered in the ISO flavor module
+# The global registry has been removed in favor of self-describing types

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iso
+    module Identifiers
+      # International Standardized Profile Identifier
+      class InternationalStandardizedProfile < SingleIdentifier
+
+        TYPED_STAGES = [
+          ::Pubid::Components::TypedStage.new(
+            code: :pwiisp,
+            stage_code: :pwi,
+            type_code: :isp,
+            abbr: ["PWI ISP"],
+            name: "Proposed Work Item for International Standardized Profile",
+            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :npisp,
+            stage_code: :np,
+            type_code: :isp,
+            abbr: ["NP ISP"],
+            name: "New Work Item Proposal for International Standardized Profile",
+            harmonized_stages: %w[10.00 10.20 10.60 10.92 10.93 10.98],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :awiisp,
+            stage_code: :awi,
+            type_code: :isp,
+            abbr: ["AWI ISP"],
+            name: "Approved Work Item for International Standardized Profile",
+            harmonized_stages: %w[10.99 20.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :wdisp,
+            stage_code: :wd,
+            type_code: :isp,
+            abbr: ["WD ISP"],
+            name: "Working Draft for International Standardized Profile",
+            harmonized_stages: %w[20.20 20.60 20.92 20.93 20.98 20.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :cdisp,
+            stage_code: :cd,
+            type_code: :isp,
+            abbr: ["CD ISP"],
+            name: "Committee Draft for International Standardized Profile",
+            harmonized_stages: %w[30.00 30.20 30.60 30.92 30.93 30.98 30.99],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :disp,
+            stage_code: :disp,
+            type_code: :isp,
+            abbr: ["DISP", "DIS ISP"],
+            name: "Draft International Standardized Profile",
+            harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :fdisp,
+            stage_code: :fdis,
+            type_code: :isp,
+            abbr: ["FDISP", "FDIS ISP"],
+            name: "Final Draft International Standardized Profile",
+            harmonized_stages: %w[50.00 50.20 50.60 50.92],
+          ),
+
+          ::Pubid::Components::TypedStage.new(
+            code: :prfisp,
+            stage_code: :prf,
+            type_code: :isp,
+            abbr: ["PRF ISP"],
+            name: "Proof International Standardized Profile",
+            harmonized_stages: %w[60.00],
+          ),
+          ::Pubid::Components::TypedStage.new(
+            code: :isp,
+            stage_code: :published,
+            type_code: :isp,
+            abbr: ["ISP"],
+            name: "International Standardized Profile",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :isp,
+            web: :international_standardized_profile, title: "International Standardized Profile",
+            short: "ISP" }
+        end
+      end
+    end
+  end
+end