pubid 2.0.26 → 2.0.28

data/lib/pubid/cen_pfs/adopted_base.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Pubid
+  module CenPfs
+    # The adopted-base dispatch hook (pubid-grammar#121 feature 4, the §4
+    # coded escape hatch). The generated builder calls this module at two
+    # explicit points — the captured adopted run, and the implicit probe —
+    # and this module owns the value-dependent dispatch the declaration
+    # cannot carry:
+    #
+    #   * the adopted string parses with the owning scheme's flavor
+    #     ("ISO/IEC" and "ISO" leads through Pubid::Iso, "IEC" through
+    #     Pubid::Iec);
+    #   * an ENV-prefixed adoption switches the class to the prestandard
+    #     (the coded ENV branch), the publisher staying ENV;
+    #   * an EN with a bare number in the IEC range (60000-79999) adopts
+    #     the corresponding IEC standard implicitly — the ISO-only range
+    #     is intentionally NOT mapped (too many real CEN publications
+    #     would change type; pubid#249).
+    module AdoptedBase
+      IMPLICIT_IEC_RANGE = (60_000..79_999)
+
+      class << self
+        # The adoption identifier the captured run builds, or nil when the
+        # run names no known flavor (the caller surfaces the parse error).
+        def build(builder, data)
+          adopted_str = builder.unwrap(data[:adopted])&.to_s&.strip
+          return nil unless adopted_str && !adopted_str.empty?
+
+          adopted_id = parse_adopted(adopted_str)
+          publisher = builder.unwrap(data[:publisher])&.to_s
+          return env_adopted(adopted_id) if publisher == "ENV"
+
+          attrs = adoption_attrs(builder, data, adopted_id, publisher)
+          Identifiers::AdoptedEuropeanNorm.new(**attrs)
+        end
+
+        # The implicit adoption probe: an EN with a bare IEC-range number,
+        # no parts and no supplements, adopts the corresponding IEC
+        # standard (the coded builder's own guard). nil otherwise.
+        def implicit(builder, data)
+          return nil unless implicit_adoption?(builder, data)
+
+          number = builder.unwrap(data[:number])&.to_s&.strip
+          return nil unless number&.match?(/\A\d{1,6}\z/)
+          return nil unless IMPLICIT_IEC_RANGE.cover?(number.to_i)
+
+          Identifiers::AdoptedEuropeanNorm.new(
+            adopted: Pubid::Iec.parse("IEC #{number}"),
+          )
+        end
+
+        private
+
+        # The ENV adoption switch: the prestandard wraps the adopted
+        # document, its publisher staying ENV.
+        def env_adopted(adopted_id)
+          Identifiers::EuropeanPrestandard.new(
+            publisher: ::Pubid::Components::Publisher.new(body: "ENV"),
+            adopted: adopted_id,
+          )
+        end
+
+        # The adoption's own columns: the draft stage rides the CEN
+        # adoption ("prEN ISO 1234:2020"), the publisher face, and the
+        # copublishers.
+        def adoption_attrs(builder, data, adopted_id, publisher)
+          attrs = { adopted: adopted_id }
+          attrs.merge!(stage_attrs(builder, data))
+          attrs[:publisher] =
+            ::Pubid::Components::Publisher.new(body: publisher) if publisher
+          copubs = Array(data[:copublishers]).map do |row|
+            value = builder.unwrap(row[:copublisher] || row["copublisher"])
+            ::Pubid::Components::Publisher.new(body: value.to_s)
+          end
+          attrs[:copublishers] = copubs unless copubs.empty?
+          attrs
+        end
+
+        def stage_attrs(builder, data)
+          stage = builder.unwrap(data[:stage])
+          return {} unless stage
+
+          typed_stage = ::Pubid::CenPfs::Builder.stage_by_code(
+            ::Pubid::CenPfs::Builder::STAGE_MAP.fetch(stage.to_s),
+          )
+          { typed_stage: typed_stage, type: typed_stage.to_type,
+            stage: typed_stage.to_stage }
+        end
+
+        # The coded guard: the EN publisher alone, no copublishers, no
+        # parts, no supplements — only then may the number imply adoption.
+        def implicit_adoption?(builder, data)
+          builder.unwrap(data[:publisher])&.to_s == "EN" &&
+            Array(data[:copublishers]).none? &&
+            builder.unwrap(data[:part]).nil? &&
+            Array(data[:supplements]).none?
+        end
+
+        # "EN ISO 13485:2016/Amd 1:2016" parses the ADOPTED string with the
+        # ISO flavor (its amendment spelling included); an IEC lead token
+        # parses with the IEC flavor. CISPR stays unparsed (the coded
+        # builder's own boundary).
+        def parse_adopted(adopted_str)
+          if adopted_str.start_with?("IEC")
+            Pubid::Iec.parse(adopted_str)
+          elsif adopted_str.start_with?("ISO")
+            Pubid::Iso.parse(adopted_str)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/builder.rb

