zugpferd 0.1.0

data/lib/zugpferd/ubl/reader.rb

@@ -0,0 +1,218 @@
+require "nokogiri"
+require "date"
+require "bigdecimal"
+require_relative "mapping"
+
+module Zugpferd
+  module UBL
+    # Reads UBL 2.1 Invoice XML into {Model::Invoice}.
+    #
+    # @example
+    #   invoice = Zugpferd::UBL::Reader.new.read(File.read("invoice.xml"))
+    class Reader
+      include Mapping
+
+      # Parses a UBL 2.1 Invoice XML string.
+      #
+      # @param xml_string [String] valid UBL 2.1 Invoice XML
+      # @return [Model::Invoice]
+      # @raise [Nokogiri::XML::SyntaxError] if the XML is malformed
+      def read(xml_string)
+        doc = Nokogiri::XML(xml_string) { |config| config.strict }
+        root = doc.root
+        build_invoice(root)
+      end
+
+      private
+
+      def build_invoice(root)
+        Model::Invoice.new(
+          number: text(root, INVOICE[:number]),
+          issue_date: parse_date(text(root, INVOICE[:issue_date])),
+          due_date: parse_date(text(root, INVOICE[:due_date])),
+          type_code: text(root, INVOICE[:type_code]),
+          currency_code: text(root, INVOICE[:currency_code]),
+          buyer_reference: text(root, INVOICE[:buyer_reference]),
+          customization_id: text(root, INVOICE[:customization_id]),
+          profile_id: text(root, INVOICE[:profile_id]),
+          note: text(root, INVOICE[:note]),
+          seller: build_party(root.at_xpath(SELLER, NS)),
+          buyer: build_party(root.at_xpath(BUYER, NS)),
+          line_items: root.xpath(INVOICE_LINE, NS).map { |n| build_line_item(n) },
+          allowance_charges: root.xpath(ALLOWANCE_CHARGE, NS).map { |n| build_allowance_charge(n) },
+          tax_breakdown: build_tax_breakdown(root.at_xpath(TAX_TOTAL, NS)),
+          monetary_totals: build_monetary_totals(root.at_xpath(MONETARY_TOTAL, NS)),
+          payment_instructions: build_payment_instructions(root),
+        )
+      end
+
+      def build_party(node)
+        return nil unless node
+
+        party = Model::TradeParty.new(
+          name: text(node, PARTY[:name]),
+          trading_name: text(node, PARTY[:trading_name]),
+          identifier: text(node, PARTY[:identifier]),
+          legal_registration_id: text(node, PARTY[:legal_registration_id]),
+          legal_form: text(node, PARTY[:legal_form]),
+          vat_identifier: text(node, PARTY[:vat_identifier]),
+          electronic_address: text(node, PARTY[:electronic_address]),
+        )
+
+        endpoint = node.at_xpath(PARTY[:electronic_address], NS)
+        party.electronic_address_scheme = endpoint["schemeID"] if endpoint
+
+        addr_node = node.at_xpath(POSTAL_ADDRESS, NS)
+        party.postal_address = build_postal_address(addr_node) if addr_node
+
+        contact_node = node.at_xpath(CONTACT, NS)
+        party.contact = build_contact(contact_node) if contact_node
+
+        party
+      end
+
+      def build_postal_address(node)
+        Model::PostalAddress.new(
+          country_code: text(node, ADDRESS[:country_code]),
+          street_name: text(node, ADDRESS[:street_name]),
+          city_name: text(node, ADDRESS[:city_name]),
+          postal_zone: text(node, ADDRESS[:postal_zone]),
+        )
+      end
+
+      def build_contact(node)
+        Model::Contact.new(
+          name: text(node, CONTACT_FIELDS[:name]),
+          telephone: text(node, CONTACT_FIELDS[:telephone]),
+          email: text(node, CONTACT_FIELDS[:email]),
+        )
+      end
+
+      def build_payment_instructions(root)
+        means_node = root.at_xpath(PAYMENT_MEANS, NS)
+        return nil unless means_node
+
+        # BT-90: In UBL, creditor reference is a PartyIdentification with schemeID="SEPA" on the seller
+        creditor_ref = root.at_xpath(
+          "#{SELLER}/cac:PartyIdentification/cbc:ID[@schemeID='SEPA']", NS
+        )&.text
+
+        Model::PaymentInstructions.new(
+          payment_means_code: text(means_node, PAYMENT[:payment_means_code]),
+          payment_id: text(means_node, PAYMENT[:payment_id]),
+          account_id: text(means_node, PAYMENT[:account_id]),
+          card_account_id: text(means_node, PAYMENT[:card_account_id]),
+          card_network_id: text(means_node, PAYMENT[:card_network_id]),
+          card_holder_name: text(means_node, PAYMENT[:card_holder_name]),
+          mandate_reference: text(means_node, PAYMENT[:mandate_reference]),
+          debited_account_id: text(means_node, PAYMENT[:debited_account_id]),
+          creditor_reference_id: creditor_ref,
+          note: text(root, PAYMENT_TERMS_NOTE),
+        )
+      end
+
+      def build_tax_breakdown(node)
+        return nil unless node
+
+        currency = node.at_xpath("cbc:TaxAmount/@currencyID", NS)&.text
+
+        breakdown = Model::TaxBreakdown.new(
+          tax_amount: text(node, "cbc:TaxAmount"),
+          currency_code: currency,
+        )
+
+        breakdown.subtotals = node.xpath(TAX_SUBTOTAL, NS).map do |sub|
+          sub_currency = sub.at_xpath("cbc:TaxableAmount/@currencyID", NS)&.text
+          Model::TaxSubtotal.new(
+            taxable_amount: text(sub, TAX[:taxable_amount]),
+            tax_amount: text(sub, TAX[:tax_amount]),
+            category_code: text(sub, TAX[:category_code]),
+            percent: parse_decimal(text(sub, TAX[:percent])),
+            currency_code: sub_currency,
+            exemption_reason: text(sub, TAX[:exemption_reason]),
+            exemption_reason_code: text(sub, TAX[:exemption_reason_code]),
+          )
+        end
+
+        breakdown
+      end
+
+      def build_monetary_totals(node)
+        return nil unless node
+
+        Model::MonetaryTotals.new(
+          line_extension_amount: text(node, TOTALS[:line_extension_amount]),
+          tax_exclusive_amount: text(node, TOTALS[:tax_exclusive_amount]),
+          tax_inclusive_amount: text(node, TOTALS[:tax_inclusive_amount]),
+          prepaid_amount: parse_decimal(text(node, TOTALS[:prepaid_amount])),
+          payable_rounding_amount: parse_decimal(text(node, TOTALS[:payable_rounding_amount])),
+          allowance_total_amount: parse_decimal(text(node, TOTALS[:allowance_total_amount])),
+          charge_total_amount: parse_decimal(text(node, TOTALS[:charge_total_amount])),
+          payable_amount: text(node, TOTALS[:payable_amount]),
+        )
+      end
+
+      def build_line_item(node)
+        item_node = node.at_xpath(ITEM, NS)
+        price_node = node.at_xpath(PRICE, NS)
+
+        Model::LineItem.new(
+          id: text(node, LINE[:id]),
+          invoiced_quantity: text(node, LINE[:invoiced_quantity]),
+          unit_code: node.at_xpath(LINE[:unit_code], NS)&.text,
+          line_extension_amount: text(node, LINE[:line_extension_amount]),
+          note: text(node, LINE[:note]),
+          item: build_item(item_node),
+          price: build_price(price_node),
+        )
+      end
+
+      def build_item(node)
+        return nil unless node
+
+        Model::Item.new(
+          name: text(node, ITEM_FIELDS[:name]),
+          description: text(node, ITEM_FIELDS[:description]),
+          sellers_identifier: text(node, ITEM_FIELDS[:sellers_identifier]),
+          tax_category: text(node, ITEM_FIELDS[:tax_category]),
+          tax_percent: parse_decimal(text(node, ITEM_FIELDS[:tax_percent])),
+        )
+      end
+
+      def build_price(node)
+        return nil unless node
+
+        Model::Price.new(
+          amount: text(node, PRICE_FIELDS[:amount]),
+        )
+      end
+
+      def build_allowance_charge(node)
+        currency = node.at_xpath("cbc:Amount/@currencyID", NS)&.text
+        Model::AllowanceCharge.new(
+          charge_indicator: text(node, ALLOWANCE_CHARGE_FIELDS[:charge_indicator]) == "true",
+          reason: text(node, ALLOWANCE_CHARGE_FIELDS[:reason]),
+          reason_code: text(node, ALLOWANCE_CHARGE_FIELDS[:reason_code]),
+          amount: text(node, ALLOWANCE_CHARGE_FIELDS[:amount]),
+          base_amount: parse_decimal(text(node, ALLOWANCE_CHARGE_FIELDS[:base_amount])),
+          multiplier_factor: parse_decimal(text(node, ALLOWANCE_CHARGE_FIELDS[:multiplier_factor])),
+          tax_category_code: text(node, ALLOWANCE_CHARGE_FIELDS[:tax_category_code]),
+          tax_percent: parse_decimal(text(node, ALLOWANCE_CHARGE_FIELDS[:tax_percent])),
+          currency_code: currency,
+        )
+      end
+
+      def text(node, xpath)
+        node.at_xpath(xpath, NS)&.text
+      end
+
+      def parse_date(str)
+        Date.parse(str) if str
+      end
+
+      def parse_decimal(str)
+        BigDecimal(str) if str
+      end
+    end
+  end
+end

