rsql 0.1.5 → 0.1.6

data/README.rdoc

@@ -13,6 +13,11 @@ to an intermediary host for access to the SQL server.
 
   gem install rsql
 
+Alternatively, RSQL can be downloaded as a tar.gz or zip and run
+directly from within the unpacked source directory. The only
+requirement is that SSH functionality will be disabled unless the
+Net::SSH Ruby library is installed and available.
+
 == USAGE
 
 RSQL is invoked from the comamnd line using:
@@ -45,22 +50,32 @@ RSQL is invoked from the comamnd line using:
   had been provided at the RSQL prompt interactively. This option
   *must* be the last option specified.
 
-The _ssh_host_ and _mysql_host_ values may also provide _user_ and
-_password_ values using the following syntax:
+The _ssh_host_ and _mysql_host_ arguments may optionally include
+_user_ and _password_ values using the following syntax:
 
   [<user>[:<password>]@]<host>
 
-It is possible to provide empty passwords by simply having nothing
-listed between demarcation points:
+An empty password can be provided by simply listing nothing between
+demarcation points:
 
   root:@127.0.0.1
 
 Once at the +rsql+ prompt, normal MySQL queries can be entered as
-expected, ending each with a semicolon (;).
+expected, ending each with a semicolon (;) for columnar output or \G
+for line-by-line output formatting.
+
+Ruby commands will be evaluated for any content entered at the RSQL
+prompt beginning with a period (.).
+
+== GETTING STARTED
+
+This example walks through many features of RSQL including how to
+build up recipes:
 
-== EXAMPLE
+https://github.com/bradrf/rsql/raw/master/example.rsqlrc
 
-Try walking through link:../example.rsqlrc.
+The file is available as example.rsqlrc installed with the gem or
+downloaded with the source.
 
 == LICENSE
 

data/bin/rsql

@@ -31,7 +31,9 @@ require 'thread'
 require 'timeout'
 require 'readline'
 require 'yaml'
-require 'net/ssh'
+
+# This is included below to make it optional if SSH is never needed.
+# require 'net/ssh'
 
 # allow ourselves to be run from within a source tree
 if File.symlink?(__FILE__)
@@ -114,6 +116,7 @@ if i = ARGV.index('-batch')
 end
 
 if i = ARGV.index('-ssh')
+    require 'net/ssh'
     ARGV.delete_at(i)
     (ssh_host, ssh_user, ssh_password) = split_login(ARGV.delete_at(i))
 end
@@ -152,7 +155,7 @@ USAGE
 end
 
 (mysql_host, mysql_user, mysql_password) = split_login(ARGV.shift)
-mysql_password = get_password('mysql password? ') unless mysql_password
+mysql_password ||= get_password("#{mysql_host}@#{mysql_host} MySQL password: ")
 real_mysql_host = mysql_host
 
 if ssh_host
@@ -162,7 +165,7 @@ else
     mysql_port = 3306
 end
 
-db_name = ARGV.shift
+MySQLResults.database_name = ARGV.shift
 
 unless $stdin.tty?
     batch_input = $stdin.read.gsub(/\r?\n/,';')
@@ -192,7 +195,7 @@ rescue Timeout::Error
     $stderr.puts "Timed out waiting to close #{name} connection"
     false
 rescue Exception => ex
-    $stderr.puts(ex)
+    $stderr.puts("#{ex.class}: #{ex.message}")
     false
 end
 
@@ -206,32 +209,65 @@ if ssh_host
     # us...or just loop reconnection here in the thread...
 
     port_opened = false
+    getting_password = false
+    password_retry_cnt = 0
 
     puts "SSH #{ssh_user}#{ssh_user ? '@' : ''}#{ssh_host}..." unless batch_input
     ssh = nil
     ssh_thread = Thread.new do
         opts = {:timeout => 15}
