facturx 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61ac3e80ab256d20b48527e6b92bccd30fcc6f0b7d1b87dec452161fd9e916fb
-  data.tar.gz: 35227d6b843d4c7f51608c2d149b4ce456ca854b16a14ed11317dab0ba2f2cfe
+  metadata.gz: e6318d858bdc82dd508e53e66c6f41ea56e455ce55df676b9e5268fa881f7a98
+  data.tar.gz: 8b182edb44be499ec57bb1b0f98ecf892290584c0f959b73e7c787be460188d1
 SHA512:
-  metadata.gz: aa5602b1058a4e5cd06821ea7995d761983b9ddf6cb736e3bcc46e8473230baaf6f215b8f78034f633f19223072b24ce6e474466f5a534801e89516e6d949854
-  data.tar.gz: 3f9504f7f0c04245bd50948d38a1608f1accc18c5bda8dc953229ef60ac4e7cd1071aa15bef81172007e41d6c4eae76cbeaa4999d67d2fb80e52fe9dd00db4da
+  metadata.gz: b529dd611b8f5c71c6aa9b9d9458ffeea4352fee2e62030e74f543a464d008c4b97bd186313b13d7b1966abf4f1614b13b9797729d7ece243aa71045e032e03b
+  data.tar.gz: 4a25ca0ef9d9f4df72150925753a250989316a2a31e171b0b14de85e342950408ebc43d5d4d3150a91863fe07b6a805271bbda7fa3a2f9c2502c68d18111918d

data/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-09-12
+
+### Added
+
+- Read XML or PDF bytes into an immutable, typed EN16931 document model with structured diagnostics.
+- Map the complete EN16931 semantic term set and the MINIMUM, BASIC WL, and BASIC subsets.
+- Verify semantic mapping provenance and official examples with the maintainer reference task.
+
 ## [0.1.0] - 2026-09-11
 
 ### Added
@@ -12,5 +20,6 @@ All notable changes to this project will be documented in this file.
 - Compose PDF/A-3b Factur-X documents with Ghostscript.
 - Extract embedded Factur-X XML from PDF documents.
 
-[Unreleased]: https://github.com/AdVitam/facturx/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/AdVitam/facturx/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/AdVitam/facturx/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/AdVitam/facturx/releases/tag/v0.1.0

data/NOTICE.md

@@ -4,6 +4,8 @@
 
 The gem includes Factur-X 1.09.2 / ZUGFeRD 2.5.2 XSD validation artefacts. Their Apache License 2.0 text, provenance, RubyGems packaging adaptation, and file checksums are packaged under `lib/facturx/schema/`.
 
+The semantic term registry is derived from the official Factur-X 1.09.2 profile workbooks. The workbooks and examples are not redistributed; their expected paths and SHA-256 checksums are recorded in `Facturx::Terms::REFERENCE_FILES` for maintainer verification.
+
 ## Ghostscript
 
 PDF composition invokes a Ghostscript installation supplied by the user. Ghostscript, `zugferd.ps`, and ICC profiles are not part of this gem and remain governed by their respective licences.

data/README.md

@@ -1,6 +1,6 @@
 # facturx
 
-`facturx` validates Factur-X XML, creates PDF/A-3b Factur-X invoices from existing PDFs, and extracts their embedded XML.
+`facturx` reads and validates Factur-X XML, creates PDF/A-3b Factur-X invoices from existing PDFs, and extracts their embedded XML.
 
 The first release supports Factur-X 1.09.2 / ZUGFeRD 2.5.2 with the MINIMUM, BASIC WL, BASIC, EN 16931, and EXTENDED profiles.
 
@@ -28,10 +28,16 @@ pdf = File.binread('invoice.pdf')
 
 Facturx.verify_xml(xml: xml) # => true
 
