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

data/lib/pubid/iso/identifier.rb

@@ -3,66 +3,17 @@
 module Pubid
   module Iso
     class Identifier < ::Pubid::Identifier
-      # Override base types with ISO-specific ones.
-      # Defaults to the type's implied publisher (ISO for most; IWA has none),
-      # so an omitted publisher key reconstructs correctly on from_hash.
-      attribute :publisher, ::Pubid::Iso::Components::Publisher,
-                default: -> { self.class.default_publisher }
+      # Override base types with ISO-specific ones
+      attribute :publisher, ::Pubid::Iso::Components::Publisher
       attribute :copublishers, ::Pubid::Iso::Components::Publisher,
                 collection: true
-
-      # The publisher implied when none is serialized. ISO for most types;
-      # publisher-less types (IWA) override this to nil.
-      def self.default_publisher
-        ::Pubid::Iso::Components::Publisher.new
-      end
-
-      # typed_stage is the single source of truth for stage (and, with the class,
-      # the doctype). Default to the class's published typed_stage, so an omitted
-      # "stage" key reconstructs the published state on from_hash.
-      attribute :typed_stage, ::Pubid::Components::TypedStage,
-                default: -> { self.class.published_typed_stage }
-
-      # The class's published typed_stage (canonical surface form), or nil for
-      # types with no stages (e.g. TC documents).
-      def self.published_typed_stage
-        return nil unless const_defined?(:TYPED_STAGES)
-
-        ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
-        return nil unless ts
-
-        ts = ts.dup
-        ts.original_abbr = ts.canonical_abbreviation
-        ts
-      end
-
-      # type and stage are derived from typed_stage, never stored — so the
-      # doctype (fixed by the class / _type) can't be lost when "stage" is
-      # omitted for the published default.
-      def type
-        typed_stage&.to_type
-      end
-
-      def stage
-        typed_stage&.to_stage
-      end
-
-      # Return a copy with the lifecycle stage set from an ISO harmonized stage
-      # code (e.g. "90.92"). typed_stage is the single source of truth, so this
-      # is all that is needed to surface the stage in #to_s and #to_urn. Returns
-      # an unchanged copy if the code is not recognised.
-      def with_harmonized_stage(harmonized_code)
-        ts = Pubid::Iso.locate_stage_by_harmonized_code(harmonized_code)
-        ts ? dup.tap { |id| id.typed_stage = ts } : dup
-      end
-
       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 identifier_types
+      # 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",
@@ -82,221 +33,20 @@ module Pubid
         "pubid:iso:data" => "Pubid::Iso::Identifiers::Data",
         "pubid:iso:tc-document" => "Pubid::Iso::Identifiers::TcDocument",
         "pubid:iso:technology-trends-assessments" => "Pubid::Iso::Identifiers::TechnologyTrendsAssessments",
-        "pubid:iso:bundled-identifier" => "Pubid::Iso::BundledIdentifier",
       }.freeze
 
-      # BundledIdentifier lives outside Pubid::Iso::Identifiers but carries a
-      # polymorphic `_type`, so the shared polymorphic_type_map needs it
-      # explicitly (see Pubid::Identifier#additional_identifier_classes).
-      def self.additional_identifier_classes
-        [Pubid::Iso::BundledIdentifier]
-      end
-      private_class_method :additional_identifier_classes
-
-      # Build type map from Pubid::Iso.identifier_types for validation
+      # Build type map from Scheme.identifiers for validation
       def self.build_type_map
-        Pubid::Iso.identifier_types.to_h do |klass|
+        Scheme.identifiers.to_h do |klass|
           [klass.polymorphic_name, klass.name]
         end
       end
 
-      # The base Pubid::Identifier no longer auto-maps attributes, so each
-      # flavor's top class must declare its own key_value mapping. Subclasses
-      # merge their own blocks on top of this one (e.g. SupplementIdentifier
-      # adds base; Directives adds subgroup), so list every base
-      # attribute ISO serializes here once.
       key_value do
         map "_type", to: :_type, polymorphic_map: ISO_TYPE_MAP
