croatia 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91babeb96c8b99906844e087b9599ec530c4b972b6d1bdf2cded59dfbbb178d1
-  data.tar.gz: cd5b1dece16ed4f0d9ec3e2b8ceac8b2b44ad251f7eb2f07e119491bc638cb9f
+  metadata.gz: 2e22a48f786d2268182526ab25ca8ef664847694e843b164afdbf38214f937bc
+  data.tar.gz: 8c36543cca8688fdccda47197ebc5b66f5554b3342629e04e03cafe528aaa88e
 SHA512:
-  metadata.gz: f103227a100270c0d53c8bf45edb30532a852719866900fed949996e1afbfcb4fd3525c0e7ae4828bd8e16a1137357f3345810600b24cd3db174774ba2f4a5fd
-  data.tar.gz: cec02f409ded5d60f9535464669219314f4da1ab516ef5139b550d033552ac9393cd6105e37486427cfe6ee606c93636caa85c2a3f7994dc783cf9984643b110
+  metadata.gz: 93126e3a11b8e23414a3bf6b3ab051aeb47092380022b4a978b0f478c693ff5d62bb143f478bb6f55464c4a1a92d8df77890b3bff6332c8934f109ce05e86851
+  data.tar.gz: 840c3dd7f3ef96143bb5c694237fba3d4c6f7270a2aadb4e270746c0787bcd170c8ae193d83ace677c216f44a26357bc414e8888603b61a8f424ba8337ab2c0b

data/lib/croatia/config.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Croatia::Config
+  DEFAULT_TAX_RATES = {
+    value_added_tax: {
+      standard: 0.25,
+      lower_rate: 0.13,
+      exempt: 0.0,
+      zero_rated: 0.0,
+      outside_scope: 0.0,
+      reverse_charge: 0.0
+    },
+    consumption_tax: Hash.new(0.0),
+    other: Hash.new(0.0)
+  }
+  DEFAULT_FISCALIZATION = {}
+
+  attr_accessor :tax_rates, :fiscalization
+
+  def initialize(**options)
+    self.tax_rates = options.delete(:tax_rates) { deep_dup(DEFAULT_TAX_RATES) }
+    self.fiscalization = options.delete(:fiscalization) { deep_dup(DEFAULT_FISCALIZATION) }
+  end
+
+  private
+
+    def deep_dup(object)
+      Marshal.load(Marshal.dump(object))
+    end
+end

data/lib/croatia/fiscalizer/xml_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+
+module Croatia::Fiscalizer::XMLBuilder
+  TNS = "http://www.apis-it.hr/fin/2012/types/f73"
+  XSI = "http://www.w3.org/2001/XMLSchema-instance"
+
+  class << self
+    def invoice_request(invoice:, message_id:, timezone: Croatia::Invoice::Fiscalizer::TZ)
+      REXML::Document.new.tap do |doc|
+        envelope = doc.add_element("tns:RacunZahtjev", {
+          "xmlns:tns" => TNS,
+          "xmlns:xsi" => XSI
+        })
+
+        envelope.add_element("tns:Zaglavlje").tap do |header|
+          header.add_element("tns:IdPoruke").text = message_id
+          header.add_element("tns:DatumVrijemeSlanja").text = timezone.now.strftime("%d.%m.%YT%H:%M:%S")
+        end
+
+        envelope.add_element("tns:Racun").tap do |payload|
+          payload.add_element("tns:Oib").text = invoice.seller.pin
+          payload.add_element("tns:USustPdv").text = invoice.seller.pays_vat ? "true" : "false"
+          payload.add_element("tns:DatVrijeme").text = timezone.to_local(invoice.issue_date).strftime("%d.%m.%YT%H:%M:%S")
+        end
+      end
+    end
+  end
+end

