ratchet 0.3.0

data/lib/ratchet/commandbuffer.rb

@@ -0,0 +1,66 @@
+=begin
+	This file is part of the Ratchet project, a client for Icecap.
+    Copyright (C) 2005-6  Andrew Thompson
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+=end
+
+#### commandbuffer.rb ####
+# A simple command buffer used for input history
+####
+
+module Ratchet
+	class CommandBuffer
+		attr_accessor :currentcommand
+		def initialize(config)
+			@config = config
+			@commandbuffer = []
+			@currentcommand = ''
+			@commandindex = 0
+		end
+		
+		#add a command to the command buffer
+		def add_command(string, increment=true)
+			if string.length == 0 or string == @commandbuffer[@commandindex]
+				@commandindex =@commandbuffer.length
+				return
+			end
+			@commandbuffer << string
+			if @commandbuffer.length > @config['commandbuffersize'].to_i
+				@commandbuffer.unshift
+			end
+			@commandindex =@commandbuffer.length
+		end
+		
+		#get the last command in the command buffer
+		def last_command
+			@commandindex -=1 if @commandindex > 0
+			command = @commandbuffer[@commandindex]
+			command ||= ''
+			return command
+		end
+		
+		#get the next command in the command buffer
+		def next_command
+			@commandindex +=1
+			if @commandindex >= @commandbuffer.length
+				@commandindex = @commandbuffer.length if @commandindex > @commandbuffer.length
+				return ''
+			else
+				return @commandbuffer[@commandindex]
+			end
+		end
+	end
+end

data/lib/ratchet/commandparser.rb