+reading = Facturx.read(xml)
+reading.document.invoice_number # => "F-2023-004"
+reading.document.totals.grand_total # => BigDecimal("120.00")
+reading.diagnostics # => [] for a complete EN16931 document
+
 facturx_pdf = Facturx.attach(pdf: pdf, xml: xml)
 File.binwrite('invoice-facturx.pdf', facturx_pdf)
 
 embedded_xml = Facturx.extract_xml(pdf: facturx_pdf)
+pdf_reading = Facturx.read(facturx_pdf)
 ```
 
 `verify_xml` infers the profile from BT-24 and validates the document against that profile's XSD. It returns `true` on success and raises a typed `Facturx::Error` on failure.
@@ -40,6 +46,20 @@ embedded_xml = Facturx.extract_xml(pdf: facturx_pdf)
 
 `extract_xml` returns the embedded bytes without validating them. This allows callers to inspect non-conforming invoices received from third parties and explicitly call `verify_xml` when appropriate.
 
+`read` accepts either XML or PDF bytes and returns an immutable `Facturx::Reading`. Its `document` contains typed immutable values: dates are `Date`, decimals are `BigDecimal`, identifiers retain their schemes, and repeating groups are frozen arrays in XML order. `source` always contains the exact embedded XML bytes and `source_type` is either `:xml` or `:pdf`.
+
+Reading is intentionally tolerant and never performs implicit XSD validation. Missing, duplicate, empty, invalid, or unmapped values are reported through immutable diagnostics while usable fields remain accessible. Call `verify_xml` separately when strict structural validation is required.
+
+Unknown or missing BT-24 values fall back to the EN16931 intersection supported for EXTENDED documents and add a diagnostic. Pass `on_unknown_profile: :raise` to reject them instead:
+
+```ruby
+Facturx.read(xml, on_unknown_profile: :raise)
+```
+
+The semantic registry covers all 184 EN16931 business terms and the MINIMUM, BASIC WL, and BASIC subsets. EXTENDED-only fields remain available in `Reading#source` and are reported as unmapped until their model is added.
+
+Reading is not a fidelity round-trip. To reissue an incoming invoice, retain and reuse `Reading#source`; a future writer built from `Reading#document` cannot reproduce fields outside the semantic model.
+
 The byte-string API materializes PDF streams in memory. Process untrusted PDFs in a resource-limited worker; limiting only the input file size does not prevent amplification by a compressed embedded stream.
 
 ## Ghostscript discovery
