pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

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

@@ -4,42 +4,16 @@ 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
 
-        # 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
+          base_identifier&.copublishers
         end
 
         def publisher
-          base&.publisher
+          base_identifier&.publisher
         end
 
         TYPED_STAGES = [
@@ -54,49 +28,48 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :"dir-sup",
-            web: :directives_supplement, title: "Directives Supplement", short: "SUP" }
+          { 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) +
+        #   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, **opts)
-          if base
+format: nil, stage_format_long: nil, with_date: nil)
+          if base_identifier
             # 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}",
+              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.render}" : ""),
-              (edition ? " Edition #{edition.value}" : ""),
+              (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, **opts)
+            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, **_opts)
+format: nil, stage_format_long: nil, with_date: nil)
           date_str = if date
                        month_part = date.month ? "-#{date.month}" : ""
-                       ":#{date.render}#{month_part}"
+                       ":#{date.year}#{month_part}"
                      else
                        ""
                      end
 
           [
-            supplement_publisher.render,
+            supplement_publisher.body,
             " SUP",
             date_str,
           ].join
@@ -105,25 +78,23 @@ format: nil, stage_format_long: nil, with_date: nil, **_opts)
         # 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
+          # If this is a standalone supplement (no base_identifier), build URN directly
+          unless base_identifier
             parts = ["urn", "iso", "doc"]
-            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
+            parts << supplement_publisher.body.downcase if supplement_publisher
             parts << "sup"
-            parts << date.render(context: urn_ctx) if date
-            parts << edition.render(context: urn_ctx) if edition&.number
+            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.to_urn
+          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.render(context: urn_ctx).split
+            jtc_parts = supplement_publisher.body.downcase.split
             # Insert JTC parts before "sup"
             parts = base_urn.split(":")
             parts.concat(jtc_parts) # Add "jtc" and "1"
@@ -131,14 +102,14 @@ format: nil, stage_format_long: nil, with_date: nil, **_opts)
           else
             # Normal supplement
             parts = [base_urn, "sup"]
-            parts << supplement_publisher.render(context: urn_ctx) if supplement_publisher
+            parts << supplement_publisher.body.downcase if supplement_publisher
           end
 
           # Year (if present)
-          parts << date.render(context: urn_ctx) if date
+          parts << date.year.to_s if date
 
           # Edition (if present)
-          parts << edition.render(context: urn_ctx) if edition&.number
+          parts << "ed-#{edition.number}" if edition&.number
 
           parts.join(":")
         end

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

@@ -4,6 +4,7 @@ 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(
@@ -17,8 +18,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ext,
-            web: :extract, title: "Extract", short: "Ext" }
+          { key: :ext, title: "Extract", short: "Ext" }
         end
 
         # def self.get_renderer_class

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

@@ -4,6 +4,7 @@ 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(

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

@@ -8,6 +8,7 @@ module Pubid
         include IdentifierMetadata
 
         # Note: type attribute uses shared Components::Type from Pubid namespace
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -141,8 +142,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :is,
-            web: :international_standard, title: "International Standard", short: nil }
+          { key: :is, title: "International Standard", short: nil }
         end
 
         # Define machine-readable metadata
@@ -164,5 +164,5 @@ module Pubid
   end
 end
 
-# NOTE: Identifiers are now registered in the ISO flavor module
-# The global registry has been removed in favor of self-describing types
+# NOTE: Identifiers are now registered in the ISO Scheme class
+# The global registry has been removed in favor of per-flavor Schemes

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

@@ -5,6 +5,7 @@ module Pubid
     module Identifiers
       # International Standardized Profile Identifier
       class InternationalStandardizedProfile < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -51,7 +52,7 @@ module Pubid
             code: :disp,
             stage_code: :disp,
             type_code: :isp,
-            abbr: ["DISP", "DIS ISP"],
+            abbr: ["DISP"],
             name: "Draft International Standardized Profile",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -60,7 +61,7 @@ module Pubid
             code: :fdisp,
             stage_code: :fdis,
             type_code: :isp,
-            abbr: ["FDISP", "FDIS ISP"],
+            abbr: ["FDISP"],
             name: "Final Draft International Standardized Profile",
             harmonized_stages: %w[50.00 50.20 50.60 50.92],
           ),
@@ -84,8 +85,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :isp,
-            web: :international_standardized_profile, title: "International Standardized Profile",
+          { key: :isp, title: "International Standardized Profile",
             short: "ISP" }
         end
       end

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

@@ -4,17 +4,12 @@ module Pubid
   module Iso
     module Identifiers
       class InternationalWorkshopAgreement < SingleIdentifier
