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

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

@@ -23,37 +23,19 @@ module Pubid
           parts << "itu"
         end
 
-        # An ITU-R Report numbers independently of the Recommendation series,
-        # so "BT.2020-1" alone is ambiguous — the type has to reach the URN as
-        # well as `to_s` and the MR slug, or the two documents share an
-        # identifier on that surface.
-        parts << "report" if identifier.is_a?(Identifiers::Report)
-
         if identifier.series
           series = identifier.series.to_s
           if identifier.code
-            # A series-code document joins with a dash, not a dot; rendering it
-            # "EMC.5" would be ambiguous with a hypothetical "ITU-T EMC.5" and
-            # would not parse back.
-            join = identifier.series_dash ? "-" : "."
-            parts << "#{series}#{join}#{identifier.code.compact_s}"
+            code = identifier.code.to_s
+            parts << "#{series}.#{code}"
           else
             parts << series
           end
         elsif identifier.code
-          code = identifier.code.compact_s
+          code = identifier.code.to_s
           parts << code
         end
 
-        # Identity-bearing markers that are not part of sector/series/code.
-        # Without them "ITU-T H.350 attachment", "ITU-T Q.120-Q.139" and
-        # "ITU-T E-100 series Suppl. 2" would each share a URN with the
-        # document they are distinct from — the same collision Code#compact_s
-        # exists to prevent for the code suffixes.
-        parts << "series" if identifier.series_word
-        parts << "attachment" if identifier.attachment
-        parts << "to-#{identifier.range_end}" if identifier.range_end
-
         if identifier.date
           date = identifier.date
           if date&.year && date.month
@@ -75,16 +57,8 @@ module Pubid
 
         base = maybe(:base)
         if base
-          # An annex or appendix base holds its identity in its OWN base (its
-          # sector/series/code are nil), so generate_base_urn would emit
-          # "urn:itu:itu" for it — go through its own to_urn instead.
-          nested_wrapper = base.is_a?(Identifiers::AnnexOfRecommendation) ||
-            base.is_a?(Identifiers::AppendixOfRecommendation)
-          base_urn = if nested_wrapper
-                       base.to_urn
-                     else
-                       self.class.new(base).generate_base_urn
-                     end
+          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(":")
@@ -98,16 +72,12 @@ module Pubid
           if identifier.series
             series = identifier.series.to_s
             if identifier.code
-              code = identifier.code.compact_s
+              code = identifier.code.to_s
               parts << "#{series}.#{code}"
             else
               parts << series
             end
           end
-          # A base-less supplement's whole identity is sector + series, so the
-          # series-group word belongs in the URN too — without it
-          # "ITU-T E-100 series Suppl. 2" and "ITU-T E-100 Suppl. 2" collide.
-          parts << "series" if identifier.series_word
         end
 
         supplement_notation = maybe(:supplement_notation)

data/lib/pubid/itu.rb

@@ -4,73 +4,17 @@ require "lutaml/model"
 
 module Pubid
   module Itu
-    extend Pubid::PrefixesSupport
-
-    # Sole ITU publisher token (see the parser's `itu_prefix` rule).
-    #
-    # The leading "Report" of an ITU-R Report's canonical form
-    # ("Report ITU-R BT.2020-1") is deliberately NOT listed: prefix routing
-    # claims every reference beginning with the token, and "Report" is a
-    # generic English word that other SDOs' references start with — the
-    # mixin's documented exclusion for ambiguous tokens. Report references
-    # route by their "ITU" token in the infix spelling
-    # ("ITU-R Report BT.2020-1"), and `Pubid::Itu.parse` accepts both.
-    PREFIXES = ["ITU"].freeze
-
     autoload :Builder, "#{__dir__}/itu/builder"
-    autoload :Components, "#{__dir__}/itu/components"
-    autoload :Identifier, "#{__dir__}/itu/identifiers/base"
+    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 :UrnParser, "#{__dir__}/itu/urn_parser"
     autoload :Model, "#{__dir__}/itu/model"
 