data/lib/croatia/fiscalizer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+require "openssl"
+require "securerandom"
+require "tzinfo"
+
+class Croatia::Fiscalizer
+  autoload :XMLBuilder, "croatia/fiscalizer/xml_builder"
+
+  TZ = TZInfo::Timezone.get("Europe/Zagreb")
+
+  attr_reader :certificate
+
+  def initialize(certificate: nil, password: nil)
+    certificate ||= Croatia.config.fiscalization[:certificate]
+    password ||= Croatia.config.fiscalization[:password]
+
+    @certificate = load_certificate(certificate, password)
+  end
+
+  def fiscalize(invoice:, message_id: SecureRandom.uuid)
+    document = XMLBuilder.invoice_request(invoice: invoice, message_id: message_id, timezone: TZ)
+
+    # TODO: Implement the fiscalization logic here
+    puts "TODO: Fiscalize invoice #{invoice}"
+    puts "GENERATED XML:\n#{document}"
+  end
+
+  def generate_issuer_protection_code(invoice)
+    buffer = []
+    buffer << invoice.issuer.pin
+    buffer << TZ.to_local(invoice.issue_date).strftime("%d.%m.%Y %H:%M:%S")
+    buffer << invoice.sequential_number
+    buffer << invoice.business_location_identifier
+    buffer << invoice.register_identifier
+    buffer << invoice.total.to_f
+
+    digest = OpenSSL::Digest::SHA1.new
+    signature = certificate.sign(digest, buffer.join)
+
+    Digest::MD5.hexdigest(signature).downcase
+  end
+
+  private
+
+    def load_certificate(cert, password)
+      if cert.is_a?(OpenSSL::PKCS12)
+        cert.key
+      elsif cert.is_a?(OpenSSL::PKey::PKey)
+        cert
+      else
+        cert = File.read(cert) if cert.respond_to?(:to_s) && File.exist?(cert.to_s)
+
+        begin
+          OpenSSL::PKey.read(cert)
+        rescue OpenSSL::PKey::PKeyError
+          OpenSSL::PKCS12.new(cert, password).key
+        end
+      end
+    end
+end

data/lib/croatia/invoice/e_invoicable.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Croatia::Invoice::EInvoicable
+end

data/lib/croatia/invoice/fiscalizable.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Croatia::Invoice::Fiscalizable
+  QR_CODE_BASE_URL = "https://porezna.gov.hr/rn"
+
+  def self.included(base)
+    base.include InstanceMethods
+  end
+
+  module InstanceMethods
+    def fiscalize!(**options)
+      Croatia::Fiscalizer.new(**options).fiscalize(invoice: self)
+    end
+
+    def reverse!(**options)
+      line_items.each(&:reverse)
+      Croatia::Fiscalizer.new(**options).fiscalize(invoice: self)
+    end
+
+    def issuer_protection_code(**options)
+      Croatia::Fiscalizer
+        .new(**options)
+        .generate_issuer_protection_code(self)
+    end
+
+    def fiscalization_qr_code(**options)
+      Croatia::QRCode.ensure_supported!
+
+      params = {
+        datv: issue_date.strftime("%Y%m%d_%H%M"),
+        izn: total_cents.to_s
+      }
+
+      if params[:izn].length > 10
+        raise ArgumentError, "Total amount exceeds 10 digits: #{params[:izn]}"
+      end
+
+      uii = options[:unique_invoice_identifier] || unique_invoice_identifier
+
+      if uii
+        params[:jir] = uii
+      elsif !params[:zki]
+        ipc = issuer_protection_code(**options)
+        params[:zki] = ipc
+      end
+
+      if (params[:jir] && params[:zki]) || (params[:jir].nil? && params[:zki].nil?)
+        raise ArgumentError, "Either unique_invoice_identifier or issuer_protection_code must be provided"
+      end
+
+      query_string = URI.encode_www_form(params)
+      url = "#{QR_CODE_BASE_URL}?#{query_string}"
+
+      Croatia::QRCode.new(url)
+    end
+  end
+end

