invoicehn 0.1.0

data/lib/invoicehn/issuance.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Invoicehn
+  # Issues a Factura: picks the authorization, allocates the correlativo,
+  # validates against the Reglamento, persists, and posts to the ledger.
+  #
+  # The whole sequence happens inside the allocator's lock, so a document is
+  # either fully recorded or its number was never consumed. Nothing here can
+  # produce a number without a document behind it.
+  class Issuance
+    attr_reader :store, :sequence, :ledger
+
+    def initialize(config: Config.new, store: nil, sequence: nil, ledger: nil)
+      @config   = config
+      @store    = store || Storage::JsonStore.new(config)
+      @sequence = sequence || Sequence.new(config)
+      @ledger   = ledger || Ledger::JsonlLedger.new(config)
+    end
+
+    # @param identifier [String] "NNN-NNN-NN", the establecimiento / punto de
+    #   emisión / tipo de documento triple. Defaults to the casa matriz's first
+    #   emission point issuing a Factura.
+    # @param issue_date [Date] pinned to today by default. Art. 43 obliges
+    #   chronological custody, and a ledger whose numbering disagrees with its
+    #   dates is the first thing an audit questions — so backdating is not
+    #   offered through the CLI.
+    def issue(customer:, line_items:, identifier: "000-001-01", currency: "HNL",
+              exchange_rate: nil, notes: nil, issue_date: Date.today)
+      issuer = @store.issuer
+      raise NoAuthorization, "no se ha configurado el emisor; ejecute «invoicehn setup»" if issuer.nil?
+
+      @sequence.allocate(identifier) do |correlative|
+        authorization = pick_authorization(identifier, correlative, issue_date)
+
+        invoice = Invoice.new(
+          correlative: correlative,
+          issuer: issuer,
+          customer: customer,
+          authorization: authorization,
+          line_items: line_items,
+          issue_date: issue_date,
+          currency: currency,
+          exchange_rate: exchange_rate,
+          notes: notes
+        )
+
+        invoice.validate!(on: issue_date)
+        @store.save_document(invoice)
+        @ledger.record(invoice, event: :emision)
+        invoice
+      end
+    end
+
+    # Art. 41 — annulment. The correlativo stays consumed; the sequence never
+    # goes backwards.
+    def annul(correlative, reason:, on: Date.today)
+      invoice = @store.find(correlative)
+      annulled = invoice.annul(reason: reason, on: on)
+
+      @store.save_document(annulled)
+      @ledger.record(annulled, event: :anulacion)
+      annulled
+    end
+
+    # What `invoicehn check` reports: whether issuing is possible right now, and
+    # what is about to go wrong.
+    def health(identifier: "000-001-01", on: Date.today)
+      issuer = @store.issuer
+      next_correlative = @sequence.peek(identifier)
+      authorizations = @store.authorizations_for(identifier)
+      active = @store.active_authorization(identifier, next_sequence: next_correlative.sequence, on: on)
+
+      {
+        identifier: identifier,
+        issuer_configured: !issuer.nil?,
+        issuer_complete: issuer&.complete? || false,
+        issuer_missing: issuer&.missing_fields || [],
+        authorizations: authorizations.size,
+        active_authorization: active,
+        next_correlative: next_correlative,
+        issued: @sequence.issued_count(identifier),
+        remaining: active ? (active.range_end.sequence - next_correlative.sequence + 1) : 0,
+        days_remaining: active&.days_remaining(on),
+        # Art. 42 — expired authorizations holding unused documents must be
+        # reported to SAR within the first 10 business days of the next month.
+        lapsed_with_unused: lapsed_with_unused(identifier, on: on),
+        ready: !issuer.nil? && issuer.complete? && !active.nil?
+      }
+    end
+
+    private
+
+    def pick_authorization(identifier, correlative, on)
+      authorization = @store.active_authorization(identifier, next_sequence: correlative.sequence, on: on)
+
+      if authorization.nil?
+        on_file = @store.authorizations_for(identifier)
+        raise NoAuthorization, <<~MSG.strip if on_file.empty?
+          no hay autorización registrada para #{identifier}; regístrela con «invoicehn auth add»
+          (el CAI, el rango y la fecha límite los otorga el SAR, Arts. 59-61)
+        MSG
+
+        raise NoAuthorization, <<~MSG.strip
+          ninguna autorización vigente cubre el correlativo #{correlative};
+          las registradas están vencidas o agotadas. Solicite una nueva al SAR.
+        MSG
+      end
+
+      authorization.assert_usable!(correlative, on: on)
+      authorization
+    end
+
+    # Authorizations past their fecha límite that still had numbers left.
+    def lapsed_with_unused(identifier, on:)
+      issued = @sequence.issued_count(identifier)
+
+      @store.authorizations_for(identifier).select do |auth|
+        auth.expired?(on) && issued < auth.range_end.sequence
+      end
+    end
+  end
+end

