pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/idf/identifier.rb

@@ -7,11 +7,8 @@ module Pubid
     class Identifier < ::Pubid::Identifier
       attribute :typed_stage, Components::TypedStage
 
-      def to_s(lang: :en, lang_single: false, with_edition: false)
-        [
-          publisher_portion(lang: lang),
-          number_portion(lang_single: lang_single),
-        ].join
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
 
       def publisher_portion(lang: :en)
@@ -31,7 +28,7 @@ module Pubid
           (subpart ? "-#{subpart.value}" : ""),
 
           # Stage iteration is optional
-          (stage_iteration ? ".#{stage_iteration.value}" : ""),
+          (stage_iteration ? ".#{stage_iteration.number}" : ""),
 
           # Date is optional
           (date ? ":#{date.year}" : ""),
@@ -64,66 +61,6 @@ module Pubid
 
         Pubid::Idf::Builder.new.build(parsed)
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Idf::Identifier.create` API.
-      # Default subclass is {Identifiers::InternationalStandard}.
-      #
-      # IDF's renderer requires `typed_stage` to be set (calls
-      # `.abbreviation` without a nil check); factory auto-resolves the
-      # "published" TypedStage for the chosen subclass.
-      TYPE_KEY_TO_KLASS = {
-        is:              "InternationalStandard",
-        reviewed_method: "ReviewedMethod",
-      }.freeze
-
-      def self.create(type: nil, stage: nil, **opts)
-        klass = resolve_create_class(type)
-        attrs = coerce_create_attrs(opts)
-        ts = resolve_create_typed_stage(klass, stage)
-        attrs[:typed_stage] = ts if ts
-        klass.new(**attrs)
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::InternationalStandard if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown IDF type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.resolve_create_typed_stage(klass, stage)
-        return nil unless klass.const_defined?(:TYPED_STAGES)
-
-        if stage
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.abbr.include?(stage.to_s)
-          end
-        else
-          klass.const_get(:TYPED_STAGES).find do |ts|
-            ts.stage_code&.to_sym == :published
-          end
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {
-          publisher: Pubid::Components::Publisher.new(
-            body: (opts[:publisher] || "IDF").to_s,
-          ),
-        }
-        if (v = opts[:number])
-          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
-        end
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class,
-                           :resolve_create_typed_stage,
-                           :coerce_create_attrs
     end
   end
 end

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

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :amd, title: "Amendment", short: "AMD" }
+          { key: :amd,
+            web: :amendment, title: "Amendment", short: "AMD" }
         end
       end
     end

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

@@ -19,7 +19,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :cor, title: "Corrigendum", short: "COR" }
+          { key: :cor,
+            web: :corrigendum, title: "Corrigendum", short: "COR" }
         end
       end
     end

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

@@ -115,7 +115,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :is, title: "International Standard", short: nil }
+          { key: :is,
+            web: :international_standard, title: "International Standard", short: nil }
         end
       end
     end

data/lib/pubid/idf/identifiers/reviewed_method.rb

@@ -92,7 +92,8 @@ module Pubid
         ].freeze
 
         def self.type
-          { key: :rm, title: "Reviewed Method", short: "RM" }
+          { key: :rm,
+            web: :reviewed_method, title: "Reviewed Method", short: "RM" }
         end
       end
     end

data/lib/pubid/idf/parser.rb

@@ -9,9 +9,10 @@ module Pubid
       include ::Pubid::Parser::CommonParseMethods
 
       # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Idf::Scheme.typed_stages
+      TYPED_STAGES = Pubid::Idf.all_typed_stages
         .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf::Scheme.supplement_typed_stages
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf.all_typed_stages
+        .select { |ts| %w[amd cor].include?(ts.type_code.to_s) }
         .map(&:abbr).flatten.sort_by(&:length).reverse
 
       root :identifier

data/lib/pubid/idf/renderer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Human-readable renderer for IDF identifiers.
+    #
+    # Produces strings like:
+    #   "IDF 125:1988"
+    #   "IDF/AMD 1:2023"
+    #   "IDF 125:1988/AMD 1:2023"
+    #
+    # The renderer is registered as the `:human` format in the IDF format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when SupplementIdentifier
+          render_supplement(id, opts, context)
+        else
+          render_single(id, opts, context)
+        end
+      end
+
+      private
+
+      def render_single(id, opts, context)
+        [
+          publisher_portion(id, context),
+          number_portion(id, opts, context),
+        ].join
+      end
+
+      def publisher_portion(id, context)
+        [
+          id.publisher.render(context:),
+          (id.typed_stage.abbreviation.empty? ? "" : "/#{id.typed_stage.abbreviation}"),
+        ].join
+      end
+
+      def number_portion(id, opts, context)
+        lang_single = opts[:lang_single] || false
+
+        [
+          (id.number ? " #{id.number.render(context:)}" : ""),
+          (id.part ? "-#{id.part.render(context:)}" : ""),
+          (id.subpart ? "-#{id.subpart.render(context:)}" : ""),
+          (id.stage_iteration ? ".#{id.stage_iteration.render(context:)}" : ""),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+          language_portion(id, lang_single: lang_single),
+        ].join
+      end
+
+      def language_portion(id, lang_single: false)
+        return "" unless id.languages&.any?
+
+        [
+          "(",
+          id.languages.map do |lang|
+            lang.to_s(lang_single: lang_single)
+          end.join(lang_single ? "/" : ","),
+          ")",
+        ].join
+      end
+
+      def render_supplement(id, opts, context)
+        lang = opts[:lang] || :en
+        lang_single = opts[:lang_single] || false
+        with_edition = opts[:with_edition] || false
+
+        [
+          id.base_identifier.to_s(lang: lang, lang_single: lang_single,
+                                   with_edition: with_edition),
+          "/",
+          id.typed_stage.abbreviation,
+          " ",
+          id.number.render(context:),
+          (id.date ? ":#{id.date.render(context:)}" : ""),
+        ].join
+      end
+    end
+  end
+end

data/lib/pubid/idf/supplement_identifier.rb

@@ -27,16 +27,8 @@ module Pubid
       # @param lang_single [Boolean] Use single-char language codes (default: false)
       # @param with_edition [Boolean] Include edition (default: false)
       # @return [String] String representation of supplement
-      def to_s(lang: :en, lang_single: false, with_edition: false)
-        [
-          base_identifier.to_s(lang: lang, lang_single: lang_single,
-                               with_edition: with_edition),
-          "/",
-          typed_stage.abbreviation,
-          " ",
-          number.value,
-          (date ? ":#{date.year}" : ""),
-        ].join
+      def to_s(**opts)
+        render(format: :human, **opts)
       end
     end
   end

data/lib/pubid/idf/urn_generator.rb

@@ -9,41 +9,6 @@ module Pubid
         identifier.type.abbr.to_s.downcase
       end
 
-      def urn_number
-        return nil unless identifier.number
-
-        identifier.number.value.to_s
-      end
-
-      def urn_part
-        return nil unless identifier.part
-
-        "-#{identifier.part.value}"
-      end
-
-      def urn_subpart
-        return nil unless identifier.subpart
-
-        "-#{identifier.subpart.value}"
-      end
-
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        identifier.year&.to_s
-      end
-
-      def urn_edition
-        return nil unless identifier.edition
-
-        num = identifier.edition.number
-        return nil unless num
-
-        "ed.#{num}"
-      end
-
       def generate
         parts = ["urn", "idf"]
         parts << urn_number if urn_number
@@ -54,12 +19,12 @@ module Pubid
         parts << urn_type if urn_type
 
         if identifier.publisher
-          parts[1] = identifier.publisher.body.to_s.downcase
+          parts[1] = identifier.publisher.render(context: URN_CONTEXT)
         end
 
         if identifier.copublishers&.any?
-          copubs = identifier.copublishers.map(&:body)
-          parts[1] = "#{parts[1]}-#{copubs.join('-').downcase}"
+          copubs = identifier.copublishers.map { |cp| cp.render(context: URN_CONTEXT) }
+          parts[1] = "#{parts[1]}-#{copubs.join('-')}"
         end
 
         if identifier.languages&.any?
@@ -73,7 +38,7 @@ module Pubid
           end
 
           if identifier.number
-            parts << identifier.number.value.to_s
+            parts << identifier.number.render(context: URN_CONTEXT)
           end
         end
 

data/lib/pubid/idf/urn_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Idf
+    # Parses IDF URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:idf:{number}:{year}:` with a trailing empty
+    # field (a known quirk of the generator).
+    #
+    # Examples:
+    # - urn:idf:87:2019: → IDF 87:2019
+    # - urn:idf:100:     → IDF 100
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body).reject(&:empty?)
+
+        number, year = parts
+        text = "IDF #{number}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/idf.rb

