cns 0.1.4 → 0.2.1

data/lib/cns/bigquery4.rb

@@ -8,23 +8,45 @@ module Cns
 
     # @return [String] comando insert SQL formatado det (trades)
     def det_ins
-      "insert #{BD}.det(txid,time,tp,user,btc,eur,dtc,dias) VALUES#{apide.trades.map { |h| det_val1(h) }.join(',')}"
+      "insert #{BD}.det(txid,time,tp,user,btc,eur,dtc,dias) VALUES#{apide.trades.map { |obj| det_1val(obj) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado del (ledger)
+    def del_ins
+      "insert #{BD}.del(txid,time,tp,add,moe,qt,fee) VALUES#{apide.ledger.map { |obj| del_val(obj) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado ust (trades)
+    def ust_ins
+      "insert #{BD}.ust(txid,ordertxid,pair,time,type,ordertype,price,cost,fee,vol,margin,misc,ledgers,dias) " \
+      "VALUES#{apius.trades.map { |key, val| ust_1val(key, val) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado usl (ledger)
+    def usl_ins
+      "insert #{BD}.usl(txid,refid,time,type,aclass,asset,amount,fee) " \
+      "VALUES#{apius.ledger.map { |key, val| usl_val(key, val) }.join(',')}"
+    end
+
+    # @return [String] comando insert SQL formatado fr (ledger)
+    def frl_ins
+      "insert #{BD}.fr(uuid,tipo,valor,moe,time,dias) VALUES#{apifr.ledger.map { |obj| frl_val(obj) }.join(',')}"
     end
 
     # @example (see Apice#trades_de)
     # @param [Hash] htx trade bitcoinde
     # @return [String] valores formatados det (trades parte1)
-    def det_val1(htx)
+    def det_1val(htx)
       "('#{htx[:trade_id]}'," \
       "DATETIME(TIMESTAMP('#{htx[:successfully_finished_at]}'))," \
       "'#{htx[:type]}'," \
       "'#{htx[:trading_partner_information][:username]}'," \
-      "#{det_val2(htx)}"
+      "#{det_2val(htx)}"
     end
 
-    # @param (see det_val1)
+    # @param (see det_1val)
     # @return [String] valores formatados det (trades parte2)
-    def det_val2(htx)
+    def det_2val(htx)
       'cast(' \
       "#{htx[:type] == 'buy' ? htx[:amount_currency_to_trade_after_fee] : "-#{htx[:amount_currency_to_trade]}"}" \
       ' as numeric),' \
@@ -33,36 +55,26 @@ module Cns
       "#{Integer(ops[:h][htx[:trade_id]] || 0)})"
     end
 
-    # @return [String] comando insert SQL formatado del (ledger)
-    def del_ins
-      "insert #{BD}.del(txid,time,tp,add,moe,qt,fee) VALUES#{apide.ledger.map { |h| del_val(h) }.join(',')}"
-    end
-
     # @example (see Apice#deposits_de)
     # @example (see Apice#withdrawals_de)
     # @param [Hash] hlx ledger (deposits + withdrawals) bitcoinde
     # @return [String] valores formatados del (ledger)
     def del_val(hlx)
+      tip = hlx[:tp]
       "(#{hlx[:txid]}," \
       "DATETIME(TIMESTAMP('#{hlx[:time].iso8601}'))," \
-      "'#{hlx[:tp]}'," \
+      "'#{tip}'," \
       "'#{hlx[:add]}'," \
       "'#{hlx[:moe]}'," \
-      "cast(#{hlx[:tp] =='withdrawal' ? '-' : ''}#{hlx[:qt]} as numeric)," \
+      "cast(#{tip == 'withdrawal' ? '-' : ''}#{hlx[:qt]} as numeric)," \
       "cast(#{hlx[:fee]} as numeric))"
     end
 
-    # @return [String] comando insert SQL formatado ust (trades)
-    def ust_ins
-      "insert #{BD}.ust(txid,ordertxid,pair,time,type,ordertype,price,cost,fee,vol,margin,misc,ledgers,dias) " \
-      "VALUES#{apius.trades.map { |k, v| ust_val1(k, v) }.join(',')}"
-    end
-
     # @example (see Apice#trades_us)
     # @param [String] idx identificador transacao
     # @param [Hash] htx trade kraken
     # @return [String] valores formatados ust (trades parte1)
-    def ust_val1(idx, htx)
+    def ust_1val(idx, htx)
       "('#{idx}'," \
       "'#{htx[:ordertxid]}'," \
       "'#{htx[:pair]}'," \
