pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/itu/scheme.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative "model"
+
+module Pubid
+  module Itu
+    class Scheme < Pubid::Scheme
+      # Attribute mappings define how parsed data maps to model attributes
+      ATTRIBUTE_MAPPINGS = {
+        sector: :sector,
+        series: :series,
+        number: :number,
+        subseries: :subseries,
+        part: :part,
+        supplement: :supplement,
+        amendment: :amendment,
+        annex: :annex,
+        corrigendum: :corrigendum,
+        addendum: :addendum,
+        appendix: :appendix,
+        date: :date,
+        month: :month,
+        year: :year,
+        second_number: :second_number,
+        range_series: :range_series,
+        range_number: :range_number,
+        sg_number: :sg_number,
+      }.freeze
+
+      # Model class to use for rendering
+      def self.model_class
+        Model
+      end
+
+      # Convert parsed data to model attributes
+      def self.transform(parsed)
+        attributes = {}
+
+        # Extract sector
+        attributes[:sector] = parsed[:sector].to_s if parsed[:sector]
+
+        # Determine content based on sector
+        content = parsed[:t_content] || parsed[:r_content] || {}
+
+        # Extract series and study group
+        if content[:series].is_a?(Hash) && content[:series][:sg_number]
+          # Study groups (questions)
+          attributes[:series] = "SG#{content[:series][:sg_number]}"
+        elsif content[:series]
+          attributes[:series] = content[:series].to_s
+        end
+
+        # Extract numbering components
+        if content[:numbering]
+          numbering = content[:numbering]
+
+          # Handle numbering as array (e.g., number + subseries)
+          if numbering.is_a?(Array)
+            numbering.each do |part|
+              if part.is_a?(Hash)
+                if part[:number]
+                  attributes[:number] = part[:number].to_s
+                elsif part[:subseries]
+                  # Collect subseries parts
+                  if attributes[:subseries]
+                    attributes[:subseries] =
+                      "#{attributes[:subseries]}.#{part[:subseries]}"
+                  else
+                    attributes[:subseries] = part[:subseries].to_s
+                  end
+                elsif part[:part]
+                  attributes[:part] = part[:part].to_s
+                end
+              end
+            end
+          elsif numbering.is_a?(Hash)
+            # Handle numbering as hash
+            attributes[:number] = numbering[:number].to_s if numbering[:number]
+            if numbering[:subseries]
+              attributes[:subseries] =
+                numbering[:subseries].to_s
+            end
+            attributes[:part] = numbering[:part].to_s if numbering[:part]
+          end
+        end
+
+        # Extract supplement/amendment/etc.
+        if content[:supplement]
+          attributes[:supplement] =
+            content[:supplement].to_s
+        end
+        attributes[:amendment] = content[:amendment].to_s if content[:amendment]
+        attributes[:annex] = content[:annex].to_s if content[:annex]
+        if content[:corrigendum]
+          attributes[:corrigendum] =
+            content[:corrigendum].to_s
+        end
+        attributes[:addendum] = content[:addendum].to_s if content[:addendum]
+
+        # Handle appendix (convert Roman numerals to Arabic)
+        if content[:appendix]
+          appendix = content[:appendix].to_s
+          attributes[:appendix] = roman_to_arabic(appendix) || appendix
+        end
+
+        # Extract date
+        if content[:date]
+          date = content[:date]
+          if date[:month] && date[:year]
+            attributes[:month] = date[:month].to_s
+            attributes[:year] = date[:year].to_s
+          elsif date[:year]
+            attributes[:year] = date[:year].to_s
+          end
+        end
+
+        # Extract second number (for combined standards like G.780/Y.1351)
+        if content[:second_number]
+          second = content[:second_number]
+          second_attrs = {}
+          second_attrs[:series] = second[:series].to_s if second[:series]
+          if second[:numbering]
+            numbering = second[:numbering]
+            if numbering[:number]
+              second_attrs[:number] =
+                numbering[:number].to_s
+            end
+            if numbering[:subseries]
+              second_attrs[:subseries] = numbering[:subseries].to_s
+            end
+            second_attrs[:part] = numbering[:part].to_s if numbering[:part]
+          end
+          attributes[:second_number] = second_attrs unless second_attrs.empty?
+        end
+
+        # Extract range (for Q.400-Q.490 style)
+        if content[:range_series] && content[:range_number]
+          attributes[:range] = {
+            series: content[:range_series].to_s,
+            number: content[:range_number].to_s,
+          }
+        end
+
+        attributes
+      end
+
+      # Convert Roman numerals to Arabic numbers
+      def self.roman_to_arabic(roman)
+        return roman unless roman.match?(/^[IVXLCDM]+$/i)
+
+        roman_map = {
+          "I" => 1, "V" => 5, "X" => 10, "L" => 50,
+          "C" => 100, "D" => 500, "M" => 1000
+        }
+
+        roman = roman.upcase
+        result = 0
+        prev_value = 0
+
+        roman.reverse.each_char do |char|
+          value = roman_map[char]
+          if value < prev_value
+            result -= value
+          else
+            result += value
+          end
+          prev_value = value
+        end
+
+        result.to_s
+      end
+    end
+  end
+end

