tweetbot 0.1.3

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use  1.9.2@tweetbot

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tweetbot.gemspec
+gemspec

data/README

@@ -0,0 +1,39 @@
+So you want to write a twitter bot. Use my gem. Then, you can just do this:
+
+load 'twitter_auth.rb'
+require 'tweetbot'
+
+bot = TweetBot.configure do |config|
+  config.response_frequency = 100
+
+  config.respond_to_phrase "tweetbot example phrase" do |responses|
+    responses << "I am tweetbot!" << "You rang?" << "Pretty cool, thanks for saying hello"
+  end
+
+  config.respond_to_phrase "hey @tweetbot" do |responses|
+    responses << "Hey back at ya" << "You rang again?"
+  end
+
+  config.twitter_auth = TwitterAuth::AuthKeys
+end
+
+bot.talk
+
+and build a file called twitter_auth.rb that has your keys
+
+module TwitterAuth
+  MyName = 'twitter_name'
+  ApigeeEnpoint = nil
+  def self.use_apigee?
+    !ApigeeEnpoint.nil?
+  end
+  AuthKeys = {
+    consumer_key: "key",
+    consumer_secret: "secret",
+    oauth_token: "token",
+    oauth_token_secret: "token_secret"
+  }
+end
+
+
+Abstracting out the apigee stuff, don't worry. Just leave it like that for now.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/example/run_bot.rb

@@ -0,0 +1,19 @@
+load 'twitter_auth.rb'
+require 'tweetbot'
+
+bot = TweetBot.configure do |config|
+  config.response_frequency = 100
+
+  config.respond_to_phrase "tweetbot example phrase" do |responses|
+    responses << "I am tweetbot!" << "You rang?" << "Pretty cool, thanks for saying hello"
+  end
+
+  config.respond_to_phrase "hey @tweetbot" do |responses|
+    responses << "Hey back at ya" << "You rang again?"
+  end
+
+  config.twitter_auth = TwitterAuth::AuthKeys
+end
+
+bot.talk
+

data/example/twitter_auth.rb

@@ -0,0 +1,13 @@
+module TwitterAuth
+  MyName = 'twitter_name'
+  ApigeeEnpoint = nil
+  def self.use_apigee?
+    !ApigeeEnpoint.nil?
+  end
+  AuthKeys = {
+    consumer_key: "key",
+    consumer_secret: "secret",
+    oauth_token: "token",
+    oauth_token_secret: "token_secret"
+  }
+end

data/lib/tweetbot.rb

@@ -0,0 +1,11 @@
+require_relative 'tweetbot/version'
+require_relative 'tweetbot/talk'
+require_relative 'tweetbot/bot'
+
+module TweetBot
+  def self.configure
+    @bot ||= Bot.new
+    yield @bot if block_given?
+    @bot
+  end
+end

data/lib/tweetbot/bot.rb

