taps2 0.5.5 → 0.6.0

data/lib/taps/progress_bar.rb

@@ -10,14 +10,14 @@
 #
 
 class ProgressBar
-  VERSION = "0.9"
+  VERSION = '0.9'.freeze
 
-  def initialize (title, total, out = STDERR)
+  def initialize(title, total, out = STDERR)
     @title = title
     @total = total
     @out = out
     @terminal_width = 80
-    @bar_mark = "="
+    @bar_mark = '='
     @current = 0
     @previous = 0
     @finished_p = false
@@ -25,7 +25,7 @@ class ProgressBar
     @previous_time = @start_time
     @title_width = 14
     @format = "%-#{@title_width}s %3d%% %s %s"
-    @format_arguments = [:title, :percentage, :bar, :stat]
+    @format_arguments = %i[title percentage bar stat]
     clear
     show
   end
@@ -35,11 +35,12 @@ class ProgressBar
   attr_accessor :start_time
 
   private
+
   def fmt_bar
     bar_width = do_percentage * @terminal_width / 100
-    sprintf("|%s%s|",
-            @bar_mark * bar_width,
-            " " *  (@terminal_width - bar_width))
+    format('|%s%s|',
+           @bar_mark * bar_width,
+           ' ' * (@terminal_width - bar_width))
   end
 
   def fmt_percentage
@@ -47,68 +48,68 @@ class ProgressBar
   end
 
   def fmt_stat
-    if @finished_p then elapsed else eta end
+    @finished_p ? elapsed : eta
   end
 
   def fmt_stat_for_file_transfer
-    if @finished_p then
-      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    if @finished_p
+      format('%s %s %s', bytes, transfer_rate, elapsed)
     else
-      sprintf("%s %s %s", bytes, transfer_rate, eta)
+      format('%s %s %s', bytes, transfer_rate, eta)
     end
   end
 
   def fmt_title
-    @title[0,(@title_width - 1)] + ":"
+    @title[0, (@title_width - 1)] + ':'
   end
 
-  def convert_bytes (bytes)
+  def convert_bytes(bytes)
     if bytes < 1024
-      sprintf("%6dB", bytes)
+      format('%6dB', bytes)
     elsif bytes < 1024 * 1000 # 1000kb
