pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/iso.rb

@@ -11,9 +11,9 @@ module Pubid
     autoload :FormatResolver, "#{__dir__}/iso/format_resolver"
     autoload :Identifier, "#{__dir__}/iso/identifier"
     autoload :Identifiers, "#{__dir__}/iso/identifiers"
+    autoload :Normalizer, "#{__dir__}/iso/normalizer"
     autoload :Parser, "#{__dir__}/iso/parser"
     autoload :RenderingStyle, "#{__dir__}/iso/rendering_style"
-    autoload :Scheme, "#{__dir__}/iso/scheme"
     autoload :SingleIdentifier, "#{__dir__}/iso/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/iso/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/iso/urn_generator"
@@ -25,6 +25,10 @@ module Pubid
     # @param format [Symbol] :auto, :human, :mr_string, or :urn
     # @return [Identifier] the parsed identifier
     def self.parse(identifier, format: :auto)
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       format = Pubid::FormatDetector.detect(identifier) if format == :auto
 
       case format
@@ -33,9 +37,77 @@ module Pubid
       when :mr_string
         Pubid::Parsers::MrString.parse(identifier)
       else
-        Scheme.parse(identifier)
+        Normalizer.apply(identifier)
+      end
+    end
+
+    # Build an ISO identifier from attributes.
+    #
+    # This is the public seam: callers in other flavors should never reach
+    # into `Pubid::Iso::Identifiers::*` or `Pubid::Iso::Components::*`
+    # directly — go through this method so the internal class registry can
+    # change without breaking callers.
+    #
+    # Accepts either raw values (Strings/Integers) or pre-built components.
+    # Raw values are wrapped in the appropriate ISO component internally.
+    #
+    # @param type [Symbol] the type key (e.g. :is, :tr, :ts, :guide)
+    # @param publisher [String, Pubid::Iso::Components::Publisher] primary publisher
+    # @param copublishers [Array<String>, Array<Pubid::Components::Publisher>]
+    # @param number [String, Integer, Pubid::Iso::Components::Code]
+    # @param year [String, Integer, Pubid::Components::Date, nil]
+    # @param attrs [Hash] additional identifier attributes
+    # @return [Pubid::Iso::Identifier]
+    def self.build(type:, publisher: nil, copublishers: nil, number: nil,
+                   year: nil, **attrs)
+      klass = locate_type(type) || raise(ArgumentError, "unknown ISO type: #{type.inspect}")
+
+      copub_list = Array(copublishers)
+      attrs[:publisher] = build_publisher(publisher, copub_list) if publisher || copub_list.any?
+      attrs[:copublishers] = build_copublishers(copub_list) if copub_list.any?
+      attrs[:number] = build_code(number) if number
+      attrs[:date] = build_date(year) if year
+
+      klass.new(attrs)
+    end
+
+    # @!visibility private
+    def self.build_publisher(value, copublishers = [])
+      return value if value.is_a?(Components::Publisher) && copublishers.empty?
+
+      copub_strings = copublishers.map { |cp| cp.is_a?(Components::Publisher) ? cp.publisher : cp.to_s }
+      Components::Publisher.new(
+        publisher: value.is_a?(Components::Publisher) ? value.publisher : value.to_s,
+        copublisher: copub_strings,
+      )
+    end
+    private_class_method :build_publisher
+
+    # @!visibility private
+    def self.build_copublishers(list)
+      Array(list).map do |cp|
+        next cp if cp.is_a?(Components::Publisher)
+
+        Components::Publisher.new(publisher: cp.to_s)
       end
     end
+    private_class_method :build_copublishers
+
+    # @!visibility private
+    def self.build_code(value)
+      return value if value.is_a?(Components::Code)
+
+      Components::Code.new(value: value.to_s)
+    end
+    private_class_method :build_code
+
+    # @!visibility private
+    def self.build_date(value)
+      return value if value.is_a?(::Pubid::Components::Date)
+
+      ::Pubid::Components::Date.new(year: value.to_s)
+    end
+    private_class_method :build_date
 
     # Parse an ISO URN string
     # @param urn [String] the URN string to parse
@@ -44,6 +116,109 @@ module Pubid
     def self.parse_urn(urn)
       UrnParser.parse(urn)
     end