@@ -72,81 +84,70 @@ module Cns
       "cast(#{htx[:price]} as numeric)," \
       "cast(#{htx[:cost]} as numeric)," \
       "cast(#{htx[:fee]} as numeric)," \
-      "#{ust_val2(idx, htx)}"
+      "#{ust_2val(idx, htx)}"
     end
 
-    # @param (see ust_val1)
+    # @param (see ust_1val)
     # @return [String] valores formatados ust (trades parte2)
-    def ust_val2(idx, htx)
+    def ust_2val(idx, htx)
+      msc = htx[:misc].to_s
       "cast(#{htx[:vol]} as numeric)," \
       "cast(#{htx[:margin]} as numeric)," \
-      "#{htx[:misc].to_s.empty? ? 'null' : "'#{htx[:misc]}'"}," \
-      "'#{apius.ledger.select { |_, v| v[:refid] == idx }.keys.join(',') || ''}'," \
+      "#{msc.empty? ? 'null' : "'#{msc}'"}," \
+      "'#{apius.ledger.select { |_, val| val[:refid] == idx }.keys.join(',') || ''}'," \
       "#{Integer(ops[:h][idx] || 0)})"
     end
 
-    # @return [String] comando insert SQL formatado usl (ledger)
-    def usl_ins
-      "insert #{BD}.usl(txid,refid,time,type,aclass,asset,amount,fee) " \
-      "VALUES#{apius.ledger.map { |k, v| usl_val(k, v) }.join(',')}"
-    end
-
     # @example (see Apice#ledger_us)
-    # @param idx (see ust_val1)
+    # @param idx (see ust_1val)
     # @param [Hash] hlx ledger kraken
     # @return [String] valores formatados usl (ledger)
     def usl_val(idx, hlx)
+      acl = hlx[:aclass].to_s
       "('#{idx}'," \
       "'#{hlx[:refid]}'," \
       "PARSE_DATETIME('%s', '#{String(hlx[:time].round)}')," \
       "'#{hlx[:type]}'," \
-      "#{hlx[:aclass].to_s.empty? ? 'null' : "'#{hlx[:aclass]}'"}," \
+      "#{acl.empty? ? 'null' : "'#{acl}'"}," \
       "'#{hlx[:asset]}'," \
       "cast(#{hlx[:amount]} as numeric)," \
       "cast(#{hlx[:fee]} as numeric))"
     end
 
-    # @return [String] comando insert SQL formatado fr (ledger)
-    def frl_ins
-      "insert #{BD}.fr(uuid,tipo,valor,moe,time,dias) VALUES#{apifr.ledger.map { |h| frl_val(h) }.join(',')}"
-    end
-
     # @example (see Apice#ledger_fr)
     # @param [Hash] hlx ledger paymium
     # @return [String] valores formatados frl (ledger)
     def frl_val(hlx)
-      "('#{hlx[:uuid]}'," \
+      uid = hlx[:uuid]
+      "('#{uid}'," \
       "'#{hlx[:name]}'," \
       "cast(#{hlx[:amount]} as numeric)," \
       "'#{hlx[:currency]}'," \
       "PARSE_DATETIME('%s', '#{hlx[:created_at_int]}')," \
-      "#{Integer(ops[:h][hlx[:uuid]] || 0)})"
-    end
-
-    # @return [String] comando insert SQL formatado fr (ledger)
-    def mtl_ins
-      "insert #{BD}.mt(id,time,type,valor,moe,pair,note,trade_id,dias) " \
-      "VALUES#{apimt.ledger.map { |h| mtl_val1(h) }.join(',')}"
+      "#{Integer(ops[:h][uid] || 0)})"
     end
 
     # @example (see Apice#ledger_mt)
     # @param [Hash] hlx ledger therock
     # @return [String] valores formatados mtl (ledger parte1)
-    def mtl_val1(hlx)
+    def mtl_1val(hlx)
+      fid = hlx[:fund_id].to_s
       "(#{hlx[:id]}," \
       "DATETIME(TIMESTAMP('#{hlx[:date]}'))," \
       "'#{hlx[:type]}'," \
       "cast(#{hlx[:price]} as numeric)," \
       "'#{hlx[:currency]}'," \
-      "#{hlx[:fund_id].to_s.empty? ? 'null' : "'#{hlx[:fund_id]}'"}," \
-      "#{mtl_val2(hlx)}"
+      "#{fid.empty? ? 'null' : "'#{fid}'"}," \
+      "#{mtl_2val(hlx)}"
     end
 