data/lib/zugpferd/ubl/writer.rb

@@ -0,0 +1,286 @@
+require "nokogiri"
+require_relative "mapping"
+
+module Zugpferd
+  module UBL
+    # Writes {Model::Invoice} to UBL 2.1 Invoice XML.
+    #
+    # @example
+    #   xml = Zugpferd::UBL::Writer.new.write(invoice)
+    class Writer
+      include Mapping
+
+      # Serializes an invoice to UBL 2.1 XML.
+      #
+      # @param invoice [Model::Invoice] the invoice to serialize
+      # @return [String] UTF-8 encoded XML string
+      def write(invoice)
+        builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          xml.Invoice(xmlns: NS["ubl"],
+                      "xmlns:cac" => NS["cac"],
+                      "xmlns:cbc" => NS["cbc"]) do
+            build_invoice(xml, invoice)
+          end
+        end
+        builder.to_xml
+      end
+
+      private
+
+      def build_invoice(xml, inv)
+        xml["cbc"].CustomizationID inv.customization_id if inv.customization_id
+        xml["cbc"].ProfileID inv.profile_id if inv.profile_id
+        xml["cbc"].ID inv.number
+        xml["cbc"].IssueDate inv.issue_date.to_s
+        xml["cbc"].DueDate inv.due_date.to_s if inv.due_date
+        xml["cbc"].InvoiceTypeCode inv.type_code
+        xml["cbc"].Note inv.note if inv.note
+        xml["cbc"].DocumentCurrencyCode inv.currency_code
+        xml["cbc"].BuyerReference inv.buyer_reference if inv.buyer_reference
+
+        build_supplier(xml, inv.seller, inv.payment_instructions) if inv.seller
+        build_customer(xml, inv.buyer) if inv.buyer
+        build_payment_means(xml, inv.payment_instructions) if inv.payment_instructions
+        build_payment_terms(xml, inv.payment_instructions) if inv.payment_instructions&.note
+        inv.allowance_charges.each { |ac| build_allowance_charge(xml, ac, inv.currency_code) }
+        build_tax_total(xml, inv.tax_breakdown) if inv.tax_breakdown
+        build_monetary_total(xml, inv.monetary_totals, inv.currency_code) if inv.monetary_totals
+        inv.line_items.each { |li| build_invoice_line(xml, li, inv.currency_code) }
+      end
+
+      def build_supplier(xml, party, payment_instructions = nil)
+        xml["cac"].AccountingSupplierParty do
+          build_party(xml, party,
+            creditor_reference_id: payment_instructions&.creditor_reference_id)
+        end
+      end
+
+      def build_customer(xml, party)
+        xml["cac"].AccountingCustomerParty do
+          build_party(xml, party)
+        end
+      end
+
+      def build_party(xml, party, creditor_reference_id: nil)
+        xml["cac"].Party do
+          if party.electronic_address
+            attrs = {}
+            attrs[:schemeID] = party.electronic_address_scheme if party.electronic_address_scheme
+            xml["cbc"].EndpointID(party.electronic_address, attrs)
+          end
+
+          if party.identifier
+            xml["cac"].PartyIdentification do
+              xml["cbc"].ID party.identifier
+            end
+          end
+
+          if creditor_reference_id
+            xml["cac"].PartyIdentification do
+              xml["cbc"].ID(creditor_reference_id, schemeID: "SEPA")
+            end
+          end
+
+          if party.trading_name
+            xml["cac"].PartyName do
+              xml["cbc"].Name party.trading_name
+            end
+          end
+
+          build_postal_address(xml, party.postal_address) if party.postal_address
+
+          if party.vat_identifier
+            xml["cac"].PartyTaxScheme do
+              xml["cbc"].CompanyID party.vat_identifier
+              xml["cac"].TaxScheme do
+                xml["cbc"].ID "VAT"
+              end
+            end
+          end
+
+          xml["cac"].PartyLegalEntity do
+            xml["cbc"].RegistrationName party.name
+            xml["cbc"].CompanyID party.legal_registration_id if party.legal_registration_id
+            xml["cbc"].CompanyLegalForm party.legal_form if party.legal_form
+          end
+
+          build_contact(xml, party.contact) if party.contact
+        end
+      end
+
+      def build_postal_address(xml, addr)
+        xml["cac"].PostalAddress do
+          xml["cbc"].StreetName addr.street_name if addr.street_name
+          xml["cbc"].CityName addr.city_name if addr.city_name
+          xml["cbc"].PostalZone addr.postal_zone if addr.postal_zone
+          xml["cac"].Country do
+            xml["cbc"].IdentificationCode addr.country_code
+          end
+        end
+      end
+
+      def build_contact(xml, contact)
+        xml["cac"].Contact do
+          xml["cbc"].Name contact.name if contact.name
+          xml["cbc"].Telephone contact.telephone if contact.telephone
+          xml["cbc"].ElectronicMail contact.email if contact.email
+        end
+      end
+
+      def build_payment_means(xml, payment)
+        xml["cac"].PaymentMeans do
+          xml["cbc"].PaymentMeansCode payment.payment_means_code
+          xml["cbc"].PaymentID payment.payment_id if payment.payment_id
+          if payment.card_account_id
+            xml["cac"].CardAccount do
+              xml["cbc"].PrimaryAccountNumberID payment.card_account_id
+              xml["cbc"].NetworkID(payment.card_network_id || "mapped-from-cii")
+              xml["cbc"].HolderName payment.card_holder_name if payment.card_holder_name
+            end
+          end
+          if payment.account_id
+            xml["cac"].PayeeFinancialAccount do
+              xml["cbc"].ID payment.account_id
+            end
+          end
+          if payment.mandate_reference
+            xml["cac"].PaymentMandate do
+              xml["cbc"].ID payment.mandate_reference
+              if payment.debited_account_id
+                xml["cac"].PayerFinancialAccount do
+                  xml["cbc"].ID payment.debited_account_id
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def build_payment_terms(xml, payment)
+        xml["cac"].PaymentTerms do
+          xml["cbc"].Note payment.note
+        end
+      end
+
+      def build_tax_total(xml, breakdown)
+        xml["cac"].TaxTotal do
+          xml["cbc"].TaxAmount(format_decimal(breakdown.tax_amount),
+                               currencyID: breakdown.currency_code)
+          breakdown.subtotals.each do |sub|
+            xml["cac"].TaxSubtotal do
+              xml["cbc"].TaxableAmount(format_decimal(sub.taxable_amount),
+                                       currencyID: sub.currency_code)
+              xml["cbc"].TaxAmount(format_decimal(sub.tax_amount),
+                                   currencyID: sub.currency_code)
+              xml["cac"].TaxCategory do
+                xml["cbc"].ID sub.category_code
+                xml["cbc"].Percent format_decimal(sub.percent) if sub.percent
+                xml["cbc"].TaxExemptionReasonCode sub.exemption_reason_code if sub.exemption_reason_code
+                xml["cbc"].TaxExemptionReason sub.exemption_reason if sub.exemption_reason
+                xml["cac"].TaxScheme do
+                  xml["cbc"].ID "VAT"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def build_monetary_total(xml, totals, currency_code)
+        xml["cac"].LegalMonetaryTotal do
+          xml["cbc"].LineExtensionAmount(format_decimal(totals.line_extension_amount),
+                                         currencyID: currency_code)
+          xml["cbc"].TaxExclusiveAmount(format_decimal(totals.tax_exclusive_amount),
+                                        currencyID: currency_code)
+          xml["cbc"].TaxInclusiveAmount(format_decimal(totals.tax_inclusive_amount),
+                                        currencyID: currency_code)
+          if totals.allowance_total_amount
+            xml["cbc"].AllowanceTotalAmount(format_decimal(totals.allowance_total_amount),
+                                            currencyID: currency_code)
+          end
+          if totals.charge_total_amount
+            xml["cbc"].ChargeTotalAmount(format_decimal(totals.charge_total_amount),
+                                          currencyID: currency_code)
+          end
+          if totals.prepaid_amount
+            xml["cbc"].PrepaidAmount(format_decimal(totals.prepaid_amount),
+                                     currencyID: currency_code)
+          end
+          if totals.payable_rounding_amount
+            xml["cbc"].PayableRoundingAmount(format_decimal(totals.payable_rounding_amount),
+                                              currencyID: currency_code)
+          end
+          xml["cbc"].PayableAmount(format_decimal(totals.payable_amount),
+                                   currencyID: currency_code)
+        end
+      end
+
+      def build_allowance_charge(xml, ac, currency_code)
+        xml["cac"].AllowanceCharge do
+          xml["cbc"].ChargeIndicator ac.charge_indicator.to_s
+          xml["cbc"].AllowanceChargeReasonCode ac.reason_code if ac.reason_code
+          xml["cbc"].AllowanceChargeReason ac.reason if ac.reason
+          xml["cbc"].MultiplierFactorNumeric format_decimal(ac.multiplier_factor) if ac.multiplier_factor
+          xml["cbc"].Amount(format_decimal(ac.amount), currencyID: currency_code)
+          xml["cbc"].BaseAmount(format_decimal(ac.base_amount), currencyID: currency_code) if ac.base_amount
+          if ac.tax_category_code
+            xml["cac"].TaxCategory do
+              xml["cbc"].ID ac.tax_category_code
+              xml["cbc"].Percent format_decimal(ac.tax_percent) if ac.tax_percent
+              xml["cac"].TaxScheme do
+                xml["cbc"].ID "VAT"
+              end
+            end
+          end
+        end
+      end
+
+      def build_invoice_line(xml, line, currency_code)
+        xml["cac"].InvoiceLine do
+          xml["cbc"].ID line.id
+          xml["cbc"].Note line.note if line.note
+          xml["cbc"].InvoicedQuantity(format_decimal(line.invoiced_quantity),
+                                      unitCode: line.unit_code)
+          xml["cbc"].LineExtensionAmount(format_decimal(line.line_extension_amount),
+                                         currencyID: currency_code)
+          build_item(xml, line.item) if line.item
+          build_price(xml, line.price, currency_code) if line.price
+        end
+      end
+
+      def build_item(xml, item)
+        xml["cac"].Item do
+          xml["cbc"].Description item.description if item.description
+          xml["cbc"].Name item.name
+          if item.sellers_identifier
+            xml["cac"].SellersItemIdentification do
+              xml["cbc"].ID item.sellers_identifier
+            end
+          end
+          if item.tax_category
+            xml["cac"].ClassifiedTaxCategory do
+              xml["cbc"].ID item.tax_category
+              xml["cbc"].Percent format_decimal(item.tax_percent) if item.tax_percent
+              xml["cac"].TaxScheme do
+                xml["cbc"].ID "VAT"
+              end
+            end
+          end
+        end
+      end
+
+      def build_price(xml, price, currency_code)
+        xml["cac"].Price do
+          xml["cbc"].PriceAmount(format_decimal(price.amount), currencyID: currency_code)
+        end
+      end
+
+      def format_decimal(value)
+        return value.to_s unless value.is_a?(BigDecimal)
+        # Remove trailing zeros but keep at least one decimal
+        str = value.to_s("F")
+        str.sub(/\.?0+$/, "")
+      end
+    end
+  end
+end

