chatterbot 1.0.2 → 2.0.0.pre

data/spec/search_spec.rb

@@ -22,8 +22,12 @@ describe "Chatterbot::Search" do
     bot = test_bot
     
     allow(bot).to receive(:client).and_return(fake_search(100, 1))
-    expect(bot.client).to receive(:search).once.ordered.with("foo", {:result_type=>"recent"})
-    expect(bot.client).to receive(:search).once.ordered.with("bar", {:result_type=>"recent"})
+    expect(bot.client).to receive(:search).once.ordered.
+                           with("foo OR bar", {
+                                  :result_type=>"recent",
+                                  :since_id => 1,
+                                  :since_id_reply => 1
+                                })
 
     bot.search(["foo", "bar"])
   end
@@ -32,7 +36,13 @@ describe "Chatterbot::Search" do
     bot = test_bot
 
     allow(bot).to receive(:client).and_return(fake_search(100, 1))
-    expect(bot.client).to receive(:search).with("foo", {:lang => "en", :result_type=>"recent"})
+    expect(bot.client).to receive(:search).
+                           with("foo", {
+                                  :lang => "en",
+                                  :result_type=>"recent",
+                                  :since_id => 1,
+                                  :since_id_reply => 1
+                                })
 
     bot.search("foo", :lang => "en")
   end
@@ -41,7 +51,12 @@ describe "Chatterbot::Search" do
     bot = test_bot
 
     allow(bot).to receive(:client).and_return(fake_search(100, 1))
-    expect(bot.client).to receive(:search).with("foo", {:result_type=>"recent"})
+    expect(bot.client).to receive(:search).
+                           with("foo", {
+                                  :result_type=>"recent",
+                                  :since_id => 1,
+                                  :since_id_reply => 1
+                                })
 
     bot.search("foo")
   end
@@ -78,11 +93,11 @@ describe "Chatterbot::Search" do
     expect(indexes).to eq([100, 99, 98])
   end
 
-  it "checks blacklist" do
+  it "checks blocklist" do
     bot = test_bot
     allow(bot).to receive(:client).and_return(fake_search(100, 3))
     
-    allow(bot).to receive(:on_blacklist?).and_return(true, false)
+    allow(bot).to receive(:on_blocklist?).and_return(true, false)
     
     indexes = []
     bot.search("foo") do |x|
@@ -92,4 +107,48 @@ describe "Chatterbot::Search" do
     expect(indexes).to eq([99, 98])
   end
 
+
+  it "checks safelist" do
+    bot = test_bot
+    allow(bot).to receive(:client).and_return(fake_search(100, 3))
+    allow(bot).to receive(:has_safelist?).and_return(true)
+    allow(bot).to receive(:on_safelist?).and_return(true, false, false)
+
+    indexes = []
+    bot.search("foo") do |x|
+      indexes << x.attrs[:index]
+    end
+
+    expect(indexes).to eq([100])
+  end
+
+  
+  it "skips retweets" do
+    bot = test_bot
+    bot.exclude_retweets
+    allow(bot).to receive(:client).and_return(fake_search(100, 3))
+    allow_any_instance_of(Twitter::Tweet).to receive(:retweeted_status?) do |t|
+      (t.id % 2) == 0
+    end
+    
+    indexes = []
+    bot.search("foo") do |x|
+      indexes << x.attrs[:index]
+    end
+
+    expect(indexes).to eq([99])
+  end
+
+  it "includes retweets" do
+    bot = test_bot
+    bot.include_retweets
+    allow(bot).to receive(:client).and_return(fake_search(100, 3))
+    indexes = []
+    bot.search("foo") do |x|
+      indexes << x.attrs[:index]
+    end
+
+    expect(indexes).to eq([100, 99, 98])
+  end
+  
 end

data/spec/spec_helper.rb

@@ -19,14 +19,19 @@ RSpec.configure do |config|
     # cause any verifying double instantiation for a class that does not
     # exist to raise, protecting against incorrectly spelt names.
     mocks.verify_doubled_constant_names = true
+  end
 
+  config.after(:each) do
+    config_file = File.join(File.dirname($0), "#{File.basename($0, ".*")}.yml")
+    if File.exist?(config_file)
+      File.delete(config_file) rescue nil
+    end
   end
 end
 
 def test_bot
   bot = Chatterbot::Bot.new
   allow(bot).to receive(:load_config).and_return({})