@@ -6,10 +6,11 @@ module Pubid
     autoload :Identifier, "#{__dir__}/idf/identifier"
     autoload :Identifiers, "#{__dir__}/idf/identifiers"
     autoload :Parser, "#{__dir__}/idf/parser"
-    autoload :Scheme, "#{__dir__}/idf/scheme"
+    autoload :Renderer, "#{__dir__}/idf/renderer"
     autoload :SingleIdentifier, "#{__dir__}/idf/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/idf/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/idf/urn_generator"
+    autoload :UrnParser, "#{__dir__}/idf/urn_parser"
 
     def self.parse(identifier)
       parser = Parser.new
@@ -18,6 +19,55 @@ module Pubid
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
+
+    # Build an IDF identifier from a parse-tree hash (used by ISO joint-identifier
+    # parsing). This is the public seam: callers should never reach into
+    # `Idf::Builder` directly.
+    # @param hash [Hash] parse tree for the joint identifier
+    # @return [Pubid::Idf::Identifier]
+    def self.build_from_parse(hash)
+      Builder.new.build(hash)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Idf::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
   end
 end
 

data/lib/pubid/iec/builder.rb

@@ -1,25 +1,16 @@
-require_relative "../components/publisher"
 # frozen_string_literal: true
-require_relative "../components/code"
-require_relative "../components/date"
 
 module Pubid
   module Iec
     class Builder < Pubid::Builder::Base