@@ -0,0 +1,668 @@
+=begin
+	This file is part of the Ratchet project, a client for Icecap.
+    Copyright (C) 2005-6  Andrew Thompson
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+=end
+
+#### commandparser.rb ####
+# Contains additional Main methods that define commands of the format cmd_<commandname>
+# the command_parse method finds the appropiate method and passes the input to it
+# callbacks are also honored for these methods
+####
+
+module Ratchet
+	class Main   
+		def command_parse(message, target)
+
+			#TODO - fix this?
+			#~ if network and !network.loggedin
+			#~ throw_message('buffering command '+message)
+			#~ network.bufferedcommands.push(message)
+			#~ return
+			#~ end
+
+#         message = check_aliases(message)
+
+			if /^(\/\w+)(?: (.+)|)/.match(message)
+				command = $1
+				arguments = $2
+			end
+
+			if command and command[0].chr == '/'
+				if result = @config['aliases'].detect{|k,v| '/'+k.downcase == message[0..k.length].downcase}
+					Alias.new(result[1], arguments, target).commands.each{|x|sleep 0.1;command_parse(x, target)}
+					return
+				else
+					cmd = command[1, command.length].downcase
+				end
+			end
+
+			begin
+				if cmd and self.respond_to?('cmd_'+cmd)
+					res = callback('cmd_'+cmd, arguments, target)
+					return if res === true
+					self.send('cmd_'+cmd, *res)
+				#unhandled command
+				elsif cmd
+#                 puts cmd
+#                 puts caller
+					res = callback(:command_missing, cmd, arguments, target)
+					return if res === true
+					command_missing(*res)
+				else
+					res = callback('cmd_message', message, target)
+					self.send('cmd_message', *res)
+				end
+				#rescue any exceptions...
+			rescue =>exception
+				puts 'Error parsing commmand : '+$!
+				puts exception.backtrace
+			end
+		end
+
+		#/exec support, -o makes it output to the channel
+		help :cmd_exec, "executes a command, the -o switch makes it output to the channel"
+		def cmd_exec(message, target)
+			return unless message
+
+			output = false
+
+			if message[0,2] == '-o'
+				output = true
+				message = message[3..-1]
+			end
+
+			res = `#{message}`
+			res.chomp
+			if $? == 0 and res
+				res.split("\n").each do |msg|
+					if output
+						if target.class == ChannelBuffer or target.class == ChatBuffer
+							reply = send_command('message'+rand(100).to_s, "msg;#{target.identifier_string};#{escape(msg)}")
+						end
+					end
+					lineref = target.send_user_event({'msg' => msg}, EVENT_USERMESSAGE)
+					reply.lineref = lineref if reply
+				end
+			end
+
+		end
+
+		help :cmd_message, "Sends a message to the channel"
+		def cmd_message(message, target)
+			#its not a command, treat as a message
+			if target.respond_to? :username
+				#puts message
+				messages = message.split("\n")
+				messages.each do |message|
+					if target.class == ChannelBuffer
+						rep = send_command('message'+rand(100).to_s, 'msg;network='+target.network.name+';channel='+target.name+';msg='+escape(message)+";mypresence="+target.presence)
+					elsif target.class == ChatBuffer
+						rep = send_command('message'+rand(100).to_s, 'msg;network='+target.network.name+';presence='+target.name+';msg='+escape(message)+";mypresence="+target.presence)
+					end
+					line = {}
+					line[PRESENCE] = target.presence
+					line[MSG] = message
+					lineref = target.send_user_event(line, EVENT_USERMESSAGE)
+					rep.lineref = lineref if rep
+				end
+			else
+				#line = {}
+				throw_error('Invalid server command')
+			end
+		end
+
+		#/join command
+		help :cmd_join, "Join a channel. usage: /join <channel>"
+		def cmd_join(arguments, target)
+			return unless target
+#         puts arguments, target, target.joined?
+			if !arguments and target.respond_to? :join and !target.joined?
+#             puts target.name
+				arguments = target.name
+			end
+			send_command('join', "channel join;#{target.network.identifier_string};channel=#{arguments}") if arguments
+		end
+
+		#/server command
+		help :cmd_server, "Define a server. usage: /server <name>:<protocol>:<address>[:<port>]"
+		def cmd_server(arguments, target)
+			if arguments  =~ /^([a-zA-Z0-9_\-]+):([a-zA-Z]+):([a-zA-Z0-9_.\-]+)(?:$|:(\d+))/
+				network_add($1, $2, $3, $4)
+			else
+				throw_error('Usage: /server <name>:<protocol>:<address>[:<port>]')
+			end
+		end
+
+		#/connect command
+		help :cmd_connect, "Connect to a network. Usage: /connect <Network> <Presence>"
+		def cmd_connect(arguments, target)
+			unless arguments
+				throw_error('Specify a network to connect to.')
+				return
+			end
+			network, presence = arguments.split(' ', 2)
+
+			unless presence
+				#presence = $config['presence']
+				throw_error('Specify a presence to use.')
+			end
+
+			if presence_add(network, presence)
+				network_connect(network, presence)
+			end
+		end
+
+		#/disconnect command
+		help :cmd_disconnect, "Disconnect from a network. Usage: /disconnect [Network]"
+		def cmd_disconnect(arguments, target)
+			if target.respond_to? :network and target.network.connected?
+				send_command('disconnect', "presence disconnect;#{target.network.identifier_string}")
+			elsif !target.network.connected?
+				throw_error('Cannot disconnect, network already disconnected')
+			else
+				throw_error('/disconnect does not function in this tab without a network argument')
+			end
+		end
+#         unless target.respond
+#             if !arguments
+#                 throw_error('/disconnect does not function in this tab without a network argument')
+#                 return
+#             end
+#         end
+
+#         if network and !arguments
+#             servername = network.name
+#             presence = network.presence
+#         else
+#             servername, presence = arguments.split(' ', 2)
+#         end
+
+#         if presence
+#         elsif target.network.name == networkname
+#             presence = target.presence
+#         else
+#             results = @serverlist.get_network_by_name(networkname)
+
+#             if results
+#                 results.delete_if {|server| !server.connected}
+#             end
+
+#             if results and results.length == 1
+#                 presence = results[0].presence
+#             elsif results and results.length > 1
+#                 throw_error('Multiple networks named '+servername+' please specify a presence')
+#             else
+#                 throw_error('No network named '+servernames)
+#             end
+#         end
+
+#         if presence and servername
+#             send_command('disconnect'+servername, "presence disconnect;network="+servername+";mypresence="+presence)
+#             server = @serverlist[servername, presence]
+#             server.disconnect
+#             #
+#             #server.close if server
+#         end
+#     end
+
+		#/part command
+		help :cmd_part, "Leave a channel. Usage: /part [channel]"
+		def cmd_part(arguments, target)
+			unless target.respond_to? :topic
+				throw_error('/part does not function in this tab.')
+				return
+			end
+			if arguments
+				channame = arguments.split(' ')
+			end
+
+			if channame
+				send_command('part', "channel part;#{target.network.identifier_string};channel="+channame[0])
+			elsif target
+				send_command('part', "channel part;#{target.identifier_string}")
+			else
+				error_throw('Part requires a channel argument or it must be called from a channel tab.')
+			end
+		end
+
+		help :cmd_close, "Close current buffer, will close all children of current buffer"
+		def cmd_close(arguments, target)
+			if target.respond_to? :connect
+				send_command('disconnect', "presence disconnect;#{target.identifier_string}")
+				@buffers.values.select{|x| x.network == target}.each do |buffer|
+					buffer.close
+				end
+			elsif target.respond_to? :topic
+				send_command('part', "channel part;#{target.identifier_string}")
+				target.close
+			else
+				target.close
+			end
+		end
+
+		#/quit command
+		help :cmd_quit, "Quit Ratchet"
+		def cmd_quit(arguments, target)
+			send_command('quit', 'quit')
+			Gtk.main_quit
+			quit
+		end
+
+		#/shutdown command
+		help :cmd_shutdown, "Kill Icecapd and quit Ratchet"
+		def cmd_shutdown(arguments, target)
+			send_command('shutdown', 'shutdown')
+			Gtk.main_quit
+			quit
+		end
+
+		help :cmd_topic, "Get or print the topic. Usage: /topic [newtopic]"
+		def cmd_topic(arguments, target)
+			unless target.kind_of? ChannelBuffer
+				error_throw('/topic only functions in a channel tab')
+				return
+			end
+
+			if arguments
+				#update the topic
+				send_command('topicchange', 'channel change;network='+target.network.name+';mypresence='+target.network.presence+';channel='+target.name+';topic='+escape(arguments))
+			else
+				#print the topic
+				event = {'init' => true, 'line'=>1, CHANNEL=>target.name, TOPIC=>target.topic}
+				target.send_user_event(event, EVENT_TOPIC)
+			end
+		end
+
+
+		#/ruby command
+		help :cmd_ruby, "Blindly execute ruby code"
+		def cmd_ruby(arguments, target)
+			unless arguments
+				throw_error('Give me some code to execute')
+				return
+			end
+			throw_message('possibly evil ruby code inputted, blindly executing')
+			eval(arguments)
+		end
+
+		#/raw command
+		help :cmd_raw, "Send raw icecap messages to icecapd"
+		def cmd_raw(arguments, target)
+			unless arguments
+				throw_error('Specify a string to send to the server')
+				return
+			end
+			throw_message('Sent raw command "'+arguments+'" to irssi2 directly')
+			send_command('raw', arguments)
+		end
+
+		#/nick command
+		help :cmd_nick, "Change your nickname. Usage: /nick <nickname>"
+		def cmd_nick(arguments, target)
+			unless target and arguments
+				unless target.respond_to? :username
+					throw_error('/nick command does not function in this tab.')
+					return
+				end
+				if !arguments
+					throw_error('Usage: /nick <nickname>')
+					return
+				end
+			end
+			name, bleh = arguments.split(' ', 2)
+			send_command('nick'+name, "presence change;#{target.network.identifier_string};name=#{name}")
+		end
+
+		#/whois command
+		help :cmd_whois, "Get the whois info on somebody"
+		def cmd_whois(arguments, target)
+			unless target.respond_to? :network
+				throw_error('/whois command does not function in this tab.')
+				return
+			end
+			if arguments
+				name, bleh = arguments.split(' ', 2)
+			else
+				name = target.username
+			end
+			send_command('whois'+name, "presence status;#{target.network.identifier_string};presence=#{name}")
+		end
+
+		#/msg command
+		help :cmd_msg, "Message another user. Usage: /msg <username> <message>"
+		def cmd_msg(arguments, target)
+			unless target.respond_to? :presence
+				throw_error('/msg does not function in this tab')
+				return
+			end
+
+			if arguments
+				nick,msgs = arguments.split(' ', 2)
+			end
+
+			if nick and msgs
+				messages = msgs.split("\n")
+				messages.each do |message|
+					send_command('msg'+rand(100).to_s, 'msg;network='+target.network.name+';presence='+nick+';msg='+message+";mypresence="+target.presence)
+					if buffer = find_buffer(target.network.name, target.presence, nil, nick)
+						buffer.send_user_event({'msg'=>message}, EVENT_USERMESSAGE)
+					end
+				end  
+			else
+				throw_error('/msg requires a username and a message')
+
+			end
+		end
+
+		help :cmd_query, "Open a new chat buffer, and optionaly message the user. Usage: /query <username> [message]"
+		def cmd_query(arguments, target)
+			if arguments
+				nick,msgs = arguments.split(' ', 2)
+				chat = add_buffer(target.network.name, target.presence, nil, nick) if nick
+#             puts chat
+				cmd_msg(arguments, chat) if msgs and chat
+				#             chat.send_user_event({'msg'=>msgs}, EVENT_USERMESSAGE)
+			end
+		end
+
+
+		help :cmd_me, "Does an emote"
+		def cmd_me(arguments, target)
+			unless target.respond_to? :users and target.network != target
+				throw_error('/me does not function in this tab')
+				return
+			end
+			reply = send_command('message'+rand(100).to_s, "msg;#{target.identifier_string};msg=#{escape(arguments)};type=action")
+			lineref = target.send_user_event({'msg'=>arguments, 'type'=>'action'}, EVENT_USERMESSAGE)
+			reply.lineref = lineref
+		end
+
+		help :cmd_networks, "List all defined networks"
+		def cmd_networks(arguments, target)
+			lines = ['Defined networks:']
+			@networks.list.each {|network| lines.push(network.name+' - '+network.protocol)}
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+		end
+
+		help :cmd_protocols, "List all supported protocols"
+		def cmd_protocols(arguments, target)
+			lines = ['Defined protocols']
+			@protocols.list.each {|protocol| lines.push("#{protocol.name} - #{protocol.charsets_in.join(', ')}, #{protocol.charset_out}") }
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+		end
+
+		help :cmd_gateways, "List all defined gateways"
+		def cmd_gateways(arguments, target)
+			lines = ['Defined gateways:']
+
+			#~ @serverlist.servers.each do |server|
+			#~ network, presence = server.getnetworkpresencepair
+			#~ if server.connected
+			#~ lines.push(network+' - '+presence+' - Connected')
+			#~ else
+			#~ lines.push(network+' - '+presence)
+			#~ end
+			#~ end
+
+			@networks.list.each do |network|
+				network.gateways.list.each do|gateway|
+					x = gateway.host
+					x += ':'+gateway.port if gateway.port
+					lines.push(x)
+				end
+			end
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+
+			#@presences.each {|presence| lines.push(presence[0]+' - '+presence[1])}
+		end
+
+		help :cmd_presences, "List all defined presences"
+		def cmd_presences(arguments, target)
+			lines = ['Defined Presences:']
+
+			#~ @serverlist.servers.each do |server|
+			#~ network, presence = server.getnetworkpresencepair
+			#~ if server.connected
+			#~ lines.push(network+' - '+presence+' - Connected')
+			#~ else
+			#~ lines.push(network+' - '+presence)
+			#~ end
+			#~ end
+
+			@networks.list.each do |network|
+				network.presences.list.each do|presence|
+					lines.push(network.name+' - '+presence.name)
+				end
+			end
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+
+		end
+
+
+		help :cmd_channels, "List all defined channels"
+		def cmd_channels(arguments, target)
+			lines = ['Defined Channels:']
+
+			@buffers.values.select{|x| x.class == ChannelBuffer}.sort{|x, y| x.name<=>y.name}.each do |channel|
+				if channel.joined?
+					lines.push(channel.network.name+' - '+channel.presence+' - '+channel.name+' - Connected')
+				else
+					lines.push(channel.network.name+' - '+channel.presence+' - '+channel.name)
+				end
+			end
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+		end
+
+#     if $args['debug']
+			def cmd_reload(arguments, target)
+				if !arguments.include? '.'
+					arguments += '.rb'
+				end
+				begin
+					load "#{arguments}"
+				rescue LoadError
+					puts "failed to load #{arguments}"
+				rescue SyntaxError
+					puts "Failed to load #{arguments}, syntax error" 
+				else
+					puts "reload of #{arguments} sucessful"
+				end
+			end
+#     end
+
+		help :cmd_load, "Specify a plugin to load. Usage: /load <name>"
+		def cmd_load(arguments, target)
+			unless arguments
+				throw_error('Specify a plugin to load.')
+				return
+			end
+			plugin_load(arguments)
+		end
+
+		help :cmd_unload, "Specify a plugin to unload. Usage: /unload <name>"
+		def cmd_unload(arguments, *args)
+			unless arguments
+				throw_error('Specify a plugin to unload.')
+				return
+			end
+			if plugin = Plugin[arguments]
+				Plugin.unregister(plugin)
+			else
+				throw_error('No plugin found called '+arguments)
+			end
+		end
+
+		help :cmd_pluginlist, "List all loaded plugins"
+		def cmd_pluginlist(arguments, target)
+			lines = ['Loaded Plugins:']
+			plugins = Plugin.list
+			plugins.each do |key, values|
+				#             v.each do |key, values|
+				temp = values[:name]
+				#                 values.each do |value|
+				#                     #puts k.name, key, value
+				#                     temp += ' '+value[1].to_s+'#'+value[0]
+				#                 end
+				lines.push(temp)
+				#             end
+			end
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+		end
+
+		help :cmd_alias, "Define an alias. Usage: /alias <aliasname> <aliascommand>"
+		def cmd_alias(arguments, target)
+			splitter = ' '
+			if arguments.include?(' /')
+				splitter = ' /'
+			end
+			original, cmdalias = arguments.split(splitter, 2).map{|e| e.strip}
+
+			if splitter == ' /'
+				cmdalias = '/'+cmdalias
+			end
+
+			puts 'aliased '+original+' to '+cmdalias
+
+			#puts original.class, cmdalias.class
+
+			@config['aliases'] ||= {}
+			@config['aliases'][original] = cmdalias
+		end
+
+		help :cmd_unalias, "Remove an alias. Usage: /unalias <aliasname>"
+		def cmd_unalias(arguments, target)
+
+			cmd, other = arguments.split(' ', 2)
+
+			cmd.strip!
+
+			@config['aliases'].delete(cmd)
+
+			puts 'unaliased '+cmd
+		end
+
+		help :cmd_aliases, "List all defined aliases"
+		def cmd_aliases(arguments, target)
+			lines = ['Aliases:']
+
+			@config['aliases'].each do |original, cmdalias|
+#             puts original.class, cmdalias.class
+				lines.push(original+' => '+cmdalias)
+			end
+
+			lines.push(' ')
+
+			lines.each do |line|
+				event = {'msg' => line}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+		end
+
+		help :cmd_version, "Print what version of ratchet you are currently using"
+		def cmd_version(arguments, target)
+			target.send_user_event({:msg => "Currently running Ratchet-#{$version}"}, EVENT_NOTICE)
+		end
+
+		help :cmd_help, "Get help on commands. Usage: /help [command]"
+		def cmd_help(arguments, target)
+			#puts 'help', self
+			#puts self.class.methods - self.class.superclass.methods
+			command_methods = command_list
+			if arguments
+#             command_methods = (self.methods).select{|method| method =~ /^cmd_/}
+#             command_methods = command_methods.select{|method| method[4..-1] == arguments}
+				command_methods = command_methods.detect{|method| method[1..-1] == arguments}
+#             command_methods ||= @config['aliases'].detect{|k,v| k == arguments}[0]
+			end
+			
+			return unless command_methods
+			
+			unless arguments
+				event = {'msg' => "Interactive help system"}
+				target.send_user_event(event, EVENT_NOTICE)
+				event = {'msg' => "<> denotes a required argument, [] denotes an optional one"}
+				target.send_user_event(event, EVENT_NOTICE)
+				event = {'msg' => ""}
+				target.send_user_event(event, EVENT_NOTICE)
+			end
+
+			command_methods.sort.each do |method|
+#             puts method, self.methods.include?('cmd_'+method[1..-1]), @config['aliases'][method[1..-1]]
+				if self.methods.include? 'cmd_'+method[1..-1]
+					if self.help('cmd_'+method[1..-1])
+						event = {'msg' => method+' : '+self.help('cmd_'+method[1..-1]).to_s}
+						target.send_user_event(event, EVENT_NOTICE)
+					else
+						event = {'msg' => method+" : Undocumented command"}
+						target.send_user_event(event, EVENT_NOTICE)
+					end
+				elsif al = @config['aliases'][method[1..-1]]
+					event = {'msg' => "#{method} : alias for #{al}"}
+					target.send_user_event(event, EVENT_NOTICE)
+				end
+			end
+		end
+
+		def command_list
+			a = (self.methods).select{|method| method =~ /^cmd_/}.map{|x| '/'+(x[4..-1])}
+			a += @config['aliases'].keys.map{|x| '/'+x}
+			#TODO - aliases too
+			a.sort
+		end
+		
+		#sorta like method_missing
+		def command_missing(command, arguments, target)
+			throw_error("Unknown command /#{command}")
+		end
+	end
+end