@@ -70,6 +90,12 @@ bundle exec rspec
 bundle exec rake build
 ```
 
+Maintainers can verify the registry hashes, D22B element names, semantic diagnostics, official XML examples, and paired PDF attachments against an extracted upstream package:
+
+```bash
+FACTURX_REFERENCE_ROOT=/path/to/ZUGFeRD_2.5.2_EN bundle exec rake reference:verify
+```
+
 ## License
 
 The gem code is available under the MIT License. Bundled standard artefacts retain their respective upstream notices; see `NOTICE.md`.

data/lib/facturx/coerce.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'date'
+require_relative 'error'
+
+module Facturx
+  class CoercionError < Error; end
+
+  module Coerce
+    CONVERTERS = {
+      string: :string,
+      date_102: :formatted_date,
+      decimal: :decimal,
+      boolean: :boolean,
+      binary: :binary
+    }.freeze
+
+    module_function
+
+    def call(value, type:, scale: nil, **context)
+      return if value.nil?
+
+      converter = CONVERTERS[type]
+      raise ArgumentError, "Unsupported coercion type: #{type.inspect}" unless converter
+
+      begin
+        public_send(converter, value, context)
+      rescue ArgumentError, TypeError => e
+        raise CoercionError.new('Value cannot be coerced', value:, type:, scale:, **context), cause: e
+      end
+    end
+
+    def string(value, _context = nil)
+      raise TypeError, 'expected a String' unless value.is_a?(String)
+
+      value.dup.freeze
+    end
+
+    def decimal(value, _context = nil)
+      raise TypeError, 'Float values are not supported' if value.is_a?(Float)
+      return value if value.is_a?(BigDecimal)
+
+      decimal = BigDecimal(value.to_s, exception: true)
+      raise ArgumentError, 'decimal must be finite' unless decimal.finite?
+
+      decimal
+    end
+
+    def formatted_date(value, _context = nil)
+      return value.dup.freeze if value.is_a?(Date)
+
+      text = string(value)
+      raise ArgumentError, 'date must use format 102' unless text.match?(/\A\d{8}\z/)
+
+      Date.strptime(text, '%Y%m%d').freeze
+    end
+
+    def boolean(value, _context = nil)
+      return value if [true, false].include?(value)
+
+      case string(value)
+      when 'true', '1' then true
+      when 'false', '0' then false
+      else raise ArgumentError, 'boolean must be true, false, 1, or 0'
+      end
+    end
+
+    def binary(value, _context = nil)
+      encoded = string(value).delete(" \t\r\n")
+      encoded.unpack1('m0').force_encoding(Encoding::BINARY).freeze
+    end
+  end
+end

data/lib/facturx/diagnostic.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'model/immutable'
+
+module Facturx
+  Diagnostic = Data.define(:code, :term_id, :path, :message, :details) do
+    include Model::ValidatedWith
+
+    def initialize(code:, message:, term_id: nil, path: nil, details: {})
+      raise TypeError, 'details must be a Hash' unless details.is_a?(Hash)
+
+      bounded_details = details.to_h do |key, value|
+        [key, value.is_a?(String) ? value.byteslice(0, 200).scrub('') : value]
+      end
+      super(code: Model.copy_and_freeze(code), term_id: Model.copy_and_freeze(term_id),
+            path: Model.copy_and_freeze(path), message: Model.copy_and_freeze(message),
+            details: Model.copy_and_freeze(bounded_details))
+    end
+  end
+end

data/lib/facturx/document.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'model'
+
+module Facturx
+  Document = Model.define(
+    :guideline_urn,
+    :business_process,
+    :invoice_number,
+    :issue_date,
+    :type_code,
+    :currency,
+    :tax_currency,
+    :vat_point_date,
+    :vat_point_date_code,
+    :payment_due_date,
+    :buyer_reference,
+    :project_reference,
+    :contract_reference,
+    :purchase_order_reference,
+    :sales_order_reference,
+    :receiving_advice_reference,
+    :despatch_advice_reference,
+    :tender_or_lot_reference,
+    :invoiced_object_identifier,
+    :buyer_accounting_reference,
+    :payment_terms,
+    :notes,
+    :seller,
+    :buyer,
+    :payee,
+    :tax_representative,
+    :delivery,
+    :billing_period,
+    :payment,
+    :lines,
+    :tax_breakdowns,
+    :allowances,
+    :charges,
+    :totals,
+    :preceding_invoices,
+    :supporting_documents,
+    collections: %i[notes lines tax_breakdowns allowances charges preceding_invoices supporting_documents]
+  )
+end

data/lib/facturx/group.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Facturx
+  Group = Data.define(:id, :model, :attribute, :parent_id, :xpath, :cardinalities)
+end

data/lib/facturx/model/common.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Facturx
+  Note = Model.define(:content, :subject_code)
+  Identifier = Model.define(:value, :scheme_id)
+  Period = Model.define(:start_date, :end_date)
+  Quantity = Model.define(:value, :unit_code)
+end

data/lib/facturx/model/immutable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Facturx
+  module Model
+    module Immutability
+      module_function
+
+      def copy(value)
+        case value
+        when Float then raise TypeError, 'Float values are not supported; use BigDecimal for decimal values'
+        when String then value.dup.freeze
+        when Array then value.map { |item| copy(item) }.freeze
+        when Hash then value.to_h { |key, item| [copy(key), copy(item)] }.freeze
+        else copy_object(value)
+        end
+      end
+
+      def copy_object(value)
+        immutable = value.nil? || value == true || value == false || value.is_a?(Numeric) || value.is_a?(Symbol)
+        return value if immutable || value.frozen?
+
+        value.dup.freeze
+      end
+    end
+
+    module ValidatedWith
+      def with(**attributes)
+        self.class.new(**to_h, **attributes)
+      end
+    end
+
+    MISSING = Object.new.freeze
+    private_constant :MISSING
+
+    module_function
+
+    def define(*members, collections: [])
+      collection_members = collections.map(&:to_sym).freeze
+
+      Data.define(*members) do
+        include ValidatedWith
+
+        define_method(:initialize) do |**attributes|
+          normalized = Model.normalize_attributes(self.class.members, collection_members, attributes)
+          super(**normalized)
+        end
+      end
+    end
+
+    def normalize_attributes(members, collections, attributes)
+      validate_attributes!(members, attributes)
+      members.to_h do |member|
+        value = attributes.fetch(member, MISSING)
+        [member, normalize_value(member, value, collections.include?(member))]
+      end
+    end
+
+    def validate_attributes!(members, attributes)
+      unknown = attributes.keys - members
+      raise ArgumentError, "Unknown attributes: #{unknown.map(&:inspect).join(', ')}" unless unknown.empty?
+    end
+
+    def normalize_value(member, value, collection)
+      value = nil if value.equal?(MISSING)
+      value = [] if collection && value.nil?
+      raise TypeError, "#{member} must be an Array" if collection && !value.is_a?(Array)
+
+      copy_and_freeze(value)
+    end
+
+    def copy_and_freeze(value)
+      Immutability.copy(value)
+    end
+  end
+end

data/lib/facturx/model/line.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facturx
+  ProductAttribute = Model.define(:name, :value)
+  ProductClassification = Model.define(:code, :list_id, :list_version_id)
+  Product = Model.define(:name, :description, :seller_identifier, :buyer_identifier, :global_identifier,
+                         :origin_country_code, :attributes, :classifications,
+                         collections: %i[attributes classifications])
+  Price = Model.define(:amount, :basis_quantity, :discount)
+  Line = Model.define(:id, :note, :product, :quantity, :gross_price, :net_price, :tax, :period, :net_amount,
+                      :allowances, :charges, :buyer_order_reference, :buyer_accounting_reference,
+                      :invoiced_object_identifier,
+                      collections: %i[allowances charges])
+end

data/lib/facturx/model/party.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Facturx
+  Contact = Model.define(:name, :telephone, :email)
+  Address = Model.define(:postcode, :line_one, :line_two, :line_three, :city, :country_code,
+                         :country_subdivision)
+  Party = Model.define(:identifiers, :name, :description, :legal_registration, :trading_name, :address,
+                       :vat_identifier, :tax_identifier, :electronic_address, :contact,
+                       collections: [:identifiers])
+end

data/lib/facturx/model/payment.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Facturx
+  CreditTransfer = Model.define(:account_identifier, :account_name, :provider_identifier)
+  PaymentCard = Model.define(:primary_account_number, :holder_name)
+  DirectDebit = Model.define(:mandate_identifier, :creditor_identifier, :debtor_account_identifier)
+  PaymentInstructions = Model.define(:means_code, :means_text, :remittance_information, :credit_transfers,
+                                     :payment_card, :direct_debit, collections: [:credit_transfers])
+end

data/lib/facturx/model/reference.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Facturx
+  DocumentReference = Model.define(:id, :line_id, :name, :issue_date)
+  Delivery = Model.define(:location_identifier, :party, :date)
+  SupportingDocument = Model.define(:reference, :description, :external_location, :content, :mime_code, :filename)
+end

data/lib/facturx/model/trade.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Facturx
+  TaxBreakdown = Model.define(:type_code, :category_code, :rate, :basis_amount, :tax_amount,
+                              :exemption_reason, :exemption_reason_code, :due_date_type_code)
+  AllowanceCharge = Model.define(:indicator, :amount, :base_amount, :percentage, :reason, :reason_code, :tax)
+  Totals = Model.define(:line_total, :charge_total, :allowance_total, :tax_basis_total, :tax_total,
+                        :tax_total_in_tax_currency, :grand_total, :prepaid, :rounding, :due_payable)
+end

data/lib/facturx/model.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'model/immutable'
+require_relative 'model/common'
+require_relative 'model/party'
+require_relative 'model/reference'
+require_relative 'model/payment'
+require_relative 'model/trade'
+require_relative 'model/line'

data/lib/facturx/pdf/extractor.rb

@@ -7,6 +7,7 @@ require_relative '../embedding'
 module Facturx
   module Pdf
     class Extractor
+      ACCEPTED_RELATIONSHIPS = %i[Alternative Data].freeze
       Result = Data.define(:xml, :filename, :relationship, :metadata, :page_count)
       Candidate = Data.define(:file_specification, :names)
 
@@ -31,7 +32,7 @@ module Facturx
 
         Result.new(xml: embedded_xml(document, file_specification),
                    filename: FACTURX_EMBEDDING.filename,
-                   relationship: FACTURX_EMBEDDING.relationship,
+                   relationship: file_specification[:AFRelationship],
                    metadata: document.metadata,
                    page_count: document.page_count)
       end
@@ -50,7 +51,9 @@ module Facturx
       end
 
       def matching_candidates(candidates)
-        candidates.select { |candidate| candidate.names.include?(FACTURX_EMBEDDING.filename) }
+        candidates
+          .select { |candidate| candidate.names.include?(FACTURX_EMBEDDING.filename) }
+          .uniq { |candidate| candidate.file_specification.object_id }
       end
 
       def associated_file_candidates(document)
@@ -93,9 +96,9 @@ module Facturx
       end
 
       def validate_relationship!(file_specification)
-        return if file_specification[:AFRelationship] == FACTURX_EMBEDDING.relationship
+        return if ACCEPTED_RELATIONSHIPS.include?(file_specification[:AFRelationship])
 
-        raise ExtractionError.new('Factur-X attachment must use the Alternative relationship',
+        raise ExtractionError.new('Factur-X attachment uses an unsupported relationship',
                                   reason: :invalid_relationship,
                                   relationship: file_specification[:AFRelationship])
       end

data/lib/facturx/reader/semantic_mapper/delivery_mapping.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Reader
+    class SemanticMapper
+      private
+
+      def delivery
+        node = first_group('BG-13-00')
+        return unless node
+
+        base = group_xpath('BG-13-00')
+        party_node = first_group('BG-13', context: node, base_xpath: base)
+        party = delivery_party(party_node) if party_node
+        Delivery.new(
+          location_identifier: party_node && delivery_identifier(party_node),
+          party:,
+          date: value('BT-72', context: node, base_xpath: base)
+        )
+      end
+
+      def delivery_party(node)
+        base = group_xpath('BG-13')
+        Party.new(
+          name: value('BT-70', context: node, base_xpath: base),
+          address: address(node, base, 'BG-15')
+        )
+      end
+
+      def delivery_identifier(node)
+        base = group_xpath('BG-13')
+        global_id = node.at_xpath('./ram:GlobalID', NAMESPACES)
+        @terms.mark(global_id) if global_id
+        local_id = value('BT-71', context: node, base_xpath: base)
+        return Identifier.new(value: local_id) if local_id
+
+        return unless global_id
+
+        Identifier.new(value: global_id.text, scheme_id: global_id['schemeID'])
+      end
+    end
+  end
+end

data/lib/facturx/reader/semantic_mapper/document_mapping.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Facturx
+  class Reader
+    class SemanticMapper
+      DOCUMENT_REFERENCE_ATTRIBUTES = %i[
+        sales_order_reference purchase_order_reference contract_reference receiving_advice_reference
+        despatch_advice_reference
+      ].freeze
+      DOCUMENT_COMPOSITE_ATTRIBUTES = [
+        *DOCUMENT_REFERENCE_ATTRIBUTES, :tender_or_lot_reference, :invoiced_object_identifier, :project_reference
+      ].freeze
+
+      private
+
+      def document_attributes(tax_breakdowns)
+        scalar_document_attributes(tax_breakdowns).merge(
+          reference_document_attributes,
+          tender_or_lot_reference: additional_reference(:tender_or_lot_reference, type_code: '50'),
+          invoiced_object_identifier: invoiced_object_identifier,
+          project_reference: project_reference
+        )
+      end
+
+      def scalar_document_attributes(tax_breakdowns)
+        attributes = [nil, 'BG-2', 'BG-19'].each_with_object({}) do |group_id, result|
+          result.merge!(scalar_attributes(:document, group_id, except: DOCUMENT_COMPOSITE_ATTRIBUTES))
+        end
+        attributes.merge(vat_point_date: tax_breakdowns.vat_point_date,
+                         vat_point_date_code: tax_breakdowns.items.find(&:due_date_type_code)&.due_date_type_code)
+      end
+
+      def reference_document_attributes
+        DOCUMENT_REFERENCE_ATTRIBUTES.to_h do |attribute|
+          [attribute, reference(term_for_attribute(:document, attribute)&.id)]
+        end
+      end
+
+      def notes
+        group_nodes('BG-1').map do |node|
+          Note.new(**scalar_attributes(:note, 'BG-1', context: node, base_xpath: group_xpath('BG-1')))
+        end
+      end
+
+      def preceding_invoices
+        group_nodes('BG-3').map do |node|
+          base = group_xpath('BG-3')
+          DocumentReference.new(**scalar_attributes(:document_reference, 'BG-3', context: node, base_xpath: base))
+        end
+      end
+
+      def supporting_documents
+        group_nodes('BG-24') { |node| supporting_document?(node) }.map do |node|
+          base = group_xpath('BG-24')
+          SupportingDocument.new(**supporting_document_attributes(node, base))
+        end
+      end
+
+      def supporting_document_attributes(node, base)
+        binary = %i[content mime_code filename]
+        attributes = scalar_attributes(:supporting_document, 'BG-24', context: node, base_xpath: base, except: binary)
+        attributes.merge!(embedded_document_attributes(node, base)) if node.at_xpath('./ram:AttachmentBinaryObject',
+                                                                                     NAMESPACES)
+        attributes
+      end
+
+      def embedded_document_attributes(node, base)
+        scalar_attributes(:supporting_document, 'BG-24', context: node, base_xpath: base,
+                                                         only: %i[content mime_code filename])
+      end
+
+      def supporting_document?(node)
+        technical_value('./ram:TypeCode', node) == '916'
+      end
+
+      def additional_reference(attribute, type_code:)
+        node = @document.at_xpath("#{group_xpath('BG-24')}[ram:TypeCode='#{type_code}']", NAMESPACES)
+        return unless node
+
+        technical_value('./ram:TypeCode', node)
+        term = term_for_attribute(:document, attribute)
+        reference(term&.id, context: node, base_xpath: group_xpath('BG-24'))
+      end
+
+      def invoiced_object_identifier
+        node = @document.at_xpath("#{group_xpath('BG-24')}[ram:TypeCode='130']", NAMESPACES)
+        return unless node
+
+        technical_value('./ram:TypeCode', node)
+        value_term = term_for_attribute(:document, :invoiced_object_identifier, xpath_suffix: '/ram:IssuerAssignedID')
+        scheme_term = term_for_attribute(:document, :invoiced_object_identifier, xpath_suffix: '/ram:ReferenceTypeCode')
+        identifier(value_term&.id, scheme_term&.id, context: node, base_xpath: group_xpath('BG-24'))
+      end
+
+      def project_reference
+        node = @document.at_xpath(
+          '/rsm:CrossIndustryInvoice/rsm:SupplyChainTradeTransaction/' \
+          'ram:ApplicableHeaderTradeAgreement/ram:SpecifiedProcuringProject',
+          NAMESPACES
+        )
+        return unless node
+
+        id = value(term_for_attribute(:document, :project_reference)&.id)
+        name = technical_value('./ram:Name', node)
+        DocumentReference.new(id:, name:)
+      end
+    end
+  end
+end