data/lib/croatia/invoice/line_item.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class Croatia::Invoice::LineItem
+  include Croatia::Enum
+
+  attr_accessor :description, :unit, :taxes
+  attr_reader :quantity, :unit_price, :discount_rate
+
+  def initialize(**options)
+    self.description = options[:description]
+    self.quantity = options.fetch(:quantity, 1)
+    self.unit = options[:unit]
+    self.unit_price = options.fetch(:unit_price, 0.0)
+    self.taxes = options.fetch(:taxes, {})
+  end
+
+  def quantity=(value)
+    unless value.is_a?(Numeric)
+      raise ArgumentError, "Quantity must be a number"
+    end
+
+    @quantity = value.to_d
+  end
+
+  def unit_price=(value)
+    unless value.is_a?(Numeric) && value >= 0
+      raise ArgumentError, "Unit price must be a non-negative number"
+    end
+
+    @unit_price = value.to_d
+  end
+
+
+  def discount_rate=(value)
+    if value.nil?
+      @discount_rate = nil
+      return
+    end
+
+    unless value.is_a?(Numeric) && value >= 0 && value <= 1
+      raise ArgumentError, "Discount rate must be a non-negative number between 0 and 1"
+    end
+
+    @discount_rate = value.to_d
+  end
+
+  def discount=(value)
+    if value.nil?
+      @discount = nil
+      return
+    end
+
+    unless value.is_a?(Numeric) && value >= 0
+      raise ArgumentError, "Discount must be a non-negative number"
+    end
+
+    @discount = value.to_d.round(2, BigDecimal::ROUND_HALF_UP)
+  end
+
+  def discount
+    if @discount
+      @discount
+    elsif @discount_rate
+      (gross * @discount_rate).round(2, BigDecimal::ROUND_HALF_UP)
+    else
+      BigDecimal("0.0")
+    end
+  end
+
+  def reverse
+    self.quantity *= -1
+  end
+
+  def gross
+    (quantity * unit_price).round(2, BigDecimal::ROUND_HALF_UP)
+  end
+
+  def subtotal
+    gross - discount
+  end
+
+  def tax
+    taxes.values.sum { |tax_obj| (subtotal * tax_obj.rate).round(2, BigDecimal::ROUND_HALF_UP) }
+  end
+
+  def total
+    (subtotal + tax).round(2, BigDecimal::ROUND_HALF_UP)
+  end
+
+  def add_tax(tax = nil, **options, &block)
+    if tax.nil?
+      tax = Croatia::Invoice::Tax.new(**options)
+    end
+
+    tax.tap(&block) if block_given?
+
+    taxes[tax.type] = tax
+    tax
+  end
+end

data/lib/croatia/invoice/party.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Croatia::Invoice::Party
+  attr_accessor \
+    :address,
+    :city,
+    :country_code,
+    :einvoice_id,
+    :iban,
+    :name,
+    :pays_vat,
+    :pin,
+    :postal_code
+
+  def initialize(**options)
+    options.each do |key, value|
+      public_send("#{key}=", value)
+    end
+  end
+end

data/lib/croatia/invoice/payable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Croatia::Invoice::Payable
+  def self.included(base)
+    base.include InstanceMethods
+  end
+
+  module InstanceMethods
+    def payment_barcode(description: nil, model: nil, reference_number: nil, payment_purpose_code: nil)
+      if buyer.nil? || seller.nil?
+        raise ArgumentError, "Both buyer and seller must be set before generating a payment barcode"
+      end
+
+      description ||= "Racun #{number}"
+
+      options = {
+        currency: currency,
+        total_cents: total_cents,
+        buyer_name: buyer.name,
+        buyer_address: buyer.address,
+        buyer_postal_code: buyer.postal_code,
+        buyer_city: buyer.city,
+        seller_name: seller.name,
+        seller_address: seller.address,
+        seller_postal_code: seller.postal_code,
+        seller_city: seller.city,
+        seller_iban: seller.iban,
+        model: model,
+        reference_number: reference_number,
+        payment_purpose_code: payment_purpose_code,
+        description: description
+      }
+
+      Croatia::PaymentBarcode.new(**options)
+    end
+  end
+end