data/lib/pubid/itu/urn_generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(Identifiers::Supplement)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      def generate_base_urn
+        parts = ["urn", "itu"]
+
+        if identifier.sector
+          sector = identifier.sector.to_s
+          parts << sector.to_s.downcase
+        else
+          parts << "itu"
+        end
+
+        if identifier.series
+          series = identifier.series.to_s
+          if identifier.code
+            code = identifier.code.to_s
+            parts << "#{series}.#{code}"
+          else
+            parts << series
+          end
+        elsif identifier.code
+          code = identifier.code.to_s
+          parts << code
+        end
+
+        if identifier.date
+          date = identifier.date
+          if date&.year && date.month
+            parts << "#{date.month}/#{date.year}"
+          elsif date&.year
+            parts << date.year.to_s
+          end
+        end
+
+        if identifier.language
+          parts << identifier.language.to_s.downcase
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "itu"]
+
+        base = maybe(:base)
+        if base
+          base_gen = self.class.new(base)
+          base_urn = base_gen.generate_base_urn
+
+          base_part = base_urn.sub(/^urn:itu:/, "")
+          base_parts = base_part.split(":")
+
+          parts.concat(base_parts)
+        else
+          if identifier.sector
+            sector = identifier.sector.to_s
+            parts << sector.to_s.downcase
+          end
+          if identifier.series
+            series = identifier.series.to_s
+            if identifier.code
+              code = identifier.code.to_s
+              parts << "#{series}.#{code}"
+            else
+              parts << series
+            end
+          end
+        end
+
+        supplement_notation = maybe(:supplement_notation)
+        if supplement_notation
+          parts << supplement_notation.to_s.downcase
+        end
+
+        if identifier.number
+          parts << identifier.number.to_s
+        end
+
+        if identifier.date
+          date = identifier.date
+          if date&.year && date.month
+            parts << "#{date.month}/#{date.year}"
+          elsif date&.year
+            parts << date.year.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/itu.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Itu
+    autoload :Builder, "#{__dir__}/itu/builder"
+    autoload :Identifier, "#{__dir__}/itu/identifier"
+    autoload :Identifiers, "#{__dir__}/itu/identifiers"
+    autoload :Parser, "#{__dir__}/itu/parser"
+    autoload :Scheme, "#{__dir__}/itu/scheme"
+    autoload :UrnGenerator, "#{__dir__}/itu/urn_generator"
+    autoload :Model, "#{__dir__}/itu/model"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+  end
+end
+
+# Register ITU flavor with the registry
+Pubid::Registry.register(:itu, Pubid::Itu)