-        opts[:password] = ssh_password if ssh_password
-        ssh = Net::SSH.start(ssh_host, ssh_user, opts)
-        ssh_enabled = true
-        ssh.forward.local(mysql_port, mysql_host, 3306)
-        port_opened = true
-        ssh.loop(1) { ssh_enabled }
+        begin
+            opts[:password] = ssh_password if ssh_password
+            ssh = Net::SSH.start(ssh_host, ssh_user, opts)
+            ssh_enabled = true
+        rescue Net::SSH::AuthenticationFailed
+            if 2 < password_retry_cnt
+                $stderr.puts 'Permission denied. Giving up.'
+            else
+                $stderr.puts 'Permission denied, please try again.' if ssh_password
+                getting_password = true
+                ssh_password = get_password("#{ssh_user}@#{ssh_host} SSH password: ")
+                getting_password = false
+                unless ssh_password.empty?
+                    password_retry_cnt += 1
+                    retry
+                end
+            end
+        end
+        if ssh_enabled
+            ssh.forward.local(mysql_port, mysql_host, 3306)
+            port_opened = true
+            ssh.loop(1) { ssh_enabled }
+        end
     end
 
     15.times do
-        break if ssh_enabled && port_opened
+        break if !ssh_thread.alive? || (ssh_enabled && port_opened)
+        while getting_password
+            # give them extra time
+            sleep(1)
+        end
         sleep(1)
     end
 
     unless ssh_enabled
-        $stderr.puts "failed to connect to #{ssh_host} ssh host in 15 seconds"
+        $stderr.puts "failed to connect to #{ssh_host} SSH host"
+        begin
+            ssh_thread.join
+        rescue Exception => ex
+            $stderr.puts("  => #{ex.message} (#{ex.class})")
+        end
         exit 1
     end
 
     unless port_opened
         $stderr.puts("failed to forward #{mysql_port}:#{mysql_host}:3306 via #{ssh_host} " \
                      "ssh host in 15 seconds")
+        begin
+            ssh_thread.join
+        rescue Exception => ex
+            $stderr.puts("  => #{ex.message}: #{ex.class}")
+        end
         exit 1
     end
 
@@ -241,7 +277,8 @@ end
 
 puts "MySQL #{mysql_user}@#{real_mysql_host}..." unless batch_input
 begin
-    MySQLResults.conn = Mysql.new(mysql_host, mysql_user, mysql_password, db_name, mysql_port)
+    MySQLResults.conn = Mysql.new(mysql_host, mysql_user, mysql_password,
+                                  MySQLResults.database_name, mysql_port)
 rescue Mysql::Error => ex
     if ex.message.include?('Client does not support authentication')
         $stderr.puts "failed to connect to #{mysql_host} mysql server: unknown credentials?"
@@ -249,6 +286,17 @@ rescue Mysql::Error => ex
         $stderr.puts "failed to connect to #{mysql_host} mysql server: #{ex.message}"
     end
     exit 1
+rescue NoMethodError
+    # this happens when mysql tries to read four bytes and assume it
+    # can index into them even when read returned nil...this happens
+    # because the connect succeeds due to the SSH forwarded port but
+    # then there isn't anybody connected on the remote side of the
+    # proxy
+    $stderr.puts "failed to connect to #{mysql_host} mysql server"
+    exit 1
+rescue Exception => ex
+    $stderr.puts "failed to connect to #{mysql_host} mysql server: #{ex.message} (#{ex.class})"
+    exit 1
 end
 
 eval_context.call_init_registrations
@@ -270,8 +318,7 @@ cmd_thread = Thread.new do
             me[:shutdown] = true         # only run once
             input = batch_input
         else
-            db_name = (MySQLResults.database_name || db_name)
-            puts '',"[#{mysql_user}@#{ssh_host||mysql_host}:#{db_name}]"
+            puts '',"[#{mysql_user}@#{ssh_host||mysql_host}:#{MySQLResults.database_name}]"
             input = ''
             prompt = bn + '> '
             loop do

