arquivo 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db2e214ab2f4424ed534529d6601643e05256b201c75ac4d6ce13ce63167f62e
-  data.tar.gz: 657d0d3b58f42150e1930d669444ab71a019df9e2b006abc2ac75caee8e4a1ee
+  metadata.gz: ed65dd3f514e1950093d139e190ba9104037dc1637f4aa63a879aa5a26e7707f
+  data.tar.gz: 75603c49ac01b58575ad63bba4aee0cf5265594fa41a95407aaa10125a717cf4
 SHA512:
-  metadata.gz: 7aa8742696b7e53e4af0ff69c8c85b71fa48969751d96f162c8546d276373796c2c0dba1a075d5d00fec89ed24bda847083e1061d7698d4919e1b0815211c91c
-  data.tar.gz: 074e49e12a77c243ff62b32bde04b6d72e84576da5f152db4e3c85b643b245cca8f59058a010ea6318c92aed10f2776d339fb5a047e52ab8614f560aa19d00d4
+  metadata.gz: 2440e3fa68fbc48bc7e34432bcbb0d832d6c530c3dbbe872b649cb9f7c6d830b7e04034621b8dbbc8a2ad506abce5587394b6334c324f9c1932fd0f09cdca2d4
+  data.tar.gz: dc20b52f6c192f51922637b96ebc8cc063178ce5812a8947aa0cc1f13c395cbba8698a0810d4269e70af9693cbbaf72ce54905726a46c74c8c958e7615a9a536

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    arquivo (0.2.1)
+    arquivo (0.2.2)
       fastimage (~> 2.1)
       google-api-client (~> 0.34)
       pdf-reader (~> 2.3)
       thor (~> 0.1)
+      yard (~> 0.9)
 
 GEM
   remote: https://rubygems.org/
@@ -19,7 +20,7 @@ GEM
     faraday (0.17.1)
       multipart-post (>= 1.2, < 3)
     fastimage (2.1.7)
-    google-api-client (0.36.1)
+    google-api-client (0.36.2)
       addressable (~> 2.5, >= 2.5.1)
       googleauth (~> 0.9)
       httpclient (>= 2.8.1, < 3.0)
@@ -64,6 +65,7 @@ GEM
     thor (0.20.3)
     ttfunk (1.5.1)
     uber (0.1.0)
+    yard (0.9.20)
 
 PLATFORMS
   ruby

data/README.md

@@ -1,6 +1,6 @@
 # Arquivo
 
-Processa documentos do condominio ph1341c118 para arquivo.
+Processa documentos do condominio ph1341c118 para arquivo. Pode tambem segmentar PDFs e MINUTAS. Tendo os documentos em pastas separadas, pode ainda criar arquivos apropriados.
 
 ## Installation
 
@@ -20,9 +20,9 @@ Or install it yourself as:
 
 ## Usage
 
-    $ arquivo dir PASTA       # processa faturas/recibos/extratos/minutas
-    $ arquivo pdf FILE        # processa extratos ou faturas
-    $ arquivo help [COMMAND]  # Describe available commands or one specific command
+    $ arquivo mp3 MINUTA  # processa MINUTA criando pasta com segmentos para arquivo
+    $ arquivo pdf EXTRATO # processa EXTRATO criando pasta com documentos para arquivo
+    $ arquivo dir PASTA   # processa faturas/recibos/extratos/minutas e cria arquivos c118
 
 ## Development
 

data/arquivo.gemspec

@@ -5,15 +5,19 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'arquivo/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'arquivo'
-  spec.version       = Arquivo::VERSION
-  spec.authors     = ['Hernâni Rodrigues Vaz']
-  spec.email       = ['hernanirvaz@gmail.com']
-  spec.homepage    = 'https://github.com/ph1341c118/arquivo'
+  spec.name         = 'arquivo'
+  spec.version      = Arquivo::VERSION
+  spec.authors      = ['Hernâni Rodrigues Vaz']
+  spec.email        = ['hernanirvaz@gmail.com']
+  spec.homepage     = 'https://github.com/ph1341c118/arquivo'
 
-  spec.summary       = 'Write a short summary, because RubyGems requires one.'
-  spec.description   = ' Write a longer description or delete this line.'
-  spec.license       = 'MIT'
+  spec.summary      = 'Processa documentos do condominio ph1341c118 ' \
+                      'para arquivo.'
+  spec.description  = spec.summary
+  spec.description += ' Pode tambem segmentar PDFs e MINUTAS. ' \
+                      'Tendo os documentos em pastas separadas, pode ainda ' \
+                      'criar arquivos apropriados.'
+  spec.license = 'MIT'
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['yard.run'] = 'yard'
@@ -36,4 +40,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'google-api-client', '~> 0.34'
   spec.add_dependency 'pdf-reader', '~> 2.3'
   spec.add_dependency 'thor', '~> 0.1'
+  spec.add_dependency 'yard', '~> 0.9'
 end

data/lib/arquivo.rb

@@ -7,36 +7,47 @@ require 'arquivo/pdf'
 require 'arquivo/jpg'
 require 'arquivo/mp3'
 
+# @author Hernani Rodrigues Vaz
+# processa documentos do condominio ph1341c118 para arquivo;
+# pode tambem segmentar PDFs e MINUTAS;
+# tendo os documentos em pastas separadas,
+# pode ainda criar arquivos apropriados.
 module Arquivo
   class Error < StandardError; end
 
-  # CLI para analisar/processar documentos c118
+  # @abstract CLI tarefas segmentar e arquivar
   class CLI < Thor
     desc 'mp3 MINUTA', 'processa MINUTA criando pasta ' \
                        'com segmentos para arquivo'
     option :tempos, type: :array, default: [],
                     desc: 'lista tempos para segmentar MINUTA, ex: [[h:]m:]s'
-    def mp3(file)
-      return unless File.exist?(file) && File.ftype(file) == 'file'
+    # segmenta minuta segundo lista tempos
+    #
+    # @param [String] minuta ficheiro audio a segmentar
+    def mp3(minuta)
+      return unless File.exist?(minuta) && File.ftype(minuta) == 'file'
 