-  allow(bot).to receive(:update_config_at_exit)
   bot.reset!
   bot
 end
@@ -54,6 +59,12 @@ def fake_replies(result_count = 0, id_base = 0)
   c
 end
 
+def fake_direct_messages(result_count = 0, id_base = 0)
+  c = stubbable_client
+  allow(c).to receive_messages(:direct_messages_received => 1.upto(result_count).collect { |i| fake_dm(i, id_base)})
+  c
+end
+
 def fake_home_timeline(result_count = 0, id_base = 0)
   c = stubbable_client
   allow(c).to receive_messages(:home_timeline => 1.upto(result_count).collect { |i| fake_tweet(i, id_base)})
@@ -79,6 +90,19 @@ def fake_tweet(index, id=0)
   Twitter::Tweet.new(x)
 end
 
+def fake_dm(index, id=0)
+  id = index if id <= 0
+  x = {
+    :from_user => "chatterbot",
+    :index => index,
+    :id => id,
+    :text => "I am a direct message",
+    :user => { :id => 1, :screen_name => "chatterbot" }
+  }
+
+  Twitter::DirectMessage.new(x)
+end
+
 def fake_follower(index=0)
   Twitter::User.new(:id => index, :name => "Follower #{index}",
                     :screen_name => "follower#{index}")

data/spec/streaming_spec.rb

@@ -1,66 +1,70 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-class StreamingHandler
-  attr_accessor :last_object
-end
-
 describe "Chatterbot::Streaming" do
   let(:bot) { test_bot }
   let(:user) { fake_user('user', 100) }
-  let(:handler) { StreamingHandler.new(test_bot) }
   let(:tweet) { fake_tweet(12345) }
 
-  def apply_to_handler(&block)
-    handler.apply block
-  end
 
-  describe "authenticated_user" do
-    it "should get user from client" do
-      expect(bot.client).to receive(:user).and_return('user')
-      expect(bot.authenticated_user).to eql('user')
+  describe "streaming_tweet_handler" do
+    before(:each) do
+      bot.skip_run = true
+      allow(bot.client).to receive(:user).and_return(user)
     end
-  end
 
-  describe "do_streaming" do
+    it "defaults to home_timeline" do
+      bot.register_handler(:home_timeline) { @result = :home_timeline }
+      bot.register_handler(:search, "foo") { @result = :search }
 
-  end
+      bot.handle_streaming_object(tweet)
+      expect(@result).to eql(:home_timeline)
+    end
+
+    it "will return search" do
+      bot.register_handler(:search, "foo") { @result = :search }
 
+      bot.handle_streaming_object(tweet)
+      expect(@result).to eql(:search)
+    end
+  end
+  
   describe "handle_streaming_object" do
     before(:each) {
+      bot.skip_run = true
       allow(bot.client).to receive(:user).and_return(user)
     }
 
     describe "Twitter::Tweet" do
       it "works if no handler" do
-        bot.handle_streaming_object(tweet, handler)
+        bot.handle_streaming_object(tweet)
       end
 
       context "with handler" do
         before(:each) do
-          apply_to_handler { replies { |t| @last_object = t } }
+          bot.register_handler(:home_timeline) { |t| @last_object = t }
         end
 
         it "ignores tweets from authenticated user" do
           expect(tweet).to receive(:user).and_return(user)
-          bot.handle_streaming_object(tweet, handler)
-          expect(handler.last_object).to be_nil
+          bot.handle_streaming_object(tweet)
+          expect(@last_object).to be_nil
         end
         
         it "passes to handler" do
-          bot.handle_streaming_object(tweet, handler)
-          expect(handler.last_object).to eql(tweet)
+          bot.handle_streaming_object(tweet)
+          expect(@last_object).to eql(tweet)
         end
 
-        it "ignores tweets from blacklist" do
-          bot.blacklist = ['chatterbot']
-          bot.handle_streaming_object(tweet, handler)
-          expect(handler.last_object).to be_nil
+        it "ignores tweets from blocklist" do
+          bot.blocklist = ['chatterbot']
+          bot.handle_streaming_object(tweet)
+          expect(@last_object).to be_nil
         end
 
         it "ignores tweets if skip_me is true" do
           bot.exclude = ['tweet']
-          bot.handle_streaming_object(tweet, handler)
-          expect(handler.last_object).to be_nil         
+          bot.handle_streaming_object(tweet)
+          expect(@last_object).to be_nil         
         end
       end
     end