data/lib/invoicehn/issuer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Invoicehn
+  # The Obligado Tributario emitting the document.
+  #
+  # Art. 10 num. 1 — "Datos de identificación del emisor":
+  #   a) Registro Tributario Nacional (RTN)
+  #   b) Nombres y Apellidos, Razón o Denominación Social. "Los Obligados
+  #      Tributarios como comerciantes individuales podrán sustituir sus Nombres
+  #      y Apellidos por el nombre comercial registrado en el Registro
+  #      Tributario Nacional (RTN)"
+  #   c) Nombre Comercial
+  #   d) Dirección de la casa matriz y del establecimiento donde esté localizado
+  #      el punto de emisión
+  #   e) Número telefónico
+  #   f) Correo Electrónico
+  #
+  # All six are required by the article, so all six are required here. The
+  # printer's data (num. 9) is not modelled: it applies only to pre-printed
+  # invoices produced through an imprenta, and this library issues under the
+  # autoimpresor modality.
+  class Issuer
+    attr_reader :rtn, :legal_name, :trade_name, :headquarters_address,
+                :branch_address, :phone, :email
+
+    # @param branch_address [String, nil] address of the establishment holding
+    #   the emission point. Defaults to the headquarters address, which is the
+    #   correct value when issuing from the casa matriz.
+    def initialize(rtn:, legal_name:, trade_name:, headquarters_address:, phone:, email:,
+                   branch_address: nil)
+      @rtn = rtn.is_a?(Rtn) ? rtn : Rtn.new(rtn)
+      @legal_name = legal_name.to_s.strip
+      @trade_name = trade_name.to_s.strip
+      @headquarters_address = headquarters_address.to_s.strip
+      branch = branch_address.to_s.strip
+      @branch_address = branch.empty? ? @headquarters_address : branch
+      @phone = phone.to_s.strip
+      @email = email.to_s.strip
+
+      freeze
+    end
+
+    # Returns the Art. 10 num. 1 fields that are missing, as human-readable
+    # Spanish descriptions. Empty means complete.
+    def missing_fields
+      {
+        "nombre o razón social (Art. 10 num. 1 lit. b)" => @legal_name,
+        "nombre comercial (Art. 10 num. 1 lit. c)" => @trade_name,
+        "dirección de la casa matriz (Art. 10 num. 1 lit. d)" => @headquarters_address,
+        "dirección del establecimiento del punto de emisión (Art. 10 num. 1 lit. d)" => @branch_address,
+        "número telefónico (Art. 10 num. 1 lit. e)" => @phone,
+        "correo electrónico (Art. 10 num. 1 lit. f)" => @email
+      }.select { |_label, value| value.nil? || value.empty? }.keys
+    end
+
+    def complete? = missing_fields.empty?
+
+    def validate!
+      return self if complete?
+
+      raise ValidationError,
+            "faltan datos obligatorios del emisor: #{missing_fields.join("; ")}"
+    end
+
+    # True when the emission point is somewhere other than the casa matriz, in
+    # which case both addresses must be shown.
+    def branch? = @branch_address != @headquarters_address
+
+    def to_h
+      {
+        "rtn" => @rtn.to_s,
+        "legal_name" => @legal_name,
+        "trade_name" => @trade_name,
+        "headquarters_address" => @headquarters_address,
+        "branch_address" => @branch_address,
+        "phone" => @phone,
+        "email" => @email
+      }
+    end
+
+    def self.from_h(hash)
+      new(
+        rtn: hash["rtn"],
+        legal_name: hash["legal_name"],
+        trade_name: hash["trade_name"],
+        headquarters_address: hash["headquarters_address"],
+        branch_address: hash["branch_address"],
+        phone: hash["phone"],
+        email: hash["email"]
+      )
+    end
+
+    def to_s = "#{@legal_name} (RTN #{@rtn.formatted})"
+  end
+end