-      def initialize(scheme)
-        @scheme = scheme
-      end
-
       def locate_identifier_klass(parsed_hash)
         # Check for working programme
         if parsed_hash[:wp_stage]
-          require_relative "identifiers/working_document"
           return Identifiers::WorkingDocument
         end
 
         # Check for working document
         if parsed_hash[:technical_committee] && parsed_hash[:wd_number]
-          require_relative "identifiers/working_document"
           return Identifiers::WorkingDocument
         end
 
@@ -27,7 +18,8 @@ module Pubid
         # :type_with_stage will be nil if it is an IS.
         typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
 
-        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+        Pubid::Iec.locate_type(typed_stage.type_code) ||
+          raise(ArgumentError, "Unknown type code: #{typed_stage.type_code}")
       end
 
       def build(parsed_hash)
@@ -55,7 +47,8 @@ module Pubid
 
           # Locate the supplement identifier class
           typed_stage = locate_typed_stage(supplement_type)
-          identifier_class = @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+          identifier_class = Pubid::Iec.locate_type(typed_stage.type_code) ||
+            raise(ArgumentError, "Unknown type code: #{typed_stage.type_code}")
 
           # Create the supplement identifier
           supplement = identifier_class.new
@@ -96,14 +89,11 @@ module Pubid
 
         if is_fragment
           # For FRAG typed stages, look up the fragment's own typed stage