@@ -0,0 +1,59 @@
+module TweetBot
+  class Bot
+    include TweetBot::Talk
+    attr_accessor :response_frequency, :twitter_auth
+
+    DefaultFrequency = 20
+
+    def initialize()
+      self.response_frequency = DefaultFrequency
+      @responses_for_phrases = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def phrases_to_search
+      @responses_for_phrases.keys
+    end
+
+    def responses_for(phrase)
+      @responses_for_phrases[phrase]
+    end
+
+    def respond_to_phrase(phrase)
+      responses = []
+      yield responses
+      add_responses_for_phrase(phrase, *responses)
+    end
+
+    def add_responses_for_phrase(phrase, *responses)
+      @responses_for_phrases[phrase.downcase] += responses
+    end
+
+    def response_for(tweet)
+      responses = responses_for_tweet(tweet)
+      "@#{tweet.user.screen_name} #{responses.sample}"
+    end
+
+    def should_i_respond_to?(tweet)
+      return false if under_rate_limit_pause?
+      matches = tweet_matches?(tweet)
+      frequency_check = (rand(100) < self.response_frequency)
+      matches && frequency_check
+    end
+
+    def rate_limited!
+      @rate_limited_until = Time.now + 3600
+    end
+
+    def under_rate_limit_pause?
+      @rate_limited_until && (Time.now < @rate_limited_until)
+    end
+
+    def tweet_matches?(tweet)
+      responses_for_tweet(tweet).any?
+    end
+
+    def responses_for_tweet(tweet)
+      @responses_for_phrases.select{|phrase, _| tweet.text =~ /#{phrase}/i}.values[0] || []
+    end
+  end
+end

data/lib/tweetbot/talk.rb

@@ -0,0 +1,126 @@
+require 'twitter'
+require 'tweetstream'
+
+if ENV["DEBUG"]
+  module Twitter
+    def self.configure
+    end
+
+    def self.update(status, options = {})
+      puts "DEBUG: #{status}"
+    end
+  end
+end
+module TweetBot
+  module Talk
+    def configure_twitter_auth
+      Twitter.configure do |config|
+        config.consumer_key = twitter_auth[:consumer_key]
+        config.consumer_secret = twitter_auth[:consumer_secret]
+        config.oauth_token = twitter_auth[:oauth_token]
+        config.oauth_token_secret = twitter_auth[:oauth_token_secret]
+      end
+      TweetStream.configure do |config|
+        config.consumer_key = twitter_auth[:consumer_key]
+        config.consumer_secret = twitter_auth[:consumer_secret]
+        config.oauth_token = twitter_auth[:oauth_token]
+        config.oauth_token_secret = twitter_auth[:oauth_token_secret]
+        config.auth_method = :oauth
+      end
+    end
+
+    def talk
+      configure_twitter_auth
+
+      if TwitterAuth.use_apigee?
+        twitter_api_endpoint = if ENV['APIGEE_TWITTER_API_ENDPOINT']
+                                 ENV['APIGEE_TWITTER_API_ENDPOINT']
+                               else
+                                 # Get this value from Heroku.
+                                 # Once you have enabled the addon, boot up the 'heroku console' and run the following:
+                                 # puts ENV['APIGEE_TWITTER_API_ENDPOINT']
+                                 # this will spit out your correct api endpoint
+                                 TwitterAuth::ApigeeEnpoint
+                               end
+        Twitter.configure do |config|
+          config.gateway = twitter_api_endpoint
+        end
+      end
+
+      bot = self
+
+      announce_wake_up
+      puts "Listening... #{Time.now}"
+
+
+      client = TweetStream::Client.new
+
+      ["INT", "TERM", "STOP"].each do |signal|
+        trap(signal) do
+          puts "Got #{signal}"
+          client.stop
+          exit!(1)
+        end
+      end
+
+      at_exit do
+        puts "Shutting down... #{Time.now}"
+        begin
+          send_twitter_message "Going to sleep... #{Time.now}"
+        rescue
+        end
+      end
+
+
+      client.on_error do |message|
+        puts "Error: #{Time.now}"
+        puts message
+      end
+
+      #EM.defer
+      #EM::HttpRequest
+      client.track(*bot.phrases_to_search) do |status|
+        if status.user.screen_name == TwitterAuth::MyName
+          puts "#{Time.now} Caught myself saying it"
+        else
+          puts "#{Time.now} #{status.user.screen_name} said #{status.text}"
+          if bot.should_i_respond_to?(status)
+            response = bot.response_for(status)
+            begin
+              send_twitter_message(response, :in_reply_to_status_id => status.id)
+            rescue Twitter::Forbidden => ex
+              puts "Rate limited!"
+              bot.rate_limited!
+            rescue Exception => e
+              puts "Exception while sending the reply"
+              puts e
+            end
+          else
+            puts "Bot told me not to respond"
+          end
+        end
+      end
+    end
+
+    def send_twitter_message(message, options = {})
+      Twitter.update message, options
+    end
+
+    def announce_wake_up
+      puts "Waking up to greet the world... #{Time.now}"
+      send_twitter_message "Waking up to greet the world... #{Time.now}"
+    rescue Twitter::Forbidden => ex
+      puts "Twitter Forbidden Error while waking up"
+      puts ex
+      puts "Continuing"
+    rescue Twitter::Error => ex
+      puts "Twitter Error while waking up"
+      puts ex
+      exit!(1)
+    rescue => ex
+      puts "Unknown Error while waking up"
+      puts ex
+      exit!(1)
+    end
+  end
+end

data/lib/tweetbot/version.rb

@@ -0,0 +1,3 @@
+module Tweetbot
+  VERSION = "0.1.3"
+end

data/spec/tweetbot_config_spec.rb

@@ -0,0 +1,103 @@
+require_relative '../lib/tweetbot'
+module Twitter
+end
+module TweetStream
+end
+
+describe "configuring tweetbot with a config block" do
+  class DummyAuth
+    attr_accessor :consumer_key, :consumer_secret, :oauth_token,
+                :oauth_token_secret, :auth_method
+  end
+
+  before do
+    Twitter.stub(:configure)
+    TweetStream.stub(:configure)
+  end
+
+  context "configuring with twitter authentication" do
+    it "configures twitter with the oauth keys" do
+      auth = DummyAuth.new
+      bot = TweetBot.configure do |bot|
+        bot.twitter_auth = {
+          consumer_key: "ckey",
+          consumer_secret: "csecret",
+          oauth_token: "token",
+          oauth_token_secret: "tokensecret"
+        }
+      end
+      Twitter.stub(:configure).and_yield auth
+      bot.configure_twitter_auth
+      auth.consumer_key.should == "ckey"
+      auth.consumer_secret.should == "csecret"
+      auth.oauth_token.should == "token"
+      auth.oauth_token_secret.should == "tokensecret"
+    end
+    it "configures tweetstream with the oauth keys" do
+      auth = DummyAuth.new
+      bot = TweetBot.configure do |bot|
+        bot.twitter_auth = {
+          consumer_key: "ckey",
+          consumer_secret: "csecret",
+          oauth_token: "token",
+          oauth_token_secret: "tokensecret"
+        }
+      end
+      TweetStream.stub(:configure).and_yield auth
+      bot.configure_twitter_auth
+      auth.consumer_key.should == "ckey"
+      auth.consumer_secret.should == "csecret"
+      auth.oauth_token.should == "token"
+      auth.oauth_token_secret.should == "tokensecret"
+    end
+  end
+
+  context "configuring twice" do
+    it "uses the same bot" do
+      bot1 = TweetBot.configure do |bot|
+        bot.response_frequency = 4
+      end
+
+      bot2 = TweetBot.configure do |bot|
+        bot.response_frequency = 10
+      end
+
+      bot1.should be(bot2)
+      bot1.response_frequency.should == 10
+    end
+  end
+
+  context "configuring frequency" do
+    let(:bot) do
+      TweetBot.configure do |bot|
+        bot.response_frequency = 4
+      end
+    end
+
+    it "saves the response_frequency" do
+      bot.response_frequency.should == 4
+    end
+  end
+
+  context "configuring responses" do
+    let(:bot) do
+      TweetBot.configure do |bot|
+        bot.respond_to_phrase "code and coffee" do |responses|
+          responses << "good times" << "bad times"
+        end
+      end
+    end
+
+    it "saves the response given in block" do
+      bot.responses_for("code and coffee").should =~ ["good times", "bad times"]
+    end
+  end
+
+  context "without a configure block" do
+    it "returns a bot that I can use" do
+      bot = TweetBot.configure
+      bot.response_frequency = 4
+      bot.response_frequency.should == 4
+    end
+  end
+end

data/spec/tweetbot_spec.rb

@@ -0,0 +1,136 @@
+require_relative '../lib/tweetbot'
+require 'timecop'
+
+
+describe TweetBot::Bot do
+  let(:bot) { TweetBot::Bot.new }
+  let(:tweet) { stub(:text => "hello world", :user => stub(:screen_name => "fun_person")) }
+
+  before do
+    bot.add_responses_for_phrase "hello world", "and hello to you"
+  end
+
+  after do
+    Timecop.return
+  end
+
+
+  describe "#phrases_to_search" do
+    it "returns the phrases that have responses associated with them" do
+      bot.add_responses_for_phrase "good night", ""
+      bot.phrases_to_search.should == ["hello world", "good night"]
+    end
+  end
+
+  describe "#tweet_matches?" do
+    before do
+      bot.add_responses_for_phrase "the night", "a dark night"
+    end
+    it "looks to see if any phrases match the tweet" do
+      tweet.stub(:text) { "the night" }
+      bot.tweet_matches?(tweet).should be_true
+      tweet.stub(:text) { "the day" }
+      bot.tweet_matches?(tweet).should be_false
+    end
+
+    it "compares case-insensitive" do
+      tweet.stub(:text) { "The Night"}
+      bot.tweet_matches?(tweet).should be_true
+    end
+
+    it "matches if anywhere in text" do
+      tweet.stub(:text) { "It is cold The Night"}
+      bot.tweet_matches?(tweet).should be_true
+    end
+  end
+
+  describe "#response_for" do
+    it "replies to the user" do
+      tweet.user.stub(:screen_name) { "corey" }
+      bot.response_for(tweet).should =~ /^@corey/
+    end
+
+    it "uses responses associated with phrase" do
+      bot.add_responses_for_phrase("good morning", "morning response")
+      bot.add_responses_for_phrase("good night", "night response")
+
+      tweet.stub(:text) { "good morning" }
+      bot.response_for(tweet).should =~ /morning response/
+      tweet.stub(:text) { "good night" }
+      bot.response_for(tweet).should =~ /night response/
+    end
+
+    it "it randomly uses a phrase from the responses" do
+      tweet.stub(:text) { "good morning" }
+      bot.add_responses_for_phrase("good morning", "response 1", "response 2")
+      responses = (1..20).map do
+        bot.response_for(tweet)
+      end
+      responses.reject! {|response| response =~ /response 1/}
+      responses.should_not be_empty
+      responses.reject! {|response| response =~ /response 2/}
+      responses.should be_empty
+    end
+
+    it "uses responses if phrase appears anywhere in tweet (case-insensitive)" do
+      bot.add_responses_for_phrase("good afternoon", "afternoon response")
+      tweet.stub(:text) { "this is a Good Afternoon" }
+      bot.response_for(tweet).should =~ /afternoon response/
+    end
+  end
+
+  describe "#should_i_respond_to?" do
+    before do
+      bot.stub(:rand) { 1 }
+      bot.stub(:tweet_matches?) { true }
+    end
+
+    context "Under rate limit" do
+      let(:now) { Time.now }
+      let(:status) { stub }
+      before do
+        Timecop.freeze(now)
+        bot.rate_limited!
+      end
+
+      it "won't allow response for 1 hour" do
+        bot.should_i_respond_to?(status).should be_false
+        Timecop.travel(now + 60 * 59) do
+          bot.should_i_respond_to?(status).should be_false
+        end
+      end
+
+      it "will allow response after an hour" do
+        Timecop.travel(now + 3600) do
+          bot.should_i_respond_to?(status).should be_true
+        end
+      end
+    end
+
+    it "only responds if rand is less than response_frequency" do
+      bot.response_frequency = 30
+      bot.stub(:rand) { 29 }
+      bot.should_i_respond_to?(stub).should be_true
+      bot.stub(:rand) { 30 }
+      bot.should_i_respond_to?(stub).should be_false
+      bot.stub(:rand) { 31 }
+      bot.should_i_respond_to?(stub).should be_false
+    end
+
+    it "only responds if phrase matches" do
+      bot.stub(:tweet_matches?) { true }
+      bot.should_i_respond_to?(stub).should be_true
+      bot.stub(:tweet_matches?) { false }
+      bot.should_i_respond_to?(stub).should be_false
+    end
+  end
+
+  describe "#respond_to_phrase" do
+    it "stores the given responses" do
+      bot.respond_to_phrase "morning fun" do |responses|
+        responses << "evening delight" << "afternoon rockets"
+      end
+      bot.responses_for_tweet(stub(:text => "morning fun")).should =~ ["evening delight", "afternoon rockets"]
+    end
+  end
+end

data/tweetbot.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tweetbot/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tweetbot"
+  s.version     = Tweetbot::VERSION
+  s.authors     = ["coreyhaines"]
+  s.email       = ["coreyhaines@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Tweetbot makes writing twitter bots twivial!}
+  s.description = %q{Using tweetbot, you can easily create twitter bots that respond to key phrases that people say on the twitters}
+
+  s.rubyforge_project = "tweetbot"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "timecop"
+  s.add_runtime_dependency "twitter"
+  s.add_runtime_dependency "tweetstream"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: tweetbot
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+  prerelease: 
+platform: ruby
+authors:
+- coreyhaines
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-13 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2153278820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153278820
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &2153278400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153278400
+- !ruby/object:Gem::Dependency
+  name: twitter
+  requirement: &2153277980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153277980
+- !ruby/object:Gem::Dependency
+  name: tweetstream
+  requirement: &2153277540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153277540
+description: Using tweetbot, you can easily create twitter bots that respond to key
+  phrases that people say on the twitters
+email:
+- coreyhaines@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README
+- Rakefile
+- example/run_bot.rb
+- example/twitter_auth.rb
+- lib/tweetbot.rb
+- lib/tweetbot/bot.rb
+- lib/tweetbot/talk.rb
+- lib/tweetbot/version.rb
+- spec/tweetbot_config_spec.rb
+- spec/tweetbot_spec.rb
+- tweetbot.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tweetbot
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Tweetbot makes writing twitter bots twivial!
+test_files:
+- spec/tweetbot_config_spec.rb
+- spec/tweetbot_spec.rb