jabbot 0.1.2

data/lib/jabbot/config.rb

@@ -0,0 +1,105 @@
+require 'optparse'
+
+module Jabbot
+  #
+  # Jabbot configuration. Use either Jabbot::CliConfig.new or
+  # JabbotFileConfig.new setup a new bot from either command line or file
+  # (respectively). Configurations can be chained so they override each other:
+  #
+  #   config = Jabbot::FileConfig.new
+  #   config << Jabbot::CliConfig.new
+  #   config.to_hash
+  #
+  # The preceding example will create a configuration which is based on a
+  # configuration file but have certain values overridden from the command line.
+  # This can be used for instance to store everything but the Twitter account
+  # password in your configuration file. Then you can just provide the password
+  # when running the bot.
+  #
+  class Config
+    attr_reader :settings
+
+    DEFAULT = {
+      :log_level => 'info',
+      :log_file => nil,
+      :login => nil,
+      :password => nil,
+      :nick => 'jabbot',
+      :channel => nil,
+      :server => nil,
+      :resource => nil
+    }
+
+    def initialize(settings = {})
+      @configs = []
+      @settings = settings
+    end
+
+    #
+    # Add a configuration object to override given settings
+    #
+    def add(config)
+      @configs << config
+      self
+    end
+
+    alias_method :<<, :add
+
+    #
+    # Makes it possible to access configuration settings as attributes
+    #
+    def method_missing(name, *args, &block)
+      regex = /=$/
+      attr_name = name.to_s.sub(regex, '').to_sym
+      return super if name == attr_name && !@settings.key?(attr_name)
+
+      if name != attr_name
+        @settings[attr_name] = args.first
+      end
+
+      @settings[attr_name]
+    end
+
+    #
+    # Merges configurations and returns a hash with all options
+    #
+    def to_hash
+      hash = {}.merge(@settings)
+      @configs.each { |conf| hash.merge!(conf.to_hash) }
+      hash
+    end
+
+    def self.default
+      Config.new({}.merge(DEFAULT))
+    end
+  end
+
+  #
+  # Configuration from files
+  #
+  class FileConfig < Config
+
+    #
+    # Accepts a stream or a file to read configuration from
+    # Default is to read configuration from ./config/bot.yml
+    #
+    # If a stream is passed it is not closed from within the method
+    #
+    def initialize(fos = File.expand_path("config/bot.yml"))
+      stream = fos.is_a?(String) ? File.open(fos, "r") : fos
+
+      begin
+        config = YAML.load(stream.read)
+        config.symbolize_keys! if config
+      rescue Exception => err
+        puts err.message
+        puts "Unable to load configuration, aborting"
+        exit
+      ensure
+        stream.close if fos.is_a?(String)
+      end
+
+      super config.is_a?(Hash) ? config : {}
+    end
+  end
+end

data/lib/jabbot/handlers.rb

