zmb 0.1.1

data/lib/zmb/commands.rb

@@ -0,0 +1,63 @@
+class Command
+  attr_accessor :delegate, :signal, :help
+  
+  def initialize(delegate, signal, commands=1, help=nil)
+    @delegate = delegate
+    @signal = signal
+    @help = help
+    @commands = commands
+  end
+  
+  def help?
+    help != nil
+  end
+  
+  def run(e, args)
+    if @commands == 0 then
+      args = Array.new
+    elsif args.size > @commands
+      a = args.first @commands-1 # Take one under amount of commands
+      a << args[@commands-1..-1].join(' ')
+      args = a
+    end
+    
+    begin
+      @delegate.send(@signal, e, *args)
+    rescue ArgumentError
+      'incorrect arguments'
+    rescue Exception
+      if e.respond_to?('user') and e.user.respond_to?('admin?') and e.user.admin? and e.private? then
+        "#{$!.message}\n#{$!.inspect}"
+      else
+        "command failed"
+      end
+    end
+  end
+end
+
+class PermCommand < Command
+  attr_accessor :perm
+  
+  def initialize(perm, *args)
+    super(*args)
+    @perm = perm
+  end
+  
+  def run(e, args)
+    if e.respond_to?('user') and e.user.permission?(@perm) then
+      super(e, args)
+    else
+      'permission denied'
+    end
+  end
+end
+
+class AuthCommand < Command
+  def run(e, args)
+    if e.respond_to?('user') and e.user.authenticated? then
+      super(e, args)
+    else
+      'permission denied'
+    end
+  end
+end

data/lib/zmb/event.rb

@@ -0,0 +1,15 @@
+class Event
+  attr_accessor :sender, :message
+  
+  def initialize(sender)
+    @sender = sender
+  end
+  
+  def message?
+    message != nil
+  end
+  
+  def reply(message)
+    @sender.reply(self, message)
+  end
+end

data/lib/zmb/plugin.rb

@@ -0,0 +1,110 @@
+class PluginManager
+  attr_accessor :plugin_sources, :plugins
+  
+  def initialize
+    @plugins = Array.new
+    @plugin_sources = Array.new
+  end
+  
+  def plugin(name)
+    plugin = @plugins.find{|plugin| plugin.name == name}
+    
+    if plugin then
+      plugin.object
+    else
+      nil
+    end
+  end
+  
+  def load_plugin_source(file)
+    begin
+      definition = instance_eval(File.read(file))
+      definition.definitition_file = File.expand_path(file)
+      @plugins << definition
+    rescue Exception
+      nil
+    end
+  end
+  
+  def add_plugin_source(directory)
+    @plugin_sources << directory
+    
+    definition_files = Dir[
+      File.join(File.expand_path(directory), "*.rb"),
+      File.join(File.expand_path(directory), "*", "plugin.rb")
+    ]
+    
+    definition_files.map do |file|
+      begin
+        load_plugin_source(file)
+      end
+    end
+  end
+  
+  def refresh_plugin_sources
+    sources = @plugin_sources
+    @plugin_sources = nil
+    @plugins = nil
+    
+    sources.each{|directory| add_plugin_source directory}
+  end
+  
+  def reload_plugin(name)
+    plugin = @plugins.find{|plugin| plugin.name == name}
+    
+    if plugin then
+      @plugins.delete(plugin)
+      reloaded = load_plugin_source plugin.definitition_file
+      @plugins << plugin if not reloaded
+      reloaded
+    end
+  end
+end
+
+class PluginBuilder
+  attr_accessor :plugin
+  
+  def initialize(&block)
+    @plugin = Plugin.new
+    @block = block
+  end
+  
+  def build
+    instance_eval(&@block)
+  end
+  
+  def name(value)
+    @plugin.name = value
+  end
+  
+  def description(value)
+    @plugin.description = value
+  end
+  
+  def object(value)
+    @plugin.object = value
+  end
+  
+  def multi_instances(value)
+    @plugin.multi_instances = value
+  end
+end
+
+
+class Plugin
+  attr_accessor :name, :description, :object, :definitition_file, :multi_instances
+  
+  def self.define(&block)
+    builder = PluginBuilder.new(&block)
+    builder.build
+    builder.plugin
+  end
+  
+  def multi_instances?
+    if @multi_instances then
+      @multi_instances
+    else
+      false
+    end
+  end
+end

