rsql 0.1.3

data/lib/rsql/commands.rb

@@ -0,0 +1,219 @@
+# Copyright (C) 2011 by Brad Robel-Forrest <brad+rsql@gigglewax.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module RSQL
+
+    require 'stringio'
+
+    EvalResults = Struct.new(:value, :stdout)
+
+    ########################################
+    # A wrapper to parse and handle commands
+    #
+    class Commands
+
+        Command = Struct.new(:content, :bangs, :declarator, :displayer)
+
+        ########################################
+
+        # split on separators, allowing for escaping
+        #
+        SEPARATORS = ';|!'
+        def initialize(input, default_displayer)
+            @default_displayer = default_displayer
+            @cmds = []
+            esc = ''
+            bangs = {}
+            match_before_bang = nil
+            in_pipe_arg = false
+            next_is_ruby = false
+
+            input.scan(/[^#{SEPARATORS}]+.?/) do |match|
+                if i = SEPARATORS.index(match[-1])
+                    sep = SEPARATORS[i]
+                    match.chop!
+
+                    if match[-1] == ?\\
+                        # unescape the separator and save the content away
+                        esc << match[0..-2] << sep
+                        next
+                    end
+                else
+                    sep = nil
+                end
+
+                if esc.any?
+                    esc << match
+                    match = esc
+                    esc = ''
+                end
+
+                if match_before_bang
+                    new_bangs = {}
+                    match.split(/\s*,\s*/).each do |ent|
+                        (key,val) = ent.split(/\s*=>\s*/)
+                        unless key && val
+                            # they are using a bang but have no maps
+                            # so we assume this is a != or something
+                            # similar and let it go through unmapped
+                            esc = match_before_bang + '!' + match
+                            match_before_bang = nil
+                            break
+                        end
+                        new_bangs[key.strip] = val.to_sym
+                    end
+                    next unless match_before_bang
+                    match = match_before_bang
+                    match_before_bang = nil
+                    bangs.merge!(new_bangs)
+                end
+
+                if sep == ?!
+                    match_before_bang = match
+                    next
+                end
+
+                if sep == ?|
+                    # we've split on a pipe so we need to handle the
+                    # case where ruby code is declaring a block with
+                    # arguments (e.g. {|x| p x} or do |x| p x end)
+                    if in_pipe_arg
+                        in_pipe_arg = false
+                        esc << match << '|'
+                        next
+                    elsif match =~ /\{\s*|do\s*/
+                        in_pipe_arg = true
+                        esc << match << '|'
+                        next
+                    end
+                end
+
+                add_command(match, bangs, next_is_ruby, sep)
+
+                bangs = {}
+                next_is_ruby = sep == ?|
+            end
+
+            add_command(esc, bangs, next_is_ruby)
+        end
+
+        def empty?
+            return @cmds.empty?
+        end
+
+        def run!(eval_context)
+            last_results = nil
+            while @cmds.any?
+                cmd = @cmds.shift
+                results = run_command(cmd, last_results, eval_context)
+                return :done if results == :done
+
+                if cmd.displayer == :pipe
+                    last_results = results
+                elsif MySQLResults === results
+                    last_results = nil
+                    results.send(cmd.displayer)
+                elsif EvalResults === results
+                    last_results = nil
+                    if results.stdout && 0 < results.stdout.size
+                        puts results.stdout.string
+                    end
+                    puts "=> #{results.value.inspect}" if results.value
+                end
+            end
+        end
+
+        ########################################
+        private
+
+            def add_command(content, bangs, is_ruby, separator=nil)
+                content.strip!
+
+                case content[0]
+                when ?.
+                    content.slice!(0)
+                    declarator = :ruby
+                when ?@
+                    content.slice!(0)
+                    declarator = :iterator
+                else
+                    declarator = is_ruby ? :ruby : nil
+                end
+
+                if content.end_with?('\G')
+                    # emulate mysql's \G output
+                    content.slice!(-2,2)
+                    displayer = :display_by_line
+                elsif separator == ?|
+                    displayer = :pipe
+                else
+                    displayer = @default_displayer
+                end
+
+                if content.any?
+                    @cmds << Command.new(content, bangs, declarator, displayer)
+                    return true
+                end
+
+                return false
+            end
+
+            def run_command(cmd, last_results, eval_context)
+                ctx = EvalContext::CommandContext.new
+
+                # set up to allow an iterator to run up to 100,000 times
+                100000.times do |i|
+                    eval_context.bangs = cmd.bangs
+
+                    if cmd.declarator
+                        ctx.index = i
+                        ctx.last_results = last_results
+                        stdout = cmd.displayer == :pipe ? StringIO.new : nil
+                        value = eval_context.safe_eval(cmd.content, ctx, stdout)
+                    else
+                        value = cmd.content
+                    end
+
+                    return :done if value == 'exit' || value == 'quit'
+
+                    if String === value
+                        begin
+                            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
+                            $stderr.puts ex.message
+                        rescue Exception => ex
+                            $stderr.puts ex.inspect
+                            raise
+                        end
+                    else
+                        last_results = EvalResults.new(value, stdout)
+                    end
+
+                    break unless ctx.incomplete
+                end
+
+                return last_results
+            end
+
+    end # class Commands
+
+end # module RSQL

data/lib/rsql/eval_context.rb

@@ -0,0 +1,414 @@
+# Copyright (C) 2011 by Brad Robel-Forrest <brad+rsql@gigglewax.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module RSQL
+
+    ################################################################################
+    # This class wraps all dynamic evaluation and serves as the reflection
+    # class for adding new methods dynamically.
+    #
+    class EvalContext
+
+        Registration = Struct.new(:name, :args, :bangs, :block, :usage, :desc)
+
+        CommandContext = Struct.new(:index, :incomplete, :last_results, :state)
+
+        HEXSTR_LIMIT = 32
+
+        def initialize
+            @hexstr_limit = HEXSTR_LIMIT
+            @last_cmd = nil
+
+            @loaded_fns = []
+            @init_registrations = []
+            @bangs = {}
+
+            @registrations = {
+                :version => Registration.new('version', [], {},
+                                             method(:version),
+                                             'version',
+                                             'RSQL version information.'),
+                :reload => Registration.new('reload', [], {},
+                                            method(:reload),
+                                            'reload',
+                                            'Reload the rsqlrc file.'),
+                :last_cmd => Registration.new('last_cmd', [], {},
+                                              Proc.new{puts @last_cmd},
+                                              'last_cmd',
+                                              'Print the last command generated.'),
+                :set_max_rows => Registration.new('set_max_rows', [], {},
+                                                  Proc.new{|r| MySQLResults.max_rows = r},
+                                                  'set_max_rows',
+                                                  'Set the maximum number of rows to process.'),
+                :max_rows => Registration.new('max_rows', [], {},
+                                              Proc.new{MySQLResults.max_rows},
+                                              'max_rows',
+                                              'Get the maximum number of rows to process.'),
+            }
+        end
+
+        attr_accessor :bangs
+
+        def call_init_registrations(mysql)
+            @init_registrations.each do |sym|
+                reg = @registrations[sym]
+                sql = reg.block.call(*reg.args)
+                mysql.query(sql) if String === sql
+            end
+        end
+
+        def load(fn)
+            ret = Thread.new {
+                begin
+                    eval(File.read(fn), binding, fn)
+                    nil
+                rescue Exception => ex
+                    ex
+                end
+            }.value
+
+            if Exception === ret
+                bt = ret.backtrace.collect{|line| line.start_with?(fn) ? line : nil}.compact
+                $stderr.puts("#{ret.class}: #{ret.message}", bt, '')
+            else
+                @loaded_fns << fn unless @loaded_fns.include?(fn)
+            end
+        end
+
+        def reload
+            @loaded_fns.each{|fn| self.load(fn)}
+            puts "loaded: #{@loaded_fns.inspect}"
+        end
+
+        def bang_eval(field, val)
+            if bang = @bangs[field]
+                begin
+                    val = Thread.new{ eval("$SAFE=2;#{bang}(val)") }.value
+                rescue Exception => ex
+                    $stderr.puts(ex.message, ex.backtrace.first)
+                end
+            end
+
+            return val
+        end
+
+        # safely evaluate Ruby content within our context
+        #
+        def safe_eval(content, context, stdout)
+            @command_context = context
+
+            # allow a simple reload to be called directly as it requires a
+            # little looser safety valve...
+            if 'reload' == content
+                reload
+                return
+            end
+
+            # same relaxed call to load too
+            if m = /^\s*load\s+'(.+)'\s*$/.match(content)
+                self.load(m[1])
+                return
+            end
+
+            if stdout
+                # capture stdout
+                orig_stdout = $stdout
+                $stdout = stdout
+            end
+
+            begin
+                value = Thread.new{ eval('$SAFE=2;' + content) }.value
+            rescue Exception => ex
+                $stderr.puts(ex.message.gsub(/\(eval\):\d+:/,''))
+            ensure
+                $stdout = orig_stdout if stdout
+            end
+
+            @last_cmd = value if String === value
+
+            return value
+        end
+
+        # provide a list of tab completions given the prompted value
+        #
+        def complete(str)
+            if str[0] == ?.
+                str.slice!(0)
+                prefix = '.'
+            else
+                prefix = ''
+            end
+
+            ret  = MySQLResults.complete(str)
+            ret += @registrations.keys.sort_by{|sym|sym.to_s}.collect do |sym|
+                name = sym.to_s
+                if name.start_with?(str)
+                    prefix + name
+                else
+                    nil
+                end
+            end
+
+            ret.compact!
+            ret
+        end
+
+        # reset the hexstr limit back to the default value
+        #
+        def reset_hexstr_limit
+            @hexstr_limit = HEXSTR_LIMIT
+        end
+
+        # convert a binary string value into a hexadecimal string
+        #
+        def to_hexstr(bin, limit=@hexstr_limit, prefix='0x')
+            cnt = 0
+            str = prefix << bin.gsub(/./m) do |ch|
+                if limit
+                    if limit < 1
+                        cnt += 1
+                        next
+                    end
+                    limit -= 1
+                end
+                '%02x' % ch[0]
+            end
+
+            if limit && limit < 1 && 0 < cnt
+                str << "... (#{cnt} bytes hidden)"
+            end
+
+            return str
+        end
+
+        ########################################
+        private
+
+            # display a listing of all registered helpers
+            #
+            def list
+                usagelen = 0
+                desclen  = 0
+
+                sorted = @registrations.values.sort_by do |reg|
+                    usagelen = reg.usage.length if usagelen < reg.usage.length
+                    longest_line = reg.desc.split(/\r?\n/).collect{|l|l.length}.max
+                    desclen = longest_line if longest_line && desclen < longest_line
+                    reg.usage
+                end
+
+                fmt = "%-#{usagelen}s  %s#{$/}"
+
+                printf(fmt, 'usage', 'description')
+                puts '-'*(usagelen+2+desclen)
+
+                sorted.each do |reg|
+                    printf(fmt, reg.usage, reg.desc)
+                end
+
+                return nil
+            end
+
+            # show all the pertinent version data we have about our
+            # software and the mysql connection
+            #
+            def version
+                puts "rsql:v#{RSQL::VERSION} client:v#{MySQLResults.conn.client_info} " \
+                     "server:v#{MySQLResults.conn.server_info}"
+            end
+
+            # provide a helper utility in the event a registered
+            # method would like to make its own queries
+            #
+            def query(content, *args)
+                MySQLResults.query(content, self, *args)
+            end
+
+            # exactly like register below except in addition to registering as
+            # a usable call for later, we will also use these as soon as we
+            # have a connection to MySQL.
+            #
+            def register_init(sym, *args, &block)
+                register(sym, *args, &block)
+                @init_registrations << sym
+            end
+
+            # if given a block, allow the block to be called later, otherwise,
+            # create a method whose sole purpose is to dynmaically generate
+            # sql with variable interpolation
+            #
+            def register(sym, *args, &block)
+                name = usage = sym.to_s
+
+                if Hash === args.last
+                    bangs = args.pop
+                    desc = bangs.delete(:desc)
+                else
+                    bangs = {}
+                end
+
+                desc = '' unless desc
+
+                if block.nil?
+                    sql = sqeeze!(args.pop)
+
+                    argstr = args.join(',')
+                    usage << "(#{argstr})" unless argstr.empty?
+
+                    blockstr = %{$SAFE=2;lambda{|#{argstr}|%{#{sql}} % [#{argstr}]}}
+                    block = Thread.new{ eval(blockstr) }.value
+                    args = []
+                else
+                    usage << "(#{block.arity})" unless 0 == block.arity
+                end
+
+                @registrations[sym] = Registration.new(name, args, bangs, block, usage, desc)
+            end
+
+            # convert a collection of values into to hexadecimal strings
+            #
+            def hexify(*ids)
+                ids.collect do |id|
+                    case id
+                    when String
+                        if id.start_with?('0x')
+                            id
+                        else
+                            '0x' << id
+                        end
+                    when Integer
+                        '0x' << id.to_s(16)
+                    else
+                        raise "invalid id: #{id.class}"
+                    end
+                end.join(',')
+            end
+
+            # convert a number of bytes into a human readable string
+            #
+            def humanize_bytes(bytes)
+                abbrev = ['B','KB','MB','GB','TB','PB','EB','ZB','YB']
+                bytes = bytes.to_i
+                fmt = '%7.2f'
+
+                abbrev.each_with_index do |a,i|
+                    if bytes < (1024**(i+1))
+                        if i == 0
+                            return "#{fmt % bytes} B"
+                        else
+                            b = bytes / (1024.0**i)
+                            return "#{fmt % b} #{a}"
+                        end
+                    end
+                end
+
+                return bytes.to_s
+            end
+
+            # convert a human readable string of bytes into an integer
+            #
+            def dehumanize_bytes(str)
+                abbrev = ['B','KB','MB','GB','TB','PB','EB','ZB','YB']
+
+                if str =~ /(\d+(\.\d+)?)\s*(\w+)?/
+                    b = $1.to_f
+                    if $3
+                        i = abbrev.index($3.upcase)
+                        return (b * (1024**i)).round
+                    else
+                        return b.round
+                    end
+                end
+
+                raise "unable to parse '#{str}'"
+            end
+
+            # convert a time into a relative string from now
+            #
+            def relative_time(dt)
+                return dt unless String === dt
+
+                now = Time.now.utc
+                theirs = Time.parse(dt + ' UTC')
+                if theirs < now
+                    diff = now - theirs
+                    postfix = 'ago'
+                else
+                    diff = theirs - now
+                    postfix = 'from now'
+                end
+
+                fmt = '%3.0f'
+
+                [
+                 [31556926.0, 'years'],
+                 [2629743.83, 'months'],
+                 [86400.0,    'days'],
+                 [3600.0,     'hours'],
+                 [60.0,       'minutes']
+                ].each do |(limit, label)|
+                    if (limit * 1.5) < diff
+                        return "#{fmt % (diff / limit)} #{label} #{postfix}"
+                    end
+                end
+
+                return "#{fmt % diff} seconds #{postfix}"
+            end
+
+            # squeeze out any spaces
+            #
+            def sqeeze!(sql)
+                sql.gsub!(/\s+/,' ')
+                sql.strip!
+                sql << ';' unless sql[-1] == ?;
+                sql
+            end
+
+            # safely store an object into a file keeping at most one
+            # backup if the file already exists
+            #
+            def safe_save(obj, name)
+                name += '.yml' unless File.extname(name) == '.yml'
+                tn = "#{name}.tmp"
+                File.open(tn, 'w'){|f| YAML.dump(obj, f)}
+                if File.exist?(name)
+                    bn = "#{name}~"
+                    File.unlink(bn) if File.exist?(bn)
+                    File.rename(name, bn)
+                end
+                File.rename(tn, name)
+                puts "Saved: #{name}"
+            end
+
+            def method_missing(sym, *args, &block)
+                if reg = @registrations[sym]
+                    @bangs.merge!(reg.bangs)
+                    final_args = reg.args + args
+                    reg.block.call(*final_args)
+                elsif MySQLResults.respond_to?(sym)
+                    MySQLResults.send(sym, *args)
+                else
+                    super.method_missing(sym, *args, &block)
+                end
+            end
+
+    end # class EvalContext
+
+end # module RSQL