chatterbot 1.0.2 → 2.0.0.pre

data/lib/chatterbot/followers.rb

@@ -1,4 +1,8 @@
 module Chatterbot
+
+  #
+  # methods related to following other users
+  #
   module Followers
     
     #

data/lib/chatterbot/handler.rb

@@ -0,0 +1,29 @@
+module Chatterbot
+
+  #
+  # class for holding onto a block/arguments we will use when calling
+  # methods on the Twitter API
+  #
+  class Handler
+    attr_reader :opts
+    attr_reader :last_ran_at
+
+    def initialize(opts, &block)
+      if block_given?
+        @opts = *opts
+        @block = block
+      else
+        @opts = nil
+        @block = opts
+      end
+    end
+
+    #
+    # call the block with the specified arguments
+    #
+    def call(*args)
+      @last_ran_at = Time.now
+      @block.call(*args)
+    end
+  end
+end

data/lib/chatterbot/helpers.rb

@@ -3,6 +3,11 @@ module Chatterbot
   #
   # a bunch of helper routines for bots
   module Helpers
+
+    #
+    # Set the username of the bot. This is used when generating
+    # config/skeleton file during registration
+    #
     def botname=(b)
       @botname = b
     end
@@ -27,11 +32,9 @@ module Chatterbot
       when Twitter::Tweet
         s.user.screen_name
       when Twitter::User
-        s.screen_name
+        s.name
       when String
         s
-      else
-        s.has_key?(:from_user) ? s[:from_user] : s[:user][:screen_name]
       end
     end
 
@@ -59,5 +62,13 @@ module Chatterbot
       end
     end
 
+    #
+    # find the user of the current tweet/object we are dealing with
+    #
+    def current_user
+      return nil if @current_tweet.nil?
+      return @current_tweet.sender if @current_tweet.respond_to?(:sender)
+      return @current_tweet.user
+    end
   end
 end

data/lib/chatterbot/home_timeline.rb

@@ -5,24 +5,21 @@ module Chatterbot
   module HomeTimeline
 
     # handle the bots timeline