data/lib/croatia/invoice/tax.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class Croatia::Invoice::Tax
+  include Croatia::Enum
+
+  attr_reader :rate
+
+  enum :type, %i[ value_added_tax consumption_tax other ]
+  enum :category, %i[ standard lower_rate exempt zero_rated outside_scope reverse_charge ]
+
+  def initialize(rate: nil, type: :value_added_tax, category: :standard)
+    self.type = type
+    self.category = category
+    self.rate = rate ? rate : Croatia.config.tax_rates[type][category]
+  end
+
+  def rate=(value)
+    if !value.is_a?(Numeric) || value < 0 || value > 1
+      raise ArgumentError, "Tax rate must be a number between 0 and 1"
+    end
+
+    @rate = value.to_d
+  end
+end

data/lib/croatia/invoice.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class Croatia::Invoice
+  autoload :Fiscalizable, "croatia/invoice/fiscalizable"
+  autoload :EInvoicable, "croatia/invoice/e_invoicable"
+  autoload :Payable, "croatia/invoice/payable"
+  autoload :Party, "croatia/invoice/party"
+  autoload :Tax, "croatia/invoice/tax"
+  autoload :LineItem, "croatia/invoice/line_item"
+  autoload :Fiscalizer, "croatia/invoice/fiscalizer"
+
+  include Croatia::Enum
+  include Fiscalizable
+  include EInvoicable
+  include Payable
+
+  attr_reader :issue_date, :due_date
+  attr_writer :issuer, :seller, :buyer
+  attr_accessor \
+    :business_location_identifier, # oznaka poslovnog prostora
+    :currency,
+    :line_items,
+    :register_identifier, # oznaka naplatnog uredaja
+    :sequential_number, # redni broj racuna
+    :unique_invoice_identifier # jir
+
+  enum :payment_method, {
+    cash: "G",
+    card: "K",
+    check: "C",
+    transfer: "T",
+    other: "O"
+  }.freeze, allow_nil: true, prefix: :payment_method
+
+  def initialize(**options)
+    self.line_items = options.delete(:line_items) { [] }
+
+    options.each do |key, value|
+      public_send("#{key}=", value)
+    end
+  end
+
+  def number
+    [ sequential_number, business_location_identifier, register_identifier ].join("/")
+  end
+
+  def subtotal
+    line_items.sum(&:subtotal).to_d
+  end
+
+  def tax
+    line_items.sum(&:tax).to_d
+  end
+
+  def total
+    line_items.sum(&:total).to_d
+  end
+
+  def total_cents
+    (total * 100).to_i
+  end
+
+  def add_line_item(line_item = nil, &block)
+    if line_item.nil? && block.nil?
+      raise ArgumentError, "You must provide a line item or a block"
+    end
+
+    line_item ||= LineItem.new.tap(&block)
+
+    self.line_items ||= []
+    line_items << line_item
+
+    line_item
+  end
+
+  def issuer(&block)
+    if block_given?
+      self.issuer = Party.new.tap(&block)
+    else
+      @issuer
+    end
+  end
+
+  def buyer(&block)
+    if block_given?
+      self.buyer = Party.new.tap(&block)
+    else
+      @buyer
+    end
+  end
+
+  def seller(&block)
+    if block_given?
+      self.seller = Party.new.tap(&block)
+    else
+      @seller
+    end
+  end
+
+  def issue_date=(value)
+    @issue_date = value.nil? ? nil : parse_date(value)
+  end
+
+  def due_date=(value)
+    @due_date = value.nil? ? nil : parse_date(value)
+  end
+
+  private
+
+    def parse_date(value)
+      case value
+      when Date, DateTime
+        value
+      else
+        DateTime.parse(value.to_s)
+      end
+    end
+end

