bjeanes-twibot 0.1.6

data/lib/twibot/handlers.rb

@@ -0,0 +1,111 @@
+module Twibot
+  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 => [],
+        :reply => [],
+        :tweet => []
+      }
+    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] && @options[:from].is_a?(String)
+      @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.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
+      sender = message.respond_to?(:sender) ? message.sender : message.user
+      return false if users && !users.include?(sender.screen_name.downcase) # 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
+
+      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/twibot/macros.rb

@@ -0,0 +1,66 @@
+module Twibot
+  @@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 reply(pattern = nil, options = {}, &blk)
+      add_handler(:reply, pattern, options, &blk)
+    end
+
+    def tweet(pattern = nil, options = {}, &blk)
+      add_handler(:tweet, pattern, options, &blk)
+    end
+
+    def twitter
+      bot.twitter
+    end
+
+    alias_method :client, :twitter
+
+    def post_tweet(msg)
+      message = msg.respond_to?(:text) ? msg.text : msg
+      puts message
+      client.status(:post, message)
+    end
+
+    def run?
+      !@@bot.nil?
+    end
+
+   private
+    def add_handler(type, pattern, options, &blk)
+      bot.add_handler(type, Twibot::Handler.new(pattern, options, &blk))
+    end
+
+    def bot
+      return @@bot unless @@bot.nil?
+
+      begin
+        @@bot = Twibot::Bot.new nil, true
+      rescue Exception
+        @@bot = Twibot::Bot.new(Twibot::Config.default << Twibot::CliConfig.new, true)
+      end
+
+      @@bot
+    end
+
+    def self.bot=(bot)
+      @@bot = bot
+    end
+  end
+end

data/lib/twibot/tweets.rb

@@ -0,0 +1,4 @@
+module Twibot
+  module Tweets
+  end
+end

data/lib/twibot.rb