@@ -1,33 +1,169 @@
-  module Pubid
-    module CenPfs
-      class Builder
-        def self.build(parsed_data)
-          new.build(parsed_data)
-        end
+module Pubid
+  module CenPfs
+    class Builder
+      # The type each declared token selects (feature 1); the
+      # token-free type is the default class.
+      TYPE_TOKENS = {
+          "TR" => "TechnicalReport",
+          "TS" => "TechnicalSpecification",
+          "Guide" => "Guide",
+          "CR" => "CenReport",
+          "CWA" => "CenWorkshopAgreement",
+          "ES" => "EuropeanSpecification",
+          "ENV" => "EuropeanPrestandard",
+          "HD" => "HarmonizationDocument",
+      }.freeze
+
+      DEFAULT_TYPE = "EuropeanNorm"
+
+      # The declared draft stages (feature 2): code → the
+      # typed-stage row the trio builds from.
+      STAGES = {
+        "pren" => { code: :pren, stage_code: :proposal, type_code: :en, abbr: ["prEN"] },
+        "fpren" => { code: :fpren, stage_code: :final_proposal, type_code: :en, abbr: ["FprEN"] },
+      }.freeze
+
+      # The captured spelling → the serialized stage code.
+      STAGE_MAP = {
+          "prEN" => "pren",
+          "FprEN" => "fpren",
+      }.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def self.stage_by_code(code)
+        row = STAGES[code.to_s]
+        return nil unless row
+
+        ::Pubid::Components::TypedStage.new(
+          code: row[:code], stage_code: row[:stage_code],
+          type_code: row[:type_code], abbr: row[:abbr],
+        )
+      end
+
+      def build(data)
+        base = build_base_document(data)
+        wrapped = wrap_supplements(base, data)
+        wrap_fragment(wrapped, data)
+      end
+
+      # The document the supplements apply to. The adopted-base
+      # dispatch (feature 4) calls the vendored hook at two explicit
+      # points: the captured adopted run, and the hook's own implicit
+      # probe — never implicitly.
+      def build_base_document(data)
+        return AdoptedBase.build(self, data) if data[:adopted]
+
+        implicit = AdoptedBase.implicit(self, data)
+        return implicit if implicit
+
+        identifier = locate_identifier_klass(data).new
+        assign_attributes(identifier, data)
+        identifier
+      end
+
+      # The class each reference selects: the type-position token
+      # first, then the publisher-position token (the publisher-type
+      # faces CR/CWA/…), then the token-free default class.
+      def locate_identifier_klass(data)
+        token = data[:guide] || data[:type]
+        token ||= data[:publisher] if TYPE_TOKENS.key?(data[:publisher].to_s)
+        name = token ? TYPE_TOKENS.fetch(token.to_s, DEFAULT_TYPE) : DEFAULT_TYPE
+        Identifiers.const_get(name)
+      end
 