-      f = C118mp3.new(file)
-      return unless f.processa_minuta?
+      f = C118mp3.new(minuta, options)
+      return unless f.segmenta_minuta?
 
       system "mkdir -p #{f.base}"
-      f.processa_minuta(options)
+      f.segmenta_minuta(options[:tempos])
     end
 
     desc 'pdf EXTRATO', 'processa EXTRATO criando pasta ' \
                         'com documentos para arquivo'
-    def pdf(file)
-      return unless File.exist?(file) && File.ftype(file) == 'file'
+    # segmenta extrato limpando publicidade
+    #
+    # @param [String] extrato pdf a segmentar
+    def pdf(extrato)
+      return unless File.exist?(extrato) && File.ftype(extrato) == 'file'
 
-      f = C118pdf.new(file)
+      f = C118pdf.new(extrato, options)
       return unless f.processa_extrato?
 
       system "mkdir -p #{f.base}"
       # extrato contem conta c118
-      if f.extrato?
+      if f.pagina_extrato?
         f.processa_extrato(0)
       else
         f.split
@@ -44,25 +55,28 @@ module Arquivo
     end
 
     desc 'dir PASTA', 'processa faturas/recibos/extratos/minutas ' \
-                      ' e cria arquivos c118'
+                      'e cria arquivos c118'
     option :fuzz, type: :numeric, default: 29,
                   desc: 'fuzz trim jpg N-1, escolhe menor -> scanned pdf'
     option :quality, type: :numeric, default: 15,
                      desc: 'compress jpg N% -> scanned pdf (less=low quality)'
 
-    option :noise, type: :boolean, default: false,
-                   desc: 'ruido de fundo - sim ou nao'
-    option :sound, type: :numeric, default: 1.0,
-                   desc: 'minimo som que determina fim do silencio (segundos)'
+    option :threshold, type: :numeric, default: 9,
+                       desc: 'limiar maximo para silencio, 0% = silencio puro'
+    option :sound, type: :numeric, default: 1,
+                   desc: 'segundos de som para terminar silencio'
+
     option :amount, type: :numeric, default: 0.00001,
                     desc: 'qtd ruido a ser removido'
     option :rate, type: :numeric, default: 16,
                   desc: 'sample rate - radio-16k, CD-44.1k, PC-48k, pro-96k'
+    # arquiva pasta de documentos c118
+    #
+    # @param [String] pasta contem os documentos para arquivar
+    def dir(pasta)
+      return unless File.ftype(pasta) == 'directory'
 
-    def dir(fdir)
-      return unless File.ftype(fdir) == 'directory'
-
-      C118dir.new(fdir).processa_pasta(fdir, options)
+      C118dir.new(pasta, options).processa_pasta(pasta)
     end
   end
 end

data/lib/arquivo/dir.rb

@@ -7,47 +7,32 @@ require 'googleauth/stores/file_token_store'
 require 'arquivo/noise'
 
 module Arquivo
-  O1 = '2>/dev/null'
-  O2 = '1>/dev/null 2>&1'
-  FT = ['.mp3', '.m4a', '.wav', '.sox'].freeze
+  # O1 = '2>/dev/null'
+  # O2 = '1>/dev/null 2>&1'
+  O1 = ''
+  O2 = ''
+  AT = ['.mp3', '.m4a', '.wav', '.sox'].freeze
 
-  # analisar/processar pasta
+  # permite processar e arquivar pasta com documentos c118
   class C118dir < Enumerator
-    # @return [Enumerator] items dentro duma pasta
-    attr_reader :items
-    # @return [String] documento c118
-    attr_reader :item
-
-    # @return [Hash] dados (faturas/recibos) de c118-contas
-    attr_reader :dados
-    # @return [Float] maximo segundos de silencio encontrados
-    attr_reader :silence
-    # @return [String] noiseprof do silencio encontrado
-    attr_reader :noiseprof
-
-    # @return [String] base nome ficheiros finais (pdf, tar.gz)
-    attr_reader :base
-
-    # @return [C118dir] documentos c118
-    def initialize(pasta)
-      @items = Dir.glob(File.join(pasta, '*')).each
-      @base = File.basename(pasta, File.extname(pasta)) + '-' +
-              Date.today.strftime('%Y%m%d')
-    end
-
-    def processa_items(options)
+    # @!group processamento
+    # processa items duma pasta - sub-pastas recursivamente
+    def processa_items
       n = 0
       while next_item
         if File.ftype(item) == 'directory'
-          C118dir.new(item).processa_pasta(item, options)
+          C118dir.new(item, opcoes).processa_pasta(item)
         else
-          processa_file(options, File.extname(item).downcase)
+          processa_file(File.extname(item).downcase)
           n += 1
         end
       end
       processa_fim(n)
     end
 
+    # cria ficheiros finais para arquivo
+    #
+    # @param [Numeric] num numero de documentos dentro do arquivo
     def processa_fim(num)
       return unless num.positive?
 
@@ -56,56 +41,65 @@ module Arquivo
             else
               "rm -f #{base}.*;pdftk tmp/stamped*.pdf cat output #{base}.pdf"
             end
-      # ;rm -rf tmp
       system cmd + ";cd tmp/zip;tar cf ../../#{base}.tar *" \
-                   ";cd ../..;gzip --best #{base}.tar;rm -rf tmp"
+                   ";cd ../..;gzip --best #{base}.tar" \
+                   '' # ';rm -rf tmp'
 
       puts "#{base} (#{num})"
     end
 
-    def processa_file(options, ext)
+    # processa ficheiro JPG, PDF ou AUDIO
+    #
+    # @param [String] ext tipo ficheiro
+    def processa_file(ext)
+      opt = opcoes
       case ext