+
+    # Build an ISO identifier from a Parslet parse-tree hash (used by other
+    # flavors when parsing joint identifiers, e.g. IEC's `IEC … | ISO …` form).
+    #
+    # This is the public seam: callers should never reach into
+    # `Pubid::Iso::Builder` directly.
+    #
+    # @param hash [Hash] parse tree for an ISO identifier
+    # @return [Pubid::Iso::Identifier]
+    def self.build_from_parse(hash)
+      builder.build(hash)
+    end
+
+    # Return the named Parslet rule atom from the ISO parser, for embedding in
+    # another flavor's grammar (e.g. IEC joint identifiers).
+    #
+    # This is the public seam: callers should never instantiate
+    # `Pubid::Iso::Parser` directly.
+    #
+    # @param rule_name [Symbol] the parser rule to expose
+    # @return [Parslet::Atoms::Base]
+    def self.joint_grammar_atom(rule_name)
+      parser.public_send(rule_name)
+    end
+
+    # 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
+
+    # Memoized builder instance used by Normalizer / URN parser
+    # @return [Pubid::Iso::Builder]
+    def self.builder
+      @builder ||= Builder.new
+    end
+
+    # Memoized parser instance used by Normalizer
+    # @return [Pubid::Iso::Parser]
+    def self.parser
+      @parser ||= Parser.new
+    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
+
+    # Lookup: stage code -> typed stage
+    # @param stage_code [String, Symbol]
+    # @return [Pubid::Components::TypedStage, nil]
+    def self.locate_stage_by_stage_code(stage_code)
+      stage_code_sym = stage_code.to_sym
+      all_typed_stages.find { |s| s.stage_code.to_sym == stage_code_sym }
+    end
+
+    # Lookup: per-typed-stage code -> typed stage
+    # @param code [String, Symbol]
+    # @return [Pubid::Components::TypedStage, nil]
+    def self.locate_stage_by_code(code)
+      code_sym = code.to_sym
+      all_typed_stages.find { |s| s.code&.to_sym == code_sym }
+    end
+
+    # Lookup: harmonized stage code -> typed stage
+    # @param harmonized_code [String]
+    # @return [Pubid::Components::TypedStage, nil]
+    def self.locate_stage_by_harmonized_code(harmonized_code)
+      harmonized_str = harmonized_code.to_s
+      all_typed_stages.find { |s| s.harmonized_stages&.include?(harmonized_str) }
+    end
+
+    # Default typed stage used when no type_with_stage is present
+    # (e.g., the bare International Standard published stage)
+    # @return [Pubid::Components::TypedStage]
+    def self.default_typed_stage
+      locate_stage("") || all_typed_stages.first
+    end
   end
 end
 

data/lib/pubid/itu/builder.rb

@@ -1,17 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../components/date"
-require_relative "components/sector"
-require_relative "components/series"
-require_relative "components/code"
-require_relative "identifiers/recommendation"
-require_relative "identifiers/combined_identifier"
-require_relative "identifiers/supplement"
-require_relative "identifiers/amendment"
-require_relative "identifiers/corrigendum"
-require_relative "identifiers/special_publication"
-require_relative "identifiers/annex"
-
 module Pubid
   module Itu
     class Builder

data/lib/pubid/itu/components/code.rb

@@ -8,16 +8,14 @@ module Pubid
       # ITU Code component
       # Format: NUMBER[.SUBSERIES][-PART]
       # Examples: 1234, 1234.5, 1234-1, 1234.5-2
+      #
+      # Stays independent of Pubid::Components::Code because ITU uses
+      # +subseries+ (dot-separated, flavor-specific) and +parts+
+      # (dash-separated).
       class Code < Lutaml::Model::Serializable
         attribute :number, :string
         attribute :subseries, :string
-        attribute :parts, :string, collection: true
-
-        def initialize(number:, subseries: nil, parts: nil)
-          @number = number
-          @subseries = subseries
-          @parts = parts || []
-        end
+        attribute :parts, :string, collection: true, default: []
 
         def to_s
           result = number.to_s
@@ -26,6 +24,10 @@ module Pubid
           result
         end
 
+        def render(context: nil)
+          to_s
+        end
+
         def ==(other)
           return false unless other.is_a?(Code)
 

data/lib/pubid/itu/components/sector.rb

@@ -12,12 +12,23 @@ module Pubid
 
         VALID_SECTORS = %w[R T D].freeze
 
-        def initialize(sector:)
-          unless VALID_SECTORS.include?(sector.to_s.upcase)
-            raise ArgumentError, "Invalid sector: #{sector}. Must be R, T, or D"
+        # Accept either a positional Hash (lutaml-model's call style:
+        # `Sector.new({lutaml_register: :default})` then attribute assignment)
+        # or a literal `sector:` kwarg (`Sector.new(sector: "R")`). Both call
+        # paths funnel through the same validate-then-set flow so the attribute
+        # stays lutaml-tracked and round-trips through to_hash/from_hash.
+        def initialize(attrs = {}, options = {})
+          super
+          sector_val = attrs[:sector] || attrs["sector"]
+          return if sector_val.nil?
+
+          normalized = sector_val.to_s.upcase
+          unless VALID_SECTORS.include?(normalized)
+            raise ArgumentError,
+                  "Invalid sector: #{sector_val}. Must be R, T, or D"
           end
 