-        def build(data)
-          Identifiers::EuropeanNorm.new(
-          number: data[:number],
-          part: data[:part],
-            date: build_date(data),
+      # The columns, as the coded builder's cast writes them.
+      def assign_attributes(identifier, data)
+        if data[:year]
+          identifier.date = ::Pubid::Components::Date.new(
+            year: data[:year]&.to_s,
           )
         end
+        identifier.number = data[:number]&.to_s
+        identifier.part = data[:part]&.to_s
+        identifier.version = present_string(data[:version])
+        if data[:publisher]
+          identifier.publisher = ::Pubid::Components::Publisher.new(body: data[:publisher].to_s)
+        end
+        copubs = Array(data[:copublishers]).map do |row|
+          value = row[:copublisher] || row["copublisher"]
+          ::Pubid::Components::Publisher.new(body: unwrap(value).to_s)
+        end
+        identifier.copublishers = copubs unless copubs.empty?
+        type_token = data[:guide] || data[:type]
+        identifier.type = ::Pubid::Components::Type.new(abbr: type_token.to_s) if type_token
+        captured = data[:stage]
+        return unless captured
+
+        typed_stage = Builder.stage_by_code(STAGE_MAP.fetch(captured.to_s))
+        identifier.typed_stage = typed_stage
+        identifier.type = typed_stage.to_type
+        identifier.stage = typed_stage.to_stage
+      end
 
-        private
+      # A capture the grammar bound as an empty string stores as nil:
+      # to_hash drops the empty string, so from_hash would give nil and
+      # the two identifiers would not be ==.
+      def present_string(value)
+        str = unwrap(value)&.to_s
+        str unless str.nil? || str.empty?
+      end
 
-        # The publication date as the shared Components::Date, or
-        # nil when the reference omits the calendar fields (a
-        # partial reference matches by excluding the date).
-        def build_date(data)
-          values = [data[:year]]
-          return nil if values.compact.empty?
+      # The run's internal captures bind only through the item row, so
+      # unbound ones arrive as raw leaves — a Parsanol::Slice or a
+      # {value:, offset: ...} span. Unwrap the captured value.
+      def unwrap(capture)
+        return capture.content if capture.is_a?(Parsanol::Slice)
+        return capture[:value] if capture.is_a?(Hash) && capture.key?(:value)
 
-          ::Pubid::Components::Date.new(
-          year: data[:year]&.to_s,
-          )
+        capture
+      end
+
+      # The wrapper classes by kind face: the run's dispatch.
+      SUPPLEMENT_WRAPPERS = {
+        "A" => Identifiers::Amendment,
+        "AC" => Identifiers::Corrigendum,
+      }.freeze
+
+      def wrap_supplements(base, data)
+        rows = Array(data[:supplements])
+        return base if rows.empty?
+
+        items = rows.map do |row|
+          inner = row[:supplement] || row["supplement"] || {}
+          inner = inner.values.first if inner.values.all?(Hash)
+          inner
         end
+        if items.any? { |item| item[:supplements_plus] || item["supplements_plus"] }
+          members = items.map { |item| supplement_from(item) }
+          Identifiers::ConsolidatedIdentifier.new(identifiers: [base] + members)
+        else
+          supplement_from(items.first, base: base)
+        end
+      end
+
+      def supplement_from(item, base: nil)
+        kind = unwrap(item[:supplement_kind] || item["supplement_kind"])
+        number = unwrap(item[:supplement_number] || item["supplement_number"])
+        attrs = {}
+        attrs[:base] = base if base
+        attrs[:number] = present_string(number)
+        attrs[:year] = present_string(unwrap(item[:supplements_year] || item["supplements_year"]))
+        attrs[:month] = present_string(unwrap(item[:supplements_month] || item["supplements_month"]))
+        SUPPLEMENT_WRAPPERS.fetch(kind.to_s).new(**attrs)
+      end
+
+      def wrap_fragment(identifier, data)
+        return identifier unless data[:fragment_number]
+
+        Identifiers::Fragment.new(
+          number: unwrap(data[:fragment_number]).to_s, base: identifier,
+        )
       end
     end
   end
 
   Pubid::CenPfs::Builder.prepend(Pubid::Builder::AllPartsWrap)
+end

data/lib/pubid/cen_pfs/identifier.rb

@@ -1,64 +1,122 @@
-  module Pubid
-    module CenPfs
-      class Identifier < ::Pubid::Identifier
-        attribute :number, :string
-        attribute :part, :string
-        attribute :date, ::Pubid::Components::Date
-
-        EN_TYPE_MAP = {
-          "pubid:cencenelec:european-norm" => "Pubid::CenPfs::Identifiers::EuropeanNorm",
-        }.freeze
-
-        key_value do
-          map "_type", to: :_type, polymorphic_map: EN_TYPE_MAP
-          map "number", to: :number
-          map "part", to: :part
-          map "year", with: { to: :year_to_kv, from: :year_from_kv }
+module Pubid
+  module CenPfs
+    # The shared base of every concrete CenPfs class. The
+    # serialization is the shared ::Pubid::Identifier's (the coded
+    # flavor's own shape): flat publisher/copublishers scalars, the
+    # date flattened to its fields, and the draft stage compacted
+    # to its code by the class hooks below.
+    class Identifier < ::Pubid::Identifier
+      # The ETSI-style version suffix ("EN 302 326-2 V2.2.1").
+      attribute :version, :string
+
+      # A published document holds no type, stage or typed stage, so
+      # a nil one means "published", not "any stage": `EN 1325` is
+      # not `prEN 1325`. The three components repeat one entry of
+      # the stage registry, so they move together.
+      subset_strict :type, :stage, :typed_stage
+
+      # The bodies that print as a publisher prefix. The publisher
+      # attribute also holds the deliverable types that ARE the
+      # designation ("CR 954"); those stay under
+      # with_publisher: false, as `BS` does for BSI.
+      PUBLISHER_PREFIXES = ["CEN", "CLC", "CENELEC", "EN", "CWA", "HD", "ES", "CR", "ENV"].freeze
+
+      def publisher_prefixes
+        super.select do |prefix|
+          PUBLISHER_PREFIXES.include?(prefix.split("/").first)
         end
+      end
+
+      # The publisher serializes as a bare string, the copublishers
+      # as a list of strings (the coded flavor's flat-scalar table).
+      def self.flat_scalar_components
+        super.merge(publisher: "publisher", copublishers: "copublishers")
+      end
 
-          # --- date serialized flat (the shared flat-scalar shape) ---
-          def year_to_kv(model, doc)
-            emit_date_part(doc, "year", model.date&.year)
-          end
+      def self.flat_scalar_fields
+        super.merge(publisher: :body, copublishers: :body)
+      end
 
-          def year_from_kv(model, value)
-            date_for(model).year = value.to_s
-          end
+      # The declared draft stages: the serialized code is the key,
+      # the official-URN code the declared `urn:` value.
+      STAGE_CODES = {
+        "pren" => { stage_code: :proposal },
+        "fpren" => { stage_code: :final_proposal },
+      }.freeze
 
-          def emit_date_part(doc, key, val)
-            return if val.nil? || val.to_s.empty?
+      # A draft stage serializes as its typed-stage code
+      # ("stage" => "pren"); #inflate_scalar_components rebuilds
+      # the three components from it (the coded compact-hash shape).
+      def self.compact_hash(model, hash)
+        stage = model.typed_stage
+        return unless stage && hash.key?("typed_stage")
+        return unless model.type == stage.to_type &&
+                      model.stage == stage.to_stage
 
-            doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, val.to_s))
-          end
+        hash.delete("type")
+        hash.delete("typed_stage")
+        hash["stage"] = stage.code.to_s
+      end
 