-      when '.jpg' then C118jpg.new(item).processa_jpg(options, dados)
-      when '.pdf' then C118pdf.new(item).processa_pdf(options, dados)
-      when *FT
-        C118mp3.new(item).processa_mp3(options, noiseprof)
+      when '.jpg' then C118jpg.new(item, opt).processa_jpg(dados)
+      when '.pdf' then C118pdf.new(item, opt).processa_pdf(dados)
+      when *AT    then C118mp3.new(item, opt).processa_mp3(noiseprof)
       else
-        puts "erro: #{item} so posso processar"
+        puts "erro: #{ext} nao posso processar este tipo de dicheiro"
       end
     end
 
-    # @return [String] ficheiro dentro da pasta
-    def next_item
-      @item = items.next
-    rescue StopIteration
-      @item = nil
-    end
-
-    def processa_pasta(pasta, options)
+    # processa conteudo duma pasta
+    #
+    # @param pasta (see CLI#dir)
+    def processa_pasta(pasta)
       unless File.ftype(items.peek) == 'directory'
-        @dados = {}
-        obtem_dados(pasta)
-
-        @silence = 0.0
         system 'mkdir -p tmp/zip'
-        obtem_noiseprof(pasta, options)
+        obtem_dados(pasta)
+        obtem_noiseprof(pasta)
       end
-      processa_items(options)
+      processa_items
     end
 
-    def obtem_dados(dir)
-      return unless /fac?tura/i.match?(dir) || /recibo/i.match?(dir)
+    # @return [String] proximo item dentro da pasta
+    def next_item
+      @item = items.next
+    rescue StopIteration
+      @item = nil
+    end
 
-      # obtem dados (faturas/recibos) da sheet c118-contas
-      id = '1PbiMrtTtqGztZMhe3AiJbDS6NQE9o3hXebnQEFdt954'
-      sh = (/fac?tura/i.match?(dir) ? 'rft' : 'rrc') + '!A2:E'
-      @dados = c118_sheets.get_spreadsheet_values(id, sh).values
+    # @!group dados online
+    # @param pasta (see CLI#dir)
+    # @return [Hash] dados oficiais para reclassificacao de faturas e recibos
+    def obtem_dados(pasta)
+      @dados = {}
+      # somente faturas e recibos necessitam reclassificacao
+      return unless /fac?tura/i.match?(pasta) || /recibo/i.match?(pasta)
+
+      # sheet c118-contas
+      dg = '1PbiMrtTtqGztZMhe3AiJbDS6NQE9o3hXebnQEFdt954'
+      # range dos dados (faturas/recibos)
+      sh = (/fac?tura/i.match?(pasta) ? 'rft' : 'rrc') + '!A2:E'
+      @dados = c118_sheets.get_spreadsheet_values(dg, sh).values
                           .group_by { |k| k[0][/\w+/] }
     rescue StandardError
       @dados = {}
     end
 
-    # assegura credenciais validas, obtidas dum arquivo de credencias
+    # assegura credenciais validas, obtidas dum ficheiro de credencias
     #
     # @return [Google::Apis::SheetsV4::SheetsService] c118 sheets_v4
     def c118_sheets

data/lib/arquivo/extrato.rb

@@ -3,64 +3,82 @@
 require 'pdf-reader'
 
 module Arquivo
-  # analisar/processar pdf
+  # permite processar documentos PDF
   class C118pdf < String
-    def c118_gs
-      # filtrar images para scq e extratos
-      fi = /^[se]/i.match?(key) ? ' -dFILTERIMAGE' : ''
-
-      'gs -sDEVICE=pdfwrite ' \
-        '-dNOPAUSE -dBATCH -dQUIET ' \
-        '-sPAPERSIZE=a4 -dFIXEDMEDIA -dPDFFitPage ' \
-        '-dPDFSETTINGS=/screen -dDetectDuplicateImages ' \
-        '-dColorImageDownsampleThreshold=1 ' \
-        '-dGrayImageDownsampleThreshold=1 ' \
-        '-dMonoImageDownsampleThreshold=1' + fi
-    end
+    # @return [String] nome do documento
+    attr_reader :file
+    # @return [String] extensao do documento
+    attr_reader :ext
+    # @return [String] base do documento
+    attr_reader :base
+    # @return [Integer] tamanho do documento
+    attr_reader :size
+    # @return [Hash] opcoes parametrizar JPG
+    attr_reader :opcoes
+    # @return [String] id do documento ft/rc/ex/sc <numero>
+    attr_reader :id
 
-    def processa_extrato?
-      return true if ext == '.pdf' &&
-                     size.positive? &&
-                     !File.exist?(base) &&
-                     first_extrato?
+    # @return [Array<Integer>] lista paginas do extrato
+    attr_reader :paginas
+    # @return [String] texto pagina
+    attr_reader :pagina
+    # @return [String] nome extrato
+    attr_reader :nome
 
-      if File.exist?(base)
-        puts "erro: #{base} pasta ja existe"
-      else
-        puts "erro: #{file} nao consigo obter primeira pagina do EXTRATO"
-      end
-      false
+    # @param [String] pdf PDF c118
+    # @param opt (see C118jpg#initialize)
+    # @option opt (see C118jpg#initialize)
+    # @return [C118pdf] PDF c118
+    def initialize(pdf, opt)
+      @file = pdf
+      @ext = File.extname(pdf).downcase
+      @base = File.basename(pdf, File.extname(pdf))
+      @id = @base[/\w+/]
+      @size = File.size(pdf)
+      @opcoes = opt
     end
 
+    # @!group segmentacao
+    # segmenta extrato limpando publicidade
+    #
+    # @param [Integer] cnt contador pagina em processamento
     def processa_extrato(cnt)
       cnt += 1
-      @paginas << cnt if conta_c118?
+      @paginas << cnt if pagina_extrato?
       if proxima_pagina
-        faz_extrato if extrato?
+        faz_extrato if novo_extrato?
         processa_extrato(cnt)
       else
         faz_extrato
       end
     end
 
