chatterbot 2.0.5 → 2.1.0

data/docs/streaming.md

@@ -1,98 +0,0 @@
----
-layout: page
-title: "Streaming API"
-category: doc
----
-
-Chatterbot has basic support for Twitter's [Streaming API](https://dev.twitter.com/streaming/overview). If
-you are an advanced developer, or want to create something very
-involved, it might make more sense to use a different library.
-However, if you do use Chatterbot, you can continue to use the DSL,
-and you get access to a bunch of helpful routines.
-
-Here's an example bot using the Streaming API:
-
-```
-#!/usr/bin/env ruby
-
-## This is a very simple working example of a bot using the streaming
-## API. It's basically a copy of echoes_bot.rb, just using streaming.
-
-#
-# require the dsl lib to include all the methods you see below.
-#
-require 'rubygems'
-require 'chatterbot/dsl'
-
-consumer_secret 'foo'
-secret 'bar'
-token 'biz'
-consumer_key 'bam'
-
-
-puts "Loading echoes_bot.rb using the streaming API"
-
-exclude "http://", "https://"
-
-blacklist "mean_user, private_user"
-
-streaming do
-  favorited do |user, tweet|
-    reply "@#{user.screen_name} thanks for the fave!", tweet
-  end
-
-  followed do |user|
-    tweet "@#{user.screen_name} just followed me!"
-    follow user
-  end
-
-  replies do |tweet|
-    favorite tweet
-
-    puts "It's a tweet!"
-    src = tweet.text.gsub(/@echoes_bot/, "#USER#")  
-    reply src, tweet
-  end
-end
-```
-
-By default, chatterbot will use the
-[user endpoint](https://dev.twitter.com/streaming/userstreams), which
-returns events for the bot -- mentions, follows, etc. If you want to
-perform a search, or use the sample endpoint, you will need to specify
-that:
-
-
-```
-#
-# sample the twitter stream
-#
-streaming(endpoint:"sample") do
-    sample do |tweet|
-      puts tweet.text
-    end
-end
-```
-
-
-```
-#
-# run a search
-#
-streaming(endpoint:"search") do
-    search("Streaming API") do |tweet|
-      puts tweet.text
-    end
-end
-```
-
-```
-#
-# find geocoded tweets
-#
-streaming(endpoint: :filter, locations:"-180,-90,180,90") do
-    user do |tweet|
-      puts tweet.text
-    end
-end
-```

data/examples/streaming_bot.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-
-## This is a very simple working example of a bot using the streaming
-## API. It's basically a copy of echoes_bot.rb, just using streaming.
-
-#
-# require the dsl lib to include all the methods you see below.
-#
-require 'rubygems'
-require 'chatterbot/dsl'
-
-consumer_secret 'foo'
-secret 'bar'
-token 'biz'
-consumer_key 'bam'
-
-
-puts "Loading echoes_bot.rb using the streaming API"
-
-exclude "http://", "https://"
-
-blocklist "mean_user, private_user"
-
-use_streaming
-
-replies do |tweet|
-  favorite tweet
-
-  puts "It's a tweet!"
-  src = tweet.text.gsub(/@echoes_bot/, "#USER#")  
-  reply src, tweet
-end
-
-direct_messages do |tweet|
-  puts "well, here i am #{tweet.text}"
-  puts tweet.inspect
-  direct_message "got it", tweet.sender
-end
-
-favorited do |user, tweet|
-  reply "@#{user.screen_name} thanks for the fave!", tweet
-end
-
-followed do |user|
-  tweet "@#{user.screen_name} just followed me!"
-  follow user
-end
-
-

data/lib/chatterbot/streaming.rb

@@ -1,72 +0,0 @@
-module Chatterbot
-
-  #
-  # simple twitter stream handler
-  module Streaming
-
-    def streaming_tweet_handler
-      usable_handlers = [:home_timeline, :search]
-      name, block = @handlers.find { |k, v| usable_handlers.include?(k) }
-
-       if block.nil? && ( block = @handlers[:replies] )
-         debug "No default handler, wrapping the replies handler"
-         return Proc.new { |tweet|
-           if tweet.text =~ /^@#{bot.screen_name}/i
-             block.call(tweet)
-           end
-         }
-       end
-
-       block
-    end
-    
-    #
-    # Take the passed in object and call the appropriate bot method
-    # for it
-    # @param [Class] object a streaming API object
-    #
-    def handle_streaming_object(object)
-      debug object
-
-      case object
-      when Twitter::Tweet
-        if object.user == authenticated_user
-          debug "skipping #{object} because it's from me"
-        elsif (h = streaming_tweet_handler) && valid_tweet?(object)
-          @current_tweet = object
-          update_since_id(object)
-
-          h.call(object)
-          @current_tweet = nil
-        end
-      when Twitter::Streaming::DeletedTweet
-        if (h = @handlers[:deleted])
-          h.call(object)
-        end
-      when Twitter::DirectMessage
-        if object.sender == authenticated_user
-          debug "skipping DM #{object} because it's from me"
-        elsif (h = @handlers[:direct_messages])
-          @current_tweet = object
-          update_since_id_dm(object)
-          h.call(object)
-          @current_tweet = nil
-        end
-      when Twitter::Streaming::Event
-        if object.respond_to?(:source) && object.source == authenticated_user
-          debug "skipping #{object} because it's from me"
-        elsif object.name == :follow && (h = @handlers[:followed])
-          h.call(object.source)
-        elsif object.name == :favorite && (h = @handlers[:favorited])
-          h.call(object.source, object.target_object)
-        end
-      when Twitter::Streaming::FriendList
-        debug "got friend list"
-      when Twitter::Streaming::StallWarning
-        debug "***** STALL WARNING *****"
-      end
-    end
-
-  end   
-end
-

data/spec/streaming_spec.rb

@@ -1,172 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Chatterbot::Streaming" do
-  let(:bot) { test_bot }
-  let(:user) { fake_user('user', 100) }
-  let(:tweet) { fake_tweet(12345) }
-
-
-  describe "streaming_tweet_handler" do
-    before(:each) do
-      bot.skip_run = true
-      bot.streaming = true
-      allow(bot.client).to receive(:user).and_return(user)
-    end
-
-    it "defaults to home_timeline" do
-      bot.register_handler(:home_timeline) { @result = :home_timeline }
-      bot.register_handler(:search, "foo") { @result = :search }
-
-      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
-      bot.streaming = 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)
-      end
-
-      context "with handler" do
-        before(:each) do
-          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)
-          expect(@last_object).to be_nil
-        end
-        
-        it "passes to handler" do
-          bot.handle_streaming_object(tweet)
-          expect(@last_object).to eql(tweet)
-        end
-
-        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)
-          expect(@last_object).to be_nil         
-        end
-      end
-    end
-
-    describe "Twitter::Streaming::DeletedTweet" do
-      it "works if no handler" do
-        obj = Twitter::Streaming::DeletedTweet.new(:id => 1)
-        bot.handle_streaming_object(obj)
-      end
-
-      it "passes to handler" do
-        bot.register_handler(:deleted) { |t| @last_object = t }
-        obj = Twitter::Streaming::DeletedTweet.new(:id => 1)
-        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)
-      end
-
-      it "passes to handler" do
-        bot.register_handler(:direct_messages) { |t| @last_object = t }
-        obj = Twitter::DirectMessage.new(:id => 1)
-        bot.handle_streaming_object(obj)
-        expect(@last_object).to eql(obj)
-      end
-    end
-
-    describe "Twitter::Streaming::Event" do
-      it "ignores events generated by authenticated user" do
-        event = Twitter::Streaming::Event.new(
-                                               :event => :follow,
-                                               :source => {:id => user.id, :name => 'name', :screen_name => 'name'},
-                                               :target => {:id => user.id, :name => 'name', :screen_name => 'name'})
-
-        bot.register_handler(:followed) { |t| @last_object = t }
-
-        bot.handle_streaming_object(event)
-        expect(@last_object).to be_nil
-      end
-
-      describe "follow" do
-        before(:each) do
-          @event = Twitter::Streaming::Event.new(
-                                                :event => :follow,
-                                                :source => {:id => 12345, :name => 'name', :screen_name => 'name'},
-                                                :target => {:id => user.id, :name => 'name', :screen_name => 'name'})
-
-        end
-
-        it "works if no handler" do
-          bot.handle_streaming_object(@event)
-          expect(@last_object).to be_nil
-        end
-
-        it "passes to handler" do
-          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
-
-      describe "favorite" do
-        before(:each) do
-          @event = Twitter::Streaming::Event.new(
-                                                 :event => :favorite,
-                                                 :source => {:id => 12345, :name => 'name', :screen_name => 'name'},
-                                                 :target => {:id => user.id, :name => 'name', :screen_name => 'name'},
-                                                 :target_object => {
-                                                   :from_user => "chatterbot",
-                                                   :id => 56789,
-                                                   :text => "I am a tweet!",
-                                                   :user => { :id => 1, :screen_name => "chatterbot" }
-                                                 })
-        end
-
-        it "works if no handler" do
-          bot.handle_streaming_object(@event)
-          expect(@last_object).to be_nil
-         end
-
-        it "passes to handler" do
-          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
-
-    describe "Twitter::Streaming::FriendList" do
-      it "works if no handler" do
-        obj = Twitter::Streaming::FriendList.new
-        bot.handle_streaming_object(obj)
-      end
-    end
-  end
-end