-          begin
-            fragment_typed_stage = @scheme.locate_typed_stage_by_abbr(
-              parsed_hash[:type_with_stage].to_s,
-            )
-          rescue ArgumentError
-            # FRAGC is a rendering notation, not a typed stage abbreviation
-            fragment_typed_stage = @scheme.locate_typed_stage_by_abbr("FRAG")
-          end
+          fragment_typed_stage = Pubid::Iec.locate_stage(parsed_hash[:type_with_stage])
+
+          # FRAGC is a rendering notation, not a typed stage abbreviation;
+          # fall back to the canonical "FRAG" typed stage
+          fragment_typed_stage ||= Pubid::Iec.locate_stage("FRAG")
 
           # For FRAG/FRAGC, we need to build the base Amendment/Corrigendum
           # then wrap it with FragmentIdentifier
@@ -158,7 +148,6 @@ module Pubid
 
         # Detect rendering style from parsed abbreviation
         if identifier.class.attributes.key?(:rendering_style) && identifier.typed_stage
-          require_relative "rendering_style"
           ts = identifier.typed_stage
 
           # Detect IEC format from parsed abbreviation
@@ -179,7 +168,7 @@ module Pubid
           with_language_code = if langs&.any?
                                  # Check if original_code was single-char (E, F, R, A, S, D)
                                  first_lang = langs.first
-                                 if first_lang.is_a?(Components::Language) && first_lang.original_code && first_lang.original_code.length == 1
+                                 if first_lang.is_a?(::Pubid::Components::Language) && first_lang.original_code && first_lang.original_code.length == 1
                                    :single
                                  else
                                    :iso # 2-char codes (en, fr, ru, ar, es, de)
@@ -202,7 +191,7 @@ module Pubid
 
         # After building base identifier, apply wrappers
         if fragment_type_data && fragment_number_data
-          frag_ts = @scheme.locate_typed_stage_by_abbr("FRAG")
+          frag_ts = Pubid::Iec.locate_stage("FRAG")
           identifier = wrap_with_fragment(identifier, fragment_number_data.to_s,
                                           nil, frag_ts)
         end
@@ -229,11 +218,25 @@ module Pubid
         end
       end
 
+      # The IEC builder's own `build` method drives identifier construction
+      # (it locates the right class per parsed hash), so the parent class's
+      # `@identifier_class` slot is never read. Provide a placeholder so
+      # `Builder.new` doesn't fail with NotImplementedError.
+      def default_identifier_class
+        Identifiers::InternationalStandard
+      end
+
+      # Look up a typed stage by abbreviation via the self-describing
+      # `Pubid::Iec` module instead of an injected scheme instance.
+      def locate_typed_stage(typed_stage_string)
+        typed_stage_string = "" if typed_stage_string.nil?
+        Pubid::Iec.locate_stage(typed_stage_string) ||
+          raise(ArgumentError, "Unknown type abbreviation: '#{typed_stage_string}'")
+      end
+
       # Wrap identifier with FragmentIdentifier for /FRAGN notation
       def wrap_with_fragment(base_identifier, fragment_number,
-edition_data = nil, typed_stage = nil)
-        require_relative "identifiers/fragment_identifier"
-
+      edition_data = nil, typed_stage = nil)
         fragment = Identifiers::FragmentIdentifier.new(
           base_identifier: base_identifier,
           fragment_number: fragment_number,
@@ -252,8 +255,6 @@ edition_data = nil, typed_stage = nil)
 
       # Wrap identifier with SheetIdentifier for /N:YEAR notation
       def wrap_with_sheet(base_identifier, sheet_number, sheet_year)
-        require_relative "identifiers/sheet_identifier"
-
         # Only pass year if it's present
         year_value = sheet_year&.to_s
 
@@ -272,10 +273,6 @@ edition_data = nil, typed_stage = nil)
 
       # Wrap identifier with ConsolidatedIdentifier for +AMD chains
       def wrap_with_consolidated(base_identifier, supplements_data)
