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

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

@@ -12,23 +12,12 @@ module Pubid
 
         VALID_SECTORS = %w[R T D].freeze
 
-        # 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"
+        def initialize(sector:)
+          unless VALID_SECTORS.include?(sector.to_s.upcase)
+            raise ArgumentError, "Invalid sector: #{sector}. Must be R, T, or D"
           end
 
-          self.sector = normalized
+          @sector = sector.to_s.upcase
         end
 
         def to_s

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

@@ -10,6 +10,10 @@ 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/identifier.rb

@@ -1,4 +1,53 @@
 # frozen_string_literal: true
 
-# Pubid::Itu::Identifier is the ITU base class (a real Pubid::Identifier
-# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.
+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 v1's Pubid::Itu::Identifier.create API. The v1 form
+      # accepts a `type:` discriminator plus attribute kwargs; this v2
+      # implementation supports the subset needed by metanorma-itu PR #497:
+      #   * type: :annex — builds Identifiers::Annex
+      #   * series: "OB" (with no type:) — builds Identifiers::SpecialPublication
+      def self.create(type: nil, **kwargs)
+        case type
+        when :annex
+          Identifiers::Annex.new(**kwargs)
+        when nil
+          if kwargs[:series].to_s == "OB"
+            create_special_publication(**kwargs)
+          else
+            raise ArgumentError,
+                  "Identifier.create without :type requires series: 'OB'"
+          end
+        else
+          raise ArgumentError,
+                "Unsupported type for Identifier.create: #{type.inspect}"
+        end
+      end
+
+      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
+    end
+  end
+end

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

@@ -1,17 +1,41 @@
 # frozen_string_literal: true
 
+require_relative "supplement"
+
 module Pubid
   module Itu
     module Identifiers
       # Amendment identifier (Amd)
-      # Pattern: "ITU-T G.989 Amd. 1", "ITU-T G.780/Y.1351 Amd. 1 (2004)"
+      # Pattern: "ITU-T G.989 Amd 1", "ITU-T G.780/Y.1351 Amd 1 (2004)"
       class Amendment < Supplement
-        # "Amd." with the period, matching ITU's own rendering and the sibling
-        # supplement types (Cor./Err./Suppl./Add.). The parser accepts both
-        # spellings (see Parser#supplement_type), so the period-less input form
-        # still round-trips through parse — it just normalizes here.
-        def to_s(**opts)
-          annotate_plain_render(render_supplement("Amd."), **opts)
+        def to_s
+          result = base ? base.to_s : "#{publisher}-#{sector}"
+
+          # Add series if no base
+          if !base && series
+            result += " #{series}"
+          end
+
+          result += " Amd #{number}"
+
+          # Add date if present
+          if date
+            result += if date.month
+                        " (#{date.month}/#{date.year})"
+                      else
+                        " (#{date.year})"
+                      end
+          end
+
+          result
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Amendment)
+
+          base == other.base &&
+            number == other.number &&
+            date == other.date
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module Pubid
   module Itu
     module Identifiers
@@ -12,19 +14,8 @@ module Pubid
       #   * long with i18n_lang + format: :long: per-language `annex_long` template
       # Languages without an `annex_to` entry (fr/es/ru/zh) use the long
       # template for the short form too.
-      class Annex < Identifier
-        attribute :base, Identifier, polymorphic: true
-
-        # Compact serialization: an Annex is just the nested (itself-flat) base
-        # plus its own language; everything else is delegated to `base`.
-        key_value do
-          map "_type", to: :_type
-          map "base", with: { to: :base_to_kv, from: :base_from_kv }
-          map "language", to: :language
-          map "common_text_twin",
-              with: { to: :common_text_twin_to_kv,
-                      from: :common_text_twin_from_kv }
-        end
+      class Annex < Base
+        attribute :base, Base, polymorphic: true
 
         def to_urn
           # Annex URN: append :annex to the inner identifier's URN.