chatterbot 0.7.1 → 0.9.0

data/lib/chatterbot/favorite.rb

@@ -0,0 +1,23 @@
+module Chatterbot
+
+  # routines for favorites
+  module Favorite
+
+    # simple wrapper for favoriting a message
+    # @param [id] id A tweet or the ID of a tweet. if not specified,
+    # tries to use the current tweet if available
+    def favorite(id=@current_tweet)
+      return if require_login == false
+
+      id = id_from_tweet(id)
+      
+      #:nocov:
+      if debug_mode?
+        debug "I'm in debug mode, otherwise I would favorite tweet id: #{id}"
+        return
+      end
+      #:nocov:
+      client.favorite id
+    end
+  end
+end

data/lib/chatterbot/followers.rb

@@ -9,5 +9,14 @@ module Chatterbot
       return unless require_login
       client.followers(opts).to_a
     end
+
+    #
+    # follow a user
+    #
+    # @param u a Twitter::User or user id
+    def follow(u)
+      return unless require_login
+      client.follow(u)
+    end
   end
 end

data/lib/chatterbot/helpers.rb

@@ -25,7 +25,9 @@ module Chatterbot
     def from_user(s)
       case s
       when Twitter::Tweet
-        s.from_user
+        s.user.screen_name
+      when Twitter::User
+        s.screen_name
       when String
         s
       else

data/lib/chatterbot/logging.rb

@@ -27,10 +27,11 @@ module Chatterbot
       return unless log_tweets?
 
       data = {:txt => txt, :bot => botname, :created_at => Time.now}
+
       if source != nil
-        data = data.merge(:user => source[:from_user],
-                          :source_id => source[:id],
-                          :source_tweet => source[:text])
+        data = data.merge(:user => source.user.screen_name,
+                          :source_id => source.id,
+                          :source_tweet => source.text)
       end
 
       # populate the table

data/lib/chatterbot/profile.rb

@@ -0,0 +1,40 @@
+module Chatterbot
+
+  # routines for managing your profile
+  module Profile
+
+    #
+    # get/set the profile description
+    #
+    def profile_text(p=nil)
+      return if require_login == false
+
+      if p.nil?
+        client.user.description
+      else
+        data = {
+          description: p
+        }
+        client.update_profile(data)
+        p
+      end
+    end
+
+    #
+    # get/set the profile URL
+    #
+    def profile_website(w=nil)
+      return if require_login == false
+
+      if w.nil?
+        client.user.website
+      else
+        data = {
+          url: w
+        }
+        client.update_profile(data)
+        w
+      end
+    end
+  end
+end

data/lib/chatterbot/reply.rb

@@ -10,16 +10,24 @@ module Chatterbot
 
       debug "check for replies since #{since_id_reply}"
 
-      opts = since_id_reply > 0 ? {:since_id => since_id_reply} : {}
+      opts = {}
+      if since_id_reply > 0
+        opts[:since_id] = since_id_reply
+      elsif since_id > 0
+        opts[:since_id] = since_id
+      end
       opts[:count] = 200
 
-      results = client.mentions(opts)
+      results = client.mentions_timeline(opts)
+      @current_tweet = nil
       results.each { |s|
         update_since_id_reply(s)
         unless ! block_given? || on_blacklist?(s) || skip_me?(s)
+          @current_tweet = s
           yield s         
         end
       }
+      @current_tweet = nil
     end
   end
 end

data/lib/chatterbot/retweet.rb

@@ -4,14 +4,20 @@ module Chatterbot
   module Retweet 
 
     # simple wrapper for retweeting a message
-    def retweet(id)
-      return if require_login == false
+    # @param [id] id A tweet or the ID of a tweet. if not specified,
+    # tries to use the current tweet if available
+    def retweet(id=@current_tweet)
+      return if require_login == false || id.nil?
 
+      id = id_from_tweet(id)
+      #:nocov:
       if debug_mode?
         debug "I'm in debug mode, otherwise I would retweet with tweet id: #{id}"
-      else
-        client.retweet id
+        return
       end
+      #:nocov:
+      
+      client.retweet id
     end
   end
 end

data/lib/chatterbot/search.rb

@@ -18,22 +18,28 @@ module Chatterbot
       if queries.is_a?(String)
         queries = [queries]
       end