-
-        # IWA identifiers have no publisher prefix (rendered "IWA 1", not
-        # "ISO IWA 1"), so there is no implied publisher to default on load.
-        def self.default_publisher
-          nil
-        end
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
-            code: :pwiiwa,
-            stage_code: :pwi,
+            code: :npiwa,
+            stage_code: :np,
             type_code: :iwa,
             abbr: ["PWI IWA"],
             name: "Proposed Work Item for International Workshop Agreement",
@@ -80,8 +75,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :iwa,
-            web: :international_workshop_agreement, title: "International Workshop Agreement", short: "IWA" }
+          { key: :iwa, title: "International Workshop Agreement", short: "IWA" }
         end
 
         def to_s(**opts)

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

@@ -5,6 +5,7 @@ module Pubid
     module Identifiers
       # Publicly Available Specification", Identifier
       class Pas < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -84,8 +85,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :pas,
-            web: :publicly_available_specification, title: "Publicly Available Specification", short: "PAS" }
+          { key: :pas, title: "Publicly Available Specification", short: "PAS" }
         end
       end
     end

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

@@ -4,6 +4,7 @@ module Pubid
   module Iso
     module Identifiers
       class Recommendation < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -31,8 +32,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :rec,
-            web: :recommendation, title: "Recommendation", short: "R" }
+          { key: :rec, title: "Recommendation", short: "R" }
         end
 
         # Override URN type code - Recommendation uses 'r' in URN (RFC 5141)

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

@@ -4,16 +4,9 @@ module Pubid
   module Iso
     module Identifiers
       class Supplement < SupplementIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
-          ::Pubid::Components::TypedStage.new(
-            code: :pwisuppl,
-            stage_code: :pwi,
-            type_code: :suppl,
-            abbr: ["PWI Suppl"],
-            name: "Proposed Work Item for Supplement",
-            harmonized_stages: %w[00.00 00.20 00.60 00.92 00.93 00.98 00.99],
-          ),
           ::Pubid::Components::TypedStage.new(
             code: :npsuppl,
             stage_code: :np,
@@ -50,7 +43,7 @@ module Pubid
             code: :dsuppl,
             stage_code: :dsuppl,
             type_code: :suppl,
-            abbr: ["DSuppl", "DIS Suppl"],
+            abbr: ["DSuppl"],
             name: "Draft Supplement",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -86,8 +79,7 @@ module Pubid
         end
 
         def self.type
-          { key: :suppl,
-            web: :supplement, title: "Supplement", short: "suppl" }
+          { key: :suppl, title: "Supplement", short: "suppl" }
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Pubid
     module Identifiers
       # Technical Committee Document
       # Format: TC 184/SC 4/WG 3 N 123, JTC 1 N 456, TC 184 N 100
-      class TcDocument < Identifier
+      class TcDocument < Base
         # TC type (TC, JTC, PC, IT, etc.)
         attribute :tc_type, ::Pubid::Components::Code
         # TC number
@@ -33,36 +33,8 @@ module Pubid
         # TC documents don't use typed stages like other identifiers
         TYPED_STAGES = [].freeze
 
-        # Serialize the committee structure (all plain-string Codes) on top of
-        # the inherited ISO mapping; TC documents have no stage.
-        key_value do
-          map "tc_type", with: { to: :tc_type_to_kv, from: :tc_type_from_kv }
-          map "tc_number", with: { to: :tc_number_to_kv, from: :tc_number_from_kv }
-          map "sc_type", with: { to: :sc_type_to_kv, from: :sc_type_from_kv }
-          map "sc_number", with: { to: :sc_number_to_kv, from: :sc_number_from_kv }
-          map "wg_type", with: { to: :wg_type_to_kv, from: :wg_type_from_kv }
-          map "wg_number", with: { to: :wg_number_to_kv, from: :wg_number_from_kv }
-        end
-
-        # TC documents have no stage; suppress the inherited stage emission.
-        def stage_to_kv(_model, _doc); end
-
-        def tc_type_to_kv(m, doc) = emit_code(doc, "tc_type", m.tc_type)
-        def tc_type_from_kv(m, v) = m.tc_type = build_code(v)
-        def tc_number_to_kv(m, doc) = emit_code(doc, "tc_number", m.tc_number)
-        def tc_number_from_kv(m, v) = m.tc_number = build_code(v)
-        def sc_type_to_kv(m, doc) = emit_code(doc, "sc_type", m.sc_type)
-        def sc_type_from_kv(m, v) = m.sc_type = build_code(v)
-        def sc_number_to_kv(m, doc) = emit_code(doc, "sc_number", m.sc_number)
-        def sc_number_from_kv(m, v) = m.sc_number = build_code(v)
-        def wg_type_to_kv(m, doc) = emit_code(doc, "wg_type", m.wg_type)
-        def wg_type_from_kv(m, v) = m.wg_type = build_code(v)
-        def wg_number_to_kv(m, doc) = emit_code(doc, "wg_number", m.wg_number)
-        def wg_number_from_kv(m, v) = m.wg_number = build_code(v)
-
         def self.type
-          { key: :tc,
-            web: :tc_document, title: "Technical Committee Document", short: "TC" }
+          { key: :tc, title: "Technical Committee Document", short: "TC" }
         end
 
         def self.typed_stages
@@ -73,26 +45,26 @@ module Pubid
           result = publisher.to_s if publisher
 
           # Add TC type and number
-          result += "/#{tc_type.render} " if tc_type&.value
-          result += tc_number.render.to_s if tc_number&.value
+          result += "/#{tc_type.value} " if tc_type&.value
+          result += tc_number.value.to_s if tc_number&.value
 
           # Add SC type and number
           if sc_type&.value && sc_number&.value
-            result += "/#{sc_type.render} "
-            result += sc_number.render.to_s
+            result += "/#{sc_type.value} "
+            result += sc_number.value.to_s
           end
 
           # Add WG type and number
           if wg_type&.value && wg_number&.value
-            result += "/#{wg_type.render} "
-            result += wg_number.render.to_s
+            result += "/#{wg_type.value} "
+            result += wg_number.value.to_s
           end
 
           # Add document number
-          result += " N #{number.render}" if number&.value
+          result += " N #{number.value}" if number&.value
 
           # Add year if present
-          result += ":#{date.render}" if date&.year
+          result += ":#{date.year}" if date&.year
 
           result
         end
@@ -100,21 +72,20 @@ module Pubid
         # Generate URN for TC document
         # Format: urn:iso:doc:iso:tc:184:sc-4:wg-3:123
         def to_urn
-          urn_ctx = Rendering::RenderingContext.urn
           parts = ["urn:iso:doc"]
-          parts << publisher.render(context: urn_ctx) if publisher
+          parts << publisher.to_s.downcase if publisher
 
           # Add TC
-          parts << "tc:#{tc_number.render(context: urn_ctx)}" if tc_number&.value
+          parts << "tc:#{tc_number.value}" if tc_number&.value
 
           # Add SC
-          parts << "sc-#{sc_number.render(context: urn_ctx)}" if sc_number&.value
+          parts << "sc-#{sc_number.value}" if sc_number&.value
 
           # Add WG
-          parts << "wg-#{wg_number.render(context: urn_ctx)}" if wg_number&.value
+          parts << "wg-#{wg_number.value}" if wg_number&.value
 
           # Add document number
-          parts << number.render(context: urn_ctx) if number&.value
+          parts << number.value if number&.value
 
           parts.join(":")
         end

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

@@ -4,6 +4,7 @@ module Pubid
   module Iso
     module Identifiers
       class TechnicalReport < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -63,7 +64,7 @@ module Pubid
             code: :dtr,
             stage_code: :draft,
             type_code: :tr,
-            abbr: ["DTR", "DIS TR"],
+            abbr: ["DTR"],
             name: "Draft Technical Report",
             harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 40.98 40.99],
           ),