@@ -0,0 +1,87 @@
+require 'time'
+require 'twitter'
+require 'twitter/client'
+require 'yaml'
+require File.join(File.dirname(__FILE__), 'hash')
+
+module Twibot
+
+  # :stopdoc:
+  VERSION = '0.1.6'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= File.basename(fname, '.*')
+    search_me = File.expand_path(File.join(File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb| require rb }
+  end
+
+  @@app_file = lambda do
+    ignore = [
+      /lib\/twibot.*\.rb/, # Library
+      /\(.*\)/,            # Generated code
+      /custom_require\.rb/ # RubyGems require
+    ]
+
+    path = caller.map { |line| line.split(/:\d/, 2).first }.find do |file|
+      next if ignore.any? { |pattern| file =~ pattern }
+      file
+    end
+
+    path || $0
+  end.call
+
+  #
+  # File name of the application file. Inspired by Sinatra
+  #
+  def self.app_file
+    @@app_file
+  end
+
+  #
+  # Runs application if application file is the script being executed
+  #
+  def self.run?
+    self.app_file == $0
+  end
+
+end  # module Twibot
+
+Twitter::Client.configure do |config|
+  config.application_name = 'Twibot'
+  config.application_version = Twibot.version
+  config.application_url = 'http://github.com/cjohansen/twibot'
+end
+
+Twibot.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/test/test_bot.rb

@@ -0,0 +1,185 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Twibot)
+require 'fileutils'
+
+class TestBot < Test::Unit::TestCase
+  should "not raise errors when initialized" do
+    assert_nothing_raised do
+      Twibot::Bot.new Twibot::Config.new
+    end
+  end
+
+  should "raise errors when initialized without config file" do
+    assert_raise SystemExit do
+      Twibot::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
+      Twibot::Bot.new
+    end
+
+    FileUtils.rm_rf("config")
+  end
+
+  should "provide configuration settings as methods" do
+    bot = Twibot::Bot.new Twibot::Config.new(:max_interval => 3)
+    assert_equal 3, bot.max_interval
+  end
+
+  should "return logger instance" do
+    bot = Twibot::Bot.new(Twibot::Config.default << Twibot::Config.new)
+    assert bot.log.is_a?(Logger)
+  end
+
+  should "respect configured log level" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "info"))
+    assert_equal Logger::INFO, bot.log.level
+
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "warn"))
+    assert_equal Logger::WARN, bot.log.level
+  end
+
+  should "should return false from receive without handlers" do
+    bot = Twibot::Bot.new(Twibot::Config.new)
+    assert !bot.receive_messages
+    assert !bot.receive_replies
+    assert !bot.receive_tweets
+  end
+
+  should "receive message" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
+    bot.add_handler(:message, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
+
+    assert bot.receive_messages
+  end
+
+  should "remember last received message" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
+    bot.add_handler(:message, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
+    assert_equal 1, bot.receive_messages
+
+    Twitter::Client.any_instance.expects(:messages).with(:received, { :since_id => 1 }).returns([])
+    assert_equal 0, bot.receive_messages
+  end
+
+  should "receive tweet" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
+    bot.add_handler(:tweet, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:timeline_for).with(:me, {}).returns([tweet("cjno", "Hei der!")])
+
+    assert_equal 1, bot.receive_tweets
+  end
+
+  should "receive friend tweets if configured" do
+    bot = Twibot::Bot.new(Twibot::Config.new({:log_level => "error", :include_friends => true}))
+    bot.add_handler(:tweet, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:timeline_for).with(:friends, {}).returns([tweet("cjno", "Hei der!")])
+
+    assert_equal 1, bot.receive_tweets
+  end
+
+  should "remember received tweets" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
+    bot.add_handler(:tweet, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:timeline_for).with(:me, {}).returns([tweet("cjno", "Hei der!")])
+    assert_equal 1, bot.receive_tweets
+
+    Twitter::Client.any_instance.expects(:timeline_for).with(:me, { :since_id => 1 }).returns([])
+    assert_equal 0, bot.receive_tweets
+  end
+
+  should "receive reply when tweet starts with login" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error", :login => "irbno"))
+    bot.add_handler(:reply, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
+
+    assert_equal 1, bot.receive_replies
+  end
+
+  should "remember received replies" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error", :login => "irbno"))
+    bot.add_handler(:reply, Twibot::Handler.new)
+    Twitter::Client.any_instance.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
+    assert_equal 1, bot.receive_replies
+
+    Twitter::Client.any_instance.expects(:status).with(:replies, { :since_id => 1 }).returns([])
+    assert_equal 0, bot.receive_replies
+  end
+
+  should "use public as default timeline method for tweet 'verb'" do
+    bot = Twibot::Bot.new(Twibot::Config.default)
+    assert_equal :public, bot.instance_eval { @config.to_hash[:timeline_for] }
+  end
+end
+
+class TestBotMacros < Test::Unit::TestCase
+  should "provide configure macro" do
+    assert respond_to?(:configure)
+  end
+
+  should "yield configuration" do
+    Twibot::Macros.bot = Twibot::Bot.new Twibot::Config.default
+    bot.prompt = false
+
+    conf = nil
+    assert_nothing_raised { configure { |c| conf = c } }
+    assert conf.is_a?(Twibot::Config)
+  end
+
+   should "add handler" do
+     Twibot::Macros.bot = Twibot::Bot.new Twibot::Config.default
+     bot.prompt = false
+
+     handler = add_handler(:message, ":command", :from => :cjno)
+     assert handler.is_a?(Twibot::Handler), handler.class
+   end
+
+  should "provide twitter macro" do
+    assert respond_to?(:twitter)
+    assert respond_to?(:client)
+  end
+end
+
+class TestBotHandlers < Test::Unit::TestCase
+
+  should "include handlers" do
+    bot = Twibot::Bot.new(Twibot::Config.new)
+
+    assert_not_nil bot.handlers
+    assert_not_nil bot.handlers[:message]
+    assert_not_nil bot.handlers[:reply]
+    assert_not_nil bot.handlers[:tweet]
+  end
+
+  should "add handler" do
+    bot = Twibot::Bot.new(Twibot::Config.new)
+    bot.add_handler :message, Twibot::Handler.new
+    assert_equal 1, bot.handlers[:message].length
+
+    bot.add_handler :message, Twibot::Handler.new
+    assert_equal 2, bot.handlers[:message].length
+
+    bot.add_handler :reply, Twibot::Handler.new
+    assert_equal 1, bot.handlers[:reply].length
+
+    bot.add_handler :reply, Twibot::Handler.new
+    assert_equal 2, bot.handlers[:reply].length
+
+    bot.add_handler :tweet, Twibot::Handler.new
+    assert_equal 1, bot.handlers[:tweet].length
+
+    bot.add_handler :tweet, Twibot::Handler.new
+    assert_equal 2, bot.handlers[:tweet].length
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Twibot)
+require 'stringio'
+
+class TestConfig < Test::Unit::TestCase
+  should "default configuration be a hash" do
+    assert_not_nil Twibot::Config::DEFAULT
+    assert Twibot::Config::DEFAULT.is_a?(Hash)
+  end
+
+  should "initialize with no options" do
+    assert_hashes_equal({}, Twibot::Config.new.settings)
+  end
+
+  should "return config from add" do
+    config = Twibot::Config.new
+    assert_equal config, config.add(Twibot::Config.new)
+  end
+
+  should "alias add to <<" do
+    config = Twibot::Config.new
+    assert config.respond_to?(:<<)
+    assert config << Twibot::Config.new
+  end
+
+  should "mirror method_missing as config getters" do
+    config = Twibot::Config.default << Twibot::Config.new
+    assert_equal Twibot::Config::DEFAULT[:min_interval], config.min_interval
+    assert_equal Twibot::Config::DEFAULT[:login], config.login
+  end
+
+  should "mirror missing methods as config setters" do
+    config = Twibot::Config.default << Twibot::Config.new
+    assert_equal Twibot::Config::DEFAULT[:min_interval], config.min_interval
+
+    val = config.min_interval
+    config.min_interval = val + 5
+    assert_not_equal Twibot::Config::DEFAULT[:min_interval], config.min_interval
+    assert_equal val + 5, config.min_interval
+  end
+
+  should "not override default hash" do
+    config = Twibot::Config.default
+    hash = Twibot::Config::DEFAULT
+
+    config.min_interval = 0
+    config.max_interval = 0
+
+    assert_hashes_not_equal Twibot::Config::DEFAULT, config.to_hash
+    assert_hashes_equal hash, Twibot::Config::DEFAULT
+  end
+
+  should "return merged configuration from to_hash" do
+    config = Twibot::Config.new
+    config.min_interval = 10
+    config.max_interval = 10
+
+    config2 = Twibot::Config.new({})
+    config2.min_interval = 1
+    config << config2
+    options = config.to_hash
+
+    assert_equal 10, options[:max_interval]
+    assert_equal 1, options[:min_interval]
+  end
+end
+
+class TestCliConfig < Test::Unit::TestCase
+  should "configure from options" do
+    config = Twibot::CliConfig.new %w{--min-interval 10 --max-interval 15}
+    assert_equal 10, config.min_interval
+    assert_equal 15, config.max_interval
+  end
+end
+
+class TestFileConfig < Test::Unit::TestCase
+  should "subclass config for file config" do
+    assert Twibot::FileConfig.new(StringIO.new).is_a?(Twibot::Config)
+  end
+
+  should "read settings from stream" do
+    config = Twibot::FileConfig.new(StringIO.new <<-YAML)
+min_interval: 10
+max_interval: 20
+    YAML
+
+    assert_equal 10, config.min_interval
+    assert_equal 20, config.max_interval
+  end
+end