data/lib/pubid/jcgm/builder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class Builder < Pubid::Builder::Base
+      def initialize(scheme)
+        @scheme = scheme
+      end
+
+      def locate_identifier_klass(parsed_hash)
+        if parsed_hash[:base_identifier]
+          return @scheme.locate_identifier_klass_by_type_code(:amendment)
+        end
+
+        if parsed_hash[:gum_number]
+          return @scheme.locate_identifier_klass_by_type_code(:gum_guide)
+        end
+
+        typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
+        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
+      end
+
+      def build(parsed_hash)
+        identifier = locate_identifier_klass(parsed_hash).new
+        assign_attributes(identifier, parsed_hash)
+
+        if identifier.class.attributes.key?(:typed_stage) && identifier.typed_stage.nil?
+          default_typed_stage = @scheme.locate_typed_stage_by_abbr("")
+          identifier.typed_stage = default_typed_stage
+          identifier.stage = default_typed_stage.to_stage if identifier.class.attributes.key?(:stage)
+          identifier.type = default_typed_stage.to_type if identifier.class.attributes.key?(:type)
+        end
+
+        identifier
+      end
+
+      private
+
+      def default_identifier_class
+        Identifiers::Guide
+      end
+
+      def cast(type, value)
+        case type
+        when :base_identifier
+          build(value)
+        when :publisher
+          Jcgm::Components::Publisher.new(publisher: value.to_s)
+        when :number
+          Pubid::Components::Code.new(value: value.to_s)
+        when :gum_number
+          Pubid::Components::Code.new(value: value.to_s)
+        when :date
+          date_str = value.to_s
+          if date_str.include?("-")
+            parts = date_str.split("-")
+            Pubid::Components::Date.new(
+              year: parts[0],
+              month: parts[1],
+              day: parts[2],
+            )
+          else
+            Pubid::Components::Date.new(year: date_str)
+          end
+        when :iteration
+          Pubid::Components::Code.new(value: value.to_s)
+        when :type_with_stage
+          typed_stage = locate_typed_stage(value.to_s)
+          {
+            stage: typed_stage.to_stage,
+            type: typed_stage.to_type,
+            typed_stage: typed_stage,
+          }
+        when :languages
+          original_value = value.to_s
+          langs = original_value.include?("/") ? original_value.split("/") : [original_value]
+          langs.map do |lang|
+            lang = lang.strip
+            original_lang = lang
+            lang = LANG_CHAR_MAP[lang] if lang.length == 1
+            Pubid::Components::Language.new(code: lang,
+                                            original_code: original_lang)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/components/publisher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Jcgm
+    module Components
+      class Publisher < Lutaml::Model::Serializable
+        attribute :publisher, :string
+
+        def to_s
+          publisher
+        end
+
+        # Alias for consistency
+        alias_method :body, :publisher
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/components.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Components
+      autoload :Publisher, "#{__dir__}/components/publisher"
+    end
+  end
+end