@@ -71,7 +72,7 @@ module Pubid
             code: :fdtr,
             stage_code: :final_draft,
             type_code: :tr,
-            abbr: ["FDTR", "FDIS TR"],
+            abbr: ["FDTR"],
             name: "Final Draft Technical Report",
             harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
           ),
@@ -94,8 +95,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tr,
-            web: :technical_report, title: "Technical Report", short: "TR" }
+          { key: :tr, title: "Technical Report", short: "TR" }
         end
       end
     end

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

@@ -4,6 +4,7 @@ module Pubid
   module Iso
     module Identifiers
       class TechnicalSpecification < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
             code: :pwits,
@@ -93,8 +94,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :ts,
-            web: :technical_specification, title: "Technical Specification", short: "TS" }
+          { key: :ts, title: "Technical Specification", short: "TS" }
         end
       end
     end

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

@@ -4,6 +4,7 @@ module Pubid
   module Iso
     module Identifiers
       class TechnologyTrendsAssessments < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(
@@ -86,8 +87,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :tta,
-            web: :technology_trends_assessments, title: "Technology Trends Assessments", short: "TTA" }
+          { key: :tta, title: "Technology Trends Assessments", short: "TTA" }
         end
       end
     end

data/lib/pubid/iso/identifiers.rb

@@ -5,6 +5,7 @@ module Pubid
     module Identifiers
       autoload :Addendum, "#{__dir__}/identifiers/addendum"
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Base, "#{__dir__}/identifiers/base"
       autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Data, "#{__dir__}/identifiers/data"
       autoload :Directives, "#{__dir__}/identifiers/directives"