-    # @param (see mtl_val1)
+    # @param (see mtl_1val)
     # @return [String] valores formatados mtl (ledger parte2)
-    def mtl_val2(hlx)
-      "#{hlx[:note].to_s.empty? ? 'null' : "'#{hlx[:note]}'"}," \
-      "#{hlx[:trade_id].to_s.empty? ? 'null' : (hlx[:trade_id]).to_s}," \
+    def mtl_2val(hlx)
+      nte = hlx[:note].to_s
+      tid = hlx[:trade_id].to_s
+      "#{nte.empty? ? 'null' : "'#{nte}'"}," \
+      "#{tid.empty? ? 'null' : tid.to_s}," \
       "#{Integer(ops[:h][String(hlx[:id])] || 0)})"
     end
   end

data/lib/cns/bitcoinde.rb

@@ -27,25 +27,25 @@ module Cns
 
     # @return [Array<Hash>] lista trades bitcoinde novos
     def trades
-      @trades ||= exd[:tt].select { |h| kyt.include?(h[:trade_id]) }
+      @trades ||= exd[:tt].select { |obj| kyt.include?(obj[:trade_id]) }
     end
 
     # @return [Array<Hash>] lista ledger (deposits + withdrawals) bitcoinde novos
     def ledger
-      @ledger ||= exd[:tl].select { |h| kyl.include?(h[:txid]) }
+      @ledger ||= exd[:tl].select { |obj| kyl.include?(obj[:txid]) }
     end
 
     # @return [String] texto saldos & transacoes & ajuste dias
     def mostra_resumo
       puts("\nBITCOINDE\ntipo              bitcoinde              bigquery")
-      exd[:sl].each { |k, v| puts(formata_saldos(k, v)) }
+      exd[:sl].each { |key, val| puts(formata_saldos(key, val)) }
       mostra_totais
 
       mostra_trades
       mostra_ledger
       return if trades.empty?
 
-      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
+      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |obj| "#{obj}:0" }.join(' ')}")
     end
 
     # @return [Hash] dados exchange bitcoinde - saldos & trades & deposits & withdrawals
@@ -59,12 +59,12 @@ module Cns
 
     # @return [Array<String>] lista txid dos trades novos
     def kyt
-      @kyt ||= exd[:tt].map { |h| h[:trade_id] }.flatten - (ops[:t] ? [] : bqd[:nt].map { |e| e[:txid] })
+      @kyt ||= exd[:tt].map { |oex| oex[:trade_id] }.flatten - (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:txid] })
     end
 
     # @return [Array<Integer>] lista txid dos ledger novos
     def kyl
-      @kyl ||= exd[:tl].map { |h| h[:txid] }.flatten - (ops[:t] ? [] : bqd[:nl].map { |e| e[:txid] })
+      @kyl ||= exd[:tl].map { |oex| oex[:txid] }.flatten - (ops[:t] ? [] : bqd[:nl].map { |obq| obq[:txid] })
     end
 
     # @example (see Apice#account_de)
@@ -72,14 +72,14 @@ module Cns
     # @param [Hash] hsx saldo bitcoinde da moeda
     # @return [String] texto formatado saldos
     def formata_saldos(moe, hsx)
-      b = bqd[:sl][moe.downcase.to_sym].to_d
-      e = hsx[:total_amount].to_d
+      vbq = bqd[:sl][moe.downcase.to_sym].to_d
+      vex = hsx[:total_amount].to_d
       format(
         '%<mo>-5.5s %<ex>21.9f %<bq>21.9f %<ok>3.3s',
         mo: moe.upcase,
-        ex: e,
-        bq: b,
-        ok: e == b ? 'OK' : 'NOK'
+        ex: vex,
+        bq: vbq,
+        ok: vex == vbq ? 'OK' : 'NOK'
       )
     end
 
@@ -117,13 +117,13 @@ module Cns
 
     # @return [String] texto numero de transacoes
     def mostra_totais
-      a = exd[:tt].count
-      b = bqd[:nt].count
-      c = exd[:tl].count
-      d = bqd[:nl].count
+      vtt = exd[:tt].count
+      vnt = bqd[:nt].count
+      vtl = exd[:tl].count
+      vnl = bqd[:nl].count
 
