ruby_danfe 0.9.0 → 1.11.5

data/lib/ruby_danfe/descricao.rb

@@ -0,0 +1,44 @@
+#encoding: utf-8
+
+module RubyDanfe
+  class Descricao
+    LINEBREAK = "\n"
+
+    def self.generate(det)
+      descricao = "#{det.css('prod/xProd').text}"
+
+      if need_infAdProd(det)
+        descricao += LINEBREAK
+        descricao += det.css('infAdProd').text
+      end
+
+      if need_fci(det)
+        descricao += LINEBREAK
+        descricao += "FCI: #{det.css('prod/nFCI').text}"
+      end
+
+      if need_st(det)
+        descricao += LINEBREAK
+        descricao += "ST: MVA: #{det.css('ICMS/*/pMVAST').text}% "
+        descricao += "* Alíq: #{det.css('ICMS/*/pICMSST').text}% "
+        descricao += "* BC: #{det.css('ICMS/*/vBCST').text} "
+        descricao += "* Vlr: #{det.css('ICMS/*/vICMSST').text}"
+      end
+
+      descricao
+    end
+
+    private
+    def self.need_infAdProd(det)
+      !det.css('infAdProd').text.empty?
+    end
+
+    def self.need_fci(det)
+      !det.css('prod/nFCI').text.empty?
+    end
+
+    def self.need_st(det)
+      det.css('ICMS/*/vBCST').text.to_i > 0
+    end
+  end
+end

data/lib/ruby_danfe/document.rb