data/lib/invoicehn/ledger.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "date"
+require "fileutils"
+
+module Invoicehn
+  # The integration point Art. 53 num. 1 requires.
+  #
+  # "El sistema de facturación debe estar integrado al menos a un sistema
+  # contable o de inventarios." That integration is part of what the operator
+  # attests in the Declaración Jurada filed before being authorized as an
+  # autoimpresor, so it is a condition of the authorization and not an optional
+  # convenience.
+  #
+  # Subclass and override #record to post into real accounting or inventory
+  # software. The default implementation writes an append-only JSONL book, which
+  # satisfies the requirement standalone and feeds the Art. 53 num. 5 export.
+  class Ledger
+    # Called once per issued or annulled document.
+    #
+    # @param invoice [Invoice]
+    # @param event [Symbol] :emision or :anulacion
+    def record(invoice, event: :emision)
+      raise NotImplementedError, "#{self.class} debe implementar #record"
+    end
+
+    # Art. 53 num. 5: "El Sistema debe tener la capacidad de generación de
+    # archivos tipo texto para su almacenamiento y traslado hacia la
+    # Administración Tributaria a través de servicios web o intercambio de
+    # protocolo."
+    def entries(from: nil, to: nil)
+      raise NotImplementedError, "#{self.class} debe implementar #entries"
+    end
+
+    # The default: a plain append-only book on disk.
+    class JsonlLedger < Ledger
+      attr_reader :path
+
+      def initialize(config = Config.new)
+        super()
+        @path = config.ledger_path
+      end
+
+      def record(invoice, event: :emision)
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.open(@path, "a") { |f| f.puts(JSON.generate(entry_for(invoice, event))) }
+        invoice
+      end
+
+      def entries(from: nil, to: nil)
+        return [] unless File.exist?(@path)
+
+        File.readlines(@path, chomp: true).reject(&:empty?).map { |line| JSON.parse(line) }
+            .select { |e| within?(Date.parse(e["issue_date"]), from, to) }
+      end
+
+      private
+
+      def entry_for(invoice, event)
+        {
+          "recorded_at" => Time.now.utc.iso8601,
+          "event" => event.to_s,
+          "correlative" => invoice.correlative.to_s,
+          "issue_date" => invoice.issue_date.iso8601,
+          "cai" => invoice.authorization.cai,
+          "customer" => invoice.customer.to_s,
+          "customer_rtn" => invoice.customer.rtn&.to_s,
+          "currency" => invoice.currency,
+          "subtotal" => invoice.subtotal.to_h["amount"],
+          "discount" => invoice.discount.to_h["amount"],
+          "isv" => invoice.isv_total.to_h["amount"],
+          "total" => invoice.total.to_h["amount"],
+          "status" => invoice.status
+        }
+      end
+
+      def within?(date, from, to)
+        return false if from && date < from
+        return false if to && date > to
+
+        true
+      end
+    end
+
+    # Fans out to several ledgers, so the built-in book can stay in place while
+    # an accounting integration is added alongside it.
+    class Multi < Ledger
+      attr_reader :ledgers
+
+      def initialize(*ledgers)
+        super()
+        @ledgers = ledgers.flatten
+      end
+
+      def record(invoice, event: :emision)
+        @ledgers.each { |l| l.record(invoice, event: event) }
+        invoice
+      end
+
+      def entries(from: nil, to: nil)
+        @ledgers.first&.entries(from: from, to: to) || []
+      end
+    end
+  end
+end