-      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: a, b: b, o: a == b ? 'OK' : 'NOK')}")
-      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: c, d: d, o: c == d ? 'OK' : 'NOK')}")
+      puts("TRADES #{format('%<a>20i %<b>21i %<o>3.3s', a: vtt, b: vnt, o: vtt == vnt ? 'OK' : 'NOK')}")
+      puts("LEDGER #{format('%<c>20i %<d>21i %<o>3.3s', c: vtl, d: vnl, o: vtl == vnl ? 'OK' : 'NOK')}")
     end
 
     # @return [String] texto transacoes trades
@@ -131,8 +131,9 @@ module Cns
       return unless ops[:v] && !trades.empty?
 
       puts("\ntrades data       hora     dt criacao tipo  par                     qtd      eur")
-      trades.sort { |a, b| Time.parse(b[:successfully_finished_at]) <=> Time.parse(a[:successfully_finished_at]) }
-            .each { |h| puts(formata_trades(h)) }
+      trades
+        .sort { |ant, prx| Time.parse(prx[:successfully_finished_at]) <=> Time.parse(ant[:successfully_finished_at]) }
+        .each { |obj| puts(formata_trades(obj)) }
     end
 
     # @return [String] texto transacoes ledger
@@ -140,7 +141,7 @@ module Cns
       return unless ops[:v] && !ledger.empty?
 
       puts("\nledger data       hora     tipo       moe          quantidade              custo")
-      ledger.sort { |a, b| b[:time] <=> a[:time] }.each { |h| puts(formata_ledger(h)) }
+      ledger.sort { |ant, prx| prx[:time] <=> ant[:time] }.each { |obj| puts(formata_ledger(obj)) }
     end
   end
 end

data/lib/cns/etherscan1.rb

@@ -29,49 +29,51 @@ module Cns
 
     # @return [Array<Hash>] lista transacoes normais novas
     def novtx