data/lib/croatia/payment_barcode.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class Croatia::PaymentBarcode
+  HEADER = "HRVHUB30"
+  EXACT_LENGTH_FIELDS = %i[ header currency total_cents model payment_purpose_code ].freeze
+  FIELD_MAX_LENGTHS = {
+    header: 8,
+    currency: 3,
+    total_cents: 15,
+    buyer_name: 30,
+    buyer_address: 27,
+    buyer_postal_code_and_city: 27,
+    seller_name: 25,
+    seller_address: 25,
+    seller_postal_code_and_city: 27,
+    seller_iban: 21,
+    model: 4,
+    reference_number: 22,
+    payment_purpose_code: 4,
+    description: 35
+  }.freeze
+
+  attr_accessor \
+    :buyer_address,
+    :buyer_city,
+    :buyer_name,
+    :buyer_postal_code,
+    :currency,
+    :description,
+    :model,
+    :payment_purpose_code,
+    :reference_number,
+    :seller_address,
+    :seller_city,
+    :seller_iban,
+    :seller_name,
+    :seller_postal_code,
+    :total_cents
+
+  def initialize(**options)
+    options.each do |key, value|
+      public_send("#{key}=", value)
+    end
+  end
+
+  def data
+    data = {
+      header: HEADER,
+      currency: currency,
+      total_cents: total_cents.to_s.rjust(FIELD_MAX_LENGTHS[:total_cents], "0"),
+      buyer_name: buyer_name,
+      buyer_address: buyer_address,
+      buyer_postal_code_and_city: "#{buyer_postal_code} #{buyer_city}".strip,
+      seller_name: seller_name,
+      seller_address: seller_address,
+      seller_postal_code_and_city: "#{seller_postal_code} #{seller_city}".strip,
+      seller_iban: seller_iban,
+      model: model,
+      reference_number: reference_number,
+      payment_purpose_code: payment_purpose_code,
+      description: description
+    }
+
+    data.each do |key, value|
+      next if value.nil?
+
+      max_length = FIELD_MAX_LENGTHS[key]
+
+      if EXACT_LENGTH_FIELDS.include?(key) && value.length != max_length
+        raise ArgumentError, "Value '#{value}' of field '#{key}' must be exactly #{max_length} characters long"
+      elsif value.length > max_length
+        raise ArgumentError, "Value '#{value}' of field '#{key}' exceeds maximum length of #{max_length} characters"
+      end
+    end
+
+    if data[:seller_iban] && (!data[:seller_iban].match?(/\A[a-z]{2}\d{19}\Z/i) && !data[:seller_iban].match?(/\A\d{7}-\d{10}\Z/i))
+      raise ArgumentError, "Invalid IBAN format '#{data[:seller_iban]}' expected IBAN or account number"
+    end
+
+    data.values.join("\n")
+  end
+
+  def barcode
+    Croatia::PDF417.ensure_supported!
+    Croatia::PDF417.new(data)
+  end
+
+  def to_png(...)
+    barcode.to_png(...)
+  end
+
+  def to_svg(...)
+    barcode.to_svg(...)
+  end
+end