-    # I18N is a YAML-loaded constant (not a class), so autoload cannot be used.
-    # It is loaded eagerly when the ITU module is first referenced.
-    require "#{__dir__}/itu/i18n"
-
     def self.parse(identifier)
       Identifier.parse(identifier)
     end
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
-    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 < Pubid::Identifier }
-        # Exclude the flavor base itself by identity (Identifier is now an
-        # alias for Pubid::Itu::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifier }
-    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/jcgm/builder.rb

@@ -3,48 +3,32 @@
 module Pubid
   module Jcgm
     class Builder < Pubid::Builder::Base
-      def locate_identifier_klass(parsed_hash)
-        if parsed_hash[:base]
-          type_with_stage = parsed_hash[:type_with_stage]
-          return Jcgm.locate_type(:amendment) unless type_with_stage
+      def initialize(scheme)
+        @scheme = scheme
+      end
 
-          return Jcgm.locate_type(locate_typed_stage(type_with_stage).type_code)
+      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 Jcgm.locate_type(:gum_guide)
+          return @scheme.locate_identifier_klass_by_type_code(:gum_guide)
         end
 
-        # Standard guide (no type_with_stage, no gum_number).
-        # Don't use locate_stage("") — Guide and GumGuide both have
-        # abbr: [""], so the result depends on constant iteration order.
-        return Jcgm.locate_type(:guide) unless parsed_hash[:type_with_stage]
-
         typed_stage = locate_typed_stage(parsed_hash[:type_with_stage])
-        Jcgm.locate_type(typed_stage.type_code)
+        @scheme.locate_identifier_klass_by_type_code(typed_stage.type_code)
       end
 
       def build(parsed_hash)
-        klass = locate_identifier_klass(parsed_hash)
-
-        # GUM guides store their part number in the shared `number` attribute
-        # ("JCGM GUM-6" -> number "6"); the parser tags it :gum_number only to
-        # pick this class. Fold it back onto :number before assigning.
-        if parsed_hash[:gum_number] && klass == Identifiers::GumGuide
-          parsed_hash = parsed_hash.merge(number: parsed_hash[:gum_number])
-          parsed_hash.delete(:gum_number)
-        end
-
-        identifier = klass.new
+        identifier = locate_identifier_klass(parsed_hash).new
         assign_attributes(identifier, parsed_hash)
 
-        # Bare guides/gum-guides carry no parsed stage; derive the (single,
-        # published) typed_stage from the concrete class so parse and from_hash
-        # agree. Avoids the ambiguous locate_stage("") lookup (Guide and
-        # GumGuide both register abbr: [""]).
         if identifier.class.attributes.key?(:typed_stage) && identifier.typed_stage.nil?
-          identifier.typed_stage = identifier.class.published_typed_stage ||
-            raise(ArgumentError, "No published typed_stage for #{identifier.class}")
+          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
@@ -56,20 +40,16 @@ module Pubid
         Identifiers::Guide
       end
 
-      def locate_typed_stage(typed_stage_string)
-        typed_stage_string = "" if typed_stage_string.nil?
-        Jcgm.locate_stage(typed_stage_string) ||
-          raise(ArgumentError, "Unknown type abbreviation: '#{typed_stage_string}'")
-      end
-
       def cast(type, value)
         case type
-        when :base
+        when :base_identifier
           build(value)
         when :publisher
           Jcgm::Components::Publisher.new(publisher: value.to_s)
         when :number