data/lib/pubid/jcgm/identifier.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class Identifier < ::Pubid::Identifier
+      def self.parse(string)
+        Pubid::Jcgm.parse(string)
+      end
+
+      # Factory mirroring pubid 1.x's `Pubid::Jcgm::Identifier.create` API.
+      # Dispatches `:guide` (default) → Guide, `:gum_guide` → GumGuide.
+      TYPE_KEY_TO_KLASS = {
+        guide:     "Guide",
+        gum_guide: "GumGuide",
+      }.freeze
+
+      def self.create(type: nil, **opts)
+        klass = resolve_create_class(type)
+        attrs = coerce_create_attrs(opts)
+        ts = klass.const_defined?(:TYPED_STAGES) &&
+             klass.const_get(:TYPED_STAGES).find do |t|
+               t.stage_code&.to_sym == :published
+             end
+        attrs[:typed_stage] = ts if ts
+        klass.new(**attrs)
+      end
+
+      def self.resolve_create_class(type)
+        return Identifiers::Guide if type.nil?
+
+        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
+        raise ArgumentError, "Unknown JCGM type: #{type.inspect}" unless klass_name
+
+        Identifiers.const_get(klass_name)
+      end
+
+      def self.coerce_create_attrs(opts)
+        attrs = {
+          publisher: Pubid::Jcgm::Components::Publisher.new(
+            publisher: (opts[:publisher] || "JCGM").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, :coerce_create_attrs
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      class Amendment < SupplementIdentifier
+        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubamd,
+            stage_code: :published,
+            type_code: :amendment,
+            abbr: ["Amd"],
+            name: "Amendment",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :amendment, title: "Amendment", short: "Amd" }
+        end
+
+        def to_s(lang: :en, lang_single: false, with_edition: false,
+format: nil, stage_format_long: nil, with_date: nil)
+          result = base_identifier.to_s if base_identifier
+          result += "/Amd"
+          result += " #{iteration.value}" if iteration
+          result += ":#{date}" if date
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      class Guide < SingleIdentifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            abbr: [""],
+            type_code: :guide,
+            stage_code: :published,
+          ),
+        ].freeze
+
+        def self.type
+          { key: :guide, title: "Guide" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers/gum_guide.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      class GumGuide < SingleIdentifier
+        attribute :gum_number, Pubid::Components::Code
+        attribute :type, Pubid::Components::Type, default: -> { self.class.type[:key] }
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubgumguide,
+            stage_code: :published,
+            type_code: :gum_guide,
+            abbr: [""],
+            name: "GUM Guide",
+            harmonized_stages: %w[60.00 60.60],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :gum_guide, title: "GUM Guide", short: "GUM" }
+        end
+
+        def to_s(lang: :en, lang_single: false, with_edition: false,
+format: nil, stage_format_long: nil, with_date: nil)
+          parts = []
+          parts << publisher.publisher if publisher
+          parts << "GUM-#{gum_number.value}" if gum_number
+
+          result = parts.join(" ")
+          result += ":#{date}" if date
+          result += language_portion if languages&.any?
+          result
+        end
+
+        private
+
+        def language_portion
+          return "" unless languages&.any?
+
+          codes = languages.map do |lang|
+            lang.original_code || lang.code
+          end
+
+          "(#{codes.join('/')})"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :GumGuide, "#{__dir__}/identifiers/gum_guide"
+    end
+  end
+end

data/lib/pubid/jcgm/parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Jcgm
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      root :identifier
+
+      rule(:identifier) do
+        amendment_identifier | base_identifier
+      end
+
+      rule(:base_identifier) do
+        publisher >> space >> number_portion >> date_portion >> language_portion.maybe
+      end
+
+      rule(:amendment_identifier) do
+        base_identifier.as(:base_identifier) >>
+          str("/") >> amendment_type >>
+          space >> amendment_number >>
+          amendment_date.maybe
+      end
+
+      rule(:publisher) do
+        str("JCGM").as(:publisher)
+      end
+
+      # Number can be plain (100, 200) or GUM-prefixed (GUM-1, GUM-6)
+      rule(:number_portion) do
+        gum_number | standard_number
+      end
+
+      rule(:standard_number) do
+        digits.as(:number)
+      end
+
+      rule(:gum_number) do
+        str("GUM-") >> digits.as(:gum_number)
+      end
+
+      # Date can be YYYY or YYYY-MM-DD
+      rule(:date_portion) do
+        str(":") >> (full_date | year_only)
+      end
+
+      rule(:year_only) do
+        year_digits.as(:date)
+      end
+
+      rule(:full_date) do
+        (year_digits >> str("-") >> month_digits >> str("-") >> day_digits).as(:date)
+      end
+
+      # Language: "(E)", "(F)", "(E/F)", "(F/E)"
+      rule(:language_portion) do
+        str("(") >>
+          (
+            # Multi-language: E/F, F/E
+            (str("E/F") | str("F/E")) |
+            # Single language: E, F, R, etc.
+            match("[A-Z]")
+          ).as(:languages) >>
+          str(")")
+      end
+
+      # Amendment support
+      rule(:amendment_type) do
+        str("Amd").as(:type_with_stage)
+      end
+
+      rule(:amendment_number) do
+        digits.as(:iteration)
+      end
+
+      rule(:amendment_date) do
+        str(":") >> (full_date | year_only)
+      end
+    end
+  end
+end