ratchet 0.3.0

data/lib/ratchet/plugins.rb

@@ -0,0 +1,616 @@
+=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
+
+#### plugins.rb ####
+# Provides a pluginAPI mixin for addding plugin support to classes
+# provides a base plugin class which all other plugins must derive from
+# provides some configuration automation for plugins
+####
+
+#include this in any classes where you want plugins
+module Ratchet
+	module PluginAPI
+		@@cb_hash = {}
+		@@cb_hash_after = {}
+		#calls all the callback blocks associated with method, should exit if a block returns true
+		def callback(method, *args)
+
+			#lookup the hash
+			#         cb_hash = self.class.cb_hashes
+			#         cb_hash ||= resolve_cb_hashes
+
+			#return if we get nothing
+			#         callbacks = self.class.find_callbacks(method.to_sym)
+			#         unless cb_hash
+			#             puts cb_hash
+			#             puts 'empty callback hash for '+self.class.to_s
+			#             return *args 
+			#         end
+
+			#check if the callback is in the hash
+			#         if cb_hash.has_key?(method.to_sym)
+			#initialize the return value as nil
+			ret = nil
+
+			#loop through the callbacks
+			#             cb_hash[method.to_sym].each do |callback|
+			self.class.find_callbacks(method.to_sym).each do |callback|
+
+				#call the block and get the return value
+				#what about instance_eval here?
+				ret = self.instance_exec(*args, &callback)
+				#                 ret = callback.call(self, *args)
+
+				#if return value is true, break off calling any more callbacks (like GTK's system)
+				if ret === true
+					break
+					#if its an array, store the results so they can be passed to sucessive callbacks
+				elsif ret.kind_of? Array
+					ret.each_with_index { |z, i| args[i]=z}
+
+					#if a single value, assume first argument is returned
+				elsif ret
+					args[0] = ret
+				end
+			end
+
+			#if it returned true, let the calling function know
+			if ret === true
+				puts "returned true, disabling further callbacks or functions for #{method}"
+				return true
+			end
+
+			#otherwise return the arguments, possibly modified by callbacks.
+			return args
+		end
+
+		#calls all the callback_after blocks associated with method, should exit if a block returns true
+		def callback_after(method, *args)
+			#lookup the hash
+			#         cb_hash_after = self.class.cb_hashes_after
+			#         cb_hash_after ||= resolve_cb_hashes_after
+
+			#         #return if nothing
+			#         unless cb_hash_after
+			#             puts 'empty callback_after hash for '+self.class.to_s
+			#             return *args 
+			#         end
+
+			#check if the callback is in the hash
+			#         if cb_hash_after.has_key?(method.to_sym)
+
+			#init the return value to nil
+			ret = nil
+
+			#loop through the callbacks
+			#             cb_hash_after[method.to_sym].each do |callback|
+			self.class.find_callbacks_after(method.to_sym).each do |callback|
+				#call the callback, and get the return stuff
+				ret = self.instance_exec(*args, &callback)
+				#                 ret = callback.call(self, *args)
+
+				#if callback returns true, break off calling any other callbacks like GTK's signals
+				if ret === true
+					break
+
+					#if its an array, update the original arguments (assume they're passed in order)
+				elsif ret.kind_of? Array
+					ret.each_with_index { |z, i| args[i]=z}
+
+					#if single return, assume first argument
+				elsif ret
+					args[0] = ret
+				end
+			end
+
+			#let the calling function know it returned true
+			if ret === true
+				puts 'returned true, disabling further callbacks or functions for '+method
+				return true
+			end
+
+			#otherwise, return the arguments, possibly modified by callbacks
+			return args
+		end
+
+		#resolves the method name of the current method (is this still needed?)
+		def get_method_name()
+			/\`([^\']+)\'/.match(caller(1).first)[1].to_sym # we need a ' to close the damn thing :)
+		end
+
+		#load a plugin
+		def plugin_load(name)
+			#expand the name
+			return unless file = Plugin.find_plugin(name)
+			@config['plugins'] = [] unless @config['plugins'].class == Array
+			@config['plugins'].push(name) unless @config['plugins'].include?(name)
+
+			#check if it exists, if so, load it
+			if File.exists?(file)
+				begin
+					load(file, true)
+				rescue Exception => details
+					puts 'Error loading plugin '+name+' : '+details.message
+					puts details.backtrace
+					@config['plugins'].delete(name)
+					return false
+				end
+
+				#no plugin found
+			else
+				puts 'plugin file '+file+' not found'
+				@config['plugins'].delete(name)
+				return false
+			end
+			Plugin[name]
+		end
+
+		#wrapper function for class method
+#     def resolve_cb_hash
+#                 puts 'resolving cb_hash'
+#         return self.class.resolve_cb_hash
+#     end
+
+#     #wrapper function for class method
+#     def resolve_cb_hash_after
+#                 puts 'resolving cb_hash_after'
+#         return self.class.resolve_cb_hash_after
+#     end
+
+		#hyperextend!, these methods are added as class methods
+		module Plugins
+			#define a callback
+			def add_callback(name, &block)
+				#initialize the hash if it doesn't exist
+				@cb_hash ||= Hash.new
+
+				#make sure there's a function to attach a callback to
+				if self.private_instance_methods.include?(name.to_s) or self.instance_methods.include?(name.to_s)
+
+					#make a new array for the callback if need be, this allows multiple callbacks per function, executed in the order they were added
+					@cb_hash[name.to_sym] ||= Array.new
+					if block_given?
+
+						#add the block to the array
+						@cb_hash[name.to_sym].push(block)
+						puts "added callback for #{name}"
+						puts @cb_hash.inspect
+						#                     ObjectSpace.each_object(self) do |klass|
+						#puts klass
+						#                         klass.class.resolve_cb_hash
+						#                     end
+						#return the name of the callback..?
+						return name
+					end
+				else
+					#no function to attach to...
+					puts "no event function called #{name}, not adding callback"
+					return nil
+				end
+			end
+
+			#add a callback to be executed after a function
+			def add_callback_after(name, &block)
+				#again, make the hash if it doesn't exist
+				@cb_hash_after ||= Hash.new
+
+				#check to see if there's a function to attach to
+				if self.private_instance_methods.include?(name.to_s) or self.instance_methods.include?(name.to_s)
+					#make an array for the callbacks if there isn't one
+					@cb_hash_after[name.to_sym] ||= Array.new
+					if block_given?
+						@cb_hash_after[name.to_sym].push(block)
+						puts "added callback_after for #{name}"
+						puts @cb_hash_after.inspect
+						#                     ObjectSpace.each_object(self) do |klass|
+						#puts klass.class
+						#                         klass.class.resolve_cb_hash_after
+						#                     end
+						#return the name, not sure why...
+						return name
+					end
+				else
+					#no function!
+					puts "no event function called #{name}, not adding callback"
+					return nil
+				end
+			end
+
+			#remove a callback
+			def del_callback(name)
+				#puts self.class
+				puts @cb_hash.delete(name.to_sym)
+				puts @cb_hash.inspect
+#             resolve_cb_hashes
+			end
+
+			#remove a callback_after
+			def del_callback_after(name)
+				@cb_hash_after.delete(name.to_sym)
+				puts @cb_hash_after.inspect
+#             resolve_cb_hashes_after
+				puts @cb_hashes_after.inspect
+			end
+
+			#remove a method
+			def del_method(name)
+				self.send(:remove_method, name.to_sym)
+#             puts self.methods.inspect
+			end
+
+			#add a new method
+			def add_method(name, &block)
+				#make sure its not already defined....
+				if self.private_instance_methods.include?(name.to_s) or self.instance_methods.include?(name.to_s)
+					puts 'method '+name+' already defined, not redefining'
+					return nil
+				end
+
+				#call define method and add it.
+				self.send(:define_method, name, &block)
+				#puts 'added '+name
+				return name
+			end
+
+			#reader for cb_hash...?
+			def cb_hash
+				@cb_hash ||= Hash.new
+				return @cb_hash
+			end
+
+			def cb_hashes
+				resolve_cb_hashes unless @cb_hashes
+				@cb_hashes
+			end
+
+			#lookup parent classes for callbacks
+			#TODO is there a way to do this less then once per callback call without messing up plugin unloading?
+			def resolve_cb_hashes
+				#a new hash to store the resulting callbacks
+				hashes = [cb_hash]
+
+				#loop through the parent classes, and build an array of them....
+				c = self
+				classes = Array.new
+
+				while c != Object || nil
+					classes.push(c)
+					c = c.superclass
+				end
+
+				#reverse the array of classes, so callbacks are overridden in child classes
+				classes.reverse!
+
+				#loop through, and add callbacks
+				classes.each do |klass|
+					if klass.respond_to? :cb_hash
+						hashes << klass.cb_hash# if klass.cb_hash
+					end
+				end
+
+				#return
+				#return temphash
+				@cb_hashes = hashes
+			end
+
+			def find_callbacks(method)
+				ret = []
+				x = cb_hashes.select{|x| x.has_key? method}
+#             puts x.inspect, @cb_hashes.inspect
+				x.each do |y|
+					ret += y[method]
+				end
+#             puts "found callbacks: #{ret.inspect}"
+				ret
+			end
+
+			def find_callbacks_after(method)
+#             puts method
+				ret = []
+				x = cb_hashes_after.select{|x| x.has_key? method}
+#             puts x.inspect, @cb_hashes_after.inspect
+				x.each do |y|
+					ret += y[method]
+				end
+#             puts "found callbacks after: #{ret.inspect}"
+				ret
+			end
+
+			#reader for cb_hash_after
+			def cb_hash_after
+				@cb_hash_after ||= Hash.new
+				return @cb_hash_after
+			end
+
+			def cb_hashes_after
+				resolve_cb_hashes_after unless @cb_hashes_after
+				@cb_hashes_after
+			end
+
+			#lookup parent classes for callback_after
+			def resolve_cb_hashes_after
+
+				#new hash to store results
+				hashes = [cb_hash_after]
+
+				#loop through parents and build an array
+				c = self
+				classes = Array.new
+
+				while c != Object || nil
+					classes.push(c)
+					c = c.superclass
+				end
+
+				#invert the array, so child callbacks override parents
+				classes.reverse!
+
+				#build hash of callback_after
+				classes.each do |klass|
+#                 puts klass, klass.respond_to?(:cb_hash_after)
+					if klass.respond_to? :cb_hash_after
+#                     puts "#{klass} has cb_hash_after"
+#                     puts klass.cb_hash_after.inspect
+						hashes <<  klass.cb_hash_after# if klass.cb_hash_after
+					end
+				end
+
+				#return
+				#return temphash
+#             puts "resolved cb_hashes_after to: #{hashes.inspect} for class #{self}"
+				@cb_hashes_after = hashes
+			end
+		end
+
+		extend Plugins
+
+		def self.append_features(klass)
+			super
+			klass.extend(Plugins)
+		end
+
+		def method_missing(symbol, *args)
+			plugin = Plugin.find_plugin_method(symbol)
+			if plugin
+				plugin[0].send(symbol, *args)
+			else
+				puts "cannot find method #{symbol} in plugins"
+				nil
+				#             raise NoMethodError
+			end
+		end
+	end
+
+#the plugin class, all plugins are derivatives of this class
+	class Plugin
+		include PluginAPI
+
+		def self.main=(main)
+			@@main= main
+			#         puts "set main to #{main}"
+		end
+
+		#register a plugin
+		def self.register(plugin)
+			#         puts 'registeting'
+			if /([\w\-]+)\.rb/.match(caller[0])
+				unless find_plugin($1)
+					raise SystemCallError, 'No such file '+$1+' to load as plugin', caller
+				end
+				name = $1
+			else
+				raise SystemCallError, 'Plugin does not have a name', caller
+			end
+
+			#plugin must be a child of Plugin class..
+			unless plugin.class.superclass == Plugin
+				puts 'Plugin must be subclass of Plugin'
+				return
+			end
+
+			#make sure its not already defined
+			if self[name]
+				puts "a plugin called #{name} is already registered"
+				return
+			end
+
+			#init the plugin hash if it doesn't exist
+			@@plugins ||= {}
+
+			#stuff the data in it
+			@@plugins[plugin] = {:name => name, :callbacks => Array.new, :callbacks_after => Array.new, :methods => Array.new} if plugin and !@@plugins[plugin]
+
+			#call the plugins load() method
+			@@main.console.send_user_event({'msg' => 'Loading Plugin '+name}, EVENT_NOTICE)
+			plugin.load
+			#         puts self, self.class
+		end
+
+		def help(a, b)
+			self.class.help(a, b)
+		end
+
+		#TODO - what if the function we lookup is shared between multiple plugins?
+		def self.find_plugin_method(method)
+			plugin = @@plugins.detect do |p, info|
+				p.respond_to? method
+			end
+			plugin
+		end
+
+		#unload a plugin and remove all methods/callbacks added by it...
+		def self.unregister(plugin)
+
+			#make sure the plugin is registered
+			return false unless @@plugins and @@plugins[plugin]
+
+			#remove all the callbacks
+			@@plugins[plugin][:callbacks].each do |c|
+				c[:class].del_callback(c[:callback])
+				puts "removed callback #{c[:callback]} for class #{c[:class]}"
+			end
+
+			#remove all the callback_afters
+			@@plugins[plugin][:callbacks_after].each do |c|
+				c[:class].del_callback_after(c[:callback])
+				puts "removed callback_after #{c[:callback]} for class #{c[:class]}"
+			end
+
+			#remove all the methods
+			@@plugins[plugin][:methods].each do |c|
+				c[:class].del_method(c[:method])
+				puts "removed method #{c[:method]} for class #{c[:class]}"
+			end
+
+			@@main.config['plugins'].delete(@@plugins[plugin][:name])
+
+			#delete the plugin from the hash
+			@@plugins.delete(plugin)
+
+			#call the unload function if the plugin wants to do any additional cleanup
+			plugin.unload
+			true
+		end
+
+		#list registered plugins.
+		def self.list
+			@@plugins ||= {}
+			return @@plugins
+		end
+
+		#lookup a string as a plugin name
+		def self.[](name)
+			#         puts "looking up #{name}"
+			@@plugins ||= {}
+			x = @@plugins.detect{|p| p[1][:name] == name}
+			x = x[0] if x
+			return x
+		end
+
+		#wrapper function for adding a callback to a class
+		def add_callback(plugin, classname, name, &block)
+
+			#make sure the plugin is registered
+			if @@plugins[plugin]
+				#add the callback, make sure its not already defined for this plugin and then define it iof add is sucessful
+				if callback = classname.add_callback(name, &block) and  !@@plugins[plugin][:callbacks].include?({:callback=>callback, :class=>classname})
+					@@plugins[plugin][:callbacks].push({:callback=>callback, :class=>classname})
+				end
+
+				#error
+			else
+				puts 'plugin not registered'
+			end
+		end
+
+		def add_callback_after(plugin, classname, name, &block)
+
+			#make sure the plugin is registered
+			if @@plugins[plugin]
+				#add the callback, make sure its not already defined for this plugin and then define it if add is sucessful
+				if callback = classname.add_callback_after(name, &block) and  !@@plugins[plugin][:callbacks_after].include?({:callback=>callback, :class=>classname})
+					@@plugins[plugin][:callbacks_after].push({:callback=>callback, :class=>classname})
+				end
+
+				#error
+			else
+				puts 'plugin not registered'
+			end
+		end
+
+		def add_method(plugin, classname, name, &block)
+			#make sure the plugin is registered
+			if @@plugins[plugin]
+				#add the callback, make sure its not already defined for this plugin and then define it if add is sucessful
+				if method = classname.add_method(name, &block) and  !@@plugins[plugin][:methods].include?({:method=>method, :class=>classname})
+					@@plugins[plugin][:methods].push({:method=>method, :class=>classname}) 
+				end
+
+				#error
+			else
+				puts 'plugin not registered'
+			end
+		end
+
+		def self.find_plugin(name)
+			return unless name
+			name += '.rb'
+			dir1 = File.join($ratchetfolder, 'plugins')
+			dir2 = "#{DATADIR}/plugins"
+			if File.directory?(dir1) and Dir.entries(dir1).include?(name)
+				return File.join(dir1, name)
+			elsif File.directory?(dir2) and Dir.entries(dir2).include?(name)
+				return File.join(dir2, name)
+			else
+				return false
+			end
+		end
+
+		#stub for unload function to allow plugins to do additional cleanup
+		def unload
+		end
+
+		#stub for configure function
+#     def configure
+#         []
+#     end
+	end
+
+	class PluginConfig
+		#The GTK specific part of this has been moved to gtk/pluginconfig.rb
+
+		def bool_changed(widget)
+			change_setting(widget, widget.active?)
+		end
+
+		def color_changed(widget)
+			change_setting(widget, Color.new(*widget.color.to_a))
+		end
+
+		def text_changed(widget)
+			change_setting(widget, widget.text)
+		end
+
+		def integer_changed(widget)
+			change_setting(widget, widget.text.to_i)
+		end
+
+		def array_changed(widget)
+			change_setting(widget, widget.text.split(',').uniq)
+		end
+
+		def change_setting(widget, setting)
+			#puts 'changed setting of '+widget.name+' to '+setting.to_s
+			@configarray[widget]['value'] = setting
+		end
+
+		def update_config
+			@configarray.each do |k, v|
+				#puts v['name']+' = '+v['value'].to_s
+				@config[v['name']] = v['value']
+			end
+			destroy
+			@main.send_command('sendconfig', @config.changes)
+		end
+
+		def destroy
+			@window.destroy
+		end
+	end
+end