-    def extrato?
-      conta_c118? && pagina.match?(/extrato +combinado/i)
+    # @return [Boolean] posso segmentar extrato?
+    def processa_extrato?
+      return true if ext == '.pdf' && size.positive? && !File.exist?(base) &&
+                     first_pagina?
+
+      if File.exist?(base)
+        puts "erro: #{base} pasta ja existe"
+      else
+        puts "erro: #{file} nao consigo obter primeira pagina do EXTRATO"
+      end
+      false
     end
 
-    def faz_extrato
-      system "#{c118_gs} " \
-        "-sOutputFile=#{base}/#{nome}-extrato.pdf " \
-        "-sPageList=#{paginas.join(',')} \"#{file}\" #{O2}"
-      puts "#{nome}-extrato"
-      proximo_extrato
+    # @return [Boolean] primeira pagina de extrato?
+    def novo_extrato?
+      pagina_extrato? && pagina.match?(/extrato +combinado/i)
     end
 
-    def conta_c118?
+    # @return [Boolean] pagina de extrato?
+    def pagina_extrato?
       pagina.include?('45463760224')
     end
 
-    def first_extrato?
-      leitor && proxima_pagina && proximo_extrato
+    # @return [Boolean] primeira pagina?
+    def first_pagina?
+      leitor && proxima_pagina && nome_extrato
     end
 
     # @return [Enumerator::Lazy] leitor pdf
@@ -77,19 +95,31 @@ module Arquivo
       @pagina = nil
     end
 
-    def proximo_extrato
+    # @return [String] nome proximo extrato
+    def nome_extrato
       return false unless pagina
 
       @paginas = []
       n = pagina.scan(%r{N\. *(\d+)/(\d+)}).flatten
-      @nome = "ex#{n[0].to_s[/\d{2}$/]}#{n[1]}"
+      @nome = n.empty? ? nil : "ex#{n[0][/\d{2}$/]}#{n[1]}"
     rescue StandardError
       @nome = nil
     end
 
+    # cria PDF do extrato
+    def faz_extrato
+      system "#{ghostscript} " \
+        "-sOutputFile=#{base}/#{nome}-extrato.pdf " \
+        "-sPageList=#{paginas.join(',')} \"#{file}\" #{O2}"
+      puts "#{nome}-extrato"
+      nome_extrato
+    end
+
+    # segmenta PDF pelas suas paginas
     def split
       system "pdftk #{file} burst output #{base}/pg%04d-#{base}.pdf;" \
              "rm -f #{base}/*.txt"
+      puts "#{base}-split"
     end
   end
 end

data/lib/arquivo/jpg.rb

@@ -15,64 +15,83 @@ module Arquivo
   # Factor 1.04 creates 2*2% borders,
   FB = 1.04
 
-  # analisar/processar jpg
+  # permite processar documentos em imagens JPG
   class C118jpg < String
-    # @return [String] nome do ficheiro
+    # @return [String] nome do documento
     attr_reader :file
-    # @return [String] extensao do ficheiro
+    # @return [String] extensao do documento
     attr_reader :ext
-    # @return [String] base do ficheiro
+    # @return [String] base do documento
     attr_reader :base
-    # @return [String] key do documento ft????/rc????/ex??0??/sc??????
-    attr_reader :key
-    # @return [Integer] tamanho do jpg
+    # @return [Integer] tamanho do documento
     attr_reader :size
+    # @return [Hash] opcoes parametrizar JPG
+    attr_reader :opcoes
+    # @return [String] id do documento ft/rc/ex/sc <numero>
+    attr_reader :id
 
-    # @return [C118jpg] jpg c118
-    def initialize(fjpg)
-      @file = fjpg
-      @ext = File.extname(fjpg).downcase
-      @base = File.basename(fjpg, File.extname(fjpg))
-      @key = @base[/\w+/]
-      @size = File.size(fjpg)
+    # @param [String] jpg JPG c118
+    # @param [Hash] opt parametrizar JPG
+    # @option opt [Numeric] :fuzz (29) trim jpg N-1, escolhe menor ->
+    #   scanned pdf
+    # @option opt [Numeric] :quality (15) compress jpg N% -> scanned pdf
+    #   (less=low quality)
+    # @return [C118jpg] JPG c118
+    def initialize(jpg, opt)
+      @file = jpg
+      @ext = File.extname(jpg).downcase
+      @base = File.basename(jpg, File.extname(jpg))
+      @id = @base[/\w+/]
+      @size = File.size(jpg)
+      @opcoes = opt
     end
 
-    def processa_jpg(options, dados)
-      trim(options).converte(options).final(dados[key]).marca
+    # @!group processamento
+    # apara jpg e converte em pdf para arquivo
+    #
+    # @param dad (see C118pdf#processa_pdf)
+    def processa_jpg(dad)
+      apara.pdf.final(dad[id]).marca
     end
 
-    def parm_trim(options, fuzz)
-      "-fuzz #{fuzz}% -trim +repage #{parm_qualidade(options)} " \
-        "tmp/#{key}-#{fuzz}.jpg #{O2}"
-    end
-
-    def parm_qualidade(options)
-      "-quality #{options[:quality]}% -compress jpeg"
-    end
-
-    def trim(options)
-      f = options[:fuzz]
+    # @return [C118jpg] jpg com melhor aparado
+    def apara
+      f = opcoes[:fuzz]
       h = {}
-      # obter jpg menor triming borders ao maximo
+      # aparar borders ao maximo
       while f >= 1
-        system "convert \"#{file}\" #{parm_trim(options, f)}"
-        h[f] = File.size("tmp/#{key}-#{f}.jpg")
+        o = "tmp/#{id}-#{f}.jpg"
+        h[o] = size_aparado(f, o)
         f -= 4
       end
       m = h.min_by { |_, v| v }
-      m[1].between?(LT, size) ? C118jpg.new("tmp/#{key}-#{m[0]}.jpg") : self
+      m[1].between?(LT, size) ? C118jpg.new(m[0], opcoes) : self
     end
 