data/lib/zmb/settings.rb

@@ -0,0 +1,48 @@
+begin
+  require 'json'
+rescue LoadError
+  require 'rubygems'
+  gem 'json'
+end
+
+class Settings
+  def initialize(directory)
+    if not File.exist?(directory) then
+      FileUtils.makedirs(directory)
+    end
+    
+    if not File.directory?(directory) and not File.owned?(directory) then
+      raise
+    end
+    
+    @directory = directory
+  end
+  
+  def setting_path(key)
+    File.join(@directory, key.gsub('/', '_') + '.json')
+  end
+  
+  def setting(key)
+    begin
+      JSON.parse(File.read(setting_path(key)))
+    rescue
+      {}
+    end
+  end
+  
+  def get(object, name, default=nil)
+    s = setting(object)
+    
+    if s.respond_to?('has_key?') and s.has_key?(name) then
+      s[name]
+    else
+      default
+    end
+  end
+  
+  def save(key, data)
+    f = File.open setting_path(key), 'w'
+    f.write data.to_json
+    f.close
+  end
+end

data/lib/zmb/timer.rb

@@ -0,0 +1,28 @@
+class Timer
+  require 'date'
+  
+  attr_accessor :delegate
+  
+  def initialize(delegate, symbol, interval, repeat=false) # interval is in seconds (decimals accepted)
+    @delegate = delegate
+    @symbol = symbol
+    @interval = interval
+    @repeat = repeat
+    
+    @fire_at = Time.now + interval
+  end
+
+  def fire(sender)
+    @delegate.send @symbol
+
+    if not @repeat
+      sender.timer_delete(self) if sender.respond_to?('timer_delete')
+    else
+      @fire_at = Time.now + @interval
+    end
+  end
+  
+  def timeout
+    @fire_at - Time.now
+  end
+end

data/plugins/bank.rb

@@ -0,0 +1,101 @@
+class Account
+  attr_accessor :username, :balance, :log
+  
+  def initialize(username, balance=0)
+    @username = username
+    @balance = balance
+    @log = Array.new
+    log 'Opening account'
+  end
+  
+  def self.create_settings(settings)
+    require 'time'
+    account = new(settings['username'], settings['balance'])
+    account.log = settings['log']
+    account
+  end
+  
+  def to_json(*a)
+    { 'username' => @username, 'balance' => @balance, 'log' => @log }.to_json(*a)
+  end
+  
+  def log(message)
+    @log << { 'message' => message, 'balance' => @balance, 'time' => Time.now }
+  end
+  
+  def funds?(amount)
+    @balance >= amount
+  end
+  
+  def transaction(amount, message=nil)
+    @balance += amount
+    log message if message
+  end
+  
+  def transfer(account, amount)
+    transaction(amount*-1, "#{amount} transfered to #{account.username}")
+    account.transaction(amount, "#{amount} transfered from #{@username}")
+  end
+end
+
+class Event
+  attr_accessor :bank
+end
+
+class Bank
+  attr_accessor :accounts
+  
+  def initialize(sender, settings={})
+    @accounts = settings['accounts'].map{ |acc| Account.create_settings(acc) } if settings.has_key?('accounts')
+    @accounts = Array.new if not @accounts
+  end
+  
+  def to_json(*a)
+    { 'accounts' => @accounts, 'plugin' => 'bank' }.to_json(*a)
+  end
+  
+  def create(username)
+    account = Account.new(username)
+    @accounts << account
+    account
+  end
+  
+  def account!(username)
+    @accounts.find{|account| account.username == username}
+  end
+  
+  def account(username)
+    account!(username) or create(username)
+  end
+  
+  def pre_event(sender, e)
+    e.bank = account(e.user.username) if e.respond_to?('user') and e.user.respond_to?('username')
+  end
+  
+  def commands
+    require 'zmb/commands'
+    {
+      'balance' => AuthCommand.new(self, :balance, 0, 'See how much funds you have.'),
+      'transfer' => AuthCommand.new(self, :transfer, 2, 'Transfer funds to another account'),
+    }
+  end
+  
+  def balance(e)
+    "Your balance is #{e.bank.balance}"
+  end
+  
+  def transfer(e, username, amount)
+    amount = Integer(amount)
+    return "#{e.user.username} attempted theft against #{username}" if amount < 0
+    return 'funds not availible' if not e.bank.funds?(amount)
+    return "#{username} doesn't appear to have a bank account, they need to open one with the balance command" if not r = account!(username)
+    e.bank.transfer(r, amount)
+    "#{amount} transfered to #{username}'s account"
+  end
+end
+
+Plugin.define do 
+  name "bank"
+  description "virtual bank/money system"
+  object Bank
+end

