twibot 0.1.6 → 0.1.7

data/History.txt

@@ -1,6 +1,19 @@
+== 0.1.7 / 2009-06-01
+
+* New feature - choose how Twibot processes incoming tweets on startup
+  (process all, process new [old behaviour], or process from a given ID)
+  Bodaniel Jeanes
+* Substantially improved error handling. Now survives all common network
+  stability issues
+* Added a host configuration option. The host name is displayed along all
+  output from Twibot. Currently Twitter4R does nothing with this option,
+  Twibot knowing about it should make it easier to put Twibot/Twitter4R on
+  other services like Laconica instances
+
 == 0.1.6 / 2009-04-13
 
-* Fixed configure block not actually working for username and password (Bodaniel Jeanes)
+* Fixed configure block not actually working for username and password
+  Bodaniel Jeanes
 * Minor updates in tests
 
 == 0.1.5 / 2009-04-12

data/Readme.rdoc

@@ -23,7 +23,7 @@ bots, heavily inspired by Sinatra.
   # Respond to @replies if they come from the right crowd
   #
   reply :from => [:cjno, :irbno] do |message, params|
-    post_tweet "@#{message.sender.screen_name} I agree"
+    post_reply message, "I agree"
   end
 
   # Listen in and log tweets

data/lib/twibot.rb

@@ -7,7 +7,7 @@ require File.join(File.dirname(__FILE__), 'hash')
 module Twibot
 
   # :stopdoc:
-  VERSION = '0.1.6'
+  VERSION = '0.1.7'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/lib/twibot/bot.rb

@@ -34,36 +34,43 @@ module Twibot
     end
 
     def twitter
-      @twitter ||= Twitter::Client.new :login => config[:login], :password => config[:password]
+      @twitter ||= Twitter::Client.new(:login => config[:login],
+                                       :password => config[:password],
+                                       :host => config[:host])
     end
 
     #
     # Run application
     #
     def run!
-      puts "Twibot #{Twibot::VERSION} imposing as @#{login}"
+      puts "Twibot #{Twibot::VERSION} imposing as @#{login} on #{config[:host]}"
 
       trap(:INT) do
         puts "\nAnd it's a wrap. See ya soon!"
         exit
       end
 
-      # Make sure we don't process messages and tweets received prior to bot launch
-      messages = twitter.messages(:received, { :count => 1 })
-      processed[:message] = messages.first.id if messages.length > 0
+      case config[:process]
+      when :all, nil
+        # do nothing so it will fetch ALL
+      when :new
+        # Make sure we don't process messages and tweets received prior to bot launch
+        messages = twitter.messages(:received, { :count => 1 })
+        processed[:message] = messages.first.id if messages.length > 0
 
-      handle_tweets = !@handlers.nil? && @handlers[:tweet].length + @handlers[:reply].length > 0
-      tweets = []
+        handle_tweets = !handlers.nil? && handlers[:tweet].length + handlers[:reply].length > 0
+        tweets = []
 
-      begin
-        tweets = handle_tweets ? twitter.timeline_for(config[:timeline_for], { :count => 1 }) : []
-      rescue Twitter::RESTError => e
-        log.error("Failed to connect to Twitter.  It's likely down for a bit:")
-        log.error(e.to_s)
-      end
+        sandbox do
+          tweets = handle_tweets ? twitter.timeline_for(config[:timeline_for], { :count => 1 }) : []
+        end
 
-      processed[:tweet] = tweets.first.id if tweets.length > 0
-      processed[:reply] = tweets.first.id if tweets.length > 0
+        processed[:tweet] = tweets.first.id if tweets.length > 0
+        processed[:reply] = tweets.first.id if tweets.length > 0
+      when Numeric, /\d+/ # a tweet ID to start from
+        processed[:tweet] = processed[:reply] = processed[:message] = config[:process]
+      else abort "Unknown process option #{config[:process]}, aborting..."
+      end
 
       poll
     end
@@ -84,7 +91,7 @@ module Twibot
 
         interval = message_count > 0 ? min_interval : [interval + step, max].min
 
-        log.debug "Sleeping for #{interval}s"
+        log.debug "#{config[:host]} sleeping for #{interval}s"
         sleep interval
       end
     end
@@ -97,12 +104,9 @@ module Twibot
       return false unless handlers[type].length > 0
       options = {}
       options[:since_id] = processed[type] if processed[type]
-      begin
+
+      sandbox(0) do
         dispatch_messages(type, twitter.messages(:received, options), %w{message messages})
-      rescue Twitter::RESTError => e
-        log.error("Failed to connect to Twitter.  It's likely down for a bit:")
-        log.error(e.to_s)
-        0
       end
     end
 
@@ -114,12 +118,9 @@ module Twibot
       return false unless handlers[type].length > 0
       options = {}
       options[:since_id] = processed[type] if processed[type]
-      begin
+
+      sandbox(0) do
         dispatch_messages(type, twitter.timeline_for(config.to_hash[:timeline_for] || :public, options), %w{tweet tweets})
-      rescue Twitter::RESTError => e
-        log.error("Failed to connect to Twitter.  It's likely down for a bit:")
-        log.error(e.to_s)
-        0
       end
     end
 