data/example.rsqlrc

@@ -206,7 +206,7 @@ end
 # say if we want to process results and keep our data around in a
 # file.
 #
-#   rsql> select name, value from rsql_example | save_values 'myobj'
+#   rsql> select name, value from rsql_example | save_values 'myobj';
 #
 # After running this, a myobj.yml file should be created in the local
 # directory containing all the content from the query. To accomplish
@@ -225,7 +225,7 @@ end
 # Dealing with variable arguments is pretty straightforward as well,
 # but with a little syntactic twist.
 #
-#   rsql> .find_names 'fancy3', 'fancy8'
+#   rsql> .find_names 'fancy3', 'fancy8';
 #
 # Here we simply expand the arguments.
 #
@@ -259,14 +259,14 @@ end
 # to our consoles than just dumping it. It converts it into a
 # hexadecimal string.
 #
-#   rsql> SELECT stuff FROM rsql_example
+#   rsql> SELECT stuff FROM rsql_example;
 #
 # The default is to limit the hex strings to 32 "bytes" reported. This
 # can be configured any time by setting the @hexstr_limit.
 #
 # RSQL makes querying for hex strings from within a recipe easy too.
 #
-#   rsql> .find_stuff 0x346950d3c051c8ac51092a3a2eff7503ef7f571c
+#   rsql> .find_stuff 0x346950d3c051c8ac51092a3a2eff7503ef7f571c;
 #
 register :find_stuff, :stuff, %q{
 SELECT * FROM #{@rsql_table} WHERE stuff=#{hexify stuff}

data/lib/rsql.rb

@@ -2,7 +2,7 @@
 # Commands using an EvalContext for handling recipes.
 #
 module RSQL
-    VERSION = '0.1.5'
+    VERSION = '0.1.6'
 
     require 'rsql/mysql'
     require 'rsql/mysql_results'

data/lib/rsql/commands.rb

@@ -49,6 +49,8 @@ module RSQL
             next_is_ruby = false
 
             input.scan(/[^#{SEPARATORS}]+.?/) do |match|
+                orig_match = match
+
                 if i = SEPARATORS.index(match[-1])
                     sep = SEPARATORS[i]
                     match.chop!
@@ -101,7 +103,7 @@ module RSQL
                         in_pipe_arg = false
                         esc << match << '|'
                         next
-                    elsif match =~ /\{\s*|do\s*/
+                    elsif orig_match =~ /\{\s*|do\s*/
                         in_pipe_arg = true
                         esc << match << '|'
                         next
@@ -190,7 +192,7 @@ module RSQL
                     stdout = cmd.displayer == :pipe ? StringIO.new : nil
                     value = eval_context.safe_eval(cmd.content, last_results, stdout)
                     if String === value
-                        cmds = Commands.new(value, @default_displayer)
+                        cmds = Commands.new(value, cmd.displayer)
                         unless cmds.empty?
                             # need to carry along the bangs into the
                             # last command so we don't lose them
@@ -212,7 +214,7 @@ module RSQL
                         last_results = MySQLResults.query(value, eval_context)
                     rescue MySQLResults::MaxRowsException => ex
                         $stderr.puts "refusing to process #{ex.rows} rows (max: #{ex.max})"
-                    rescue MysqlError => ex
+                    rescue Mysql::Error => ex
                         $stderr.puts ex.message
                     rescue Exception => ex
                         $stderr.puts ex.inspect

data/lib/rsql/eval_context.rb

@@ -21,6 +21,8 @@
 
 module RSQL
 
+    require 'time'
+
     ################################################################################
     # This class wraps all dynamic evaluation and serves as the reflection
     # class for adding methods dynamically.
@@ -283,6 +285,13 @@ module RSQL
                 @registrations[sym] = Registration.new(name, args, bangs, block, usage, desc)
             end
 
+            # Convert a list of values into a comma-delimited string,
+            # optionally with each value in single quotes.
+            #
+            def to_list(vals, quoted=false) # :doc:
+                vals.collect{|v| quoted ? "'#{v}'" : v.to_s}.join(',')
+            end
+
             # Convert a collection of values into hexadecimal strings.
             #
             def hexify(*ids)    # :doc:
@@ -304,7 +313,7 @@ module RSQL
 
             # Convert a number of bytes into a human readable string.
             #
-            def humanize_bytes(bytes)
+            def humanize_bytes(bytes) # :doc:
                 abbrev = ['B','KB','MB','GB','TB','PB','EB','ZB','YB']
                 bytes = bytes.to_i
                 fmt = '%7.2f'
@@ -341,6 +350,16 @@ module RSQL
                 raise "unable to parse '#{str}'"
             end
 
+            # Show a nice percent value of a decimal string.
+            #
+            def humanize_percentage(decimal, precision=1) # :doc:
+                if decimal.nil? || decimal == 'NULL'
+                    'NA'
+                else
+                    "%5.#{precision}f%%" % (decimal.to_f * 100)
+                end
+            end
+
             # Convert a time into a relative string from now.
             #
             def relative_time(dt) # :doc:

data/lib/rsql/mysql_results.rb

@@ -32,6 +32,7 @@ module RSQL
         @@field_separator = ' '
         @@max_rows        = 1000
         @@database_name   = nil
+        @@databases       = nil
 
         class MaxRowsException < RangeError
             def initialize(rows, max)
@@ -56,35 +57,48 @@ module RSQL
             #
             def database_name; @@database_name; end
 
+            # Set the name of the current database in use.
+            #
+            def database_name=(database); @@database_name = database; end
+
             # Get the list of databases available.
             #
             def databases
-                @@databases ||= @@conn.list_dbs.sort if @@conn
+                if @@conn && @@databases.nil?
+                    @@databases = @@conn.list_dbs.sort
+                end
+                @@databases
             end
 
-            @@last_table_list = Hash.new{|h,k| h[k] = [Time.at(0), []]}
+            # Force the table cache to be reread on the next request
+            # for tables.
+            #
+            def reset_cache
+                @@databases       = nil
+                @@last_table_list = Hash.new{|h,k| h[k] = [Time.at(0), []]}
+            end
 
             # Get the list of tables available (if a database is
             # selected) at most once every ten seconds.
             #
-            def tables(database = nil)
+            def tables(database=@@database_name)
                 now = Time.now
-                (last, tables) = @@last_table_list[database]
+                (last, tnames) = @@last_table_list[database]
                 if last + 10 < now
                     begin
                         if @@conn
-                            if database && database != database_name
-                                tables = @@conn.list_tables("FROM #{database}").sort
+                            if database && database != @@database_name
+                                tnames = @@conn.list_tables("FROM #{database}").sort
                             else
-                                tables = @@conn.list_tables.sort
+                                tnames = @@conn.list_tables.sort
                             end
                         end
                     rescue Mysql::Error => ex
-                        tables = []
+                        tnames = []
                     end
-                    @@last_table_list[database] = [now, tables]
+                    @@last_table_list[database] = [now, tnames]
                 end
-                tables
+                tnames
             end
 
             # Provide a list of tab completions given the prompted
@@ -105,16 +119,16 @@ module RSQL
                         end
                     end
                     ret.compact!
-                    return ret
+                else
+                    ret = databases.select{|n| n != @@database_name && n.downcase.start_with?(str)}
+                    if @@database_name
+                        # if we've selected a db then we want to offer
+                        # completions for other dbs as well as tables for
+                        # the currently selected db
+                        ret += tables.select{|n| n.downcase.start_with?(str)}
+                    end
                 end
 
-                ret = databases.select{|n| n != database_name && n.downcase.start_with?(str)}
-                if database_name
-                    # if we've selected a db then we want to offer
-                    # completions for other dbs as well as tables for
-                    # the currently selected db
-                    ret += tables.select{|n| n.downcase.start_with?(str)}
-                end
                 return ret
             end
 
@@ -181,6 +195,9 @@ module RSQL
 
         end # class << self
 
+        # init the cache
+        reset_cache
+
         ########################################
 
         def initialize(sql, elapsed, affected_rows,
@@ -230,11 +247,12 @@ module RSQL
         # Get a row from the table hashed with the field names.
         #
         def [](index)
-            hash = {}
-            if @fields && @table
-                row = @table[index]
-                @fields.each_with_index {|f,i| hash[f.name] = row[i]}
+            if index < 0 || !@fields || !@table || @table.size <= index
+                return nil
             end
+            hash = {}
+            row = @table[index]
+            @fields.each_with_index {|f,i| hash[f.name] = row[i]}
             return hash
         end
 

data/test/dummy_mysql.rb

@@ -0,0 +1,11 @@
+# Dummy up some MySQL constants.
+module RSQL
+    class Mysql
+        class Error < Exception
+        end
+        class Field
+            TYPE_TINY_BLOB = 1
+            TYPE_STRING    = 2
+        end
+    end
+end

data/test/test_commands.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+require 'mocha'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib')) << File.dirname(__FILE__)
+require 'dummy_mysql.rb'
+require 'rsql/mysql_results.rb'
+require 'rsql/eval_context.rb'
+require 'rsql/commands.rb'
+
+class TestCommands < Test::Unit::TestCase
+
+    include RSQL
+
+    def setup
+        @orig_stdout = $stdout
+        $stdout = @strout = StringIO.new
+        @ctx = EvalContext.new
+        @conn = MySQLResults.conn = mock('Mysql')
+    end
+
+    def teardown
+        $stdout = @orig_stdout
+    end
+
+    def test_simple_ruby
+        cmds = Commands.new('. puts :hello', :display_by_column)
+        assert_equal(false, cmds.empty?)
+        assert_not_nil(cmds.last)
+        cmds.run!(@ctx)
+        assert_equal('hello', @strout.string.chomp)
+    end
+
+    def test_simple_sql
+        cmds = Commands.new('do some silly stuff', :display_by_column)
+        @conn.expects(:query).with(instance_of(String)).returns(nil)
+        @conn.expects(:affected_rows).returns(1)
+        cmds.run!(@ctx)
+        assert_match(/Query OK, 1 row affected/, @strout.string)
+    end
+
+    def test_separators
+        cmds = Commands.new('. puts :hello\; puts :world;', :display_by_column)
+        cmds.run!(@ctx)
+        assert_equal('hello'+$/+'world', @strout.string.chomp)
+
+        # make sure our logic to handle eval'd blocks with args works
+        @strout.string = ''
+        cmds = Commands.new('. Proc.new{|a| p a} | @results.value.call(:fancy)', :display_by_column)
+        cmds.run!(@ctx)
+        assert_equal(':fancy', @strout.string.chomp)
+    end
+
+    def test_multiple
+        @conn.expects(:query).with('one thing').returns(nil)
+        @conn.expects(:affected_rows).returns(1)
+        cmds = Commands.new('. "one thing" ; . p :hello', :display_by_column)
+        cmds.run!(@ctx)
+        assert_match(/^QueryOK,1rowaffected\(\d+.\d+sec\):hello$/,
+                     @strout.string.gsub(/\s+/,''))
+    end
+
+    def test_bangs
+        cmds = Commands.new('silly stuff ! this => that', :display_by_column)
+        @conn.expects(:query).with('silly stuff').returns(nil)
+        @conn.expects(:affected_rows).returns(13)
+        cmds.run!(@ctx)
+        assert_match(/Query OK, 13 rows affected/, @strout.string)
+
+        # now test logic to continue if it _doesn't_ look like a bang
+        cmds = Commands.new('silly stuff ! more things', :display_by_column)
+        @conn.expects(:query).with('silly stuff ! more things').returns(nil)
+        @conn.expects(:affected_rows).returns(4)
+        cmds.run!(@ctx)
+        assert_match(/Query OK, 4 rows affected/, @strout.string)
+    end
+
+end # class TestCommands

data/test/test_eval_context.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'tempfile'
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+require 'mocha'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib')) << File.dirname(__FILE__)
+require 'dummy_mysql.rb'
+require 'rsql/mysql_results.rb'
+require 'rsql/eval_context.rb'
+
+class TestEvalContext < Test::Unit::TestCase
+
+    include RSQL
+
+    def setup
+        @orig_stdout = $stdout
+        $stdout = @strout = StringIO.new
+        @conn = MySQLResults.conn = mock('Mysql')
+        @conn.expects(:query).with(instance_of(String)).returns(nil)
+        @conn.expects(:affected_rows).returns(0)
+        @ctx = EvalContext.new
+        @ctx.load(File.join(File.dirname(__FILE__),'..','example.rsqlrc'))
+    end
+
+    def teardown
+        $stdout = @orig_stdout
+    end
+
+    def test_load
+        @ctx.reload
+        assert_match(/loaded: .+?example.rsqlrc/, @strout.string)
+    end
+
+    def test_eval
+        out = StringIO.new
+
+        # test a simple string registration
+        val = @ctx.safe_eval('cleanup_example', nil, out)
+        assert_equal('DROP TEMPORARY TABLE IF EXISTS rsql_example;', val)
+        assert_equal(true, out.string.empty?)
+
+        # test a block registration
+        val = @ctx.safe_eval('fill_table', nil, out)
+        assert_match(/(INSERT IGNORE INTO .+?){10}/, val)
+        assert_equal(true, out.string.empty?)
+
+        # test results handling and output redirection
+        res = mock
+        res.expects(:each_hash).yields({'value' => '2352'})
+        val = @ctx.safe_eval('to_report', res, out)
+        assert_equal(nil, val)
+        assert_equal("There are 1 small values and 0 big values.", out.string.chomp)
+    end
+
+    def test_list
+        out = StringIO.new
+        val = @ctx.safe_eval('list', nil, out)
+        assert_match(/usage\s+description/, out.string)
+    end
+
+    def test_complete
+        @conn.expects(:list_dbs).returns([])
+        assert_equal(17, @ctx.complete('').size)
+        assert_equal(['version'], @ctx.complete('v'))
+        assert_equal(['.version'], @ctx.complete('.v'))
+    end
+
+    def test_bang_eval
+        @ctx.bangs = {'time' => :relative_time}
+        t = (Time.now - 2532435).to_s
+        assert_equal(t, @ctx.bang_eval('do no harm', t))
+        assert_equal(' 29 days ago', @ctx.bang_eval('time', t))
+    end
+
+    def test_humanize
+        out = StringIO.new
+        assert_equal('   9.16 GB',
+                     @ctx.safe_eval('humanize_bytes(9832742324)', nil, out))
+        assert_equal(9835475108,
+                     @ctx.safe_eval('dehumanize_bytes("   9.16 GB")', nil, out))
+        assert_equal(' 20.9%',
+                     @ctx.safe_eval('humanize_percentage(0.209384)', nil, out))
+        assert(out.string.empty?)
+    end
+
+    def test_hex
+        bin = ''
+        100.times{|i| bin << i}
+        hex = @ctx.to_hexstr(bin)
+        assert_equal('0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' <<
+                     '... (68 bytes hidden)', hex)
+
+        out = StringIO.new
+        assert_equal('0x1234', @ctx.safe_eval('hexify("1234")', nil, out))
+        assert_equal('0x1234', @ctx.safe_eval('hexify("0x1234")', nil, out))
+        assert_equal('0x1234', @ctx.safe_eval('hexify(0x1234)', nil, out))
+        assert(out.string.empty?)
+    end
+
+    def test_safe_save
+        out = StringIO.new
+        @ctx.safe_eval('@mystuff = {:one => 1, :two => 2}', nil, out)
+        tf = Tempfile.new('mystuff')
+        @ctx.safe_eval("safe_save(@mystuff, '#{tf.path}')", nil, out)
+        tf = tf.path + '.yml'
+        assert_equal("Saved: #{tf}", out.string.chomp)
+        assert_equal({:one => 1, :two => 2}, YAML.load_file(tf))
+
+        # now make sure it keeps one backup copy
+        out = StringIO.new
+        @ctx.safe_eval('@mystuff = {:one => 1}', nil, out)
+        @ctx.safe_eval("safe_save(@mystuff, '#{tf}')", nil, out)
+        assert_equal("Saved: #{tf}", out.string.chomp)
+        assert_equal({:one => 1}, YAML.load_file(tf))
+        assert_equal({:one => 1, :two => 2}, YAML.load_file(tf+'~'))
+    ensure
+        File.unlink(tf) if File.exists?(tf)
+        File.unlink(tf+'~') if File.exists?(tf+'~')
+    end
+
+end # class TestEvalContext

data/test/test_mysql_results.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+require 'mocha'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib')) << File.dirname(__FILE__)
+require 'dummy_mysql.rb'
+require 'rsql/mysql_results.rb'
+
+class TestMySQLResults < Test::Unit::TestCase
+
+    include RSQL
+
+    def setup
+        MySQLResults.conn = nil
+        MySQLResults.database_name = nil
+        MySQLResults.reset_cache
+    end
+
+    def test_databases
+        assert_equal(nil, MySQLResults.databases)
+        conn = mock('Mysql')
+        conn.expects(:list_dbs).returns(['accounts'])
+        MySQLResults.conn = conn
+        assert_equal(['accounts'], MySQLResults.databases)
+    end
+
+    def test_tables
+        assert_equal([], MySQLResults.tables)
+        MySQLResults.reset_cache
+
+        conn = mock('Mysql')
+        conn.expects(:list_tables).returns(['users','groups'])
+        MySQLResults.conn = conn
+        assert_equal(['groups','users'], MySQLResults.tables)
+        MySQLResults.reset_cache
+
+        conn.expects(:list_tables).with(instance_of(String)).returns(['prefs'])
+        assert_equal(['prefs'], MySQLResults.tables('accounts'))
+    end
+
+    def test_complete
+        assert_equal([], MySQLResults.complete(nil))
+
+        conn = mock('Mysql')
+        conn.expects(:list_dbs).returns(['accounts','devices','locations'])
+        MySQLResults.conn = conn
+
+        assert_equal(['accounts','devices','locations'], MySQLResults.complete(''))
+        assert_equal(['accounts'], MySQLResults.complete('a'))
+
+        MySQLResults.database_name = 'accounts'
+        conn.expects(:list_tables).returns(['prefs','names'])
+        assert_equal(['devices','locations','names','prefs'], MySQLResults.complete(''))
+        assert_equal(['names'], MySQLResults.complete('n'))
+
+        assert_equal(['accounts.names','accounts.prefs'], MySQLResults.complete('accounts.'))
+    end
+
+    def test_query
+        f1 = mock('f1')
+        f1.expects(:name).returns('c1').times(12)
+        f1.expects(:type).returns(1).times(2)
+        f2 = mock('f2')
+        f2.expects(:name).returns('c2').times(11)
+        f2.expects(:type).returns(1).times(2)
+
+        res = mock('results')
+        res.expects(:num_rows).returns(2).times(2)
+        res.expects(:fetch_fields).returns([f1,f2])
+
+        rows = sequence(:rows)
+        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+
+        conn = mock('Mysql')
+        conn.expects(:query).with(instance_of(String)).returns(res)
+        conn.expects(:affected_rows).returns(1)
+        MySQLResults.conn = conn
+
+        bangs = mock('bangs')
+        bangs.expects(:bang_eval).with(instance_of(String),instance_of(String)).
+            returns('val').times(4)
+
+        mres = MySQLResults.query('ignored', bangs)
+        assert_equal('ignored', mres.sql)
+        assert_equal(true, mres.any?)
+        assert_equal(false, mres.empty?)
+        assert_equal(2, mres.num_rows)
+        assert_equal({"c1"=>"val", "c2"=>"val"}, mres[0])
+        assert_equal({"c1"=>"val", "c2"=>"val"}, mres[1])
+        assert_equal(nil, mres[2])
+
+        cnt = 0
+        mres.each_hash do |row|
+            cnt += 1
+            assert_equal({"c1"=>"val", "c2"=>"val"}, row)
+        end
+        assert_equal(2, cnt)
+
+        dout = StringIO.new
+        mres.display_by_column(dout)
+        assert_match(/^c1c2--------valvalvalval--------2rowsinset/,
+                     dout.string.gsub(/\s+/,''))
+
+        dout = StringIO.new
+        mres.display_by_batch(dout)
+        assert_equal('valvalvalval', dout.string.gsub(/\s+/,''))
+
+        dout = StringIO.new
+        mres.display_by_line(dout)
+        assert_match(/^\*+1.row\*+c1:valc2:val\*+2.row\*+c1:valc2:val2rowsinset/,
+                     dout.string.gsub(/\s+/,''))
+    end
+
+end # class TestMySQLResults

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rsql
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 1
-  - 5
-  version: 0.1.5
+  - 6
+  version: 0.1.6
 platform: ruby
 authors: 
 - Brad Robel-Forrest
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-16 00:00:00 Z
+date: 2011-05-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: net-ssh
@@ -48,13 +48,16 @@ extra_rdoc_files:
 files: 
 - LICENSE
 - README.rdoc
-- TODO
 - bin/rsql
 - example.rsqlrc
 - lib/rsql.rb
 - lib/rsql/commands.rb
 - lib/rsql/eval_context.rb
 - lib/rsql/mysql_results.rb
+- test/dummy_mysql.rb
+- test/test_commands.rb
+- test/test_eval_context.rb
+- test/test_mysql_results.rb
 - lib/rsql/mysql.rb
 homepage: https://github.com/bradrf/rsql
 licenses: []
@@ -65,6 +68,8 @@ rdoc_options:
 - RSQL Documentation
 - --main
 - README.rdoc
+- --exclude
+- mysql.rb
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/TODO

@@ -1,37 +0,0 @@
-* Fix multiline dump to be columnar sensitive (i.e. all but the first
-  line will need a prefix of previous column length whitespace.
-
-* Add option to allow registration to include an automatic displayer.
-
-* Add ability to save passwords in local OS password storage.
-
-* Add ability to highlight lines (e.g. to indicate warning lines about
-  some data like LastHeartbeatTime not recent).
-
-* Add way to prevent this and just allow the raw string to be printed:
-  elsif HEX_RANGE.include?(field.type) && val =~ /[^[:print:]\s]/
-      val = @@eval_context.to_hexstr(val)
-  end
-
-* Fix overlap of functionality between getting input in rsql and
-  parsing input in commands.rb (e.g. they both duplicate the concepts
-  of looking for exit/quit as well as what the end character(s) should
-  be)
-
-* Wrap calling of mysql query in a thread to make it interruptable
-  (might need to re-establish a connection if it's stopped but
-  expected a reply...look at the source).
-
-* Consider using mysql's ping to determine if we need to reconnect.
-
-* Fix need for SSH password! It never asks.
-
-* Find out if it's easy to point at source from the wiki to point
-  people at the example.rsqlrc.
-
-* Consider adding the option to specify a dispalyer when registering a
-  recipe.
-
-* Move everything in here into github issues.
-
-* Consder renaming "register" to "recipe"