data/lib/croatia/pdf417.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class Croatia::PDF417
+  def self.ensure_supported!
+    return if supported?
+
+    raise LoadError, "PDF417 library is not loaded. Please ensure you have the pdf-417 gem installed."
+  end
+
+  def self.supported?
+    defined?(PDF417)
+  end
+
+  attr_reader :data, :options
+
+  def initialize(data, **options)
+    @data = data
+    @options = options
+  end
+
+  def to_svg(**options)
+    ary = bar
+
+    unless ary
+      raise ArgumentError, "Data is not valid for PDF417 encoding"
+    end
+
+    options[:x_scale] ||= 1
+    options[:y_scale] ||= 1
+    options[:margin]  ||= 10
+
+    full_width  = (ary.first.size * options[:x_scale]) + (options[:margin] * 2)
+    full_height = (ary.size       * options[:y_scale]) + (options[:margin] * 2)
+
+    dots = ary.map { |l| l.chars.map { |c| c == "1" } }
+
+    svg = []
+    svg << %Q(<?xml version="1.0" standalone="no"?>)
+    svg << %Q(<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="#{full_width}" height="#{full_height}">)
+    svg << %Q(<rect width="100%" height="100%" fill="white" />)
+
+    y = options[:margin]
+    dots.each do |line|
+      x = options[:margin]
+      line.each do |bar|
+        if bar
+          svg << %Q(<rect x="#{x}" y="#{y}" width="#{options[:x_scale]}" height="#{options[:y_scale]}" fill="black" />)
+        end
+        x += options[:x_scale]
+      end
+      y += options[:y_scale]
+    end
+
+    svg << "</svg>"
+    svg.join("\n")
+  end
+
+  def to_png(**options)
+    barcode.to_png(**options)
+  end
+
+  private
+
+    def barcode
+      @barcode ||= PDF417.new(data).tap(&:generate)
+    end
+
+    def bar
+      barcode.instance_variable_get(:@bar)
+    end
+end

data/lib/croatia/pin.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# OIB - Osobni Identifikacijski Broj
+# PIN - Personal Identification Number
 module Croatia::PIN
   def self.valid?(pin)
     return false unless pin

data/lib/croatia/qr_code.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Croatia::QRCode
+  def self.ensure_supported!
+    return if supported?
+
+    raise LoadError, "RQRCode library is not loaded. Please ensure you have the rqrcode gem installed."
+  end
+
+  def self.supported?
+    defined?(RQRCode)
+  end
+
+  attr_reader :data, :options
+
+  def initialize(data, **options)
+    @data = data
+    @options = options
+  end
+
+  def to_svg(**options)
+    qr_code.as_svg(**options)
+  end
+
+  def to_png(**options)
+    qr_code.as_png(**options)
+  end
+
+  private
+
+    def qr_code
+      @qr_code ||= RQRCode::QRCode.new(data, **options)
+    end
+end

data/lib/croatia/umcn.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# JMBG - Jedinstveni Matični Broj Građana
+# UMCN - Unique Master Citizen Number
+module Croatia::UMCN
+  def self.valid?(umcn)
+    return false unless umcn =~ /\A\d{13}\Z/
+
+    digits = umcn.chars.map(&:to_i)
+
+    day = digits[0..1].join.to_i
+    month = digits[2..3].join.to_i
+    year = digits[4..6].join.to_i
+    century = case digits[4]
+    when 0 then 2000
+    when 9 then 1800
+    else 1900
+    end
+    full_year = century + year
+
+    return false unless Date.valid_date?(full_year, month, day)
+
+    weights = [ 7, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2 ]
+    sum = digits[0..11].each_with_index.sum { |d, i| d * weights[i] }
+    mod = sum % 11
+    checksum = mod == 0 || mod == 1 ? 0 : 11 - mod
+
+    digits[12] == checksum
+  end
+end

