chatterbot 1.0.2 → 2.0.0.pre

data/lib/chatterbot/streaming_handler.rb

@@ -1,96 +0,0 @@
-
-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/whitelist.rb

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

data/spec/blacklist_spec.rb

@@ -1,116 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Chatterbot::Blacklist" do
-  it "has a list of excluded phrases" do
-    @bot = test_bot
-    @bot.exclude = ["junk", "i hate bots", "foobar", "spam"]
-    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.exclude = ["junk", "i hate bots", "foobar", "spam"]
-    end
-
-    it "blocks tweets with phrases we don't want" do
-      expect(@bot.skip_me?("did you know that i hate bots?")).to eq(true)
-    end
-
-    it "isn't case-specific" do
-      expect(@bot.skip_me?("DID YOU KNOW THAT I HATE BOTS?")).to eq(true)
-    end
-
-    it "allows users we do want" do
-      expect(@bot.skip_me?("a tweet without any bad content")).to eq(false)
-    end
-
-    it "works with result hashes" do
-      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.blacklist = ["skippy", "blippy", "dippy"]
-    end
-
-    it "blocks users we don't want" do
-      expect(@bot.on_blacklist?("skippy")).to eq(true)
-    end
-
-    it "allows users we do want" do
-      expect(@bot.on_blacklist?("flippy")).to eq(false)
-    end
-
-    it "isn't case-specific" do
-      expect(@bot.on_blacklist?("FLIPPY")).to eq(false)
-      expect(@bot.on_blacklist?("SKIPPY")).to eq(true)
-    end
-
-    it "works with result hashes" do
-      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
-
-  describe "on_global_blacklist?" do
-    before(:each) do
-      @bot = test_bot
-    end
-
-    it "doesn't freak out if no db" do
-      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
-      allow(@bot).to receive(:has_db?).and_return(true)
-      blacklist_table = double(Object)
-      double_dataset = double(Object, {:count => 1})
-      expect(blacklist_table).to receive(:where).
-        with({ :user => "a"}).
-        and_return( double_dataset )
-
-      
-      missing_dataset = double(Object, {:count => 0})
-      expect(blacklist_table).to receive(:where).
-        with({ :user => "b"}).
-        and_return( missing_dataset )
-      
-      allow(@bot).to receive(:db).and_return({ 
-                                   :blacklist => blacklist_table
-                                 })
-      expect(@bot.on_global_blacklist?("a")).to eq(true)
-      expect(@bot.on_global_blacklist?("b")).to eq(false)
-    end
-  end
-
-
-  describe "db interaction" do
-    before(:each) do
-#      @db_tmp = Tempfile.new("blacklist.db")
-      @db_uri = "sqlite:/"
-
-      @bot = Chatterbot::Bot.new    
-      @bot.config[:db_uri] = @db_uri
-      @bot.db
-    end
-
-    describe "add_to_blacklist" do
-      it "adds to the blacklist table" do      
-        @bot.add_to_blacklist("tester")
-      end
-
-      it "doesn't add a double entry" do
-        @bot.add_to_blacklist("tester")
-        @bot.add_to_blacklist("tester")      
-      end
-    end
-    
-  end
-end

data/spec/db_spec.rb

@@ -1,53 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-#require 'sequel'
-
-describe "Chatterbot::DB" do
-  before(:each) do
-    @db_uri = "sqlite:/tmp/chatterbot.db"
-    File.delete("/tmp/chatterbot.db") if File.exist?("/tmp/chatterbot.db")
-  end
-
-  context "prerequisites" do
-    describe "get_connection" do
-      it "should make sure sequel is actually installed" do
-        allow_any_instance_of(Chatterbot::Bot).to receive(:has_sequel?) { false }
-        @bot = Chatterbot::Bot.new
-        @bot.config[:db_uri] = @db_uri
-        expect(@bot).to receive(:display_db_config_notice)
-        @bot.db
-      end
-    end
-  end
-
-  context "db interactions" do
-    before(:each) do
-      @bot = Chatterbot::Bot.new
-      allow(@bot).to receive(:update_config_at_exit)
-      @bot.config[:db_uri] = @db_uri
-    end
-
-    after(:each) do
-      @bot.db.disconnect unless @bot.db.nil?
-    end
-  
-    describe "table creation" do
-      [:blacklist, :tweets, :config].each do |table|
-        it "should create table #{table}" do
-          @tmp_conn = @bot.db
-          expect(@tmp_conn.tables.include?(table)).to eq(true)
-        end
-      end      
-    end
-    
-    describe "store_database_config" do
-      it "doesn't fail" do
-        @bot = Chatterbot::Bot.new    
-        @bot.config[:db_uri] = @db_uri
-        
-        @bot.db
-        expect(@bot.store_database_config).to eq(true)
-      end
-    end
-  end
-end

data/spec/streaming_handler_spec.rb

@@ -1,78 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Chatterbot::StreamingHandler" do
-  let(:bot) { test_bot }
-  let(:handler) { StreamingHandler.new(test_bot) }
-
-  def apply_to_handler(&block)
-    handler.apply block
-  end
-
-  describe "endpoint" do
-    it "should default to :user" do
-      expect(handler.endpoint).to eql(:user)
-    end
-
-    it "should pull from opts" do
-      expect(StreamingHandler.new(test_bot, {:endpoint => :bar}).endpoint).to eql(:bar)
-    end
-  end
-  
-  it "should set search query" do
-    apply_to_handler { search 'foo' }
-    expect(handler.search_filter).to eql('foo')
-  end
-  
-  it "should set tweet_handler" do
-    apply_to_handler { replies {'bar'} }
-    expect(handler.tweet_handler.call).to eql('bar')
-  end
-
-  it "should set favorited_handler" do
-    apply_to_handler { favorited {'bar'} }
-    expect(handler.favorite_handler.call).to eql('bar')
-  end
-
-  it "should set dm_handler" do
-    apply_to_handler { direct_message {'bar'} }
-    expect(handler.dm_handler.call).to eql('bar')
-  end
-
-  it "should set follow_handler" do
-    apply_to_handler { followed {'bar'} }
-    expect(handler.follow_handler.call).to eql('bar')
-  end
-
-  it "should set delete_handler" do
-    apply_to_handler { delete {'bar'} }
-    expect(handler.delete_handler.call).to eql('bar')
-  end
-
-  it "should set friends_handler" do
-    apply_to_handler { friends {'bar'} }
-    expect(handler.friends_handler.call).to eql('bar')
-  end
-
-  it "should pull config from bot" do
-    expect(handler.bot).to receive(:config).and_return('config')
-    expect(handler.config).to eql('config')
-  end
-
-  it "limits to one main block type" do
-    apply_to_handler { replies {'bar'} }
-    expect{
-      apply_to_handler { replies {'bar'} }
-    }.to raise_error(RuntimeError)
-  end
-  
-  describe "connection_params" do
-    it "has defaults" do
-      expect(handler.connection_params[:stall_warnings]).to eql("false")
-    end
-
-    it "applies search filter" do
-      apply_to_handler { search 'foo' }
-      expect(handler.connection_params[:track]).to eql("foo")
-    end
-  end
-end