-        # Code components serialize as their plain string value, not {value,number}.
-        map "number", with: { to: :number_to_kv, from: :number_from_kv }
-        map "part", with: { to: :part_to_kv, from: :part_from_kv }
-        map "subpart", with: { to: :subpart_to_kv, from: :subpart_from_kv }
-        map "stage_iteration",
-            with: { to: :stage_iteration_to_kv, from: :stage_iteration_from_kv }
-        # date serialized flat as year/month/day, nils omitted.
-        map "year", with: { to: :year_to_kv, from: :year_from_kv }
-        map "month", with: { to: :month_to_kv, from: :month_from_kv }
-        map "day", with: { to: :day_to_kv, from: :day_from_kv }
-        # ISO/IEC undated reference (e.g. ISO 16634:--). The `false` default
-        # is omitted; only the meaningful `true` round-trips via to_hash.
-        map "undated", with: { to: :undated_to_kv, from: :undated_from_kv }
-        map "edition", to: :edition
-        map "languages", to: :languages
-        # publisher emitted only when the primary isn't the type default;
-        # copublishers (the other bodies) as an array, omitted when empty.
-        map "publisher", with: { to: :publisher_to_kv, from: :publisher_from_kv }
-        map "copublishers", with: { to: :copublishers_to_kv, from: :copublishers_from_kv }
-        map "locality", to: :locality
-        # `type` and generic `stage` are fully derived from `typed_stage`
-        # (builder sets them via to_type/to_stage), so we serialize only the
-        # unique typed-stage `code` under "stage" and recompute the rest on
-        # load. _type already pins the document type.
-        map "stage", with: { to: :stage_to_kv, from: :stage_from_kv }
-        # Omit the `false` default; only the meaningful `true` is serialized.
-        map "all_parts", with: { to: :all_parts_to_kv, from: :all_parts_from_kv }
-      end
-
-      def all_parts_to_kv(model, doc)
-        return unless model.all_parts
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("all_parts", true),
-        )
-      end
-
-      def all_parts_from_kv(model, value)
-        model.all_parts = value
-      end
-
-      # Serialize typed_stage as just its unique code (e.g. "is", "dis",
-      # "committee_draft_amd"). type/stage are recomputed from it on load.
-      def stage_to_kv(model, doc)
-        ts = model.typed_stage
-        return unless ts&.code
-        # Omit the published default (recomputed from the class on load).
-        return if ts.stage_code.to_s == "published"
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("stage", ts.code.to_s),
-        )
-      end
-
-      # Resolve the typed-stage code back to the full TypedStage within this
-      # identifier's class, then derive type/stage from it.
-      def stage_from_kv(model, value)
-        return if value.nil? || value.to_s.empty?
-
-        # The fallback consults the flavor-wide table. It used to call
-        # `Pubid::Iso::Scheme`, a class removed repo-wide in e3c19ea1 — so any
-        # code absent from the class's own TYPED_STAGES raised NameError
-        # instead of falling back. The IEC twin (iec/identifier.rb) was
-        # migrated at the time; ISO was missed.
-        ts = (model.class.const_defined?(:TYPED_STAGES) &&
-              model.class::TYPED_STAGES.find { |t| t.code.to_s == value.to_s }) ||
-             Pubid::Iso.locate_stage_by_code(value)
-        return unless ts
-
-        # The renderer prefers `original_abbr` (the parsed surface form); without
-        # it the supplement renderer falls back to `short_abbr` (e.g. "AMD").
-        # Resolving from a code has no surface form, so render the canonical
-        # abbreviation (`abbr.first`, e.g. "Amd").
-        ts = ts.dup
-        ts.original_abbr = ts.canonical_abbreviation
-        model.typed_stage = ts
-      end
-
-      # --- Code components <-> plain string ---
-      def number_to_kv(model, doc) = emit_code(doc, "number", model.number)
-      def number_from_kv(model, value) = model.number = build_code(value)
-      def part_to_kv(model, doc) = emit_code(doc, "part", model.part)
-      def part_from_kv(model, value) = model.part = build_code(value)
-      def subpart_to_kv(model, doc) = emit_code(doc, "subpart", model.subpart)
-      def subpart_from_kv(model, value) = model.subpart = build_code(value)
-
-      def stage_iteration_to_kv(model, doc)
-        iter = model.stage_iteration
-        v = iter.is_a?(::Pubid::Components::Iteration) ? iter.number : iter
-        return if v.nil? || v.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("stage_iteration",
-                                                                v.to_s))
-      end
-
-      def stage_iteration_from_kv(model, value)
-        model.stage_iteration = ::Pubid::Components::Iteration.new(number: value.to_s)
-      end
-
-      def emit_code(doc, key, code)
-        v = code.is_a?(::Pubid::Components::Code) ? code.value : code
-        return if v.nil? || v.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, v.to_s))
-      end
-
-      def build_code(value)
-        ::Pubid::Iso::Components::Code.new(value: value.to_s)
-      end
-
-      # --- date serialized flat as year/month/day ---
-      def year_to_kv(model, doc) = emit_date_part(doc, "year", model.date&.year)
-      def year_from_kv(model, value) = date_for(model).year = value.to_s
-      def month_to_kv(model, doc) = emit_date_part(doc, "month", model.date&.month)
-      def month_from_kv(model, value) = date_for(model).month = value.to_s
-      def day_to_kv(model, doc) = emit_date_part(doc, "day", model.date&.day)
-      def day_from_kv(model, value) = date_for(model).day = value.to_s
-
-      # --- date undated flag (ISO/IEC undated reference, e.g. ISO 16634:--) ---
-      # The `false` default is omitted; only the meaningful `true` round-trips
-      # via to_hash / from_hash.
-      def undated_to_kv(model, doc)
-        return unless model.date&.undated?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("undated", true))
-      end
-
-      def undated_from_kv(model, value)
-        date_for(model).undated = value.to_s == "true"
-      end
-
-      def emit_date_part(doc, key, val)
-        return if val.nil? || val.to_s.empty?
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
-      end
-
-      def date_for(model)
-        model.date ||= ::Pubid::Components::Date.new
-      end
-
-      # --- publisher: primary only when non-default; copublishers as a list ---
-      def publisher_to_kv(model, doc)
-        pub = model.publisher&.publisher
-        return if pub.nil? || pub == model.class.default_publisher&.publisher
-
-        doc.add_child(Lutaml::KeyValue::DataModel::Element.new("publisher", pub))
-      end
-
-      def publisher_from_kv(model, value)
-        publisher_for(model).publisher = value.to_s
-      end
-
-      def copublishers_to_kv(model, doc)
-        cp = model.publisher&.copublisher
-        return unless cp&.any?
-
-        doc.add_child(
-          Lutaml::KeyValue::DataModel::Element.new("copublishers", cp.map(&:to_s)),
-        )
-      end
-
-      def copublishers_from_kv(model, value)
-        list = Array(value).map(&:to_s)
-        return unless list.any?
-
-        # Mirror Builder#parse: copublishers live both on the primary
-        # publisher (as strings) and as the top-level `copublishers`
-        # collection of Publisher objects. `==` compares the latter, so
-        # populate both or a deserialized id never equals a parsed one.
-        publisher_for(model).copublisher = list
-        model.copublishers = list.map do |cp|
-          ::Pubid::Iso::Components::Publisher.new(publisher: cp)
-        end
-      end
-
-      def publisher_for(model)
-        model.publisher ||= ::Pubid::Iso::Components::Publisher.new
       end
 
       def self.parse(string, format: :auto)