-        require_relative "identifiers/consolidated_identifier"
-        require_relative "identifiers/amendment"
-        require_relative "identifiers/corrigendum"
-
         supplements = supplements_data.filter_map do |supp|
           type = supp[:supplement_type].to_s
           number = supp[:supplement_number].to_s
@@ -302,13 +299,10 @@ edition_data = nil, typed_stage = nil)
         )
       end
 
-      # Wrap identifier with VapIdentifier for CSV/CMV/RLV/SER suffix
+      # Wrap identifier with VapIdentifier for one or more VAP codes
+      # (e.g. "CSV" or "EXV-CMV").
       def wrap_with_vap(base_identifier, vap_suffix_data)
-        require_relative "identifiers/vap_identifier"
-        require_relative "identifiers/consolidated_identifier"
-        require_relative "components/vap_suffix"
-
-        vap_suffix = Components::VapSuffix.new(code: vap_suffix_data.to_s)
+        vap = vap_suffix_data.to_s.split("-")
 
         # Extract edition - need to go deep for ConsolidatedIdentifier
         edition = nil
@@ -326,7 +320,7 @@ edition_data = nil, typed_stage = nil)
 
         Identifiers::VapIdentifier.new(
           base_identifier: base_identifier,
-          vap_suffix: vap_suffix,
+          vap: vap,
           edition: edition,
         )
       end
@@ -337,6 +331,12 @@ edition_data = nil, typed_stage = nil)
         super
       end
 
+      # IEC normalizes em/en dashes to hyphens but preserves slashes and
+      # spaces, which can be semantically meaningful in IEC identifiers.
+      def normalize_number_with_part(value)
+        value.to_s.tr(Parser::DASH_CHARS.join, "-")
+      end
+
       def cast(type, value)
         case type
         when :base_identifier
@@ -374,28 +374,7 @@ edition_data = nil, typed_stage = nil)
           # or "60038-1" ('1' is part)
           # or "60038-1-2" ('1' is part, '2' is subpart)
           # or "29110-5-1-1" ('5' is part, '1-1' is subpart)
-
-          # Split the number into parts
-          normalized_value = value.to_s.tr(Parser::DASH_CHARS.join, "-")
-
-          parts = normalized_value.split("-")
-          number = parts.shift # The first part is always the number
-          part = parts.shift # The second part is the part, if present
-          subpart = parts.any? ? parts.join("-") : nil # The remaining parts form the subpart, if present
-
-          part = convert_roman_to_integer(part)
-
-          code_hash = { number: Components::Code.new(value: number) }
-
-          if part
-            code_hash[:part] = Components::Code.new(value: part)
-          end
-
-          if subpart
-            code_hash[:subpart] = Components::Code.new(value: subpart)
-          end
-
-          code_hash
+          parse_number_with_part(value, code_class: Components::Code)
 
         when :type_with_stage
           # "WD"
@@ -416,13 +395,17 @@ edition_data = nil, typed_stage = nil)
           }
         when :stage_iteration
           # "1" or "2"
-          Components::Code.new(value: value.to_s)
+          Pubid::Components::Iteration.new(number: value.to_s)
 
         when :date
           parse_date(value)
 
         when :edition
-          Pubid::Components::Edition.new(number: value)
+          # Coerce to String: the parsed value may be a Parslet::Slice, which
+          # Edition.number (Type::Value) would store verbatim and serialize as a
+          # !ruby/object:Parslet::Slice node — unloadable by the index reader's
+          # YAML.safe_load(permitted_classes: [Symbol]).
+          Pubid::Components::Edition.new(number: value&.to_s)
 
         when :sheet_number
           value.to_s
@@ -445,8 +428,7 @@ edition_data = nil, typed_stage = nil)
         when :joint_identifier
           case value[:publisher]
           when "ISO"
-            require_relative "../iso/builder"
-            Iso::Builder.new(Iso::Scheme).build(value)
+            Pubid::Iso.build_from_parse(value)
           end
 
         else