zmb 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 kylef
+
+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.

data/README.markdown

@@ -0,0 +1,39 @@
+## zmb messenger bot
+
+zmb is a complete messenger bot supporting irc, and command line interface.
+
+### Install
+	gem install zmb
+
+### Uninstall
+	gem uninstall zmb
+	rm -rf ~/.zmb # If you used the default settings location
+
+### Creating a bot
+
+This command will use the default settings location of ~/.zmb, you can pass `-s <PATH>` to change this.
+
+	zmb --create
+
+### Launching the bot
+	zmb --daemon
+
+### Using the bot in command shell mode
+
+You can run zmb in a shell mode to test plugins without even connecting to any irc servers. It will create a shell where you can enter commands.
+
+	zmb --shell
+
+### Included plugins
+
+- IRC
+- Quote
+- Relay - Relay between servers and/or channels
+- Users - User management
+- Bank - Points system
+
+### Support
+
+You can find support at #zmb @ efnet.
+
+For complete documentation please visit [Documentation](http://kylefuller.co.uk/projects/zmb/)

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "zmb"
+    gem.summary = %Q{ZMB, messenger bot}
+    gem.description = %Q{ZMB, messenger bot}
+    gem.email = "inbox@kylefuller.co.uk"
+    gem.homepage = "http://github.com/kylef/zmb"
+    gem.authors = ["kylef"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_dependency "json", ">= 1.0.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "zmb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/zmb

@@ -0,0 +1,188 @@
+#!/usr/bin/ruby
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'zmb'
+require 'optparse'
+
+class AdminUser
+  attr_accessor :username, :userhosts
+  
+  def initialize
+    @username = 'admin'
+    @userhosts = []
+  end
+  
+  def admin?
+    true
+  end
+  
+  def permission?(perm)
+    true
+  end
+  
+  def authenticated?
+    true
+  end
+end
+
+class Event
+  attr_accessor :message
+  
+  def initialize(message)
+    @message = message
+  end
+  
+  def message?
+    true
+  end
+  
+  def private?
+    true
+  end
+  
+  def user
+    AdminUser.new
+  end
+  
+  def reply(msg)
+    puts "> #{msg}"
+  end
+end
+
+def ask(question)
+  puts "#{question} (yes/no)"
+  answer = gets.chomp
+  answer == 'yes' or answer == 'y'
+end
+
+def get_value(question)
+  puts question
+  answer = gets.chomp
+  
+  return nil if answer == ''
+  answer
+end
+
+def wizard(zmb, plugin)
+  STDOUT.flush
+  
+  if ask("Would you like to add the #{plugin.name} plugin? #{plugin.description}") then
+    if plugin.multi_instances? then
+      instance = get_value("What would you like to name this instance of #{plugin.name}?")
+    else
+      instance = plugin.name
+    end
+    
+    if not instance then
+      puts "Must supply instance name, if this plugin should only be loaded once such as commands or users then you can call it that."
+      return wizard zmb, plugin
+    end
+    
+    zmb.setup(plugin.name, instance)
+    obj = zmb.plugin_manager.plugin plugin.name
+    if obj.respond_to?('wizard') then
+      settings = zmb.settings.setting(instance)
+      settings['plugin'] = plugin.name
+      
+      obj.wizard.each do |key, value|
+        if value.has_key?('help') then
+          set = get_value("#{value['help']} (default=#{value['default']})")
+          settings[key] = set if set
+        end
+      end
+      
+      zmb.settings.save(instance, settings)
+    end
+    zmb.load instance
+  end
+end
+
+options = {}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: zmb [options]"
+  
+  options[:settings] = nil
+  opts.on('-s', '--settings SETTING', 'Use a settings folder') do |settings|
+    options[:settings] = settings
+  end
+  
+  options[:daemon] = false
+  opts.on('-d', '--daemon', 'Run ZMB') do
+    options[:daemon] = true
+  end
+  
+  options[:create] = false
+  opts.on('-c', '--create', 'Create a new ZMB settings file') do
+    options[:create] = true
+  end
+  
+  options[:shell] = false
+  opts.on('-b', '--shell', 'Create a commands shell') do
+    options[:shell] = true
+  end
+  
+  options[:command] = false
+  opts.on('-l', '--line LINE', 'Execute a command') do |line|
+    options[:command] = line
+  end
+end
+
+optparse.parse!
+
+if not options[:settings] then
+  options[:settings] = File.expand_path('~/.zmb')
+  puts "No settings file specified, will use #{options[:settings]}"
+end
+
+zmb = Zmb.new(options[:settings])
+
+if options[:create] then
+  STDOUT.flush
+  
+  zmb.save
+  
+  while ask('Would you like to add additional plugin sources?')
+    source = get_value('Which path?')
+    if source and File.exists?(source) then
+      zmb.plugin_manager.add_plugin_source source
+      puts 'Source added'
+      zmb.save
+    else
+      puts 'Invalid source'
+    end
+  end
+  
+  zmb.plugin_manager.plugins.reject{ |plugin| zmb.instances.has_key? plugin.name }.each{ |plugin| wizard(zmb, plugin) }
+  
+  if zmb.instances.has_key?('users') and ask('Would you like to add a admin user?') then
+    username = get_value('Username:')
+    password = get_value('Password:')
+    userhost = get_value('Userhost: (Leave blank for none)')
+    zmb.instances['users'].create_user(username, password, userhost).permit('admin')
+  end
+  
+  zmb.save
+end
+
+if options[:command] then
+  zmb.event(nil, Event.new(options[:command]))
+  zmb.save
+end
+
+if options[:shell] then
+  STDOUT.flush
+  
+  begin
+    while 1
+      zmb.event(nil, Event.new(gets.chomp))
+    end
+  rescue Interrupt
+    zmb.save
+  end
+end
+
+if options[:daemon] then
+  zmb.run
+end

data/lib/zmb.rb

@@ -0,0 +1,296 @@
+require 'socket'
+
+begin
+  require 'json'
+rescue LoadError
+  require 'rubygems'
+  gem 'json'
+end
+
+require 'zmb/plugin'
+require 'zmb/settings'
+require 'zmb/event'
+require 'zmb/commands'
+require 'zmb/timer'
+
+class Zmb
+  attr_accessor :instances, :plugin_manager, :settings
+  
+  def initialize(config_dir)
+    @plugin_manager = PluginManager.new
+    @settings = Settings.new(config_dir)
+    
+    @instances = {'core/zmb' => self}
+    @sockets = Hash.new
+    
+    @minimum_timeout = 0.5 # Half a second
+    @maximum_timeout = 60.0 # Sixty seconds
+    @timers = Array.new
+    timer_add(Timer.new(self, :save, 120.0, true)) # Save every 2 minutes
+    
+    @settings.get('core/zmb', 'plugin_sources', []).each{|source| @plugin_manager.add_plugin_source source}
+    
+    if @plugin_manager.plugin_sources.empty? then
+      @plugin_manager.add_plugin_source File.join(File.expand_path(File.dirname(File.dirname(__FILE__))), 'plugins')
+    end
+    
+    @settings.get('core/zmb', 'plugin_instances', []).each{|instance| load instance}
+    
+    @running = false
+  end
+  
+  def running?
+    @running
+  end
+  
+  def to_json(*a)
+    {
+      'plugin_sources' => @plugin_manager.plugin_sources,
+      'plugin_instances' => @instances.keys,
+    }.to_json(*a)
+  end
+  
+  def save
+    @instances.each{ |k,v| @settings.save(k, v) }
+  end
+  
+  def load(key)
+    return true if @instances.has_key?(key)
+    
+    if p = @settings.get(key, 'plugin') then
+      object = @plugin_manager.plugin(p)
+      return false if not object
+      @instances[key] = object.new(self, @settings.setting(key))
+      post! :plugin_loaded, key, @instances[key]
+      true
+    else
+      false
+    end
+  end
+  
+  def unload(key, tell=true)
+    return false if not @instances.has_key?(key)
+    instance = @instances.delete(key)
+    @settings.save key, instance
+    socket_delete instance
+    timer_delete instance
+    instance.unloaded if instance.respond_to?('unloaded') and tell
+    post! :plugin_unloaded, key, instance
+  end
+  
+  def run
+    post! :running, self
+    
+    @running = true
+    begin
+      while @running
+        socket_run(timeout)
+        timer_run
+      end
+    rescue Interrupt
+      save
+    end
+  end
+  
+  def timeout
+    if timer_timeout > @maximum_timeout
+      if @sockets.count < 1 then
+        5
+      else
+        @maximum_timeout
+      end
+    elsif timer_timeout > @minimum_timeout
+      timer_timeout
+    else
+      @minimum_timeout
+    end
+  end
+  
+  def socket_add(delegate, socket)
+    @sockets[socket] = delegate
+  end
+  
+  def socket_delete(item)
+    if @sockets.has_value?(item) then
+      @sockets.select{ |sock, delegate| delegate == item }.each{ |sock, delegate| @sockets.delete(sock) }
+    end
+    
+    if @sockets.has_key?(item) then
+      @sockets.delete(item)
+    end
+  end
+  
+  def socket_run(timeout)
+    result = select(@sockets.keys, nil, nil, timeout)
+    
+    if result != nil then
+      result[0].select{|sock| @sockets.has_key?(sock)}.each do |sock|
+        if sock.eof? then
+          @sockets[sock].disconnected(self, sock) if @sockets[sock].respond_to?('disconnected')
+          socket_delete sock
+        else
+          @sockets[sock].received(self, sock, sock.gets()) if @sockets[sock].respond_to?('received')
+        end
+      end
+    end
+  end
+  
+  def timer_add(timer)
+    @timers << timer
+  end
+  
+  def timer_delete(search)
+    @timers.each{ |timer| @timers.delete(timer) if timer.delegate == search }
+    @timers.delete(search)
+  end
+  
+  def timer_timeout # When will the next timer run?
+    @timers.map{|timer| timer.timeout}.sort.fetch(0, @maximum_timeout)
+  end
+  
+  def timer_run
+    @timers.select{|timer| timer.timeout <= 0.0 and timer.respond_to?("fire") }.each{|timer| timer.fire(self)}
+  end
+  
+  def post(signal, *args)
+    results = Array.new
+    
+    @instances.select{|name, instance| instance.respond_to?(signal)}.each do |name, instance|
+      results << instance.send(signal, *args) rescue nil
+    end
+    
+    results
+  end
+  
+  def post!(signal, *args) # This will exclude the plugin manager
+    @instances.select{|name, instance| instance.respond_to?(signal) and instance != self}.each do |name, instance|
+      instance.send(signal, *args) rescue nil
+    end
+  end
+  
+  def setup(plugin, instance)
+    object = @plugin_manager.plugin plugin
+    return false if not object
+    
+    settings = Hash.new
+    settings['plugin'] = plugin
+    
+    if object.respond_to? 'wizard' then
+      d = object.wizard
+      d.each{ |k,v| settings[k] = v['default'] if v.has_key?('default') and v['default'] }
+    end
+    
+    @settings.save instance, settings
+    
+    true
+  end
+  
+  def event(sender, e)
+    post! :pre_event, sender, e
+    post! :event, sender, e
+  end
+  
+  def commands
+    {
+      'reload' => PermCommand.new('admin', self, :reload_command),
+      'unload' => PermCommand.new('admin', self, :unload_command),
+      'load' => PermCommand.new('admin', self, :load_command),
+      'save' => PermCommand.new('admin', self, :save_command, 0),
+      'loaded' => PermCommand.new('admin', self, :loaded_command, 0),
+      'setup' => PermCommand.new('admin', self, :setup_command, 2),
+      'set' => PermCommand.new('admin', self, :set_command, 3),
+      'get' => PermCommand.new('admin', self, :get_command, 2),
+      'clone' => PermCommand.new('admin', self, :clone_command, 2),
+      'reset' => PermCommand.new('admin', self, :reset_command),
+      'addsource' => PermCommand.new('admin', self, :addsource_command),
+    }
+  end
+  
+  def reload_command(e, instance)
+    if @instances.has_key?(instance) then
+      sockets = Array.new
+      @sockets.each{ |sock,delegate| sockets << sock if delegate == @instances[instance] }
+      unload(instance, false)
+      reloaded = @plugin_manager.reload_plugin(@settings.get(instance, 'plugin'))
+      load(instance)
+      
+      sockets.each{ |socket| @sockets[socket] = @instances[instance] }
+      @instances[instance].socket = sockets[0] if sockets.size == 1 and @instances[instance].respond_to?('socket=')
+      
+      reloaded ? "#{instance} reloaded" : "#{instance} refreshed"
+    else
+      "No such instance #{instance}"
+    end
+  end
+  
+  def unload_command(e, instance)
+    if @instances.has_key?(instance) then
+      unload(instance)
+      "#{instance} unloaded"
+    else
+      "No such instance #{instance}"
+    end
+  end
+  
+  def load_command(e, instance)
+    if not @instances.has_key?(instance) then
+      load(instance) ? "#{instance} loaded" : "#{instance} did not load correctly"
+    else
+      "Instance already #{instance}"
+    end
+  end
+  
+  def save_command(e)
+    save
+    'settings saved'
+  end
+  
+  def loaded_command(e)
+    @instances.keys.join(', ')
+  end
+  
+  def setup_command(e, plugin, instance)
+    if setup(plugin, instance) then
+      object = @plugin_manager.plugin plugin
+      result = ["Instance saved, please use the set command to override the default configuration for this instance."]
+      result += d.map{ |k,v| "#{k} - #{v['help']} (default=#{v['default']})" } if object.respond_to? 'wizard'
+      result.join("\n")
+    else
+      "plugin not found"
+    end
+  end
+  
+  def set_command(e, instance, key, value)
+    settings = @settings.setting(instance)
+    settings[key] = value
+    @settings.save(instance, settings)
+    "#{key} set to #{value} for #{instance}"
+  end
+  
+  def get_command(e, instance, key)
+    if value = @settings.get(instance, key) then
+      "#{key} is #{value} for #{instance}"
+    else
+      "#{instance} or #{instance}/#{key} not found."
+    end
+  end
+  
+  def clone_command(e, instance, new_instance)
+    if (settings = @settings.setting(instance)) != {} then
+      @settings.save(new_instance, settings)
+      "The settings for #{instance} were copied to #{new_instance}"
+    else
+      "No settings for #{instance}"
+    end
+  end
+  
+  def reset_command(e, instance)
+    @settings.save(instance, {})
+    "Settings for #{instance} have been deleted."
+  end
+  
+  def addsource_command(e, source)
+    @plugin_manager.add_plugin_source source
+    "#{source} added to plugin manager"
+  end
+end