-        unless string.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         format = Pubid::FormatDetector.detect(string) if format == :auto
 
         case format
@@ -306,13 +56,14 @@ module Pubid
           Pubid::Parsers::MrString.parse(string)
         else
           parsed = Pubid::Iso::Parser.new.parse(string)
-          Pubid::Iso::Builder.new.build(parsed)
+          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
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier, which
-      # routes `_type` through polymorphic_type_map (ISO_TYPE_MAP's dynamic
-      # equivalent). ISO_TYPE_MAP remains as the key_value polymorphic_map.
     end
   end
 end

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

@@ -4,6 +4,7 @@ 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"
@@ -64,11 +65,9 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :dad,
-            abbr: ["DAD", "DAdd", "D ADD", "Dad", "DIS Add"],
+            abbr: ["DAD", "DAdd", "D ADD", "Dad"],
             short_abbr: "DAD",
-            # "DAdd" stays in `abbr` so it still parses, but render the canonical
-            # "DAD" (pubid v1 legacy_abbr parity). No long_abbr → no long render.
-            long_abbr: nil,
+            long_abbr: "DAdd",
             type_code: :add,
             stage_code: :dad,
             name: "Draft Addendum",
@@ -76,10 +75,9 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :fdad,
-            abbr: ["FDAD", "FDAdd", "FD ADD", "FDad", "FDIS Add"],
+            abbr: ["FDAD", "FDAdd", "FD ADD", "FDad"],
             short_abbr: "FDAD",