@@ -0,0 +1,116 @@
+module Jabbot
+  module Handlers
+    #
+    # Add a handler for this bot
+    #
+    def add_handler(type, handler)
+      handlers[type] << handler
+      handler
+    end
+
+    def dispatch(type, message)
+      handlers[type].each { |handler| handler.dispatch(message) }
+    end
+
+    def handlers
+      @handlers ||= {
+        :message => [],
+        :private => [],
+        :join => [],
+        :subject => [],
+        :leave => []
+      }
+    end
+
+    def handlers=(hash)
+      @handlers = hash
+    end
+  end
+
+  #
+  # A Handler object is an object which can handle a direct message, tweet or
+  # at reply.
+  #
+  class Handler
+    def initialize(pattern = nil, options = {}, &blk)
+      if pattern.is_a?(Hash)
+        options = pattern
+        pattern = nil
+      end
+
+      @options = options
+      @options[:from].collect! { |s| s.to_s } if @options[:from] && @options[:from].is_a?(Array)
+      @options[:from] = [@options[:from].to_s] if @options[:from] && [String, Symbol].include?(@options[:from].class)
+      @handler = nil
+      @handler = block_given? ? blk : nil
+      self.pattern = pattern
+    end
+
+    #
+    # Parse pattern string and set options
+    #
+    def pattern=(pattern)
+      return if pattern.nil? || pattern == ""
+
+      if pattern == :all
+        return
+      end
+
+      if pattern.is_a?(Regexp)
+        @options[:pattern] = pattern
+        return
+      end
+
+      words = pattern.split.collect { |s| s.strip }          # Get all words in pattern
+      @options[:tokens] = words.inject([]) do |sum, token|   # Find all tokens, ie :symbol :like :names
+        next sum unless token =~ /^:.*/                      # Don't process regular words
+        sym = token.sub(":", "").to_sym                      # Turn token string into symbol, ie ":token" => :token
+        regex = @options[sym] || '[^\s]+'                    # Fetch regex if configured, else use any character but space matching
+        pattern.sub!(/(^|\s)#{token}(\s|$)/, '\1(' + regex.to_s + ')\2') # Make sure regex captures named switch
+        sum << sym
+      end
+
+      @options[:pattern] = /#{pattern}(\s.+)?/
+    end
+
+    #
+    # Determines if this handler is suited to handle an incoming message
+    #
+    def recognize?(message)
+      return false if @options[:pattern] && message.text !~ @options[:pattern] # Pattern check
+
+      users = @options[:from] ? @options[:from] : nil
+      return false if users && !users.include?(message.user) # Check allowed senders
+      true
+    end
+
+    #
+    # Process message to build params hash and pass message along with params of
+    # to +handle+
+    #
+    def dispatch(message)
+      return unless recognize?(message)
+      @params = {}
+
+      if @options[:pattern] && @options[:tokens]
+        matches = message.text.match(@options[:pattern])
+        @options[:tokens].each_with_index { |token, i| @params[token] = matches[i+1] }
+        @params[:text] = (matches[@options[:tokens].length+1] || "").strip
+      elsif @options[:pattern] && !@options[:tokens]
+        @params = message.text.match(@options[:pattern]).to_a[1..-1] || []
+      else
+        @params[:text] = message.text
+      end
+
+      return handle(message, @params)
+    end
+
+    #
+    # Handle a message. Calls the internal Proc with the message and the params
+    # hash as parameters.
+    #
+    def handle(message, params)
+      @handler.call(message, params) if @handler
+    end
+  end
+end

data/lib/jabbot/macros.rb

@@ -0,0 +1,85 @@
+module Jabbot
+  @@prompt = false
+
+  def self.prompt=(p)
+    @@prompt = f
+  end
+
+  module Macros
+    def self.included(mod)
+      @@bot = nil
+    end
+
+    def configure(&blk)
+      bot.configure(&blk)
+    end
+
+    def message(pattern = nil, options = {}, &blk)
+      add_handler(:message, pattern, options, &blk)
+    end
+
+    def query(pattern = nil, options = {}, &blk)
+      add_handler(:private, pattern, options, &blk)
+    end
+    alias_method :private_message, :query
+
+    def join(options = {}, &blk)
+      add_handler(:join, /\Ajoin\Z/, options, &blk)
+    end
+    
+    def leave(options = {}, &blk)
+      add_handler(:leave, /\Aleave\Z/, options, &blk)
+    end
+
+    def subject(pattern = nil, options = {}, &blk)
+      add_handler(:subject, pattern, options, &blk)
+    end
+    alias_method :topic, :subject
+
+    def client
+      bot.client
+    end
+
+    def close
+      bot.close
+    end
+    alias_method :quit, :close
+
+    def user
+      bot.user
+    end
+
+    def post(msg, to=nil)
+      if msg.is_a?(Hash) && msg.keys.size == 1
+        to = msg.values.first
+        msg = msg.keys.first
+      end
+      bot.send_message(msg, to)
+    end
+
+    def run?
+      !@@bot.nil?
+    end
+
+   private
+    def add_handler(type, pattern, options, &blk)
+      bot.add_handler(type, Jabbot::Handler.new(pattern, options, &blk))
+    end
+
+    def bot
+      return @@bot unless @@bot.nil?
+
+      begin
+        @@bot = Jabbot::Bot.new nil
+      rescue Exception
+        @@bot = Jabbot::Bot.new(Jabbot::Config.default)
+      end
+
+      @@bot
+    end
+
+    def self.bot=(bot)
+      @@bot = bot
+    end
+  end
+end

data/lib/jabbot/message.rb

@@ -0,0 +1,7 @@
+module Jabbot
+  Message = Struct.new(:user, :text, :time) do
+    def to_s
+      "#{user}: #{text}"
+    end
+  end
+end

data/test/test_bot.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'fileutils'
+
+class TestBot < Test::Unit::TestCase
+  should "not raise errors when initialized" do
+    assert_nothing_raised do
+      Jabbot::Bot.new Jabbot::Config.new
+    end
+  end
+
+  should "raise errors when initialized without config file" do
+    assert_raise SystemExit do
+      Jabbot::Bot.new
+    end
+  end
+
+  should "not raise error on initialize when config file exists" do
+    if File.exists?("config")
+      FileUtils.rm("config/bot.yml")
+    else
+      FileUtils.mkdir("config")
+    end
+
+    File.open("config/bot.yml", "w") { |f| f.puts "" }
+
+    assert_nothing_raised do
+      Jabbot::Bot.new
+    end
+
+    FileUtils.rm_rf("config")
+  end
+
+  should "provide configuration settings as methods" do
+    bot = Jabbot::Bot.new Jabbot::Config.new(:login => "jabbot")
+    assert_equal "jabbot", bot.login
+  end
+
+  should "return logger instance" do
+    bot = Jabbot::Bot.new(Jabbot::Config.default << Jabbot::Config.new)
+    assert bot.log.is_a?(Logger)
+  end
+
+  should "respect configured log level" do
+    bot = Jabbot::Bot.new(Jabbot::Config.new(:log_level => "info"))
+    assert_equal Logger::INFO, bot.log.level
+
+    bot = Jabbot::Bot.new(Jabbot::Config.new(:log_level => "warn"))
+    assert_equal Logger::WARN, bot.log.level
+  end
+end
+
+class TestBotMacros < Test::Unit::TestCase
+  should "provide configure macro" do
+    assert respond_to?(:configure)
+  end
+
+  should "yield configuration" do
+    Jabbot::Macros.bot = Jabbot::Bot.new Jabbot::Config.default
+
+    conf = nil
+    assert_nothing_raised { configure { |c| conf = c } }
+    assert conf.is_a?(Jabbot::Config)
+  end
+
+   should "add handler" do
+     Jabbot::Macros.bot = Jabbot::Bot.new Jabbot::Config.default
+
+     handler = add_handler(:message, ":command", :from => :cjno)
+     assert handler.is_a?(Jabbot::Handler), handler.class
+   end
+
+  should "provide client macro" do
+    assert respond_to?(:client)
+  end
+
+  should "provide user macro" do
+    assert respond_to?(:user)
+  end
+end
+
+class TestBotHandlers < Test::Unit::TestCase
+
+  should "include handlers" do
+    bot = Jabbot::Bot.new(Jabbot::Config.new)
+
+    assert_not_nil bot.handlers
+    assert_not_nil bot.handlers[:message]
+    assert_not_nil bot.handlers[:private]
+    assert_not_nil bot.handlers[:join]
+    assert_not_nil bot.handlers[:leave]
+    assert_not_nil bot.handlers[:subject]
+  end
+
+  should "add handler" do
+    bot = Jabbot::Bot.new(Jabbot::Config.new)
+    bot.add_handler :message, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:message].length
+
+    bot.add_handler :message, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:message].length
+
+    bot.add_handler :private, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:private].length
+
+    bot.add_handler :private, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:private].length
+
+    bot.add_handler :join, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:join].length
+
+    bot.add_handler :join, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:join].length
+
+    bot.add_handler :leave, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:leave].length
+
+    bot.add_handler :leave, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:leave].length
+
+    bot.add_handler :subject, Jabbot::Handler.new
+    assert_equal 1, bot.handlers[:subject].length
+
+    bot.add_handler :subject, Jabbot::Handler.new
+    assert_equal 2, bot.handlers[:subject].length
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+require 'stringio'
+
+class TestConfig < Test::Unit::TestCase
+  should "default configuration be a hash" do
+    assert_not_nil Jabbot::Config::DEFAULT
+    assert Jabbot::Config::DEFAULT.is_a?(Hash)
+  end
+
+  should "initialize with no options" do
+    assert_hashes_equal({}, Jabbot::Config.new.settings)
+  end
+
+  should "return config from add" do
+    config = Jabbot::Config.new
+    assert_equal config, config.add(Jabbot::Config.new)
+  end
+
+  should "alias add to <<" do
+    config = Jabbot::Config.new
+    assert config.respond_to?(:<<)
+    assert config << Jabbot::Config.new
+  end
+
+  should "mirror method_missing as config getters" do
+    config = Jabbot::Config.default << Jabbot::Config.new
+    assert_equal Jabbot::Config::DEFAULT[:password], config.password
+    assert_equal Jabbot::Config::DEFAULT[:login], config.login
+  end
+
+  should "mirror missing methods as config setters" do
+    config = Jabbot::Config.default << Jabbot::Config.new
+    assert_equal Jabbot::Config::DEFAULT[:login], config.login
+
+    val = "jabbot"
+    config.login = val+'!' 
+    assert_not_equal Jabbot::Config::DEFAULT[:login], config.login
+    assert_equal val+'!', config.login
+  end
+
+  should "not override default hash" do
+    config = Jabbot::Config.default
+    hash = Jabbot::Config::DEFAULT
+
+    config.login = "jabbot"
+    config.password = "secret"
+
+    assert_hashes_not_equal Jabbot::Config::DEFAULT, config.to_hash
+    assert_hashes_equal hash, Jabbot::Config::DEFAULT
+  end
+
+  should "return merged configuration from to_hash" do
+    config = Jabbot::Config.new
+    config.login = "jabbot"
+    config.password = "secret"
+
+    config2 = Jabbot::Config.new({})
+    config2.login = "not_jabbot2"
+    config << config2
+    options = config.to_hash
+
+    assert_equal "secret", options[:password]
+    assert_equal "not_jabbot2", options[:login]
+  end
+end
+
+class TestFileConfig < Test::Unit::TestCase
+  should "subclass config for file config" do
+    assert Jabbot::FileConfig.new(StringIO.new).is_a?(Jabbot::Config)
+  end
+
+  should "read settings from stream" do
+    config = Jabbot::FileConfig.new(StringIO.new <<-YAML)
+login: jabbot
+password: secret
+    YAML
+
+    assert_equal "jabbot", config.login
+    assert_equal "secret", config.password
+  end
+end