-          def date_for(model)
-            model.date ||= ::Pubid::Components::Date.new
-          end
+      # Reads the short stage form back; the nested form still
+      # reads as before.
+      def self.inflate_scalar_components(data)
+        data = super
+        return data unless data.is_a?(::Hash) && component_attribute?(:stage)
 
-        PUBLISHER = "CEN"
+        key = data.key?("stage") ? "stage" : :stage
+        value = data[key]
+        return data unless value.is_a?(::String) || value.is_a?(::Symbol)
 
-        # The scheme's declared publisher token: the internal-form
-        # cut (to_s(with_publisher: false)) strips it from the
-        # rendered face.
-        def publisher_prefixes
-          [PUBLISHER]
-        end
+        stage = locate_stage_by_code(value)
+        return data unless stage
+
+        data = data.dup
+        data.delete(key)
+        data["type"] = stage.to_type.to_hash
+        data["stage"] = stage.to_stage.to_hash
+        data["typed_stage"] = stage.to_hash
+        data
+      end
 
-        def self.parse(identifier)
-          unless identifier.is_a?(String)
-            raise Pubid::Errors::InvalidInputError,
-                  Pubid::INPUT_NOT_A_STRING_MESSAGE
-          end
+      # The stage entry by serialized code, or nil.
+      def self.locate_stage_by_code(code)
+        Builder.stage_by_code(code.to_s)
+      end
 
-          if identifier.length > Pubid::MAX_INPUT_LENGTH
-            raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-          end
+      # The draft stage's own code is the MR type segment
+      # ("en.pren.10160"); a published identifier has no typed
+      # stage, so the shared hook answers nil.
+      def mr_type
+        stage = typed_stage
+        return super unless stage && stage.stage_code.to_s != "published"
 
-          identifier = ::Pubid.utf8_input(identifier)
+        stage.code.to_s.downcase
+      end
+
+      def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
 
-          parsed = Pubid::Parg::Model.bound(:cen_pfs, identifier)
-          Builder.build(parsed)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
+
+        identifier = ::Pubid.utf8_input(identifier)
+
+        parsed = Pubid::Parg::Model.bound(:cen_pfs, identifier)
+        Builder.build(parsed)
+      end
+
+      private
+
+      # "amd.1.2005" from ("amd", "1", 2005). A nil or blank
+      # segment is left out.
+      def mr_join_segments(*segments)
+        segments.map(&:to_s).reject(&:empty?).join(".").downcase
       end
     end
   end