data/lib/invoicehn/line_item.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Invoicehn
+  # One line of the invoice.
+  #
+  # Art. 11 num. 1 requires per line: lit. d) "Descripción detallada del bien
+  # vendido o del servicio prestado", lit. e) "Cantidad de unidades de bienes
+  # vendidos", lit. f) "Valor unitario del bien vendido o del servicio
+  # prestado", and — added by Acuerdo 725-2018 — lit. l) "Discriminación de los
+  # descuentos y rebajas otorgados".
+  #
+  # The discount reduces the taxable base. Ley del ISV Art. 3 closes the
+  # base-imponible article with: "No forman parte de la base gravable los
+  # descuentos efectivos que consten en la factura o documento equivalente,
+  # siempre que resulten normales según la costumbre comercial." Showing a
+  # discount while taxing the gross value would overcharge the customer the very
+  # tax that Art. 9 calls hurto to mis-collect.
+  class LineItem
+    attr_reader :description, :quantity, :unit_price, :discount, :treatment
+
+    # @param discount [Money, nil] absolute amount taken off this line's gross
+    #   value, expressed in the invoice's currency.
+    def initialize(description:, quantity:, unit_price:, treatment:, discount: nil)
+      @description = description.to_s.strip
+      @quantity    = coerce_quantity(quantity)
+      @unit_price  = coerce_money(unit_price, "valor unitario")
+      @treatment   = TaxTreatment.fetch(treatment)
+      @discount    = discount.nil? ? Money.zero(@unit_price.currency) : coerce_money(discount, "descuento")
+
+      validate!
+      freeze
+    end
+
+    def currency = @unit_price.currency
+
+    # Quantity times unit price, before any discount.
+    def gross = @unit_price * @quantity
+
+    def discounted? = @discount.positive?
+
+    # The amount that enters the taxable base for this line's rate.
+    def taxable_base = gross - @discount
+
+    # The tax this line contributes on its own. The invoice does not sum these:
+    # it rounds once per rate on the summed base, so that the printed ISV equals
+    # the printed rate times the printed subtotal. This is offered for line-level
+    # display and reconciliation only.
+    def isv = (taxable_base * @treatment.rate).round_statutory
+
+    def total = taxable_base + isv
+
+    def to_h
+      {
+        "description" => @description,
+        "quantity" => @quantity.to_s("F"),
+        "unit_price" => @unit_price.to_h,
+        "discount" => @discount.to_h,
+        "treatment" => @treatment.key.to_s
+      }
+    end
+
+    def self.from_h(hash)
+      new(
+        description: hash["description"],
+        quantity: BigDecimal(hash["quantity"]),
+        unit_price: Money.from_h(hash["unit_price"]),
+        discount: Money.from_h(hash["discount"]),
+        treatment: hash["treatment"]
+      )
+    end
+
+    def to_s
+      "#{@quantity.to_s("F")} × #{@unit_price} #{@description} (#{@treatment})"
+    end
+
+    private
+
+    def validate!
+      if @description.empty?
+        raise ValidationError,
+              "la descripción del bien o servicio es obligatoria (Art. 11 num. 1 lit. d)"
+      end
+      raise ValidationError, "la cantidad debe ser mayor que cero (Art. 11 num. 1 lit. e)" unless @quantity.positive?
+      raise ValidationError, "el valor unitario no puede ser negativo (Art. 11 num. 1 lit. f)" if @unit_price.negative?
+      raise ValidationError, "el descuento no puede ser negativo" if @discount.negative?
+
+      if @discount.currency != @unit_price.currency
+        raise CurrencyMismatch, "el descuento está en #{@discount.currency} y el precio en #{@unit_price.currency}"
+      end
+
+      return unless @discount > gross
+
+      raise ValidationError,
+            "el descuento (#{@discount}) excede el valor de la línea (#{gross})"
+    end
+
+    def coerce_quantity(value)
+      case value
+      when BigDecimal then value
+      when Integer then BigDecimal(value)
+      when Rational then BigDecimal(value, 20)
+      when String then BigDecimal(value)
+      when Float
+        raise ValidationError, "Float no está permitido en cantidades; use BigDecimal, Integer o String"
+      else
+        raise ValidationError, "cantidad no numérica: #{value.inspect}"
+      end
+    rescue ArgumentError
+      raise ValidationError, "cantidad no numérica: #{value.inspect}"
+    end
+
+    def coerce_money(value, label)
+      return value if value.is_a?(Money)
+
+      raise ValidationError, "#{label} debe ser un Invoicehn::Money, se recibió #{value.class}"
+    end
+  end
+end