-    def converte(options)
-      # expande jpg on a larger canvas
-      system "convert \"#{file}\" #{expande} #{parm_qualidade(options)} " \
-             "-format pdf tmp/#{key}-trimed.pdf #{O2}"
+    # @return [C118pdf] pdf com jpg processada dentro
+    def pdf
+      system "convert \"#{file}\" #{oa4} #{oqualidade} " \
+             "-format pdf tmp/#{id}-trimed.pdf #{O2}"
+
+      C118pdf.new("tmp/#{id}-trimed.pdf", opcoes)
+    end
+
+    # @param [Numeric] fuzz fuzziness actual em processamento
+    # @param [String] out jpg aparada
+    # @return [Numeric] tamanho da jpg aparada
+    def size_aparado(fuzz, out)
+      system "convert \"#{file}\" -fuzz #{fuzz}% -trim +repage " \
+             "#{oqualidade} #{out} #{O2}"
+      File.size(out)
+    end
 
-      # devolve pdf processado a partir de jpg
-      C118pdf.new("tmp/#{key}-trimed.pdf")
+    # @return [String] opcoes comprimir jpg
+    def oqualidade
+      "-quality #{opcoes[:quality]}% -compress jpeg"
     end
 
-    def expande
+    # @return [String] opcoes centrar jpg em canvas A4
+    def oa4
       # image dimensions in pixels.
       x, y = FastImage.size(file)
 

data/lib/arquivo/mp3.rb

@@ -1,71 +1,94 @@
 # frozen_string_literal: true
 
 module Arquivo
-  # analisar/processar mp3
+  # permite processar documentos em audio
   class C118mp3 < String
-    # @return [String] nome do ficheiro
+    # @return [String] nome do documento
     attr_reader :file
-    # @return [String] extensao do ficheiro
+    # @return [String] extensao do documento
     attr_reader :ext
-    # @return [String] base do ficheiro
+    # @return [String] base do documento
     attr_reader :base
-    # @return [Float] segundos do mp3
+    # @return [Integer] tamanho do documento
     attr_reader :size
+    # @return [Hash] opcoes parametrizar MINUTA
+    attr_reader :opcoes
 
-    # @return [String] nome segmento
-    attr_reader :nome
-
-    # @return [C118mp3] mp3 c118
-    def initialize(fmp3)
-      @file = fmp3
-      @ext = File.extname(fmp3).downcase
-      @base = File.basename(fmp3, File.extname(fmp3))
-      @size = `soxi -V0 -D #{fmp3} #{O1}`.to_f
+    # @param [String] mp3 MP3 c118
+    # @param [Hash] opt parametrizar MINUTA
+    # @option opt [Numeric] :amount (0.00001) qtd ruido a ser removido,
+    # @option opt [Numeric] :rate (16) sample rate - radio-16k, CD-44.1k,
+    #   PC-48k, pro-96k
+    # @return [C118mp3] MP3 c118
+    def initialize(mp3, opt)
+      @file = mp3
+      @ext = File.extname(mp3).downcase
+      @base = File.basename(mp3, File.extname(mp3))
+      @size = `soxi -V0 -D #{mp3} #{O1}`.to_f
+      @opcoes = opt
     end
 
-    def processa_mp3(options, npr)
-      cmd = if npr
-              "noisered #{npr} #{format('%<v>.9f', v: options[:amount])} "
-            else
-              ''
-            end
-      cmd += "rate -v #{options[:rate]}k channels 1"
-      system "sox -G #{file} tmp/zip/#{base}.mp3 #{cmd} #{O2}"
+    # @!group processamento
+    # Processa mp3 para arquivo
+    #
+    # @param [String] npr perfil do silencio
+    def processa_mp3(npr)
+      system "sox -G #{file} tmp/zip/#{base}.mp3 #{onoise(npr)}#{orate} #{O2}"
     end
 
-    def segmenta(tps, pse, cmd)
-      return cmd[1..-1] unless pse < tps.size
-
-      puts proximo_segmento(pse)
+    # @param npr (see #processa_mp3)
+    # @return [String] opcoes reducao ruido de fundo
+    def onoise(npr)
+      npr ? "noisered #{npr} #{format('%<v>.9f', v: opcoes[:amount])} " : ''
+    end
 
-      cmd += ";sox #{file} #{nome} trim #{tps[pse]}"
-      pse += 1
-      cmd += " =#{tps[pse]}" if pse < tps.size
+    # @return [String] opcoes sample rate & channels
+    def orate
+      "rate -v #{opcoes[:rate]}k channels 1"
+    end
 
-      segmenta(tps, pse, cmd + " #{O2}")
+    # @!group segmentacao
+    # Segmenta minuta segundo lista tempos
+    #
+    # @param [Array] tempos lista tempos para segmentar minuta
+    # @example tempos
+    #   ["120", "10:11", "[[h:]m:]s", ...]
+    def segmenta_minuta(tempos)
+      system cmd_segmenta(['0'] + tempos, 0, '')
     end
 
-    def proximo_segmento(pse)
-      out = "s#{format('%<v>02d', v: pse)}-#{base[/\d{8}/]}#{base[/-\w+/]}"
-      @nome = "#{base}/#{out}#{ext}"
-      out
+    # @param [Integer] pse numero do segmento em processamento
+    # @return [String] nome do segmento
+    def nome_segmento(pse)
+      "s#{format('%<v>02d', v: pse)}-#{base[/\d{8}/]}#{base[/-\w+/]}"
     end
 
-    def processa_minuta(options)
-      system segmenta(['0'] + options[:tempos], 0, '')
+    # @param tempos (see #segmenta_minuta)
+    # @param pse (see #nome_segmento)
+    # @param [String] cmd comando para segmentar minuta
+    # @return [String] comando para segmentar minuta
+    def cmd_segmenta(tempos, pse, cmd)
+      return cmd[1..-1] unless pse < tempos.size
+
+      o = nome_segmento(pse)
+      cmd += ";sox #{file} #{base}/#{o}#{ext} trim #{tempos[pse]}"
+      pse += 1
+      cmd += " =#{tempos[pse]}" if pse < tempos.size
+      puts o
+
+      cmd_segmenta(tempos, pse, cmd + " #{O2}")
     end
 