-            # See :dad — parse "FDAdd", render canonical "FDAD" (v1 parity).
-            long_abbr: nil,
+            long_abbr: "FDAdd",
             type_code: :add,
             stage_code: :fdad,
             name: "Final Draft Addendum",
@@ -98,8 +96,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :add,
-            web: :addendum, title: "Addendum", short: "ADD" }
+          { key: :add, title: "Addendum", short: "ADD" }
         end
       end
     end

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

@@ -4,6 +4,7 @@ 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(
@@ -70,10 +71,7 @@ module Pubid
             code: :damd,
             abbr: ["DAM", "DAmd"],
             short_abbr: "DAM",
-            # "DAmd" stays in `abbr` so it still parses, but render the canonical
-            # "DAM" (matches pubid v1's legacy_abbr semantics: parse the long
-            # spelling, emit the short one). No long_abbr → no long rendering.
-            long_abbr: nil,
+            long_abbr: "DAmd",
             type_code: :amd,
             stage_code: :damd,
             name: "Draft Amendment",
@@ -83,8 +81,7 @@ module Pubid
             code: :fdamd,
             abbr: ["FDAM", "FDAmd"],
             short_abbr: "FDAM",
-            # See :damd — parse "FDAmd", render canonical "FDAM" (v1 parity).
-            long_abbr: nil,
+            long_abbr: "FDAmd",
             type_code: :amd,
             stage_code: :fdamd,
             name: "Final Draft Amendment",
@@ -123,8 +120,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd,
-            web: :amendment, title: "Amendment", short: "AMD" }
+          { key: :amd, title: "Amendment", short: "AMD" }
         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

@@ -4,6 +4,7 @@ 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(
@@ -58,7 +59,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :dcor,
-            abbr: ["DCor", "DCOR", "DIS Cor"],
+            abbr: ["DCor", "DCOR"],
             short_abbr: "DCOR",
             long_abbr: "DCor",
             type_code: :cor,
@@ -68,7 +69,7 @@ module Pubid
           ),
           ::Pubid::Components::TypedStage.new(
             code: :fdcor,
-            abbr: ["FDCor", "FDCOR", "FCOR", "FDIS Cor"],
+            abbr: ["FDCor", "FDCOR", "FCOR"],
             short_abbr: "FDCOR",
             long_abbr: "FDCor",
             type_code: :cor,
@@ -99,8 +100,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cor,
-            web: :corrigendum, title: "Corrigendum", short: "COR" }
+          { key: :cor, title: "Corrigendum", short: "COR" }
         end
       end
     end

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

@@ -5,6 +5,7 @@ module Pubid
     module Identifiers
       # Data Identifier
       class Data < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
 
         TYPED_STAGES = [
           ::Pubid::Components::TypedStage.new(

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

@@ -4,14 +4,9 @@ module Pubid
   module Iso
     module Identifiers
       class Directives < SingleIdentifier
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.type[:key] }
         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,
@@ -27,8 +22,7 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :dir,
-            web: :directives, title: "Directives", short: "DIR" }
+          { key: :dir, title: "Directives", short: "DIR" }
         end
 
         def to_s(**opts)