data/plugins/commands.rb

@@ -0,0 +1,119 @@
+require 'zmb/commands'
+
+class Commands
+  attr_accessor :cmds, :cc
+  
+  def initialize(sender, settings={})
+    @cmds = Hash.new
+    
+    @cc = settings['cc'] if settings.has_key?('cc')
+    @cc = '!' if @cc == nil
+    
+    @cmds.merge!(commands)
+    
+    sender.post('commands').each do |command|
+      @cmds.merge!(command)
+    end
+  end
+  
+  def to_json(*a)
+    { 'cc' => @cc, 'plugin' => 'commands' }.to_json(*a)
+  end
+  
+  def self.wizard
+    {
+      'cc' => { 'help' => 'Control command, commands send to zmb must be prefixed with this.', 'default' => '.' },
+    }
+  end
+  
+  def event(sender, e)
+    return if not e.message?
+    
+    if e.message[0, @cc.length] == @cc then
+      line = e.message[@cc.length..-1].clone
+    elsif e.private? then
+      line = e.message.clone
+    end
+    
+    # Encode escaped quotation marks
+    line.gsub!(/\\"|\\'/) { |m| m =~ /^\\"$/ ? "\000d\000" : "\000s\000" }
+    
+    # Encode pipes inside quotation marks
+    line.gsub!(/"\w*\|\w*"/) { |m| m.sub('|', "\000p\000") }
+    
+    # Check there are a even amount of "" and ''
+    if ((line.count("'") % 2) == 1) and ((line.count('""') % 2) == 1) then
+      return e.reply('Incorrect amount of quotation marks\'s')
+    end
+    
+    # Split the commands up
+    commands = line.split('|')
+    input = nil
+    
+    commands.each do |command|
+      command = command.reverse.chomp.reverse
+      
+      # Split strings by quotation marks and spaces
+      args = command.split(/"([^"]*)"|'([^']*)'|\s/).reject{ |x| x.empty? }
+      
+      # Decode escape quotation marks and pipes inside the args
+      args.each do |arg|
+        arg.sub!("\000d\000", '"')
+        arg.sub!("\000s\000", "'")
+        arg.sub!("\000p\000", '|')
+      end
+      
+      cmd = args.delete_at(0)
+      
+      if @cmds.has_key?(cmd) then
+        args << input if input
+        input = @cmds[cmd].run(e, args)
+      end
+    end
+    
+    e.reply(input) if input
+  end
+  
+  def plugin_loaded(key, instance)
+    @cmds.merge!(instance.commands) if instance.respond_to?('commands')
+  end
+  
+  def plugin_unloaded(key, instance)
+    instance.commands.each{|command, cmd| @cmds.delete(command)} if instance.respond_to?('commands')
+  end
+  
+  def commands
+    {
+      'help' => Command.new(self, :help),
+      'cc' => PermCommand.new('admin', self, :control_command),
+    }
+  end
+  
+  def help(e, command=nil)
+    if command then
+      if @cmds.has_key?(command) and @cmds[command].help? then
+        "#{command}: #{@cmds[command].help}"
+      else
+        'Command not found or no help availible for the command.'
+      end
+    else
+      @cmds.keys.join(', ')
+    end
+  end
+  
+  def control_command(e, cc=nil)
+    if cc then
+      @cc = cc
+    else
+      @cc = '!'
+    end
+    
+    "Control command set to #{@cc}"
+  end
+end
+
+Plugin.define do
+  name "commands"
+  description "This plugin is needed for other plugins to function properly."
+  object Commands
+end