@@ -131,14 +132,10 @@ module Twibot
       return false unless handlers[type].length > 0
       options = {}
       options[:since_id] = processed[type] if processed[type]
-      begin
+
+      sandbox(0) do
         dispatch_messages(type, twitter.status(:replies, options), %w{reply replies})
-      rescue Twitter::RESTError => e
-        log.error("Failed to connect to Twitter.  It's likely down for a bit:")
-        log.error(e.to_s)
-        0
       end
-
     end
 
     #
@@ -150,7 +147,7 @@ module Twibot
       processed[type] = messages.first.id if messages.length > 0
 
       num = messages.length
-      log.info "Received #{num} #{num == 1 ? labels[0] : labels[1]}"
+      log.info "#{config[:host]}: Received #{num} #{num == 1 ? labels[0] : labels[1]}"
       num
     end
 
@@ -216,6 +213,43 @@ Unable to continue without login and password. Do one of the following:
 
       @conf
     end
+
+    #
+    # Takes a block and executes it in a sandboxed network environment. It
+    # catches and logs most common network connectivity and timeout errors.
+    #
+    # The method takes an optional parameter. If set, this value will be
+    # returned in case an error was raised.
+    #
+    def sandbox(return_value = nil)
+      begin
+        return_value = yield
+      rescue Twitter::RESTError => e
+        log.error("Failed to connect to Twitter. It's likely down for a bit:")
+        log.error(e.to_s)
+      rescue Errno::ECONNRESET => e
+        log.error("Connection was reset")
+        log.error(e.to_s)
+      rescue Timeout::Error => e
+        log.error("Timeout")
+        log.error(e.to_s)
+      rescue EOFError => e
+        log.error(e.to_s)
+      rescue Errno::ETIMEDOUT => e
+        log.error("Timeout")
+        log.error(e.to_s)
+      rescue JSON::ParserError => e
+        log.error("JSON Parsing error")
+        log.error(e.to_s)
+      rescue OpenSSL::SSL::SSLError => e
+        log.error("SSL error")
+        log.error(e.to_s)
+      rescue SystemStackError => e
+        log.error(e.to_s)
+      end
+
+      return return_value
+    end
   end
 end
 

data/lib/twibot/config.rb

@@ -20,6 +20,7 @@ module Twibot
     attr_reader :settings
 
     DEFAULT = {
+      :host => "twitter.com",
       :min_interval => 30,
       :max_interval => 300,
       :interval_step => 10,
@@ -27,6 +28,7 @@ module Twibot
       :log_file => nil,
       :login => nil,
       :password => nil,
+      :process => :new,
       :prompt => false,
       :daemonize => false,
       :include_friends => false,

data/lib/twibot/macros.rb

@@ -37,7 +37,16 @@ module Twibot
       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

data/test/test_bot.rb

@@ -55,10 +55,68 @@ class TestBot < Test::Unit::TestCase
     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)
-    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
+    bot.twitter.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
 
     assert bot.receive_messages
   end
@@ -66,17 +124,17 @@ class TestBot < Test::Unit::TestCase
   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!")])
+    bot.twitter.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([])
+    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)
-    Twitter::Client.any_instance.expects(:timeline_for).with(:public, {}).returns([tweet("cjno", "Hei der!")])
+    bot.twitter.expects(:timeline_for).with(:public, {}).returns([tweet("cjno", "Hei der!")])
 
     assert_equal 1, bot.receive_tweets
   end
@@ -84,7 +142,7 @@ class TestBot < Test::Unit::TestCase
   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)
-    Twitter::Client.any_instance.expects(:timeline_for).with(:friends, {}).returns([tweet("cjno", "Hei der!")])
+    bot.twitter.expects(:timeline_for).with(:friends, {}).returns([tweet("cjno", "Hei der!")])
 
     assert_equal 1, bot.receive_tweets
   end
@@ -92,17 +150,17 @@ class TestBot < Test::Unit::TestCase
   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(:public, {}).returns([tweet("cjno", "Hei der!")])
+    bot.twitter.expects(:timeline_for).with(:public, {}).returns([tweet("cjno", "Hei der!")])
     assert_equal 1, bot.receive_tweets
 
-    Twitter::Client.any_instance.expects(:timeline_for).with(:public, { :since_id => 1 }).returns([])
+    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)
-    Twitter::Client.any_instance.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
+    bot.twitter.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
 
     assert_equal 1, bot.receive_replies
   end
@@ -110,10 +168,10 @@ class TestBot < Test::Unit::TestCase
   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!")])
+    bot.twitter.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([])
+    bot.twitter.expects(:status).with(:replies, { :since_id => 1 }).returns([])
     assert_equal 0, bot.receive_replies
   end
 
@@ -121,6 +179,41 @@ class TestBot < Test::Unit::TestCase
     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
@@ -149,6 +242,28 @@ class TestBotMacros < Test::Unit::TestCase
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: twibot
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors: 
 - Christian Johansen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-13 00:00:00 +02:00
+date: 2009-06-01 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency