mattmueller-twibot 0.1.7.1

data/lib/twibot/config.rb

@@ -0,0 +1,140 @@
+require 'optparse'
+
+module Twibot
+  #
+  # Twibot configuration. Use either Twibot::CliConfig.new or
+  # TwibotFileConfig.new setup a new bot from either command line or file
+  # (respectively). Configurations can be chained so they override each other:
+  #
+  #   config = Twibot::FileConfig.new
+  #   config << Twibot::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 = {
+      :host => "twitter.com",
+      :min_interval => 30,
+      :max_interval => 300,
+      :interval_step => 10,
+      :log_level => "info",
+      :log_file => nil,
+      :login => nil,
+      :password => nil,
+      :process => :new,
+      :prompt => false,
+      :daemonize => false,
+      :include_friends => false,
+      :timeline_for => :public
+    }
+
+    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 command line
+  #
+  class CliConfig < Config
+
+    def initialize(args = $*)
+      super()
+
+      @parser = OptionParser.new do |opts|
+        opts.banner += "Usage: #{File.basename(Twibot.app_file)} [options]"
+
+        opts.on("-m", "--min-interval SECS", Integer, "Minimum poll interval in seconds") { |i| @settings[:min_interval] = i }
+        opts.on("-x", "--max-interval SECS", Integer, "Maximum poll interval in seconds") { |i| @settings[:max_interval] =  i }
+        opts.on("-s", "--interval-step SECS", Integer, "Poll interval step in seconds") { |i| @settings[:interval_step] =  i }
+        opts.on("-f", "--log-file FILE", "Log file") { |f| @settings[:log_file] =  f }
+        opts.on("-l", "--log-level LEVEL", "Log level (err, warn, info, debug), default id info") { |l| @settings[:log_level] =  l }
+        opts.on("-u", "--login LOGIN", "Twitter login") { |l| @settings[:login] =  l }
+        opts.on("-p", "--password PASSWORD", "Twitter password") { |p| @settings[:password] =  p }
+        opts.on("-h", "--help", "Show this message") { puts opts; exit }
+
+        begin
+          require 'daemons'
+          opts.on("-d", "--daemonize", "Run as background process (Not implemented)") { |t| @settings[:daemonize] = true }
+        rescue LoadError
+        end
+
+      end.parse!(args)
+    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/twibot/handlers.rb

@@ -0,0 +1,122 @@
+module Twibot
+  module Handlers
+    #
+    # Add a handler for this bot
+    #
+    def add_handler(type, handler)
+      handlers_for_type(type) << handler
+      handler
+    end
+
+    def handlers_for_type(type)
+      if type.is_a? Array
+        handlers[type.first][type.last] ||= []
+      else
+        handlers[type] || {}
+      end
+    end
+
+    def dispatch(type, message)
+      handlers_for_type(type).each { |handler| handler.dispatch(message) }
+    end
+
+    def handlers
+      @handlers ||= {
+        :message => [],
+        :reply => [],
+        :tweet => [],
+        :follower => [],
+        :search => {}
+      }
+    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
+    attr_reader :options
+    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,101 @@
+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 follower(&blk)
+      add_handler(:follower, nil, {}, &blk)
+    end
+    
+    def hashtag(tag_or_tags, pattern = nil, options = {}, &blk)
+      query = [tag_or_tags].flatten.map {|ht| ht.to_s[0] == ?# ? ht.to_s : "##{ht}"}.join(" OR ")
+      add_handler([:search, query], pattern, options, &blk)
+    end
+    alias_method :hashtags, :hashtag
+    
+    def search(query, pattern = nil, options = {}, &blk)
+      add_handler([:search, query], pattern, options, &blk)
+    end
+    
+    def after(event=:all, &blk)
+      add_hook :"after_#{event}", &blk
+    end
+    
+    def before(event=:all, &blk)
+      add_hook :"before_#{event}", &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 post_reply(status, msg)
+      text = msg.respond_to?(:text) ? msg.text : msg
+      reply_to_screen_name = status.user.screen_name
+      reply_to_status_id = status.id
+      message = "@#{reply_to_screen_name} #{text}"
+      puts message
+      client.status(:reply, message, reply_to_status_id)
+    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 add_hook(hook, &blk)
+      bot.add_hook(hook, &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/test/test_bot.rb

@@ -0,0 +1,300 @@
+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
+
+  context "with the process option specified" do
+    setup do
+      @bot = Twibot::Bot.new(@config = Twibot::Config.default)
+      @bot.stubs(:prompt?).returns(false)
+      @bot.stubs(:twitter).returns(stub)
+      @bot.stubs(:processed).returns(stub)
+
+      # stop Bot actually starting during tests
+      @bot.stubs(:poll)
+    end
+
+    should "not process tweets prior to bot launch if :process option is set to :new" do
+      @bot.stubs(:handlers).returns({:tweet => [stub], :reply => []})
+
+      # Should fetch the latest ID for both messages and tweets
+      @bot.twitter.expects(:messages).with(:received, { :count => 1 }).
+        returns([stub(:id => (message_id = stub))]).once
+      @bot.twitter.expects(:timeline_for).with(:public, { :count => 1 }).
+        returns([stub(:id => (tweet_id = stub))]).once
+
+      # And set them to the since_id value to be used for future polling
+      @bot.processed.expects(:[]=).with(:message, message_id)
+      @bot.processed.expects(:[]=).with(:tweet,   tweet_id)
+      @bot.processed.expects(:[]=).with(:reply,   tweet_id)
+
+      @bot.configure { |c| c.process = :new }
+      @bot.run!
+    end
+
+    [:all, nil].each do |value|
+      should "process all tweets if :process option is set to #{value.inspect}" do
+        @bot.twitter.expects(:messages).never
+        @bot.twitter.expects(:timeline_for).never
+
+        # Shout not set the any value for the since_id tweets
+        @bot.processed.expects(:[]=).never
+
+        @bot.configure { |c| c.process = value }
+        @bot.run!
+      end
+    end
+
+    should "process all tweets after the ID specified in the :process option" do
+      tweet_id = 12345
+
+      @bot.processed.expects(:[]=).with(anything, 12345).times(3)
+
+      @bot.configure { |c| c.process = tweet_id }
+      @bot.run!
+    end
+
+    should "raise exit when the :process option is not recognized" do
+      @bot.configure { |c| c.process = "something random" }
+      assert_raise(SystemExit) { @bot.run! }
+    end
+
+  end
+
+  should "receive message" do
+    bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
+    bot.add_handler(:message, Twibot::Handler.new)
+    bot.twitter.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)
+    bot.twitter.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
+    assert_equal 1, bot.receive_messages
+
+    bot.twitter.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)
+    bot.twitter.expects(:timeline_for).with(:public, {}).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", :timeline_for => :friends}))
+    bot.add_handler(:tweet, Twibot::Handler.new)
+    bot.twitter.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)
+    bot.twitter.expects(:timeline_for).with(:public, {}).returns([tweet("cjno", "Hei der!")])
+    assert_equal 1, bot.receive_tweets
+
+    bot.twitter.expects(:timeline_for).with(:public, { :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)
+    bot.twitter.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)
+    bot.twitter.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
+    assert_equal 1, bot.receive_replies
+
+    bot.twitter.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
+
+  context "sandboxed network errors" do
+    should "rescue certain errors" do
+      bot = Twibot::Bot.new(Twibot::Config.default)
+
+      assert_nothing_raised do
+        bot.send(:sandbox) { raise Twitter::RESTError.new }
+        bot.send(:sandbox) { raise Errno::ECONNRESET.new }
+        bot.send(:sandbox) { raise Timeout::Error.new }
+        bot.send(:sandbox) { raise EOFError.new }
+        bot.send(:sandbox) { raise Errno::ETIMEDOUT.new }
+        bot.send(:sandbox) { raise JSON::ParserError.new }
+        bot.send(:sandbox) { raise OpenSSL::SSL::SSLError.new }
+        bot.send(:sandbox) { raise SystemStackError.new }
+      end
+    end
+
+    should "return default value if error is rescued" do
+      bot = Twibot::Bot.new(Twibot::Config.default)
+      assert_equal(42, bot.send(:sandbox, 42) { raise Twitter::RESTError })
+    end
+
+    should "not return default value when no error was raised" do
+      bot = Twibot::Bot.new(Twibot::Config.default)
+      assert_equal(65, bot.send(:sandbox, 42) { 65 })
+    end
+
+    should "not swallow unknown errors" do
+      bot = Twibot::Bot.new(Twibot::Config.default)
+
+      assert_raise StandardError do
+        bot.send(:sandbox) { raise StandardError.new "Oops!" }
+      end
+    end
+  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
+
+  context "posting replies" do
+    should "work with string messages" do
+      text = "Hey there"
+      status = Twitter::Status.new(:id => 123,
+                                   :text => "Some text",
+                                   :user => Twitter::User.new(:screen_name => "cjno"))
+      client.expects(:status).with(:reply, "@cjno #{text}", 123).returns(true)
+
+      assert post_reply(status, text)
+    end
+
+    should "work with status object messages" do
+      reply = Twitter::Status.new :text => "Hey there"
+      status = Twitter::Status.new(:id => 123,
+                                   :text => "Some text",
+                                   :user => Twitter::User.new(:screen_name => "cjno"))
+      client.expects(:status).with(:reply, "@cjno Hey there", 123).returns(true)
+
+      assert post_reply(status, reply)
+    end
+  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