-    def processa_minuta?
-      return true if FT.include?(ext) && size.positive? &&
-                     !File.exist?(base)
+    # @return [Boolean] posso segmentar minuta?
+    def segmenta_minuta?
+      return true if AT.include?(ext) && size.positive? && !File.exist?(base)
 
       if File.exist?(base)
         puts "erro: #{base} pasta ja existe"
       else
         puts 'erro: so consigo processar minutas com som ' \
-             "e tipo #{FT}"
+             "e do tipo #{AT}"
       end
-
       false
     end
   end

data/lib/arquivo/noise.rb

@@ -1,54 +1,106 @@
 # frozen_string_literal: true
 
 module Arquivo
-  # analisar/processar pasta
+  # permite processar e arquivar pasta com documentos c118
   class C118dir < Enumerator
-    def obtem_noiseprof(pasta, options)
-      return unless /minuta/i.match?(pasta) && !options[:noise]
+    # @return [Enumerator] items dentro duma pasta
+    attr_reader :items
+    # @return [String] base nome ficheiros para arquivo (pdf, tar.gz)
+    attr_reader :base
+    # @return [Hash] parametrizar JPG, MINUTA
+    attr_reader :opcoes
+    # @return [String] documento c118
+    attr_reader :item
 
-      d = Dir.glob(File.join(pasta, '*')).map { |e| [e, duracao(e)] }
-      t = 0
-      s = ['', 0, 0]
-      s = maximo(d, t += 1, options[:sound]) while t < 9 && s[2] <= silence
+    # @return (see #obtem_dados)
+    attr_reader :dados
+    # @return (see #obtem_noiseprof)
+    attr_reader :noiseprof
 
-      processa_silencio(s)
+    # @param pasta (see CLI#dir)
+    # @param [Hash] opt parametrizar JPG, MINUTA
+    # @option opt [Numeric] :fuzz (29) trim jpg N-1, escolhe menor ->
+    #   scanned pdf
+    # @option opt [Numeric] :quality (15) compress jpg N% -> scanned pdf
+    #   (less=low quality)
+    # @option opt [Numeric] :threshold (9) limiar maximo para silencio,
+    #   0% = silencio puro
+    # @option opt [Numeric] :sound (1) segundos de som para terminar silencio
+    # @option opt [Numeric] :amount (0.00001) qtd ruido a ser removido,
+    # @option opt [Numeric] :rate (16) sample rate - radio-16k, CD-44.1k,
+    #   PC-48k, pro-96k
+    # @return [C118dir] pasta de documentos c118
+    def initialize(pasta, opt)
+      @items = Dir.glob(File.join(pasta, '*')).each
+      @base = File.basename(pasta, File.extname(pasta)) + '-' +
+              Date.today.strftime('%Y%m%d')
+      @opcoes = opt
     end
 
-    def processa_silencio(seg)
-      return unless seg[2] > silence
+    # @!group perfil silencio
+    # @param pasta (see CLI#dir)
+    # @return [String] perfil do maior silencio inicial de todos segmentos audio
+    def obtem_noiseprof(pasta)
+      return unless /minuta/i.match?(pasta)
 
-      o = "tmp/silencio-#{File.basename(seg[0])}"
-      system "sox #{seg[0]} #{o} trim 0 #{seg[2]} #{O2}"
-      seg[2] = duracao(o)
-      return unless seg[2].positive?
+      l = obtem_segmentos(pasta)
+      return unless l.size.positive?
 
-      processa_noiseprof(seg, o)
-    end
+      t = -1
+      m = ['', 0]
+      m = obtem_maximo_silencio(l, t += 1) while noisy?(m, t)
 
-    def processa_noiseprof(seg, trm)
-      o = "tmp/noiseprof-#{File.basename(seg[0], File.extname(seg[0]))}"
-      # obter noiseprof do silencio encontrado
-      system "sox #{trm} -n noiseprof #{o} #{O2}"
+      cria_noiseprof(m)
+    end
 
-      # so noiseprof validos sao devolvidos
-      @silence = File.size?(o) ? seg[2] : 0.0
-      @noiseprof = silence.positive? ? o : nil
+    # @param [Array<String, Float>] seg segmento, duracao silencio inicial
+    # @param thr (see #obtem_maximo_silencio)
+    # @return [Boolean] segmento audio tem som ou silencio no inicio
+    def noisy?(seg, thr)
+      thr < opcoes[:threshold] && seg[1] <= opcoes[:sound]
     end
 
-    def maximo(seg, thr, som)
-      seg.sort.map { |e| add_silencio(e, thr, som) }.max_by { |_, _, s| s }
+    # @param [Array] lsg lista segmentos audio com duracoes
+    # @param [Numeric] thr limiar para silencio em processamento
+    # @return [Array<String, Float>] segmento com maior duracao silencio inicial
+    def obtem_maximo_silencio(lsg, thr)
+      lsg.sort.map { |e| obtem_silencio(e, thr) }.max_by { |_, s| s }
     end
 
-    def add_silencio(seg, thr, som)
+    # @param [Array<String, Float>] seg segmento audio, duracao
+    # @param thr (see #obtem_maximo_silencio)
+    # @return [Array<String, Float>] segmento audio, duracao silencio inicial
+    def obtem_silencio(seg, thr)
       o = "tmp/thr-#{File.basename(seg[0])}"