-      @novtx ||= bcd.map { |e| e[:tx].select { |n| idt.include?(n[:itx]) } }.flatten
+      @novtx ||= bcd.map { |obc| obc[:tx].select { |obj| idt.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<Hash>] lista transacoes token novas
     def novkx
-      @novkx ||= bcd.map { |e| e[:kx].select { |n| idk.include?(n[:itx]) } }.flatten
+      @novkx ||= bcd.map { |obc| obc[:kx].select { |obj| idk.include?(obj[:itx]) } }.flatten
     end
 
     # @return [Array<String>] lista dos meus enderecos
     def lax
-      @lax ||= bqd[:wb].map { |h| h[:ax] }
+      @lax ||= bqd[:wb].map { |obj| obj[:ax] }
     end
 
     # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
     def bcd
-      @bcd ||= api.account_es(lax).map { |e| base_bc(e) }
+      @bcd ||= api.account_es(lax).map { |obj| base_bc(obj) }
     end
 
     # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
     def dados
-      @dados ||= bqd[:wb].map { |b| bq_bc(b, bcd.select { |s| b[:ax] == s[:ax] }.first) }
+      @dados ||= bqd[:wb].map { |obq| bq_bc(obq, bcd.select { |obc| obq[:ax] == obc[:ax] }.first) }
     end
 
     # @return [Array<Integer>] lista indices transacoes normais novas
     def idt
-      @idt ||= (bcd.map { |e| e[:tx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nt].map { |t| t[:itx] }))
+      @idt ||= bcd.map { |obc| obc[:tx].map { |obj| obj[:itx] } }.flatten -
+               (ops[:t] ? [] : bqd[:nt].map { |obq| obq[:itx] })
     end
 
     # @return [Array<Integer>] lista indices transacoes token novas
     def idk
-      @idk ||= (bcd.map { |e| e[:kx].map { |n| n[:itx] } }.flatten - (ops[:t] ? [] : bqd[:nk].map { |t| t[:itx] }))
+      @idk ||= bcd.map { |obc| obc[:kx].map { |obj| obj[:itx] } }.flatten -
+               (ops[:t] ? [] : bqd[:nk].map { |obq| obq[:itx] })
     end
 
     # @example (see Apibc#account_es)
     # @param [Hash] abc account etherscan
     # @return [Hash] dados etherscan - address, saldo & transacoes
     def base_bc(abc)
-      a = abc[:account]
+      acc = abc[:account]
       {
-        ax: a,
+        ax: acc,
         sl: (abc[:balance].to_d / 10**18).round(10),
-        tx: filtrar_tx(a, api.norml_es(a)),
-        kx: filtrar_tx(a, api.token_es(a))
+        tx: filtrar_tx(acc, api.norml_es(acc)),
+        kx: filtrar_tx(acc, api.token_es(acc))
       }
     end
 
@@ -81,10 +83,10 @@ module Cns
     def bq_bc(wbq, hbc)
       {
         id: wbq[:id],
-        ax: wbq[:ax],
+        ax: xbq = wbq[:ax],
         bs: wbq[:sl],
-        bt: bqd[:nt].select { |t| t[:iax] == wbq[:ax] },
-        bk: bqd[:nk].select { |t| t[:iax] == wbq[:ax] },
+        bt: bqd[:nt].select { |ont| ont[:iax] == xbq },
+        bk: bqd[:nk].select { |onk| onk[:iax] == xbq },
         es: hbc[:sl],
         et: hbc[:tx],
         ek: hbc[:kx]
@@ -97,23 +99,23 @@ module Cns
     def filtrar_tx(add, ary)
       # elimina transferencia from: (lax) to: (add) - esta transferencia aparece em from: (add) to: (lax)
       # elimina chaves irrelevantes (DL) & adiciona chave indice itx & adiciona identificador da carteira iax
-      ary.delete_if { |h| h[:to] == add && lax.include?(h[:from]) }
-         .map { |h| h.delete_if { |k, _| DL.include?(k) }.merge(itx: Integer(h[:blockNumber]), iax: add) }
+      ary.delete_if { |odl| odl[:to] == add && lax.include?(odl[:from]) }
+         .map { |omp| omp.delete_if { |key, _| DL.include?(key) }.merge(itx: Integer(omp[:blockNumber]), iax: add) }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes normais novas
     def sortx
-      novtx.sort { |a, b| a[:itx] <=> b[:itx] }
+      novtx.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes token novas
     def sorkx
-      novkx.sort { |a, b| a[:itx] <=> b[:itx] }
+      novkx.sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
 
     # @return [Array<Hash>] lista ordenada transacoes (normais & token) novas
     def sorax
-      (novtx + novkx).sort { |a, b| a[:itx] <=> b[:itx] }
+      (novtx + novkx).sort { |ant, prx| ant[:itx] <=> prx[:itx] }
     end
   end
 end

data/lib/cns/etherscan2.rb

@@ -9,7 +9,7 @@ module Cns
       return unless dados.count.positive?
 
       puts("\nid     address                            etherscan nm tk     bigquery nm tk")
-      dados.each { |e| puts(formata_carteira(e)) }
+      dados.each { |obj| puts(formata_carteira(obj)) }
       mostra_transacao_norml
       mostra_transacao_token
       mostra_configuracao_ajuste_dias
@@ -52,9 +52,9 @@ module Cns
     # @param [Integer] max chars a mostrar
     # @return [String] endereco formatado
     def formata_endereco(add, max)
-      i = Integer((max - 2) / 2)
-      e = (max <= 20 ? bqd[:wb].select { |s| s[:ax] == add }.first : nil) || { id: add }
-      max < 7 ? 'erro' : "#{e[:id][0, i - 3]}..#{add[-i - 3..]}"
+      int = Integer((max - 2) / 2)
+      hid = (max <= 20 ? bqd[:wb].select { |obj| obj[:ax] == add }.first : nil) || { id: add }
+      max < 7 ? 'erro' : "#{hid[:id][0, int - 3]}..#{add[-int - 3..]}"
     end
 
     # @example (see Apibc#norml_es)
@@ -91,7 +91,7 @@ module Cns
       return unless ops[:v] && novtx.count.positive?
 
       puts("\ntx normal from                 to                   data                   valor")
-      sortx.each { |e| puts(formata_transacao_norml(e)) }
+      sortx.each { |obj| puts(formata_transacao_norml(obj)) }
     end
 
     # @return [String] texto transacoes token
@@ -99,14 +99,14 @@ module Cns
       return unless ops[:v] && novkx.count.positive?
 
       puts("\ntx token  from                 to                   data             valor")
-      sorkx.each { |e| puts(formata_transacao_token(e)) }
+      sorkx.each { |obj| puts(formata_transacao_token(obj)) }
     end
 
     # @return [String] texto configuracao ajuste dias das transacoes (normais & token)
     def mostra_configuracao_ajuste_dias
       return unless (novtx.count + novkx.count).positive?
 
-      puts("\nstring ajuste dias\n-h=#{sorax.map { |e| "#{e[:blockNumber]}:0" }.join(' ')}")
+      puts("\nstring ajuste dias\n-h=#{sorax.map { |obj| "#{obj[:blockNumber]}:0" }.join(' ')}")
     end
   end
 end