@@ -68,28 +72,28 @@ describe "Chatterbot::Streaming" do
     describe "Twitter::Streaming::DeletedTweet" do
       it "works if no handler" do
         obj = Twitter::Streaming::DeletedTweet.new(:id => 1)
-        bot.handle_streaming_object(obj, handler)
+        bot.handle_streaming_object(obj)
       end
 
       it "passes to handler" do
-        apply_to_handler { delete { |t| @last_object = t } }
+        bot.register_handler(:deleted) { |t| @last_object = t }
         obj = Twitter::Streaming::DeletedTweet.new(:id => 1)
-        bot.handle_streaming_object(obj, handler)
-        expect(handler.last_object).to eql(obj)
+        bot.handle_streaming_object(obj)
+        expect(@last_object).to eql(obj)
       end
     end
 
     describe "Twitter::DirectMessage" do
       it "works if no handler" do
         obj = Twitter::DirectMessage.new(:id => 1)
-        bot.handle_streaming_object(obj, handler)
+        bot.handle_streaming_object(obj)
       end
 
       it "passes to handler" do
-        apply_to_handler { direct_message { |t| @last_object = t } }
+        bot.register_handler(:direct_messages) { |t| @last_object = t }
         obj = Twitter::DirectMessage.new(:id => 1)
-        bot.handle_streaming_object(obj, handler)
-        expect(handler.last_object).to eql(obj)
+        bot.handle_streaming_object(obj)
+        expect(@last_object).to eql(obj)
       end
     end
 
@@ -100,9 +104,10 @@ describe "Chatterbot::Streaming" do
                                                :source => {:id => user.id, :name => 'name', :screen_name => 'name'},
                                                :target => {:id => user.id, :name => 'name', :screen_name => 'name'})
 
-        apply_to_handler { followed { |t| @last_object = t } }
-        bot.handle_streaming_object(event, handler)
-        expect(handler.last_object).to be_nil
+        bot.register_handler(:followed) { |t| @last_object = t }
+
+        bot.handle_streaming_object(event)
+        expect(@last_object).to be_nil
       end
 
       describe "follow" do
@@ -115,15 +120,15 @@ describe "Chatterbot::Streaming" do
         end
 
         it "works if no handler" do
-          bot.handle_streaming_object(@event, handler)
-          expect(handler.last_object).to be_nil
+          bot.handle_streaming_object(@event)
+          expect(@last_object).to be_nil
         end
 
         it "passes to handler" do
-          apply_to_handler { followed { |t| @last_object = t } }
-          bot.handle_streaming_object(@event, handler)
-          expect(handler.last_object.class).to be(Twitter::User)
-          expect(handler.last_object.id).to be(12345)
+          bot.register_handler(:followed) { |t| @last_object = t }
+          bot.handle_streaming_object(@event)
+          expect(@last_object.class).to be(Twitter::User)
+          expect(@last_object.id).to be(12345)
         end
       end
 
@@ -142,15 +147,15 @@ describe "Chatterbot::Streaming" do
         end
 
         it "works if no handler" do
-          bot.handle_streaming_object(@event, handler)
-          expect(handler.last_object).to be_nil
+          bot.handle_streaming_object(@event)
+          expect(@last_object).to be_nil
          end
 
         it "passes to handler" do
-          apply_to_handler { favorited { |_, t| @last_object = t } }
-          bot.handle_streaming_object(@event, handler)
-          expect(handler.last_object.class).to be(Twitter::Tweet)
-          expect(handler.last_object.text).to eq("I am a tweet!")
+          bot.register_handler(:favorited) { |_, t| @last_object = t }
+          bot.handle_streaming_object(@event)
+          expect(@last_object.class).to be(Twitter::Tweet)
+          expect(@last_object.text).to eq("I am a tweet!")
         end
       end
     end
@@ -158,14 +163,7 @@ describe "Chatterbot::Streaming" do
     describe "Twitter::Streaming::FriendList" do
       it "works if no handler" do
         obj = Twitter::Streaming::FriendList.new
-        bot.handle_streaming_object(obj, handler)
-      end
-
-      it "passes to handler" do
-        apply_to_handler { friends { |t| @last_object = t } }
-        obj = Twitter::Streaming::FriendList.new
-        bot.handle_streaming_object(obj, handler)
-        expect(handler.last_object).to eql(obj)
+        bot.handle_streaming_object(obj)
       end
     end
   end

data/spec/whitelist_spec.rb

@@ -1,30 +1,30 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Chatterbot::Whitelist" do
-  describe "on_whitelist?" do
+describe "Chatterbot::Safelist" do
+  describe "on_safelist?" do
     before(:each) do
       @bot = test_bot
-      @bot.whitelist = [fake_user('user', 100), "skippy", "blippy", "dippy"]
+      @bot.safelist = [fake_user('user', 100), "skippy", "blippy", "dippy"]
     end
 
     it "includes users we want" do
-      expect(@bot.on_whitelist?("user")).to eq(true)
-      expect(@bot.on_whitelist?("skippy")).to eq(true)
+      expect(@bot.on_safelist?("user")).to eq(true)
+      expect(@bot.on_safelist?("skippy")).to eq(true)
     end
 
     it "excludes users we don't want" do
-      expect(@bot.on_whitelist?("flippy")).to eq(false)
+      expect(@bot.on_safelist?("flippy")).to eq(false)
     end
 
     it "isn't case-specific" do
-      expect(@bot.on_whitelist?("FLIPPY")).to eq(false)
-      expect(@bot.on_whitelist?("SKIPPY")).to eq(true)
+      expect(@bot.on_safelist?("FLIPPY")).to eq(false)
+      expect(@bot.on_safelist?("SKIPPY")).to eq(true)
     end
 
     it "works with result hashes" do
-      expect(@bot.on_whitelist?(Twitter::Tweet.new(:id => 1,
+      expect(@bot.on_safelist?(Twitter::Tweet.new(:id => 1,
                                             :user => {:id => 1, :screen_name => "skippy"}))).to eq(true)
-      expect(@bot.on_whitelist?(Twitter::Tweet.new(:id => 1,
+      expect(@bot.on_safelist?(Twitter::Tweet.new(:id => 1,
                                             :user => {:id => 1, :screen_name => "flippy"}))).to eq(false)
     end   
   end

data/specs.watchr

@@ -31,11 +31,9 @@ end
 # --------------------------------------------------
 # Watchr Rules
 # --------------------------------------------------
-watch('^spec/(.*)_spec\.rb') { |m| run_spec_matching(m[1]) }
-#watch('^spec/controllers/(.*)_spec\.rb') { |m| run_spec_matching(m[1]) }
-
+watch('^spec/(.*)_spec\.rb') { |m| puts m.inspect; run_spec_matching(m[1]) }
 watch("^lib/chatterbot/(.*)\.rb") { |m| run_spec_matching(m[1]) }
-#watch('^spec/spec_helper\.rb') { run_all_specs }
+watch('^spec/spec_helper\.rb') { run_all_specs }
 
 # --------------------------------------------------
 # Signal Handling

data/templates/skeleton.txt

@@ -8,30 +8,166 @@ require 'chatterbot/dsl'
 # generated on %{timestamp}
 #
 
-consumer_key '%{consumer_key}'
-consumer_secret '%{consumer_secret}'
+#
+# Hello! This is some starter code for your bot. You will need to keep
+# this file and %{name}.yml together to run your bot. The .yml file
+# will hold your authentication credentials and help track certain
+# information about what tweets the bot has seen so far.
+#
+# The code here is a basic starting point for a bot. It shows you the
+# different methods you can use to get tweets, send tweets, etc. It
+# also has a few settings/directives which you will want to read
+# about, and comment or uncomment as you see fit.
+#
+
+
+#
+# Placing your security credentials right in a script like this is
+# handy, but potentially dangerous, especially if your code is
+# publicly available on github or somewhere else. However, if it is
+# convenient for you to have your authentication data here, you can
+# uncomment the lines below, and copy your configuration data from
+# %{name}.yml into the commands.
+#
+# consumer_key 'consumer_key'
+# consumer_secret 'consumer_secret'
+#
+# secret 'secret'
+# token 'token'
 
-secret '%{secret}'
-token '%{token}'
 
-# remove this to send out tweets
+# Enabling **debug_mode** prevents the bot from actually sending
+# tweets. Keep this active while you are developing your bot. Once you
+# are ready to send out tweets, you can remove this line.
 debug_mode
 
-# remove this to update the db
+# Chatterbot will keep track of the most recent tweets your bot has
+# handled so you don't need to worry about that yourself. While
+# testing, you can use the **no_update** directive to prevent
+# chatterbot from updating those values. This directive can also be
+# handy if you are doing something advanced where you want to track
+# which tweet you saw last on your own.
 no_update
-# remove this to get less output when running
+
+# remove this to get less output when running your bot
 verbose
 
-# here's a list of users to ignore
-blacklist "abc", "def"
+# The blocklist is a list of users that your bot will never interact
+# with. Chatterbot will discard any tweets involving these users.
+# Simply add their twitter handle to this list.
+blocklist "abc", "def"
+
+# If you want to be even more restrictive, you can specify a
+# 'safelist' of accounts which your bot will *only* interact with. If
+# you uncomment this line, Chatterbot will discard any incoming tweets
+# from a user that is not on this list.
+# safelist "foo", "bar"
 
-# here's a list of things to exclude from searches
+# Here's a list of words to exclude from searches. Use this list to
+# add words which your bot should ignore for whatever reason.
 exclude "hi", "spammer", "junk"
 
-search "keyword" do |tweet|
- reply "Hey #USER# nice to meet you!", tweet
+# Exclude a list of offensive, vulgar, 'bad' words. This list is
+# populated from Darius Kazemi's wordfilter module
+# @see https://github.com/dariusk/wordfilter
+exclude bad_words
+
+# This will restrict your bot to tweets that come from accounts that
+# are following your bot. A tweet from an account that isn't following
+# will be rejected
+only_interact_with_followers
+
+#
+# Specifying 'streaming true' will cause Chatterbot to use Twitter's
+# Streaming API. Your bot will run constantly, listening for tweets.
+# Alternatively, you can run your bot as a cron/scheduled job. In that
+# case, do not use this line. Every time you run your bot, it will
+# execute once, and then exit.
+#
+streaming true
+
+#
+# Here's the fun stuff!
+#
+
+# Searches: You can do all sorts of stuff with searches on Twitter.
+# However, please note, interacting with users who don't follow your
+# bot is very possibly:
+#  - rude
+#  - uncool
+#  - likely to get your bot suspended
+#
+# Still here? Hopefully it's because you're going to do something cool
+# with the data that doesn't bother other people. Hooray!
+#
+search "chatterbot" do |tweet|
+  # here's the content of a tweet
+  puts tweets.text
 end
 
+#
+# this block responds to mentions of your bot
+#
 replies do |tweet|
+  # Any time you put the #USER# token in a tweet, Chatterbot will
+  # replace it with the handle of the user you are interacting with
   reply "Yes #USER#, you are very kind to say that!", tweet
 end
+
+#
+# this block handles incoming Direct Messages. if you want to do
+# something with DMs, go for it!
+# 
+# direct_messages do |dm|
+#  puts "DM received: #{dm.text}"
+#  direct_message "HELLO, I GOT YOUR MESSAGE", dm.sender
+# end
+
+#
+# Use this block to get tweets that appear on your bot's home timeline
+# (ie, if you were visiting twitter.com) -- using this block might
+# require a little extra work but can be very handy
+#
+# home_timeline do |tweet|
+#  puts tweet.inspect
+# end
+
+#
+# Use this block if you want to be notified about new followers of
+# your bot. You might do this to follow the user back.
+#
+# NOTE: This block only works with the Streaming API. If you use it,
+# chatterbot will assume you want to use streaming and will
+# automatically activate it for you.
+#
+# followed do |user|
+#  puts user.inspect
+# end
+
+#
+# Use this block if you want to be notified when one of your tweets is
+# favorited. The object passed in will be a Twitter::Streaming::Event
+# @see http://www.rubydoc.info/gems/twitter/Twitter/Streaming/Event
+#
+# NOTE: This block only works with the Streaming API. If you use it,
+# chatterbot will assume you want to use streaming and will
+# automatically activate it for you.
+#
+# favorited do |event|
+#  puts event.inspect
+# end
+
+#
+# Use this block if you want to be notified of deleted tweets from
+# your bots home timeline. The object passed in will be a
+# Twitter::Streaming::DeletedTweet
+# @see http://www.rubydoc.info/gems/twitter/Twitter/Streaming/DeletedTweet
+#
+# NOTE: This block only works with the Streaming API. If you use it,
+# chatterbot will assume you want to use streaming and will
+# automatically activate it for you.
+#
+#deleted do |tweet|
+#
+#end
+