+
       
       #
       # search twitter
       #
       queries.each { |query|
-        debug "search: #{query} #{opts.merge(default_opts)}"
-        result = search_client.search(
+        debug "search: #{query} #{default_opts.merge(opts)}"
+        result = client.search(
                                       exclude_retweets(query),
-                                      opts.merge(default_opts)
+                                      default_opts.merge(opts)
                                       )
-        update_since_id(result.max_id)
+        update_since_id(result)
 
-        result.collection.each { |s|
+        @current_tweet = nil
+        result.each { |s|
           debug s.text
-          yield s unless ! block_given? || on_blacklist?(s) || skip_me?(s)
+          if block_given? && !on_blacklist?(s) && !skip_me?(s)
+            @current_tweet = s
+            yield s
+          end
         }
+        @current_tweet = nil
       }
     end
   

data/lib/chatterbot/skeleton.rb

@@ -16,7 +16,10 @@ module Chatterbot
         puts opts.inspect
         
         if RUBY_VERSION =~ /^1\.8\./
+          #:nocov:
           apply_vars(src, opts)
+          #:nocov:
+
         else
           src % opts
         end
@@ -26,6 +29,7 @@ module Chatterbot
       # handle string interpolation in ruby 1.8. modified from
       # https://raw.github.com/svenfuchs/i18n/master/lib/i18n/core_ext/string/interpolate.rb
       #
+      #:nocov:
       def apply_vars(s, args)
         pattern = Regexp.union(
                                              /%\{(\w+)\}/,                               # matches placeholders like "%{foo}"
@@ -47,6 +51,8 @@ module Chatterbot
           end
         end
       end
+      #:nocov:
+
     end
   end
 end

data/lib/chatterbot/streaming.rb

@@ -0,0 +1,67 @@
+module Chatterbot
+
+  #
+  # simple twitter stream handler
+  module Streaming
+
+    def authenticated_user
+      @user ||= client.user
+    end
+    
+    # Streams messages for a single user, optionally including an
+    # additional search/etc
+    #
+    # @param opts [Hash] options
+    # @option options [String] :with Specifies whether to return information for just the users specified in the follow parameter, or include messages from accounts they follow.
+    # @option options [String] :replies Specifies whether to return additional @replies.
+    # @option options [String] :stall_warnings Specifies whether stall warnings should be delivered.
+    # @option options [String] :track Includes additional Tweets matching the specified keywords. Phrases of keywords are specified by a comma-separated list.
+    # @option options [String] :locations Includes additional Tweets falling within the specified bounding boxes.
+    # @yield [Twitter::Tweet, Twitter::Streaming:
+    def do_streaming(streamer)
+      debug "streaming twitter client"
+      streaming_client.send(streamer.endpoint, streamer.connection_params) do |object|
+        handle_streaming_object(object, streamer)
+      end    
+    end
+
+    def handle_streaming_object(object, streamer)
+      debug object
+
+      case object
+      when Twitter::Tweet
+        if object.user == authenticated_user
+          puts "skipping #{object} because it's from me"
+        elsif streamer.tweet_handler && !on_blacklist?(object) && !skip_me?(object)
+          @current_tweet = object
+          streamer.tweet_handler.call object
+          @current_tweet = nil
+        end
+      when Twitter::Streaming::DeletedTweet
+        if streamer.delete_handler
+          streamer.delete_handler.call(object)
+        end
+      when Twitter::DirectMessage
+        if streamer.dm_handler # && !on_blacklist?(object) && !skip_me?(object)
+          @current_tweet = object
+          streamer.dm_handler.call object
+          @current_tweet = nil
+        end
+      when Twitter::Streaming::Event
+        if object.respond_to?(:source) && object.source == authenticated_user
+          puts "skipping #{object} because it's from me"
+        elsif object.name == :follow && streamer.follow_handler
+          streamer.follow_handler.call(object.source)
+        elsif object.name == :favorite && streamer.favorite_handler
+          streamer.favorite_handler.call(object.source, object.target_object)
+        end
+      when Twitter::Streaming::FriendList
+        debug "got friend list"
+        if streamer.friends_handler
+          streamer.friends_handler.call(object)
+        end
+      end
+    end
+  end
+end
+

data/lib/chatterbot/streaming_handler.rb

@@ -0,0 +1,96 @@
+
+class StreamingHandler
+  attr_reader :tweet_handler
+  attr_reader :favorite_handler
+  attr_reader :dm_handler
+  attr_reader :follow_handler
+  attr_reader :delete_handler
+  attr_reader :friends_handler
+  attr_reader :search_filter
+
+  attr_accessor :opts
+
+  def initialize(bot, opts = {})
+    @bot = bot
+    @opts = opts
+  end
+
+  def bot
+    @bot
+  end
+  
+  def config
+    bot.config
+  end
+
+  # filter, firehose, sample, user
+  def endpoint
+    opts[:endpoint] || :user
+  end
+  
+  def search(query, opts = {}, &block)
+    @search_filter = query
+    @search_opts = opts
+    apply_main_block(&block) if block_given?
+  end
+  
+  def user(&block)
+    apply_main_block(&block)
+  end
+  alias_method :replies, :user
+  alias_method :timeline, :user
+  alias_method :sample, :user
+  alias_method :filter, :user
+  
+  def favorited(&block)
+    @favorite_handler = block
+  end
+
+  def direct_message(&block)
+    @dm_handler = block
+  end
+  
+  def followed(&block)
+    @follow_handler = block
+  end
+
+  def delete(&block)
+    @delete_handler = block
+  end
+
+  def friends(&block)
+    @friends_handler = block
+  end
+  
+  def connection_params 
+    opts = {
+      #:with => 'followings',
+      #:replies => false,
+      :stall_warnings => false
+    }.merge(@opts)
+   
+    opts.delete(:endpoint)
+      
+    # convert true/false to strings
+    opts.each { |k, v| opts[k] = v.to_s }
+    
+    if @search_filter
+      opts[:track] = @search_filter
+    end
+
+    opts
+  end  
+
+  def apply_main_block(&block)
+    if !@tweet_handler.nil?
+      warn "WARNING: when using streaming, you may only have one block of user/replies/timeline/sample/filter"
+      raise RuntimeError, 'Unable to load bot'
+    end
+    @tweet_handler = block
+  end
+  
+  
+  def apply(block)
+    instance_exec &block
+  end
+end

data/lib/chatterbot/tweet.rb

@@ -17,8 +17,10 @@ module Chatterbot
         client.update txt, params
       end
     rescue Twitter::Error::Forbidden => e
+      #:nocov:
       debug e
       false
+      #:nocov:
     end
 
     # reply to a tweet

data/lib/chatterbot/ui.rb

@@ -9,6 +9,7 @@ module Chatterbot
     # print out a message about getting a PIN from twitter, then output
     # the URL the user needs to visit to authorize
     #
+    #:nocov:
     def get_oauth_verifier
       puts "****************************************"
       puts "****************************************"
@@ -91,6 +92,6 @@ module Chatterbot
     def display_oauth_error
       STDERR.puts "Oops!  Looks like something went wrong there, please try again!"
     end
-
   end
+  #:nocov:
 end

data/lib/chatterbot/utils.rb

@@ -0,0 +1,11 @@
+module Chatterbot
+  module Utils
+    def id_from_tweet(t)
+      t.is_a?(Twitter::Tweet) ? t.id : t
+    end
+
+    def id_from_user(u)
+      u.is_a?(Twitter::User) ? u.id : u
+    end
+  end
+end

data/lib/chatterbot/version.rb

@@ -1,3 +1,3 @@
 module Chatterbot
-  VERSION = "0.7.1"
+  VERSION = "0.9.0"
 end

data/spec/blacklist_spec.rb

@@ -4,56 +4,57 @@ describe "Chatterbot::Blacklist" do
   it "has a list of excluded phrases" do
     @bot = test_bot
     @bot.exclude = ["junk", "i hate bots", "foobar", "spam"]
-    @bot.skip_me?("did you know that i hate bots?").should == true
+    expect(@bot.skip_me?("did you know that i hate bots?")).to eq(true)
   end
 
   describe "skip_me?" do
     before(:each) do
       @bot = test_bot
-      @bot.stub(:exclude).and_return(["junk", "i hate bots", "foobar", "spam"])
+      allow(@bot).to receive(:exclude).and_return(["junk", "i hate bots", "foobar", "spam"])
     end
 
     it "blocks tweets with phrases we don't want" do
-      @bot.skip_me?("did you know that i hate bots?").should == true
+      expect(@bot.skip_me?("did you know that i hate bots?")).to eq(true)
     end
 
     it "isn't case-specific" do
-      @bot.skip_me?("DID YOU KNOW THAT I HATE BOTS?").should == true
+      expect(@bot.skip_me?("DID YOU KNOW THAT I HATE BOTS?")).to eq(true)
     end
 
-
     it "allows users we do want" do
-      @bot.skip_me?("a tweet without any bad content").should == false
+      expect(@bot.skip_me?("a tweet without any bad content")).to eq(false)
     end
 
     it "works with result hashes" do
-      @bot.skip_me?(Twitter::Tweet.new(:id => 1, :text => "did you know that i hate bots?")).should == true
-      @bot.skip_me?(Twitter::Tweet.new(:id => 1, :text => "a tweet without any bad content")).should == false
+      expect(@bot.skip_me?(Twitter::Tweet.new(:id => 1, :text => "did you know that i hate bots?"))).to eq(true)
+      expect(@bot.skip_me?(Twitter::Tweet.new(:id => 1, :text => "a tweet without any bad content"))).to eq(false)
     end
   end
 
   describe "on_blacklist?" do
     before(:each) do
       @bot = test_bot
-      @bot.stub(:blacklist).and_return(["skippy", "blippy", "dippy"])
+      allow(@bot).to receive(:blacklist).and_return(["skippy", "blippy", "dippy"])
     end
 
     it "blocks users we don't want" do
-      @bot.on_blacklist?("skippy").should == true
+      expect(@bot.on_blacklist?("skippy")).to eq(true)
     end
 
     it "allows users we do want" do
-      @bot.on_blacklist?("flippy").should == false
+      expect(@bot.on_blacklist?("flippy")).to eq(false)
     end
 
     it "isn't case-specific" do
-      @bot.on_blacklist?("FLIPPY").should == false
-      @bot.on_blacklist?("SKIPPY").should == true
+      expect(@bot.on_blacklist?("FLIPPY")).to eq(false)
+      expect(@bot.on_blacklist?("SKIPPY")).to eq(true)
     end
 
     it "works with result hashes" do
-      @bot.on_blacklist?(Twitter::Tweet.new(:id => 1, :from_user => "skippy")).should == true
-      @bot.on_blacklist?(Twitter::Tweet.new(:id => 1, :from_user => "flippy")).should == false
+      expect(@bot.on_blacklist?(Twitter::Tweet.new(:id => 1,
+                                            :user => {:id => 1, :screen_name => "skippy"}))).to eq(true)
+      expect(@bot.on_blacklist?(Twitter::Tweet.new(:id => 1,
+                                            :user => {:id => 1, :screen_name => "flippy"}))).to eq(false)
     end   
   end
 
@@ -63,29 +64,29 @@ describe "Chatterbot::Blacklist" do
     end
 
     it "doesn't freak out if no db" do
-      @bot.should_receive(:has_db?).and_return(false)
-      @bot.on_global_blacklist?("foobar").should == false
+      expect(@bot).to receive(:has_db?).and_return(false)
+      expect(@bot.on_global_blacklist?("foobar")).to eq(false)
     end
 
     it "collects name from the db if it exists" do
-      @bot.stub(:has_db?).and_return(true)
+      allow(@bot).to receive(:has_db?).and_return(true)
       blacklist_table = double(Object)
       double_dataset = double(Object, {:count => 1})
-      blacklist_table.should_receive(:where).
+      expect(blacklist_table).to receive(:where).
         with({ :user => "a"}).
         and_return( double_dataset )
 
       
       missing_dataset = double(Object, {:count => 0})
-      blacklist_table.should_receive(:where).
+      expect(blacklist_table).to receive(:where).
         with({ :user => "b"}).
         and_return( missing_dataset )
       
-      @bot.stub(:db).and_return({ 
+      allow(@bot).to receive(:db).and_return({ 
                                    :blacklist => blacklist_table
                                  })
-      @bot.on_global_blacklist?("a").should == true
-      @bot.on_global_blacklist?("b").should == false
+      expect(@bot.on_global_blacklist?("a")).to eq(true)
+      expect(@bot.on_global_blacklist?("b")).to eq(false)
     end
   end