data/lib/croatia/utils/enum.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Croatia::Enum
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def enum(name, values, **options)
+      name = name.to_s.to_sym unless name.is_a?(Symbol)
+      values = values.zip(values) if values.is_a?(Array)
+
+      unless values.respond_to?(:to_h)
+        raise ArgumentError, "Enum values must be defined as a Hash or as an Array"
+      end
+
+      values = values.to_h.freeze
+      values_method_name = "#{name}_values".to_sym
+
+      define_singleton_method(values_method_name) do
+        values
+      end
+
+      define_method("#{name}=") do |value|
+        values = self.class.public_send(values_method_name)
+
+        enum_value = values[value]
+        enum_value = value if enum_value.nil? && values.has_value?(value)
+
+        if enum_value.nil? && !options[:allow_nil]
+          raise ArgumentError, "Invalid value for enum #{name}: #{value.inspect}"
+        end
+
+        instance_variable_set("@#{name}", enum_value)
+      end
+
+      define_method(name) do
+        instance_variable_get("@#{name}")
+      end
+
+      prefix = options[:prefix] ? "#{options[:prefix]}_" : ""
+      suffix = options[:suffix] ? "_#{options[:suffix]}" : ""
+
+      values.each do |key, value|
+        value_method_name = "#{prefix}#{key}#{suffix}"
+
+        define_method("#{value_method_name}?") do
+          instance_variable_get("@#{name}") == value
+        end
+
+        define_method("#{value_method_name}!") do
+          public_send("#{name}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/croatia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Croatia
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/croatia.rb

@@ -4,4 +4,39 @@ require_relative "croatia/version"
 
 module Croatia
   class Error < StandardError; end
+
+  autoload :Config, "croatia/config"
+  autoload :Enum, "croatia/utils/enum"
+  autoload :QRCode, "croatia/qr_code"
+  autoload :PDF417, "croatia/pdf417"
+  autoload :PIN, "croatia/pin"
+  autoload :UMCN, "croatia/umcn"
+  autoload :PaymentBarcode, "croatia/payment_barcode"
+  autoload :Fiscalizer, "croatia/fiscalizer"
+  autoload :Invoice, "croatia/invoice"
+
+  class << self
+    def with_config(config = nil, &block)
+      Thread.current[:tmp_croatia_config] = config
+      block.call
+    ensure
+      Thread.current[:tmp_croatia_config] = nil
+    end
+
+    def config
+      return Thread.current[:tmp_croatia_config] if Thread.current[:tmp_croatia_config]
+
+      @config ||= Croatia::Config.new
+    end
+
+    def configure(config = nil, &block)
+      if config.is_a?(Croatia::Config)
+        @config = config
+      elsif block
+        self.config.tap(&block)
+      else
+        raise ArgumentError, "Either a Croatia::Config instance or a block is required"
+      end
+    end
+  end
 end

metadata

@@ -1,29 +1,84 @@
 --- !ruby/object:Gem::Specification
 name: croatia
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Stanko K.R.
 bindir: exe
 cert_chain: []
-date: 2025-05-29 00:00:00.000000000 Z
-dependencies: []
-description: 'Croatia is a gem that contains various utilities for performing Croatia-specific
-  actions - like PIN/OIB validation
-
-  '
+date: 2025-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Croatia is a gem that contains various utilities for performing Croatia-specific actions like:
+  - PIN/OIB validation
 email:
 - hey@stanko.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - LICENSE.txt
 - Rakefile
 - lib/croatia.rb
+- lib/croatia/config.rb
+- lib/croatia/fiscalizer.rb
+- lib/croatia/fiscalizer/xml_builder.rb
+- lib/croatia/invoice.rb
+- lib/croatia/invoice/e_invoicable.rb
+- lib/croatia/invoice/fiscalizable.rb
+- lib/croatia/invoice/line_item.rb
+- lib/croatia/invoice/party.rb
+- lib/croatia/invoice/payable.rb
+- lib/croatia/invoice/tax.rb
+- lib/croatia/payment_barcode.rb
+- lib/croatia/pdf417.rb
 - lib/croatia/pin.rb
+- lib/croatia/qr_code.rb
+- lib/croatia/umcn.rb
+- lib/croatia/utils/enum.rb
 - lib/croatia/version.rb
 - sig/croatia.rbs
 homepage: https://github.com/monorkin/croatia

data/.rubocop.yml

@@ -1,5 +0,0 @@
-inherit_gem:
-  rubocop-rails-omakase: rubocop.yml
-
-AllCops:
-  TargetRubyVersion: 3.1