-      system "sox #{seg[0]} #{o} silence 1 #{som}t #{thr}% #{O2}"
-      s = (seg[1] - duracao(o)).round(2, half: :down)
+      system "sox #{seg[0]} #{o} silence 1 #{opcoes[:sound]}t #{thr}% #{O2}"
+
+      [seg[0], (seg[1] - duracao(o)).round(2, half: :down)]
+    end
+
+    # @param seg (see #noisy?)
+    # @return [String] perfil sonoro do silencio inicial dum segmento
+    def cria_noiseprof(seg)
+      return unless seg[1] > opcoes[:sound]
+
+      o = "tmp/noiseprof-#{File.basename(seg[0], File.extname(seg[0]))}"
+      # obter noiseprof do silencio no inicio
+      system "sox #{seg[0]} -n trim 0 #{seg[1]} noiseprof #{o} #{O2}"
+
+      # so noiseprof validos sao devolvidos
+      @noiseprof = File.size?(o).positive? ? o : nil
+    end
 
-      seg + [s > som ? s : 0.0]
+    # @param pasta (see CLI#dir)
+    # @return [Array] lista segmentos audio com duracoes
+    def obtem_segmentos(pasta)
+      AT.map { |e| Dir.glob(File.join(pasta, 's[0-9][0-9]-*' + e)) }.flatten
+        .map { |s| [s, duracao(s)] }
     end
 
-    def duracao(seg)
-      `soxi -V0 -D #{seg} #{O1}`.to_f
+    # @param [String] audio ficheiro de audio
+    # @return [Float] duracao ficheiro audio em segundos
+    def duracao(audio)
+      `soxi -V0 -D #{audio} #{O1}`.to_f
     end
   end
 end

data/lib/arquivo/pdf.rb

@@ -6,107 +6,103 @@ require 'i18n'
 I18n.config.available_locales = :pt
 
 module Arquivo
-  # analisar/processar pdf
+  # permite processar documentos PDF
   class C118pdf < String
-    # @return [String] nome do documento
-    attr_reader :file
-    # @return [String] extensao do documento
-    attr_reader :ext
-    # @return [String] base do documento
-    attr_reader :base
-    # @return [String] key do documento ft????/rc????/ex??0??/sc??????
-    attr_reader :key
-    # @return [Integer] tamanho do pdf
-    attr_reader :size
-
-    # @return [Array<Integer>] numeros pagina do extrato final
-    attr_reader :paginas
-    # @return [String] texto pagina pdf
-    attr_reader :pagina
-    # @return [String] nome extrato
-    attr_reader :nome
-
-    # @return [C118pdf] pdf c118
-    def initialize(fpdf)
-      @file = fpdf
-      @ext = File.extname(fpdf).downcase
-      @base = File.basename(fpdf, File.extname(fpdf))
-      @key = @base[/\w+/]
-      @size = File.size(fpdf)
-    end
-
-    def processa_pdf(options, dados)
-      # em caso de scanned pdf extract.trim.jpg -> trimed pdf
-      tpdf = jpg? ? extract.trim(options).converte(options) : self
+    # @!group processamento
+    # processa pdf para arquivo
+    #
+    # @param [Hash] dad dados oficiais para reclassificacao de faturas e recibos
+    # @example dad
+    #   {"ft1901"=>[["ft1901","legal","assembleia","expediente","-1395"]],
+    #    "ft1944"=>[["ft1944","banco","juro","dc3029998410","100"],
+    #               ["ft1944","banco","irc","dc3029998410","-28"]]}
+    def processa_pdf(dad)
+      o = "tmp/#{id}-extract.jpg"
+      pdf = jpg?(o) ? C118jpg.new(o, opcoes).apara.pdf : self
 
       # usar trimed pdf somente se for menor que original
-      (tpdf.size < size ? tpdf : self).final(dados[key]).marca
-    end
-
-    def marca
-      o = "tmp/stamped-#{base[/-(\w+)/, 1]}-#{key}.pdf"
-      s = '2 2 moveto /Ubuntu findfont 7 scalefont ' \
-           "setfont (#{base}) show"
-      system "#{c118_gs} -sOutputFile=tmp/stamp-#{key}.pdf -c \"#{s}\";" \
-             "pdftk tmp/zip/#{base}.pdf " \
-             "stamp tmp/stamp-#{key}.pdf output #{o} #{O2}"
-      # puts key
+      (pdf.size < size ? pdf : self).final(dad[id]).marca
     end
 
+    # @param [Array] kda lista dados para reclassificacao do documento
+    # @return [C118pdf] pdf totalmente processado
+    # @example kda-ft1901
+    #   [["ft1901","legal","assembleia","expediente","-1395"]]
     def final(kda)
-      c118_stamp(kda)
+      stamp(kda)
       o = "tmp/zip/#{base}.pdf"
 
-      system "#{c118_gs} -sOutputFile=#{o} \"#{file}\" #{O2}"
-      # usar copia do original se processado for maior
+      system "#{ghostscript} -sOutputFile=#{o} \"#{file}\" #{O2}"
+      # copia original se processado for maior
       system "cp \"#{file}\" #{o}" if File.size(o) > size
 
-      C118pdf.new(o)
+      C118pdf.new(o, opcoes)
+    end
+
+    # @param kda (see #final)
+    # @return [String] texto completo do selo
+    def stamp(kda)
+      stamp_base(kda)
+      return unless kda
+
+      stamp_digitos(kda)
+      stamp_mb(kda)
+      d = stamp_descricao(kda)
+      return if d.empty?
+
+      @base += '-' + I18n.transliterate(d, locale: :pt)
+                         .gsub(/[ [[:punct:]]]/, '-')
     end
 
-    def base_stamp(kda)
-      @base = key + '-' + rubrica(kda) + digest
+    # @param kda (see #final)
+    # @return [String] texto base do selo
+    def stamp_base(kda)
+      @base = id + '-' + stamp_rubrica(kda) + stamp_sha
     end
 
-    def vnum_stamp(kda)
+    # @param kda (see #final)
+    # @return [String] adiciona digitos do valor absoluto do documento
+    # @example kda-ft1901 (see #final)
+    def stamp_digitos(kda)
       n = kda.inject(0) { |s, e| s + e[4].to_i }.abs
       @base += '-' + format('%<valor>06d', valor: n)
     end
 