+end

data/lib/pubid/cen_pfs/identifiers/adopted_european_norm.rb

@@ -0,0 +1,55 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete Adopted European Norm identifier type (PFS type `adopted_european_norm`).
+      class AdoptedEuropeanNorm < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :aen, web: :adopted_european_norm, title: "Adopted European Norm", short: "EN" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "EN")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The adopted document (feature 4): the whole identity lives
+        # on the nested ISO/IEC identifier.
+        attribute :adopted, ::Pubid::Identifier, polymorphic: true
+
+        def root
+          adopted ? adopted.root : self
+        end
+
+        # MR "cen.iso.ts.21003-7": the publisher group fused, then the
+        # adopted document's own MR string in place of a number.
+        def mr_publisher
+          mr_join(*([publisher] + Array(copublishers)).compact
+            .map { |p| p.to_s.downcase })
+        end
+
+        def mr_number_with_part
+          adopted ? adopted.to_mr_string : super
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:adopted-european-norm"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # The synthesized Amendment wrapper (PFS supplements
+      # declaration, issue #121 feature 3): the kind face
+      # "A" is the run's dispatch token and the
+      # printed notation's face.
+      class Amendment < Supplement
+        FACE = "A".freeze
+
+        def self.face
+          FACE
+        end
+
+        def self.polymorphic_name
+          "pubid:cencenelec:amendment"
+        end
+                            
+                            # The MR slug's supplement suffix: the shared MrString
+                            # recurses into base and appends this.
+                            def mr_supplement_suffix
+                              mr_join_segments("amd", number, year)
+                            end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/cen_report.rb

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete CEN Report identifier type (PFS type `cen_report`).
+      class CenReport < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :cr, web: :cen_report, title: "CEN Report", short: "CR" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "CR")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:cen-report"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/cen_workshop_agreement.rb

@@ -0,0 +1,36 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # Concrete CEN Workshop Agreement identifier type (PFS type `cen_workshop_agreement`).
+      class CenWorkshopAgreement < Identifier
+          TYPED_STAGES = [
+          ].freeze
+
+        def self.type
+          { key: :cwa, web: :cen_workshop_agreement, title: "CEN Workshop Agreement", short: "CWA" }
+        end
+
+        # The publisher default (feature 5): the type's own token
+        # when the type is its designation, else the scheme default.
+        def self.default_publisher
+          ::Pubid::Components::Publisher.new(body: "CWA")
+        end
+
+        attribute :publisher, ::Pubid::Components::Publisher, default: -> { self.class.default_publisher }
+        attribute :type, ::Pubid::Components::Type, default: -> { self.class.default_type }
+
+        def self.default_type
+          ::Pubid::Components::Type.new(abbr: type[:short])
+        end
+
+        # The scheme-canonical wire tag declared in the definition:
+        # to_hash stays byte-identical with the scheme's coded
+        # flavor, and this flavor's own from_hash routes the tag
+        # to this class.
+        def self.polymorphic_name
+          "pubid:cencenelec:cen-workshop-agreement"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/cen_pfs/identifiers/consolidated_identifier.rb

@@ -0,0 +1,41 @@
+module Pubid
+  module CenPfs
+    module Identifiers
+      # The consolidated (plus-run) bundle: the base document is
+      # the first member; the supplements carry no base.
+      class ConsolidatedIdentifier < ::Pubid::CenPfs::Identifier
+        attribute :identifiers, ::Pubid::CenPfs::Identifier,
+                  polymorphic: true, collection: true
+
+        # The origin document. Members live in `identifiers`, so
+        # walk the first member to its root.
+        def root
+          identifiers&.first&.root || self
+        end
+
+        def base_document
+          identifiers&.first&.base_document || self
+        end
+
+        def drop_supplements
+          identifiers&.first || self
+        end
+
+        # The base document, then each member's own supplement
+        # suffix behind the plus marker — the coded shape.
+        def to_mr_string
+          base, *supplements = identifiers
+          return "" unless base
+
+          ([base.to_mr_string] +
+            supplements.map { |s| "plus-#{s.mr_supplement_suffix}" })
+            .join(::Pubid::Renderers::MrString::SEPARATOR_SUPPLEMENT)
+        end
+
+        def self.polymorphic_name
+          "pubid:cencenelec:consolidated-identifier"
+        end
+      end
+    end
+  end
+end