-          @sector = sector.to_s.upcase
+          self.sector = normalized
         end
 
         def to_s

data/lib/pubid/itu/components/series.rb

@@ -10,10 +10,6 @@ module Pubid
       class Series < Lutaml::Model::Serializable
         attribute :series, :string # e.g., BO, V, X, R, SG1, OB
 
-        def initialize(series:)
-          @series = series
-        end
-
         def to_s
           series
         end

data/lib/pubid/itu/components.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Components
+      autoload :Sector, "#{__dir__}/components/sector"
+      autoload :Series, "#{__dir__}/components/series"
+      autoload :Code, "#{__dir__}/components/code"
+    end
+  end
+end

data/lib/pubid/itu/identifier.rb

@@ -1,118 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "parser"
-require_relative "builder"
-require_relative "identifiers"
-require_relative "components/sector"
-require_relative "components/series"
-require_relative "components/code"
-
-module Pubid
-  module Itu
-    module Identifier
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse ITU identifier '#{identifier}': #{e.message}"
-      end
-
-      # Factory mirroring pubid 1.x's `Pubid::Itu::Identifier.create` API.
-      # Dispatch on `:type`:
-      #   * nil → Recommendation (or SpecialPublication for series "OB")
-      #   * :recommendation     → Identifiers::Recommendation
-      #   * :annex              → Identifiers::Annex
-      #   * :special_publication → Identifiers::SpecialPublication
-      #
-      # Component-typed kwargs are accepted as primitives and coerced:
-      #   * sector: "T"   → Components::Sector.new(sector: "T")
-      #   * series: "X"   → Components::Series.new(series: "X")
-      #   * number: "509" → Components::Code.new(number: "509")
-      #   * year: "2020"  → Pubid::Components::Date.new(year: "2020")
-      TYPE_KEY_TO_KLASS = {
-        recommendation:      "Recommendation",
-        annex:               "Annex",
-        special_publication: "SpecialPublication",
-      }.freeze
-
-      def self.create(type: nil, **kwargs)
-        # Backward-compat: nil type + series "OB" → SpecialPublication.
-        if type.nil? && kwargs[:series].to_s == "OB"
-          return create_special_publication(**kwargs)
-        end
-
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(kwargs, klass: klass))
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::Recommendation if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown ITU type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      # Backward-compat helper retained for the OB-series shortcut.
-      def self.create_special_publication(number:, series: "OB", date: nil,
-                                          language: nil)
-        Identifiers::SpecialPublication.new(
-          series:   Components::Series.new(series: series.to_s),
-          code:     Components::Code.new(number: number.to_s),
-          date:     date,
-          language: language&.to_s,
-        )
-      end
-
-      def self.coerce_create_attrs(opts, klass: nil)
-        attrs = {}
-        if (v = opts[:sector])
-          attrs[:sector] = if v.is_a?(Components::Sector)
-                             v
-                           else
-                             Components::Sector.new(sector: v.to_s.upcase)
-                           end
-        end
-        if (v = opts[:series])
-          attrs[:series] = if v.is_a?(Components::Series)
-                             v
-                           else
-                             Components::Series.new(series: v.to_s)
-                           end
-        end
-        if opts[:number] || opts[:code]
-          code_value = opts[:code]
-          if code_value.is_a?(Components::Code)
-            attrs[:code] = code_value
-          else
-            attrs[:code] = Components::Code.new(
-              number:    (opts[:number] || code_value).to_s,
-              subseries: opts[:subseries]&.to_s,
-              parts:     opts[:parts] ? Array(opts[:parts]).map(&:to_s) : nil,
-            )
-          end
-        end
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        attrs[:date] = opts[:date] if opts[:date].is_a?(Pubid::Components::Date)
-        attrs[:language] = opts[:language].to_s if opts[:language]
-
-        # Pass through any subclass-specific kwarg the chosen class
-        # declares (e.g. Annex#base) — preserves callers that already pass
-        # an explicit attribute that our coercion table doesn't cover.
-        if klass
-          consumed = %i[sector series number code subseries parts year date
-                        language]
-          opts.each do |k, v|
-            next if consumed.include?(k) || attrs.key?(k)
-            attrs[k] = v if klass.attributes.key?(k)
-          end
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
-    end
-  end
-end
+# Pubid::Itu::Identifier is the ITU base class (a real Pubid::Identifier
+# subclass); its body, `.parse`, and the Identifiers::Base back-compat alias
+# live in identifiers/base.rb. This file just ensures it is loaded.
+require_relative "identifiers/base"

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "supplement"
-
 module Pubid
   module Itu
     module Identifiers

data/lib/pubid/itu/identifiers/annex.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-
 module Pubid
   module Itu
     module Identifiers