-    def numb_stamp(kda)
-      d = kda.group_by { |e| e[0][/-(mb\d{8})/, 1] }
+    # @param kda (see #final)
+    # @return [String] adiciona ids dos movimentos multibanco
+    # @example kda-ft1904
+    #   [["ft1904-mb00016410","material","mangueira","limpeza","-3998"],
+    #    ["ft1904-mb00095312","material","lampadas","sos","-4585"]]
+    def stamp_mb(kda)
+      d = kda.group_by { |e| e[0][/-(mb\d+)/, 1] }
              .keys.join('-')
       @base += '-' + d unless d.size.zero?
     end
 
-    def sfim_stamp(kda)
-      if key[0] == 'f'
+    # @param kda (see #final)
+    # @return [String] descricoes dos movimentos contabilidade
+    # @example kda-rc1911
+    #   [[_,_,"quota 2019-Janeiro","glB albino soares","541"],
+    #    [_,_,"quota 2019-Fevereiro","glB albino soares","541"]]
+    # @example kda-ft1901 (see #final)
+    def stamp_descricao(kda)
+      if id[0] == 'f'
         kda.group_by { |e| e[2] }
       else
         kda.group_by { |e| e[2][/\d{4}-(\w{3})/, 1] }
       end.keys.filter { |e| e }.join('-')
     end
 
-    def c118_stamp(kda)
-      base_stamp(kda)
-      return unless kda
-
-      vnum_stamp(kda)
-      numb_stamp(kda)
-      d = sfim_stamp(kda)
-      return if d.empty?
-
-      @base += '-' + I18n.transliterate(d, locale: :pt)
-                         .gsub(/[ [[:punct:]]]/, '-')
-    end
-
-    def rubrica(kda)
+    # @param kda (see #final)
+    # @return [String] rubrica dos movimentos contabilidade
+    # @example kda-ft1901 (see #final)
+    # @example kda-rc1911 (see #stamp_descricao)
+    def stamp_rubrica(kda)
       if kda
-        # rubrica obtida da sheet arquivo
-        # isto permite fazer re-classificacoes de documentos
-        if key[0] == 'f'
+        if id[0] == 'f'
           kda.group_by { |e| e[1] }
         else
+          # rubrica recibos = id condomino (ex: h3d)
           kda.group_by { |e| e[3][/\w+/] }
         end.keys.join('-')
       else
@@ -114,30 +110,51 @@ module Arquivo
       end
     end
 
-    def digest
+    # @return [String] SHA256 do documento para arquivar
+    def stamp_sha
       '-' + `sha256sum #{file}`[/\w+/]
     end
 
-    def jpg?
-      return false if key[0] == 'r'
+    # @param [String] jpg imagem final (se existir)
+    # @return [Boolean] scanned pdf?
+    def jpg?(jpg)
+      return false if id[0] == 'r'
 
-      o = "tmp/#{key}.txt"
-      # teste scanned pdf (se contem texto -> not scanned)
+      o = "tmp/#{id}.txt"
+      # se pdf contem texto -> not scanned
       system "pdftotext -q -eol unix -nopgbrk \"#{file}\" #{o}"
-      File.size?(o) ? false : true
-    end
+      return false if File.size?(o)
+
+      system "pdfimages -q -j \"#{file}\" tmp/#{id}"
+      # utilizar somente 1 imagem, comvertida em jpg
+      system "convert #{Dir.glob("tmp/#{id}-???.???")[0]} #{jpg} #{O2}"
 
-    def extract
-      o = "tmp/#{key}-extract.jpg"
+      File.size?(jpg) > LT
+    end
 
-      system "pdfimages -q -j \"#{file}\" tmp/#{key}"
-      # nem sempre as imagens sao jpg
-      # somente utilizar a primeira
-      g = Dir.glob("tmp/#{key}-???.???")
-      system "convert #{g[0]} #{o} #{O2}"
-      return unless File.size(o) > LT
+    # cria pdf com selo no canto inferior esquerdo
+    def marca
+      # nome pdf com selo determina a ordem das paginas no arquivo final
+      o = "tmp/stamped-#{base[/-(\w+)/, 1]}-#{id}.pdf"
+      s = '2 2 moveto /Ubuntu findfont 7 scalefont ' \
+           "setfont (#{base}) show"
+      system "#{ghostscript} -sOutputFile=tmp/stamp-#{id}.pdf -c \"#{s}\";" \
+             "pdftk tmp/zip/#{base}.pdf " \
+             "stamp tmp/stamp-#{id}.pdf output #{o} #{O2}"
+    end
 
-      C118jpg.new(o)
+    # @return [String] comando PDF language interpreter c118
+    def ghostscript
+      # filtrar images para scq e extratos
+      fi = /^[se]/i.match?(id) ? ' -dFILTERIMAGE' : ''
+
+      'gs -sDEVICE=pdfwrite ' \
+        '-dNOPAUSE -dBATCH -dQUIET ' \
+        '-sPAPERSIZE=a4 -dFIXEDMEDIA -dPDFFitPage ' \
+        '-dPDFSETTINGS=/screen -dDetectDuplicateImages ' \
+        '-dColorImageDownsampleThreshold=1 ' \
+        '-dGrayImageDownsampleThreshold=1 ' \
+        '-dMonoImageDownsampleThreshold=1' + fi
     end
   end
 end

data/lib/arquivo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Arquivo
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arquivo
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Hernâni Rodrigues Vaz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-23 00:00:00.000000000 Z
+date: 2019-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,7 +94,23 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-description: " Write a longer description or delete this line."
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Processa documentos do condominio ph1341c118 para arquivo. Pode tambem
+  segmentar PDFs e MINUTAS. Tendo os documentos em pastas separadas, pode ainda criar
+  arquivos apropriados.
 email:
 - hernanirvaz@gmail.com
 executables:
@@ -144,5 +160,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Write a short summary, because RubyGems requires one.
+summary: Processa documentos do condominio ph1341c118 para arquivo.
 test_files: []