@@ -0,0 +1,80 @@
+module RubyDanfe
+  class Document
+    def initialize
+      @document = Prawn::Document.new(
+        :page_size => 'A4',
+        :page_layout => :portrait,
+        :left_margin => 0,
+        :right_margin => 0,
+        :top_margin => 0,
+        :botton_margin => 0
+      )
+
+      @document.font "Times-Roman"
+    end
+
+    def method_missing(method_name, *args, &block)
+      @document.send(method_name, *args, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @document.respond_to?(method_name, include_private) || super
+    end
+
+    def ititle(h, w, x, y, title)
+      self.text_box title, :size => 10, :at => [x.cm, Helper.invert(y.cm) - 2], :width => w.cm, :height => h.cm, :style => :bold
+    end
+
+    def ibarcode(h, w, x, y, info)
+      Barby::Code128C.new(info).annotate_pdf(self, :x => x.cm, :y => Helper.invert(y.cm), :width => w.cm, :height => h.cm) if info != ''
+    end
+
+    def iqrcode(h, w, x, y, info)
+      Barby::QrCode.new(info, :level => :q).annotate_pdf(self, :x => x.cm, :y => Helper.invert(y.cm), :width => w.cm, :height => h.cm) if info != ''
+    end
+
+    def irectangle(h, w, x, y)
+      self.stroke_rectangle [x.cm, Helper.invert(y.cm)], w.cm, h.cm
+    end
+
+    def ibox(h, w, x, y, title = '', info = '', options = {})
+      box [x.cm, Helper.invert(y.cm)], w.cm, h.cm, title, info, options
+    end
+
+    def idate(h, w, x, y, title = '', info = '', options = {})
+      tt = info.gsub(/T.*/, '').split('-')
+      ibox h, w, x, y, title, "#{tt[2]}/#{tt[1]}/#{tt[0]}", options
+    end
+
+    def box(at, w, h, title = '', info = '', options = {})
+      options = {
+        :align => :left,
+        :size => 10,
+        :style => nil,
+        :valign => :top,
+        :border => 1
+      }.merge(options)
+      self.stroke_rectangle at, w, h if options[:border] == 1
+      self.text_box title, :size => 6, :style => :italic, :at => [at[0] + 2, at[1] - 2], :width => w - 4, :height => 8 if title != ''
+      self.text_box info, :size => options[:size], :at => [at[0] + 2, at[1] - (title != '' ? 14 : 4) ], :width => w - 4, :height => h - (title != '' ? 14 : 4), :align => options[:align], :style => options[:style], :valign => options[:valign]
+    end
+
+    def inumeric(h, w, x, y, title = '', info = '', options = {})
+      numeric [x.cm, Helper.invert(y.cm)], w.cm, h.cm, title, info, options
+    end
+
+    def numeric(at, w, h, title = '', info = '', options = {})
+      options = {:decimals => 2}.merge(options)
+      info = Helper.numerify(info, options[:decimals]) if info != ''
+      box at, w, h, title, info, options.merge({:align => :right})
+    end
+
+    def itable(h, w, x, y, data, options = {}, &block)
+      self.bounding_box [x.cm, Helper.invert(y.cm)], :width => w.cm, :height => h.cm do
+        self.table data, options do |table|
+          yield(table)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_danfe/helper.rb

@@ -0,0 +1,68 @@
+module RubyDanfe
+  class Helper
+    def self.numerify(number, decimals = 2)
+      number = number.tr("\n","").delete(" ")
+      return "" if !number || number == ""
+      int, frac = ("%.#{decimals}f" % number).split(".")
+      int.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1\.")
+      int + "," + frac
+      rescue
+        number
+    end
+
+    def self.invert(y)
+      28.7.cm - y
+    end
+
+    def self.format_quantity(qty)
+      return Helper.numerify(qty, RubyDanfe.options.quantity_decimals) if RubyDanfe.options.numerify_prod_qcom
+      qty.gsub!(",", ".")
+      qty[qty.rindex('.')] = ',' if qty.rindex('.')
+      qty
+    end
+
+    def self.format_datetime(string)
+      formated_datetime = ""
+
+      if not string.empty?
+        date = DateTime.strptime(string, "%Y-%m-%dT%H:%M:%S")
+        formated_datetime = date.strftime("%d/%m/%Y %H:%M:%S")
+      end
+
+      formated_datetime
+    end
+
+    def self.format_date(string)
+      formated_date = ""
+
+      if not string.empty?
+        date = Date.strptime(string, "%Y-%m-%d")
+        formated_date = date.strftime("%d/%m/%Y")
+      end
+
+      formated_date
+    end
+
+    def self.format_time(string)
+      formated_time = ""
+
+      if not string.empty?
+        time = Time.strptime(string, "%H:%M:%S")
+        formated_time = time.strftime("%H:%M:%S")
+      end
+
+      formated_time
+    end
+
+    def self.extract_time_from_date(string)
+      formated_time = ""
+
+      if not string.empty?
+        date = DateTime.strptime(string, "%Y-%m-%dT%H:%M:%S")
+        formated_time = date.strftime("%H:%M:%S")
+      end
+
+      formated_time
+    end
+  end
+end

data/lib/ruby_danfe/options.rb

@@ -0,0 +1,24 @@
+module RubyDanfe
+  class Options < OpenStruct
+
+    DEFAULTOPTIONS = {
+      quantity_decimals: 2,
+      numerify_prod_qcom: false
+    }
+
+    def initialize(new_options={})
+      options = DEFAULTOPTIONS.merge(config_yaml_load)
+      super options.merge(new_options)
+    end
+
+    private
+      def file
+        File.exists?("config/ruby_danfe.yml") ? File.open("config/ruby_danfe.yml").read : ""
+      end
+
+      def config_yaml_load
+        @file_read = YAML.load(file)
+        @file_read ? (@file_read["ruby_danfe"]||{})["options"] : {}
+      end
+  end
+end

data/lib/ruby_danfe/railtie.rb

@@ -0,0 +1,20 @@
+require "prawn"
+require "prawn/measurement_extensions"
+require "barby"
+require "barby/barcode/code_128"
+require "barby/outputter/prawn_outputter"
+require "nokogiri"
+require 'ostruct'
+require 'yaml'
+
+require_relative '../ruby_danfe.rb'
+require_relative 'options.rb'
+require_relative 'helper.rb'
+require_relative 'cst.rb'
+require_relative 'document.rb'
+require_relative 'version.rb'
+require_relative 'dacte_generator.rb'
+require_relative 'danfe_generator.rb'
+require_relative 'xml.rb'
+require_relative 'descricao.rb'
+require_relative 'ruby_danfe.rb'

data/lib/ruby_danfe/ruby_danfe.rb

@@ -0,0 +1,49 @@
+# encoding:utf-8
+module RubyDanfe
+  def self.generate(pdf_filename, xml_filename, type = :danfe, new_options = {})
+    self.options = new_options if !new_options.empty?
+
+    xml_string = File.new(xml_filename)
+    render_file(pdf_filename, xml_string, type)
+  end
+
+  def self.render(xml_string, type = :danfe, new_options = {})
+    self.options = new_options if !new_options.empty?
+
+    pdf = generatePDF(xml_string, type)
+    pdf.render
+  end
+
+  def self.render_file(pdf_filename, xml_string, type = :danfe, new_options = {})
+    self.options = new_options if !new_options.empty?
+
+    pdf = generatePDF(xml_string, type)
+    pdf.render_file pdf_filename
+  end
+
+  def self.options
+    @options ||= RubyDanfe::Options.new
+  end
+
+  def self.options=(new_options = {})
+    @options = RubyDanfe::Options.new(new_options)
+  end
+
+  private
+    def self.generatePDF(xml_string, type = :danfe, new_options = {})
+      self.options = new_options if !new_options.empty?
+
+      xml = XML.new(xml_string)
+
+      if type == :danfe
+        generator = DanfeGenerator.new(xml)
+      elsif type == :danfe_nfce
+        generator = DanfeNfceGenerator.new(xml)
+      else
+        generator = DacteGenerator.new(xml)
+      end
+
+      pdf = generator.generatePDF
+      pdf
+    end
+end

data/lib/ruby_danfe/version.rb

@@ -0,0 +1,3 @@
+module RubyDanfe
+  VERSION = "1.11.5"
+end

data/lib/ruby_danfe/xml.rb

@@ -0,0 +1,58 @@
+module RubyDanfe
+  class XML
+    def css(xpath)
+      @xml.css(xpath)
+    end
+
+    def xpath(regex)
+      doc = Nokogiri::HTML(@xml.to_s)
+      return doc.xpath(regex)
+    end
+
+    def regex_string(search_string, regex)
+      doc = Nokogiri::HTML(search_string)
+      return doc.xpath(regex)      
+    end
+
+    def initialize(xml)
+      @xml = Nokogiri::XML(xml)
+    end
+
+    def [](xpath)
+      node = @xml.css(xpath)
+      return node ? node.text : ""
+    end
+
+    def render
+      if @xml.at_css('infNFe/ide')
+        RubyDanfe.render @xml.to_s, :danfe
+      else
+        RubyDanfe.render @xml.to_s, :dacte
+      end
+    end
+
+    def collect(ns, tag, &block)
+      result = []
+      # Tenta primeiro com uso de namespace
+      begin
+        @xml.xpath("//#{ns}:#{tag}").each do |det|
+          result << yield(det)
+        end
+      rescue
+        # Caso dê erro, tenta sem
+        @xml.xpath("//#{tag}").each do |det|
+          result << yield(det)
+        end
+      end
+      result
+    end
+
+    def attrib(node, attrib)
+      begin
+        return @xml.css(node).attr(attrib).text
+      rescue
+        ""
+      end
+    end
+  end
+end

data/ruby_danfe.gemspec

@@ -1,12 +1,27 @@
-Gem::Specification.new do |s|
-  s.name        = 'ruby_danfe'
-  s.version     = '0.9.0'
-  s.summary     = "DANFE generator for Brazilian NFE."
-  s.authors     = ["Eduardo Rebouças"]
-  s.email       = 'eduardo.reboucas@gmail.com'
-  s.files       = ["ruby_danfe.gemspec", "lib/ruby_danfe.rb"]
-  s.add_dependency('nokogiri')
-  s.add_dependency('prawn')
-  s.add_dependency('barby')
-  s.homepage    = 'https://github.com/taxweb/ruby_danfe'
+# coding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby_danfe/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_danfe"
+  spec.version       = RubyDanfe::VERSION
+  spec.summary       = "DANFE and DACTE pdf generator for Brazilian invoices and transportation docs."
+  spec.author        = "Eduardo Reboucas"
+  spec.email         = "eduardo.reboucas@gmail.com"
+  spec.homepage      = "http://github.com/taxweb/ruby_danfe"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "prawn", '~> 1.0.0'
+  spec.add_dependency "barby"
+  spec.add_dependency "rake"
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
 end

data/spec/features/ruby_danfe_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe "RubyDanfe generated pdf files" do
+  let(:base_dir) { "./spec/fixtures/"}
+  let(:output_pdf) { "#{base_dir}output.pdf" }
+
+  before {
+    File.delete(output_pdf) if File.exist?(output_pdf)
+    RubyDanfe.options = {"quantity_decimals" => 2}
+  }
+
+  it "renders a basic NF-e with namespace" do
+    expect(File.exist?(output_pdf)).to be_false
+
+    RubyDanfe.generate(output_pdf, "#{base_dir}nfe_with_ns.xml")
+
+    expect("#{base_dir}nfe_with_ns.xml.fixture.pdf").to be_same_file_as(output_pdf)
+  end
+
+  it "renders another basic NF-e without namespace" do
+    expect(File.exist?(output_pdf)).to be_false
+
+    RubyDanfe.generate(output_pdf, "#{base_dir}nfe_without_ns.xml")
+
+    expect("#{base_dir}nfe_without_ns.xml.fixture.pdf").to be_same_file_as(output_pdf)
+  end
+
+  it "renders a NF-e having FCI in its items" do
+    expect(File.exist?(output_pdf)).to be_false
+
+    RubyDanfe.generate(output_pdf, "#{base_dir}nfe_with_fci.xml")
+
+    expect("#{base_dir}nfe_with_fci.xml.fixture.pdf").to be_same_file_as(output_pdf)
+  end
+
+  it "renders a NF-e of Simples Nacional using CSOSN" do
+    expect(File.exist?(output_pdf)).to be_false
+
+    RubyDanfe.generate(output_pdf, "#{base_dir}nfe_simples_nacional.xml")
+
+    expect("#{base_dir}nfe_simples_nacional.xml.fixture.pdf").to be_same_file_as(output_pdf)
+  end
+
+  it "renders a basic CT-e" do
+    expect(File.exist?(output_pdf)).to be_false
+
+    RubyDanfe.generate(output_pdf, "#{base_dir}cte.xml", :dacte)
+
+    expect("#{base_dir}cte.xml.fixture.pdf").to be_same_file_as(output_pdf)
+  end
+
+  it "renders quantity field with 4 decimals" do
+    expect(File.exist?(output_pdf)).to be_false
+
+    RubyDanfe.generate(output_pdf, "#{base_dir}4_decimals_nfe_simples_nacional.xml", :danfe, {"quantity_decimals" => 4})
+
+    expect("#{base_dir}4_decimals_nfe_simples_nacional.xml.fixture.pdf").to be_same_file_as(output_pdf)
+  end
+end