data/lib/invoicehn/locale.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Invoicehn
+  # Interface strings for the CLI, in Spanish or English.
+  #
+  # This deliberately covers *only* the interface. The Factura's own legends are
+  # legal text fixed by the Reglamento and live as constants in
+  # Renderers::Text — an English-locale CLI still issues a Spanish invoice,
+  # because the document's wording is not a presentation choice.
+  module Locale
+    DEFAULT = "es"
+    AVAILABLE = %w[es en].freeze
+    ENV_VAR = "INVOICEHN_LANG"
+
+    class << self
+      def current
+        @current ||= detect
+      end
+
+      def current=(lang)
+        lang = lang.to_s.downcase[0, 2]
+        @current = AVAILABLE.include?(lang) ? lang : DEFAULT
+      end
+
+      # Looks up a dotted key: t("setup.title"). Interpolation uses %{name}
+      # placeholders. A missing key returns the key itself rather than raising —
+      # a broken label must never stop an invoice from being issued.
+      def t(key, **values)
+        string = dig(catalog(current), key) || dig(catalog(DEFAULT), key)
+        return key.to_s if string.nil?
+
+        values.empty? ? string : format(string, **values)
+      rescue KeyError
+        string
+      end
+
+      def reset!
+        @current = nil
+        @catalogs = nil
+      end
+
+      private
+
+      # Spanish unless English is asked for explicitly, via INVOICEHN_LANG or
+      # --lang. The system LANG is deliberately ignored: the users are Honduran
+      # businesses, and someone running an English-locale laptop still wants the
+      # Spanish interface next to a Spanish document.
+      def detect
+        normalize(ENV.fetch(ENV_VAR, DEFAULT))
+      end
+
+      def normalize(lang)
+        lang = lang.to_s.downcase[0, 2]
+        AVAILABLE.include?(lang) ? lang : DEFAULT
+      end
+
+      def catalogs
+        @catalogs ||= AVAILABLE.to_h do |lang|
+          path = File.expand_path("../../config/locales/#{lang}.yml", __dir__)
+          data = File.exist?(path) ? (YAML.safe_load_file(path) || {}) : {}
+          [lang, data[lang] || {}]
+        end
+      end
+
+      def catalog(lang) = catalogs.fetch(lang, {})
+
+      def dig(hash, key)
+        value = key.to_s.split(".").reduce(hash) do |acc, part|
+          acc.is_a?(Hash) ? acc[part] : nil
+        end
+        value.is_a?(String) ? value : nil
+      end
+    end
+  end
+end