-          value.to_s
+          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?("-")
@@ -82,6 +62,8 @@ module Pubid
           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)
           {

data/lib/pubid/jcgm/identifier.rb

@@ -3,16 +3,6 @@
 module Pubid
   module Jcgm
     class Identifier < ::Pubid::Identifier
-      # `number`/`part`/`subpart` are declared here rather than inherited as a
-      # Components::Code: JCGM stores a bare string in `number` and uses neither
-      # of the other two. Declaring on this class is safe because its body lives
-      # in this one file and is never reopened, so every subclass body opens
-      # after it has run (lutaml deep-dups the parent attribute table at
-      # class-definition time).
-      attribute :number, :string
-      attribute :part, :string
-      attribute :subpart, :string
-
       def self.parse(string)
         Pubid::Jcgm.parse(string)
       end

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

@@ -4,6 +4,8 @@ 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,
@@ -18,6 +20,15 @@ module Pubid
         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

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

@@ -3,10 +3,10 @@
 module Pubid
   module Jcgm
     module Identifiers
-      # A GUM guide, e.g. "JCGM GUM-6:2020". The GUM-series part number ("6")
-      # lives in the inherited `number` attribute (serialized as `number: "6"`);
-      # `_type: pubid:jcgm:gum-guide` disambiguates it from a plain guide.
       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,
@@ -22,6 +22,18 @@ module Pubid
           { 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

data/lib/pubid/jcgm/identifiers.rb

@@ -4,10 +4,8 @@ module Pubid
   module Jcgm
     module Identifiers
       autoload :Amendment, "#{__dir__}/identifiers/amendment"
-      autoload :Corrigendum, "#{__dir__}/identifiers/corrigendum"
       autoload :Guide, "#{__dir__}/identifiers/guide"
       autoload :GumGuide, "#{__dir__}/identifiers/gum_guide"
-      autoload :Meeting, "#{__dir__}/identifiers/meeting"
     end
   end
 end

data/lib/pubid/jcgm/parser.rb

@@ -4,86 +4,24 @@ require "parslet"
 
 module Pubid
   module Jcgm
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       include ::Pubid::Parser::CommonParseRules
       include ::Pubid::Parser::CommonParseMethods
 
       root :identifier
 
       rule(:identifier) do
-        meeting_identifier | amendment_identifier | corrigendum_identifier |
-          numbered_corrigendum_identifier | base | named_guide_identifier
+        amendment_identifier | base_identifier
       end
 
-      # "JCGM 200:2008 Corrigendum" — a base guide plus a trailing
-      # " Corrigendum" word (no number). Must precede base: Parslet
-      # is an ordered PEG that commits to the first matching alternative, so if
-      # base ran first it would consume "JCGM 200:2008" and root
-      # would fail on the leftover " Corrigendum". Emits type_with_stage so the
-      # builder routes it to Corrigendum.
-      rule(:corrigendum_identifier) do
-        base.as(:base) >> space >>
-          str("Corrigendum").as(:type_with_stage)
-      end
-
-      # "JCGM 101:2008/Cor 1:2009" — a base guide plus a slash-separated
-      # numbered corrigendum (mirrors the ISO/IEC supplement form). The
-      # trailing :YYYY is optional so "JCGM 101:2008/Cor 1" also parses.
-      # Must precede base for the same PEG-commit reason as corrigendum_identifier.
-      rule(:numbered_corrigendum_identifier) do
-        base.as(:base) >>
-          str("/") >> str("Cor").as(:type_with_stage) >>
-          space >> digits.as(:number) >>
-          corrigendum_date.maybe
-      end
-
-      # Dateless "named" guides: "JCGM GUM", "JCGM VIM-3" (and future "VIM-N").
-      # Last in the alternation — only reached when base fully fails
-      # (these have no date, so number_portion/date_portion never match).
-      rule(:named_guide_identifier) do
-        publisher >> space >> named_number
-      end
-
-      rule(:named_number) do
-        (str("GUM") | (str("VIM") >> (str("-") >> digits).maybe)).as(:number)
-      end
-
-      # Committee/meeting record, e.g. "JCGM 17th Meeting (2012)". Diverges
-      # from base right after the digits (base wants ":", meeting
-      # wants the ordinal suffix), so ordered choice is unambiguous. Emits the
-      # same tokens as a guide plus type_with_stage "Meeting", so the generic
-      # builder path resolves it to Identifiers::Meeting (like "Amd").
-      #
-      # The trailing " (YYYY)" group is optional, so the partial reference
-      # "JCGM 11st Meeting" parses with `date` left nil. JCGM numbers its
-      # meetings in one sequence, so the ordinal alone names the event and the
-      # year is redundant detail. The whole group is `.maybe` (not the year
-      # inside it), so a dangling "(" or a truncated year still fails —
-      # the same shape as `date_portion.maybe` in `rule(:base)`.
-      rule(:meeting_identifier) do
-        publisher >> space >> digits.as(:number) >> ordinal_suffix >>
-          space >> str("Meeting").as(:type_with_stage) >>
-          (space >> str("(") >> year_digits.as(:date) >> str(")")).maybe
-      end
-
-      rule(:ordinal_suffix) do
-        str("st") | str("nd") | str("rd") | str("th")
-      end
-
-      # `date_portion` is optional so a partial reference that omits the
-      # trailing `:YYYY` date (e.g. "JCGM 100") parses with `date` left nil,
-      # letting relaton match a collection via `matches?(row, ignore: [:date])`.
-      # The whole sub-rule is `.maybe` (not the year inside it) so a dangling
-      # ":" still fails. Mirrors ETSI (lib/pubid/etsi/parser.rb).
-      rule(:base) do
-        publisher >> space >> number_portion >>
-          date_portion.maybe >> language_portion.maybe
+      rule(:base_identifier) do
+        publisher >> space >> number_portion >> date_portion >> language_portion.maybe
       end
 
       rule(:amendment_identifier) do
-        base.as(:base) >>
+        base_identifier.as(:base_identifier) >>
           str("/") >> amendment_type >>
-          space >> digits.as(:number) >>
+          space >> amendment_number >>
           amendment_date.maybe
       end
 
@@ -135,17 +73,12 @@ module Pubid
       end
 
       rule(:amendment_number) do
-        digits.as(:number)
+        digits.as(:iteration)
       end
 
       rule(:amendment_date) do
         str(":") >> (full_date | year_only)
       end
-
-      # Numbered corrigendum date: same shape as amendment_date.
-      rule(:corrigendum_date) do
-        str(":") >> (full_date | year_only)
-      end
     end
   end
 end

data/lib/pubid/jcgm/scheme.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class Scheme < Pubid::Scheme
+      class << self
+        def identifiers
+          [
+            Identifiers::Guide,
+            Identifiers::GumGuide,
+          ]
+        end
+
+        def supplement_identifiers
+          [
+            Identifiers::Amendment,
+          ]
+        end
+
+        def typed_stages
+          (identifiers + supplement_identifiers).flat_map do |klass|
+            klass::TYPED_STAGES
+          end
+        end
+
+        def locate_typed_stage_by_abbr(abbr)
+          # Empty abbr means Guide (published)
+          abbr = "" if abbr.nil? || abbr.to_s.strip.empty?
+
+          typed_stage = typed_stages.detect do |ts|
+            ts.abbr.include?(abbr)
+          end
+
+          unless typed_stage
+            raise ArgumentError,
+                  "Unknown type abbreviation: '#{abbr}'"
+          end
+
+          typed_stage
+        end
+
+        def locate_identifier_klass_by_type_code(type_code)
+          # Check all identifier classes (base + supplement)
+          all_classes = identifiers + supplement_identifiers
+
+          identifier_klass = all_classes.detect do |klass|
+            klass.type[:key].to_s == type_code.to_s
+          end
+
+          unless identifier_klass
+            raise ArgumentError,
+                  "Unknown type code: #{type_code}"
+          end
+
+          identifier_klass
+        end
+      end
+    end
+  end
+end