data/lib/zugpferd.rb

@@ -0,0 +1,20 @@
+require_relative "zugpferd/model/invoice"
+require_relative "zugpferd/model/trade_party"
+require_relative "zugpferd/model/postal_address"
+require_relative "zugpferd/model/contact"
+require_relative "zugpferd/model/line_item"
+require_relative "zugpferd/model/item"
+require_relative "zugpferd/model/price"
+require_relative "zugpferd/model/monetary_totals"
+require_relative "zugpferd/model/tax_breakdown"
+require_relative "zugpferd/model/tax_subtotal"
+require_relative "zugpferd/model/payment_instructions"
+require_relative "zugpferd/model/allowance_charge"
+require_relative "zugpferd/ubl/reader"
+require_relative "zugpferd/ubl/writer"
+require_relative "zugpferd/cii/reader"
+require_relative "zugpferd/cii/writer"
+
+module Zugpferd
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: zugpferd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Zeitler
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/zugpferd.rb
+- lib/zugpferd/cii/mapping.rb
+- lib/zugpferd/cii/reader.rb
+- lib/zugpferd/cii/writer.rb
+- lib/zugpferd/model/allowance_charge.rb
+- lib/zugpferd/model/contact.rb
+- lib/zugpferd/model/invoice.rb
+- lib/zugpferd/model/item.rb
+- lib/zugpferd/model/line_item.rb
+- lib/zugpferd/model/monetary_totals.rb
+- lib/zugpferd/model/payment_instructions.rb
+- lib/zugpferd/model/postal_address.rb
+- lib/zugpferd/model/price.rb
+- lib/zugpferd/model/tax_breakdown.rb
+- lib/zugpferd/model/tax_subtotal.rb
+- lib/zugpferd/model/trade_party.rb
+- lib/zugpferd/ubl/mapping.rb
+- lib/zugpferd/ubl/reader.rb
+- lib/zugpferd/ubl/writer.rb
+homepage: https://alexzeitler.github.io/zugpferd/
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/alexzeitler/zugpferd
+  homepage_uri: https://alexzeitler.github.io/zugpferd/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.20
+signing_key:
+specification_version: 4
+summary: EN 16931 E-Invoice library for Ruby (UBL + CII)
+test_files: []