data/lib/invoicehn/money.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+module Invoicehn
+  # An amount of money, held as a BigDecimal at full precision.
+  #
+  # Rounding to centavos happens only through #round_statutory, which implements
+  # Artículo 9 de la Ley del Impuesto Sobre Ventas (redactado por Decreto 135-94):
+  #
+  #   "Cuando al calcular dicho gravamen, resulte una fracción menor de 0.005 de
+  #    Lempira, deberá reducirse el recargo hasta la cifra de centavos próxima
+  #    inferior, en cambio, si la fracción citada es igual o mayor de 0.005 de
+  #    Lempira, entonces podrá subirse el cómputo hasta la cifra de centavos
+  #    próxima superior. El recargo del impuesto al consumidor fuera de la regla
+  #    establecida en el párrafo anterior, se considerará como hurto."
+  #
+  # Charging the customer an amount rounded outside that rule is characterised by
+  # the statute as theft, so this is a correctness requirement and not a policy
+  # choice. Float never appears in this class or in the tax path; test/test_no_float.rb
+  # enforces that.
+  class Money
+    include Comparable
+
+    SCALE = 2
+    CURRENCIES = {
+      "HNL" => { symbol: "L", singular: "LEMPIRA", plural: "LEMPIRAS" },
+      "USD" => { symbol: "$", singular: "DÓLAR", plural: "DÓLARES" }
+    }.freeze
+
+    attr_reader :amount, :currency
+
+    class << self
+      def zero(currency = "HNL")
+        new(0, currency)
+      end
+
+      # Sums a collection, inferring the currency from the members. An empty
+      # collection has no currency to infer, so the caller supplies one.
+      def sum(monies, currency: "HNL")
+        monies = Array(monies)
+        return zero(currency) if monies.empty?
+
+        monies.reduce { |acc, m| acc + m }
+      end
+
+      def currency?(code)
+        CURRENCIES.key?(code.to_s.upcase)
+      end
+    end
+
+    def initialize(amount, currency = "HNL")
+      @currency = currency.to_s.upcase
+      raise ValidationError, "moneda no soportada: #{currency}" unless CURRENCIES.key?(@currency)
+
+      @amount = coerce_to_decimal(amount)
+      freeze
+    end
+
+    # Rounds to centavos under Ley del ISV Art. 9: a fraction of a centavo below
+    # 0.005 lempira rounds down, one at or above 0.005 rounds up. That is
+    # half-up at the centavo, with the tie going up.
+    def round_statutory
+      self.class.new(@amount.round(SCALE, BigDecimal::ROUND_HALF_UP), @currency)
+    end
+
+    def +(other)
+      combine(other) { |a, b| a + b }
+    end
+
+    def -(other)
+      combine(other) { |a, b| a - b }
+    end
+
+    # Scaling by a quantity or a tax rate. The result keeps full precision;
+    # call #round_statutory at the point the amount becomes payable.
+    def *(other)
+      self.class.new(@amount * coerce_to_decimal(other), @currency)
+    end
+
+    def /(other)
+      divisor = coerce_to_decimal(other)
+      raise ZeroDivisionError, "división por cero" if divisor.zero?
+
+      self.class.new(@amount / divisor, @currency)
+    end
+
+    def -@
+      self.class.new(-@amount, @currency)
+    end
+
+    def zero? = @amount.zero?
+    def positive? = @amount.positive?
+    def negative? = @amount.negative?
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      assert_same_currency!(other)
+      @amount <=> other.amount
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.currency == @currency && other.amount == @amount
+    end
+    alias eql? ==
+
+    def hash = [@amount, @currency].hash
+
+    def symbol = CURRENCIES.fetch(@currency)[:symbol]
+    def currency_word = CURRENCIES.fetch(@currency)[@amount.abs == 1 ? :singular : :plural]
+
+    # "L 1,234.56" — the symbol satisfies Art. 11 num. 1 lit. j).
+    def to_s
+      integer, fraction = to_fixed.delete("-").split(".")
+      grouped = integer.reverse.scan(/\d{1,3}/).join(",").reverse
+      "#{"-" if @amount.negative?}#{symbol} #{grouped}.#{fraction}"
+    end
+
+    def inspect = "#<Invoicehn::Money #{self}>"
+
+    # Always two decimals: BigDecimal#to_s("F") would render 900 as "900.0",
+    # and a fiscal amount must show both centavo digits.
+    def to_fixed
+      rounded = @amount.round(SCALE, BigDecimal::ROUND_HALF_UP)
+      integer, fraction = rounded.abs.to_s("F").split(".")
+      "#{"-" if rounded.negative?}#{integer}.#{fraction.to_s.ljust(SCALE, "0")[0, SCALE]}"
+    end
+
+    # Serialised as a string so no downstream JSON parser can turn it into a Float.
+    def to_h
+      { "amount" => to_fixed, "currency" => @currency }
+    end
+
+    def self.from_h(hash)
+      new(hash["amount"] || hash[:amount], hash["currency"] || hash[:currency] || "HNL")
+    end
+
+    private
+
+    def combine(other)
+      assert_same_currency!(other)
+      self.class.new(yield(@amount, other.amount), @currency)
+    end
+
+    def assert_same_currency!(other)
+      return if other.currency == @currency
+
+      raise CurrencyMismatch, "no se pueden combinar #{@currency} y #{other.currency}"
+    end
+
+    # Accepts Integer, BigDecimal, Rational, or a numeric String. Float is
+    # rejected outright: admitting it here would let binary rounding error into
+    # a figure the statute makes criminal to get wrong.
+    def coerce_to_decimal(value)
+      case value
+      when BigDecimal then value
+      when Integer    then BigDecimal(value)
+      when Rational   then BigDecimal(value, 20)
+      when Money      then value.amount
+      when String
+        begin
+          BigDecimal(value)
+        rescue ArgumentError
+          raise ValidationError, "importe no numérico: #{value.inspect}"
+        end
+      when Float
+        raise ValidationError,
+              "Float no está permitido en importes (Ley del ISV Art. 9); " \
+              "use BigDecimal, Integer o String, p. ej. \"#{value}\""
+      else
+        raise ValidationError, "importe no numérico: #{value.inspect}"
+      end
+    end
+  end
+end