-      sprintf("%5.1fKB", bytes.to_f / 1024)
-    elsif bytes < 1024 * 1024 * 1000  # 1000mb
-      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+      format('%5.1fKB', bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000 # 1000mb
+      format('%5.1fMB', bytes.to_f / 1024 / 1024)
     else
-      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+      format('%5.1fGB', bytes.to_f / 1024 / 1024 / 1024)
     end
   end
 
   def transfer_rate
     bytes_per_second = @current.to_f / (Time.now - @start_time)
-    sprintf("%s/s", convert_bytes(bytes_per_second))
+    format('%s/s', convert_bytes(bytes_per_second))
   end
 
   def bytes
     convert_bytes(@current)
   end
 
-  def format_time (t)
+  def format_time(t)
     t = t.to_i
     sec = t % 60
     min  = (t / 60) % 60
     hour = t / 3600
-    sprintf("%02d:%02d:%02d", hour, min, sec);
+    format('%02d:%02d:%02d', hour, min, sec)
   end
 
   # ETA stands for Estimated Time of Arrival.
   def eta
     if @current == 0
-      "ETA:  --:--:--"
+      'ETA:  --:--:--'
     else
       elapsed = Time.now - @start_time
-      eta = elapsed * @total / @current - elapsed;
-      sprintf("ETA:  %s", format_time(eta))
+      eta = elapsed * @total / @current - elapsed
+      format('ETA:  %s', format_time(eta))
     end
   end
 
   def elapsed
     elapsed = Time.now - @start_time
-    sprintf("Time: %s", format_time(elapsed))
+    format('Time: %s', format_time(elapsed))
   end
 
   def eol
-    if @finished_p then "\n" else "\r" end
+    @finished_p ? "\n" : "\r"
   end
 
   def do_percentage
@@ -124,10 +125,10 @@ class ProgressBar
     default_width = 80
     begin
       tiocgwinsz = 0x5413
-      data = [0, 0, 0, 0].pack("SSSS")
-      if @out.ioctl(tiocgwinsz, data) >= 0 then
-        _, cols = data.unpack("SSSS")
-        if cols > 0 then cols else default_width end
+      data = [0, 0, 0, 0].pack('SSSS')
+      if @out.ioctl(tiocgwinsz, data) >= 0
+        _, cols = data.unpack('SSSS')
+        cols > 0 ? cols : default_width
       else
         default_width
       end
@@ -138,11 +139,11 @@ class ProgressBar
 
   def show
     arguments = @format_arguments.map do |method|
-      method = sprintf("fmt_%s", method)
+      method = format('fmt_%s', method)
       send(method)
     end
 
-    line = sprintf(@format, *arguments)
+    line = format(@format, *arguments)
 
     width = get_width
     if line.length == width - 1
@@ -150,7 +151,7 @@ class ProgressBar
       @out.flush
     elsif line.length >= width
       @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
-      if @terminal_width == 0 then @out.print(line + eol) else show end
+      @terminal_width == 0 ? @out.print(line + eol) : show
     else # line.length < width - 1
       @terminal_width += width - line.length + 1
       show
@@ -169,16 +170,16 @@ class ProgressBar
 
     # Use "!=" instead of ">" to support negative changes
     if cur_percentage != prev_percentage ||
-        Time.now - @previous_time >= 1 || @finished_p
+       Time.now - @previous_time >= 1 || @finished_p
       show
     end
   end
 
-public
+  public
 
   def clear
     @out.print "\r"
-    @out.print(" " * (get_width - 1))
+    @out.print(' ' * (get_width - 1))
     @out.print "\r"
   end
 
@@ -193,30 +194,26 @@ public
   end
 
   def file_transfer_mode
-    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+    @format_arguments = %i[title percentage bar stat_for_file_transfer]
   end
 
-  def format= (format)
-    @format = format
-  end
+  attr_writer :format
 
-  def format_arguments= (arguments)
-    @format_arguments = arguments
-  end
+  attr_writer :format_arguments
 
   def halt
     @finished_p = true
     show
   end
 
-  def inc (step = 1)
+  def inc(step = 1)
     @current += step
     @current = @total if @current > @total
     show_if_needed
     @previous = @current
   end
 
-  def set (count)
+  def set(count)
     if count < 0 || count > @total
       raise "invalid count: #{count} (total: #{@total})"
     end

data/lib/taps/schema.rb

@@ -9,7 +9,7 @@ module Taps
 
     def dump(database_url)
       db = Sequel.connect(database_url)
-      db.dump_schema_migration(:indexes => false)
+      db.dump_schema_migration(indexes: false)
     end
 
     def dump_table(database_url, table)
@@ -17,7 +17,7 @@ module Taps
         <<END_MIG
 Class.new(Sequel::Migration) do
   def up
-    #{db.extension(:schema_dumper).dump_table_schema(Sequel.identifier(table.to_sym), :indexes => false)}
+    #{db.extension(:schema_dumper).dump_table_schema(Sequel.identifier(table.to_sym), indexes: false)}
   end
 
   def down

data/lib/taps/server.rb

@@ -12,17 +12,17 @@ module Taps
 
     use Rack::Deflater unless ENV['NO_DEFLATE']
 
-    set :raise_errors => false
-    set :show_exceptions => false
+    set raise_errors: false
+    set show_exceptions: false
 
     error do
       e = request.env['sinatra.error']
 
       puts "ERROR: #{e.class}: #{e.message}"
 
-      if e.kind_of?(Taps::BaseError)
-        content_type "application/json"
-        halt 412, ::OkJson.encode({ 'error_class' => e.class.to_s, 'error_message' => e.message, 'error_backtrace' => e.backtrace.join("\n") })
+      if e.is_a?(Taps::BaseError)
+        content_type 'application/json'
+        halt 412, ::OkJson.encode('error_class' => e.class.to_s, 'error_message' => e.message, 'error_backtrace' => e.backtrace.join("\n"))
       else
         "Taps Server Error: #{e}\n#{e.backtrace}"
       end
@@ -30,8 +30,8 @@ module Taps
 
     before do
       unless request.path_info == '/health'
-        major, minor = request.env['HTTP_TAPS_VERSION'].split('.') rescue []
-        unless "#{major}.#{minor}" == Taps.compatible_version
+        major, minor = request.env['HTTP_TAPS_VERSION'].to_s.split('.')
+        unless Taps.compatible_version == "#{major}.#{minor}"
           halt 417, "Taps >= v#{Taps.compatible_version}.x is required for this server"
         end
       end
@@ -39,29 +39,29 @@ module Taps
 
     get '/health' do
       content_type 'application/json'
-      ::OkJson.encode({ :ok => true })
+      ::OkJson.encode(ok: true)
     end
 
     get '/' do
-      "hello"
+      'hello'
     end
 
     post '/sessions' do
-      key = rand(9999999999).to_s
+      key = rand(9_999_999_999).to_s
 
-      if ENV['NO_DEFAULT_DATABASE_URL']
-        database_url = request.body.string
-      else
-        database_url = Taps::Config.database_url || request.body.string
-      end
+      database_url = if ENV['NO_DEFAULT_DATABASE_URL']
+                       request.body.string
+                     else
+                       Taps::Config.database_url || request.body.string
+                     end
 
-      DbSession.create(:key => key, :database_url => database_url, :started_at => Time.now, :last_access => Time.now)
+      DbSession.create(key: key, database_url: database_url, started_at: Time.now, last_access: Time.now)
 
       "/sessions/#{key}"
     end
 
     post '/sessions/:key/push/verify_stream' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       state = DataStream.parse_json(params[:state])
@@ -75,11 +75,11 @@ module Taps
       end
 
       content_type 'application/json'
-      ::OkJson.encode({ :state => stream.to_hash })
+      ::OkJson.encode(state: stream.to_hash)
     end
 
     post '/sessions/:key/push/table' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       json = DataStream.parse_json(params[:json])
@@ -97,14 +97,14 @@ module Taps
     end
 
     post '/sessions/:key/push/reset_sequences' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       Taps::Utils.schema_bin(:reset_db_sequences, session.database_url)
     end
 
     post '/sessions/:key/push/schema' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       schema_data = request.body.read
@@ -112,7 +112,7 @@ module Taps
     end
 
     post '/sessions/:key/push/indexes' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       index_data = request.body.read
@@ -120,14 +120,14 @@ module Taps
     end
 
     post '/sessions/:key/pull/schema' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       Taps::Utils.schema_bin(:dump_table, session.database_url, params[:table_name])
     end
 
     get '/sessions/:key/pull/indexes' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       content_type 'application/json'
@@ -135,7 +135,7 @@ module Taps
     end
 
     get '/sessions/:key/pull/table_names' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       tables = []
@@ -148,18 +148,18 @@ module Taps
     end
 
     post '/sessions/:key/pull/table_count' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       count = 0
       session.conn do |db|
-        count = db[ params[:table].to_sym.identifier ].count
+        count = db[params[:table].to_sym.identifier].count
       end
       count.to_s
     end
 
     post '/sessions/:key/pull/table' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       encoded_data = nil
@@ -172,15 +172,15 @@ module Taps
       end
 
       checksum = Taps::Utils.checksum(encoded_data).to_s
-      json = ::OkJson.encode({ :checksum => checksum, :state => stream.to_hash })
+      json = ::OkJson.encode(checksum: checksum, state: stream.to_hash)
 
       content, content_type_value = Taps::Multipart.create do |r|
-        r.attach :name => :encoded_data,
-          :payload => encoded_data,
-          :content_type => 'application/octet-stream'
-        r.attach :name => :json,
-          :payload => json,
-          :content_type => 'application/json'
+        r.attach name: :encoded_data,
+                 payload: encoded_data,
+                 content_type: 'application/octet-stream'
+        r.attach name: :json,
+                 payload: json,
+                 content_type: 'application/json'
       end
 
       content_type content_type_value
@@ -188,13 +188,12 @@ module Taps
     end
 
     delete '/sessions/:key' do
-      session = DbSession.filter(:key => params[:key]).first
+      session = DbSession.filter(key: params[:key]).first
       halt 404 unless session
 
       session.destroy
 
-      "ok"
+      'ok'
     end
-
   end
 end

data/lib/taps/utils.rb

@@ -31,45 +31,41 @@ module Taps
     end
 
     def base64encode(data)
-      [data].pack("m")
+      [data].pack('m')
     end
 
     def base64decode(data)
-      data.unpack("m").first
+      data.unpack('m').first
     end
 
-    def format_data(data, opts={})
-      return {} if data.size == 0
+    def format_data(data, opts = {})
+      return {} if data.empty?
       string_columns = opts[:string_columns] || []
       schema = opts[:schema] || []
       table  = opts[:table]
 
-      max_lengths = schema.inject({}) do |hash, (column, meta)|
-        if meta[:db_type] =~ /^varchar\((\d+)\)/
-          hash.update(column => $1.to_i)
-        end
-        hash
+      max_lengths = schema.each_with_object({}) do |(column, meta), hash|
+        hash.update(column => Regexp.last_match(1).to_i) if meta[:db_type] =~ /^varchar\((\d+)\)/
       end
 
       header = data[0].keys
       only_data = data.collect do |row|
         row = blobs_to_string(row, string_columns)
         row.each do |column, value|
-          if value.to_s.length > (max_lengths[column] || value.to_s.length)
-            raise Taps::InvalidData.new(<<-ERROR)
+          next unless value.to_s.length > (max_lengths[column] || value.to_s.length)
+          raise Taps::InvalidData, <<-ERROR
 Detected value that exceeds the length limitation of its column. This is
 generally due to the fact that SQLite does not enforce length restrictions.
 
 Table  : #{table}
 Column : #{column}
-Type   : #{schema.detect{|s| s.first == column}.last[:db_type]}
+Type   : #{schema.detect { |s| s.first == column }.last[:db_type]}
 Value  : #{value}
-ERROR
-          end
+          ERROR
         end
         header.collect { |h| row[h] }
       end
-      { :header => header, :data => only_data }
+      { header: header, data: only_data }
     end
 
     # mysql text and blobs fields are handled the same way internally
@@ -87,9 +83,9 @@ ERROR
     end
 
     def blobs_to_string(row, columns)
-      return row if columns.size == 0
+      return row if columns.empty?
       columns.each do |c|
-        row[c] = row[c].to_s if row[c].kind_of?(Sequel::SQL::Blob)
+        row[c] = row[c].to_s if row[c].is_a?(Sequel::SQL::Blob)
       end
       row
     end
@@ -138,42 +134,43 @@ ERROR
     end
 
     def single_integer_primary_key(db, table)
-      table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
+      table = table.to_sym.identifier unless table.is_a?(Sequel::SQL::Identifier)
       keys = db.schema(table).select { |c| c[1][:primary_key] }
-      not keys.nil? and keys.size == 1 and keys[0][1][:type] == :integer
+      !keys.nil? && (keys.size == 1) && (keys[0][1][:type] == :integer)
     end
 
     def order_by(db, table)
       pkey = primary_key(db, table)
       if pkey
-        pkey.kind_of?(Array) ? pkey : [pkey.to_sym]
+        pkey.is_a?(Array) ? pkey : [pkey.to_sym]
       else
-        table = table.to_sym.identifier unless table.kind_of?(Sequel::SQL::Identifier)
+        table = table.to_sym.identifier unless table.is_a?(Sequel::SQL::Identifier)
         db[table].columns
       end
     end
 
-
     # try to detect server side errors to
     # give the client a more useful error message
-    def server_error_handling(&blk)
-      begin
-        blk.call
-      rescue Sequel::DatabaseError => e
-        if e.message =~ /duplicate key value/i
-          raise Taps::DuplicatePrimaryKeyError, e.message
-        else
-          raise
-        end
+    def server_error_handling
+      yield
+    rescue Sequel::DatabaseError => e
+      if e.message =~ /duplicate key value/i
+        raise Taps::DuplicatePrimaryKeyError, e.message
+      else
+        raise
       end
     end
 
     def reraise_server_exception(e)
-      if e.kind_of?(RestClient::Exception)
+      if e.is_a?(RestClient::Exception)
         if e.respond_to?(:response) && e.response.headers[:content_type] == 'application/json'
           json = ::OkJson.decode(e.response.to_s)
-          klass = eval(json['error_class']) rescue nil
-          raise klass.new(json['error_message'], :backtrace => json['error_backtrace']) if klass
+          klass = begin
+                    eval(json['error_class'])
+                  rescue
+                    nil
+                  end
+          raise klass.new(json['error_message'], backtrace: json['error_backtrace']) if klass
         end
       end
       raise e