-    def home_timeline(opts={}, &block)
+    def home_timeline(*args, &block)
       return unless require_login
 
       debug "check for home_timeline tweets since #{since_id}"
 
       opts = {
-        :since_id => since_id,
+        :since_id => since_id_home_timeline,
         :count => 200
-      }.merge(opts)
-
+      }
       results = client.home_timeline(opts)
 
       @current_tweet = nil
       results.each { |s|
-        update_since_id(s)
-        if has_whitelist? && !on_whitelist?(s)
-          debug "skipping because user not on whitelist"
-        elsif block_given? && !on_blacklist?(s) && !skip_me?(s)
+        update_since_id_home_timeline(s)
+        if block_given? && valid_tweet?(s)
           @current_tweet = s
           yield s         
         end

data/lib/chatterbot/logging.rb

@@ -21,23 +21,6 @@ module Chatterbot
       debug s
     end
     
-    #
-    # log a tweet to the database
-    def log(txt, source=nil)
-      return unless log_tweets?
-
-      data = {:txt => txt, :bot => botname, :created_at => Time.now}
-
-      if source != nil
-        data = data.merge(:user => source.user.screen_name,
-                          :source_id => source.id,
-                          :source_tweet => source.text)
-      end
-
-      # populate the table
-      db[:tweets].insert(data)
-    end
-
 protected
     #
     # initialize a Logger object, writing to log_dest

data/lib/chatterbot/profile.rb

@@ -8,7 +8,6 @@ module Chatterbot
     #
     def profile_text(p=nil)
       return if require_login == false
-
       if p.nil?
         client.user.description
       else

data/lib/chatterbot/reply.rb

@@ -5,26 +5,21 @@ module Chatterbot
   module Reply
 
     # handle replies for the bot
-    def replies(&block)
+    def replies(*args, &block)
       return unless require_login
 
       debug "check for replies since #{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
+      opts = {
+        :since_id => since_id_reply,
+        :count => 200
+      }
 
       results = client.mentions_timeline(opts)
       @current_tweet = nil
       results.each { |s|
         update_since_id_reply(s)
-        if has_whitelist? && !on_whitelist?(s)
-          debug "skipping because user not on whitelist"
-        elsif block_given? && !on_blacklist?(s) && !skip_me?(s)
+        if block_given? && valid_tweet?(s)
           @current_tweet = s
           yield s         
         end

data/lib/chatterbot/retweet.rb

@@ -16,12 +16,8 @@ module Chatterbot
         return
       end
       #:nocov:
-
-      begin
-        client.retweet id
-      rescue StandardError => e
-        puts e.inspect
-      end
+      
+      client.retweet id
     end
   end
 end

data/lib/chatterbot/safelist.rb

@@ -0,0 +1,33 @@
+module Chatterbot
+
+  #
+  # methods for only tweeting to users on a specific list
+  module Safelist
+    attr_accessor :safelist
+
+    alias :whitelist :safelist
+    
+    # A list of Twitter users that we can communicate with
+    def safelist
+      @safelist || []
+    end
+
+    def safelist=(b)
+      @safelist = b.flatten.collect { |e|
+        from_user(e).downcase
+      }
+      @safelist
+    end
+
+    def has_safelist?
+      !safelist.empty?
+    end
+
+    #
+    # Is this tweet from a user on our safelist?
+    def on_safelist?(s)
+      search = from_user(s).downcase
+      safelist.any? { |b| search.include?(b.downcase) }
+    end
+  end
+end

data/lib/chatterbot/search.rb

@@ -4,21 +4,30 @@ module Chatterbot
   # handle Twitter searches
   module Search
 
+    # set a reasonable limit on the maximum number of tweets we will
+    # ever return. otherwise it is possible to exceed Twitter's rate limits
     MAX_SEARCH_TWEETS = 1000
     
     @skip_retweets = true
     
     #
-    # modify a query string to exclude retweets from searches
+    # exclude retweets from searches
     #
     def exclude_retweets
       @skip_retweets = true
     end
 
+    #
+    # include retweets from searches
+    #
     def include_retweets
       @skip_retweets = false
     end
 
+
+    #
+    # check if this is a retweet that we want to skip
+    #
     def skippable_retweet?(t)
       @skip_retweets && t.retweeted_status?
     end
@@ -26,31 +35,32 @@ module Chatterbot
     # internal search code
     def search(queries, opts = {}, &block)
       debug "check for tweets since #{since_id}"
-
+      
       max_tweets = opts.delete(:limit) || MAX_SEARCH_TWEETS
       
       if queries.is_a?(String)
         queries = [queries]
       end
 
+      query = queries.join(" OR ")
+      
       #
       # search twitter
       #
-      queries.each { |query|
-        debug "search: #{query} #{default_opts.merge(opts)}"
-        @current_tweet = nil
-        client.search( query, default_opts.merge(opts) ).take(max_tweets).each { |s|
-          update_since_id(s)
-          debug s.text
-          if has_whitelist? && !on_whitelist?(s)
-            debug "skipping because user not on whitelist"
-          elsif block_given? && !on_blacklist?(s) && !skip_me?(s) && !skippable_retweet?(s)
-            @current_tweet = s
-            yield s
-          end
-        }
-        @current_tweet = nil
+
+      debug "search: #{query} #{default_opts.merge(opts)}"
+      @current_tweet = nil
+      client.search( query, default_opts.merge(opts) ).take(max_tweets).each { |s|
+        update_since_id(s)
+        debug s.text
+
+        if block_given? && valid_tweet?(s)
+          @current_tweet = s
+          yield s
+        end
       }
+      @current_tweet = nil
+
     end
   
   end

data/lib/chatterbot/skeleton.rb

@@ -4,10 +4,15 @@ module Chatterbot
   # bot template generator
   class Skeleton
     class << self
+
+      #
+      # generate a template file for the specified bot
+      # @param [Bot] bot object
+      #
       def generate(bot)
         path = File.join(Chatterbot.libdir, "..", "templates", "skeleton.txt")
         src = File.read(path)
-        puts bot.config.inspect
+
         opts = bot.config.merge({
           :name => bot.botname,
           :timestamp => Time.now
@@ -15,44 +20,8 @@ module Chatterbot
 
         puts opts.inspect
         
-        if RUBY_VERSION =~ /^1\.8\./
-          #:nocov:
-          apply_vars(src, opts)
-          #:nocov:
-
-        else
-          src % opts
-        end
-      end
-
-      #
-      # 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}"
-                                             /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
-                                             )
-        
-        pattern_with_escape = Regexp.union(
-                                                         /%%/,
-                                                         pattern
-                                                         )
-        
-        s.gsub(pattern_with_escape) do |match|
-          if match == '%%'
-            '%'
-          else
-            key = ($1 || $2).to_sym
-            raise KeyError unless args.has_key?(key)
-            $3 ? sprintf("%#{$3}", args[key]) : args[key]
-          end
-        end
+        src % opts
       end
-      #:nocov:
-
     end
   end
 end

data/lib/chatterbot/streaming.rb

@@ -4,64 +4,57 @@ module Chatterbot
   # simple twitter stream handler
   module Streaming
 
-    def authenticated_user
-      @user ||= client.user
+    def streaming_tweet_handler
+      usable_handlers = [:home_timeline, :search]
+      name, block = @handlers.find { |k, v| usable_handlers.include?(k) }
+      block
     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)
+    # 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 streamer.tweet_handler && !on_blacklist?(object) && !skip_me?(object)
+        elsif (h = streaming_tweet_handler) && valid_tweet?(object)
           @current_tweet = object
-          streamer.tweet_handler.call object
+          update_since_id(object)
+
+          h.call(object)
           @current_tweet = nil
         end
       when Twitter::Streaming::DeletedTweet
-        if streamer.delete_handler
-          streamer.delete_handler.call(object)
+        if (h = @handlers[:deleted])
+          h.call(object)
         end
       when Twitter::DirectMessage
-        if streamer.dm_handler # && !on_blacklist?(object) && !skip_me?(object)
+        if object.sender == authenticated_user
+          debug "skipping DM #{object} because it's from me"
+        elsif (h = @handlers[:direct_messages])
           @current_tweet = object
-          streamer.dm_handler.call 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 && 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)
+        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"
-        if streamer.friends_handler
-          streamer.friends_handler.call(object)
-        end
       end
     end
-  end
+
+  end   
 end