twibot 0.1.2 → 0.1.3

data/Readme.rdoc

@@ -1,13 +1,13 @@
-=Twibot
+= Twibot
 Official URL: http://github.com/cjohansen/twibot/tree/master
 Christian Johansen (http://www.cjohansen.no)
 
-== DESCRIPTION
+== Description
 
 Twibot (pronounced like "Abbot"), is a Ruby microframework for creating Twitter
 bots, heavily inspired by Sinatra.
 
-== USAGE
+== Usage
 
 === Simple example
 
@@ -95,22 +95,21 @@ The DSL gives you access to your Twitter client instance through "client" (or "t
     twitter.status :post, "Hello world" # Also: client.status :post, "Hello world"
   end
 
-== REQUIREMENTS
+== Requirements
 
 Twitter4r. You'll need atleast 0.3.1, which is currently only available from GitHub.
 Versions of Twitter4r prior to 0.3.1 does not allow for the since_id parameter to be
 appended to URLs to the REST API. Twibot needs these to only fetch fresh messages
 and tweets.
 
-== INSTALLATION
+== Installation
 
 gem install twibot
 
 == Is it Ruby 1.9?
 
-Unfortunately no. Context, used for Twibots tests is not Ruby 1.9 compliant, which
-makes it hard to figure out which part is causing trouble. Will be fixed soon. Fork
-away if you want to help out!
+As of Twibot 0.1.3, yes it is! All tests pass, please give feedback from real world
+usage if you have trouble.
 
 == Polling
 
@@ -132,11 +131,11 @@ As long as Twibot finds any messages and/or tweets, the interval stays the same
 sleep is increased by interval_step configuration option. This happens until it
 reaches max_interval, where it will stay until Twibot finds anything.
 
-== CONTRIBUTORS
+== Contributors
 
- * Dan Van Derveer (bug fixes)
+ * Dan Van Derveer (bug fixes) - http://dan.van.derveer.com/
 
-== LICENSE
+== License
 
 (The MIT License)
 

data/lib/twibot.rb

@@ -7,7 +7,7 @@ require File.join(File.dirname(__FILE__), 'hash')
 module Twibot
 
   # :stopdoc:
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/test/test_bot.rb

@@ -2,19 +2,19 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unles
 require 'fileutils'
 
 class TestBot < Test::Unit::TestCase
-  test "should not raise errors when initialized" do
+  should "not raise errors when initialized" do
     assert_nothing_raised do
       Twibot::Bot.new Twibot::Config.new
     end
   end
 
-  test "should raise errors when initialized without config file" do
+  should "raise errors when initialized without config file" do
     assert_raise SystemExit do
       Twibot::Bot.new
     end
   end
 
-  test "should not raise error on initialize when config file exists" do
+  should "not raise error on initialize when config file exists" do
     if File.exists?("config")
       FileUtils.rm("config/bot.yml")
     else
@@ -30,17 +30,17 @@ class TestBot < Test::Unit::TestCase
     FileUtils.rm_rf("config")
   end
 
-  test "should provide configuration settings as methods" do
+  should "provide configuration settings as methods" do
     bot = Twibot::Bot.new Twibot::Config.new(:max_interval => 3)
     assert_equal 3, bot.max_interval
   end
 
-  test "log should return logger instance" do
+  should "return logger instance" do
     bot = Twibot::Bot.new(Twibot::Config.default << Twibot::Config.new)
     assert bot.log.is_a?(Logger)
   end
 
-  test "logger should respect configured level" do
+  should "respect configured log level" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "info"))
     assert_equal Logger::INFO, bot.log.level
 
@@ -48,32 +48,32 @@ class TestBot < Test::Unit::TestCase
     assert_equal Logger::WARN, bot.log.level
   end
 
-  test "receive should return false without handlers" do
+  should "should return false from receive without handlers" do
     bot = Twibot::Bot.new(Twibot::Config.new)
     assert !bot.receive_messages
     assert !bot.receive_replies
     assert !bot.receive_tweets
   end
 
-  test "should receive message" do
+  should "receive message" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
     bot.add_handler(:message, Twibot::Handler.new)
-    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([message("cjno", "Hei der!")])
+    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
 
     assert bot.receive_messages
   end
 
-  test "should remember last received message" do
+  should "remember last received message" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
     bot.add_handler(:message, Twibot::Handler.new)
-    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([message("cjno", "Hei der!")])
+    Twitter::Client.any_instance.expects(:messages).with(:received, {}).returns([twitter_message("cjno", "Hei der!")])
     assert_equal 1, bot.receive_messages
 
     Twitter::Client.any_instance.expects(:messages).with(:received, { :since_id => 1 }).returns([])
     assert_equal 0, bot.receive_messages
   end
 
-  test "should receive tweet" do
+  should "receive tweet" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
     bot.add_handler(:tweet, Twibot::Handler.new)
     Twitter::Client.any_instance.expects(:timeline_for).with(:me, {}).returns([tweet("cjno", "Hei der!")])
@@ -81,7 +81,7 @@ class TestBot < Test::Unit::TestCase
     assert_equal 1, bot.receive_tweets
   end
 
-  test "should remember received tweets" do
+  should "remember received tweets" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error"))
     bot.add_handler(:tweet, Twibot::Handler.new)
     Twitter::Client.any_instance.expects(:timeline_for).with(:me, {}).returns([tweet("cjno", "Hei der!")])
@@ -91,7 +91,7 @@ class TestBot < Test::Unit::TestCase
     assert_equal 0, bot.receive_tweets
   end
 
-  test "should receive reply when tweet starts with login" do
+  should "receive reply when tweet starts with login" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error", :login => "irbno"))
     bot.add_handler(:reply, Twibot::Handler.new)
     Twitter::Client.any_instance.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
@@ -99,7 +99,7 @@ class TestBot < Test::Unit::TestCase
     assert_equal 1, bot.receive_replies
   end
 
-  test "should remember received replies" do
+  should "remember received replies" do
     bot = Twibot::Bot.new(Twibot::Config.new(:log_level => "error", :login => "irbno"))
     bot.add_handler(:reply, Twibot::Handler.new)
     Twitter::Client.any_instance.expects(:status).with(:replies, {}).returns([tweet("cjno", "@irbno Hei der!")])
@@ -111,11 +111,11 @@ class TestBot < Test::Unit::TestCase
 end
 
 class TestBotMacros < Test::Unit::TestCase
-  test "should provide configure macro" do
+  should "provide configure macro" do
     assert respond_to?(:configure)
   end
 
-  test "configure should yield configuration" do
+  should "yield configuration" do
     Twibot::Macros.bot = Twibot::Bot.new Twibot::Config.default
     bot.prompt = false
 
@@ -124,12 +124,15 @@ class TestBotMacros < Test::Unit::TestCase
     assert conf.is_a?(Twibot::Config)
   end
 
-  test "should add handler" do
-    handler = add_handler(:message, ":command", :from => :cjno)
-    assert handler.is_a?(Twibot::Handler), handler.class
-  end
+   should "add handler" do
+     Twibot::Macros.bot = Twibot::Bot.new Twibot::Config.default
+     bot.prompt = false
+
+     handler = add_handler(:message, ":command", :from => :cjno)
+     assert handler.is_a?(Twibot::Handler), handler.class
+   end
 
-  test "should provide twitter macro" do
+  should "provide twitter macro" do
     assert respond_to?(:twitter)
     assert respond_to?(:client)
   end
@@ -137,7 +140,7 @@ end
 
 class TestBotHandlers < Test::Unit::TestCase
 
-  test "should include handlers" do
+  should "include handlers" do
     bot = Twibot::Bot.new(Twibot::Config.new)
 
     assert_not_nil bot.handlers
@@ -146,7 +149,7 @@ class TestBotHandlers < Test::Unit::TestCase
     assert_not_nil bot.handlers[:tweet]
   end
 
-  test "should add handler" do
+  should "add handler" do
     bot = Twibot::Bot.new(Twibot::Config.new)
     bot.add_handler :message, Twibot::Handler.new
     assert_equal 1, bot.handlers[:message].length

data/test/test_config.rb

@@ -2,33 +2,33 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unles
 require 'stringio'
 
 class TestConfig < Test::Unit::TestCase
-  test "default configuration should be a hash" do
+  should "default configuration be a hash" do
     assert_not_nil Twibot::Config::DEFAULT
     assert Twibot::Config::DEFAULT.is_a?(Hash)
   end
 
-  test "should initialize with no options" do
+  should "initialize with no options" do
     assert_hashes_equal({}, Twibot::Config.new.settings)
   end
 
-  test "add config should return config" do
+  should "return config from add" do
     config = Twibot::Config.new
     assert_equal config, config.add(Twibot::Config.new)
   end
 
-  test "add config should be aliased to <<" do
+  should "alias add to <<" do
     config = Twibot::Config.new
     assert config.respond_to?(:<<)
     assert config << Twibot::Config.new
   end
 
-  test "missing methods should act as config getters" do
+  should "mirror method_missing as config getters" do
     config = Twibot::Config.default << Twibot::Config.new
     assert_equal Twibot::Config::DEFAULT[:min_interval], config.min_interval
     assert_equal Twibot::Config::DEFAULT[:login], config.login
   end
 
-  test "missing methods should act as config setters" do
+  should "mirror missing methods as config setters" do
     config = Twibot::Config.default << Twibot::Config.new
     assert_equal Twibot::Config::DEFAULT[:min_interval], config.min_interval
 
@@ -38,7 +38,7 @@ class TestConfig < Test::Unit::TestCase
     assert_equal val + 5, config.min_interval
   end
 
-  test "default configuration should not override default hash" do
+  should "not override default hash" do
     config = Twibot::Config.default
     hash = Twibot::Config::DEFAULT
 
@@ -49,7 +49,7 @@ class TestConfig < Test::Unit::TestCase
     assert_hashes_equal hash, Twibot::Config::DEFAULT
   end
 
-  test "to_hash should return merged configuration" do
+  should "return merged configuration from to_hash" do
     config = Twibot::Config.new
     config.min_interval = 10
     config.max_interval = 10
@@ -65,7 +65,7 @@ class TestConfig < Test::Unit::TestCase
 end
 
 class TestCliConfig < Test::Unit::TestCase
-  test "should configure from options" do
+  should "configure from options" do
     config = Twibot::CliConfig.new %w{--min-interval 10 --max-interval 15}
     assert_equal 10, config.min_interval
     assert_equal 15, config.max_interval
@@ -73,11 +73,11 @@ class TestCliConfig < Test::Unit::TestCase
 end
 
 class TestFileConfig < Test::Unit::TestCase
-  test "file config should subclass config" do
+  should "subclass config for file config" do
     assert Twibot::FileConfig.new(StringIO.new).is_a?(Twibot::Config)
   end
 
-  test "should read settings from stream" do
+  should "read settings from stream" do
     config = Twibot::FileConfig.new(StringIO.new <<-YAML)
 min_interval: 10
 max_interval: 20

data/test/test_handler.rb

@@ -1,142 +1,144 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Twibot)
 
 class TestHandler < Test::Unit::TestCase
-  test "pattern writer should abort on empty values" do
-    handler = Twibot::Handler.new
+  context "pattern writer" do
+    should "abort on empty values" do
+      handler = Twibot::Handler.new
 
-    handler.pattern = nil
-    assert_nil handler.instance_eval { @options[:pattern] }
-    assert_nil handler.instance_eval { @options[:tokens] }
+      handler.pattern = nil
+      assert_nil handler.instance_eval { @options[:pattern] }
+      assert_nil handler.instance_eval { @options[:tokens] }
 
-    handler.pattern = ""
-    assert_nil handler.instance_eval { @options[:pattern] }
-    assert_nil handler.instance_eval { @options[:tokens] }
-  end
+      handler.pattern = ""
+      assert_nil handler.instance_eval { @options[:pattern] }
+      assert_nil handler.instance_eval { @options[:tokens] }
+    end
 
-  test "pattern writer should turn regular pattern into regex" do
-    handler = Twibot::Handler.new
-    handler.pattern = "command"
+    should "turn regular pattern into regex" do
+      handler = Twibot::Handler.new
+      handler.pattern = "command"
 
-    assert_equal(/command(\s.+)?/, handler.instance_eval { @options[:pattern] })
-    assert_equal 0, handler.instance_eval { @options[:tokens] }.length
-  end
+      assert_equal(/command(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 0, handler.instance_eval { @options[:tokens] }.length
+    end
 
-  test "pattern writer should convert single named switch to regex" do
-    handler = Twibot::Handler.new
-    handler.pattern = ":command"
+    should "convert single named switch to regex" do
+      handler = Twibot::Handler.new
+      handler.pattern = ":command"
 
-    assert_equal(/([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
-    assert_equal 1, handler.instance_eval { @options[:tokens] }.length
-    assert_equal :command, handler.instance_eval { @options[:tokens].first }
-  end
+      assert_equal(/([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 1, handler.instance_eval { @options[:tokens] }.length
+      assert_equal :command, handler.instance_eval { @options[:tokens].first }
+    end
 
-  test "pattern writer should convert several named switches to regexen" do
-    handler = Twibot::Handler.new
-    handler.pattern = ":command fixed_word :subcommand"
+    should "convert several named switches to regexen" do
+      handler = Twibot::Handler.new
+      handler.pattern = ":command fixed_word :subcommand"
 
-    assert_equal(/([^\s]+) fixed_word ([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
-    assert_equal 2, handler.instance_eval { @options[:tokens] }.length
-    assert_equal :command, handler.instance_eval { @options[:tokens].first }
-    assert_equal :subcommand, handler.instance_eval { @options[:tokens][1] }
-  end
+      assert_equal(/([^\s]+) fixed_word ([^\s]+)(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 2, handler.instance_eval { @options[:tokens] }.length
+      assert_equal :command, handler.instance_eval { @options[:tokens].first }
+      assert_equal :subcommand, handler.instance_eval { @options[:tokens][1] }
+    end
 
-  test "pattern writer should convert several named switches to regexen specified by options" do
-    handler = Twibot::Handler.new(":time :hour", :hour => /\d\d/)
+    should "convert several named switches to regexen specified by options" do
+      handler = Twibot::Handler.new(":time :hour", :hour => /\d\d/)
 
-    assert_equal(/([^\s]+) ((?-mix:\d\d))(\s.+)?/, handler.instance_eval { @options[:pattern] })
-    assert_equal 2, handler.instance_eval { @options[:tokens] }.length
-    assert_equal :time, handler.instance_eval { @options[:tokens].first }
-    assert_equal :hour, handler.instance_eval { @options[:tokens][1] }
+      assert_equal(/([^\s]+) ((?-mix:\d\d))(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 2, handler.instance_eval { @options[:tokens] }.length
+      assert_equal :time, handler.instance_eval { @options[:tokens].first }
+      assert_equal :hour, handler.instance_eval { @options[:tokens][1] }
+    end
   end
 
-  test "should recognize empty pattern" do
+  should "recognize empty pattern" do
     handler = Twibot::Handler.new
-    message = message "cjno", "A twitter direct message"
+    message = twitter_message "cjno", "A twitter direct message"
 
     assert handler.recognize?(message)
   end
 
-  test "should recognize empty pattern and allowed user" do
+  should "recognize empty pattern and allowed user" do
     handler = Twibot::Handler.new "", :from => "cjno"
-    message = message "cjno", "A twitter direct message"
+    message = twitter_message "cjno", "A twitter direct message"
     assert handler.recognize?(message)
 
     handler = Twibot::Handler.new "", :from => ["cjno", "irbno"]
     assert handler.recognize?(message)
   end
 
-  test "should not recognize empty pattern and disallowed user" do
+  should "not recognize empty pattern and disallowed user" do
     handler = Twibot::Handler.new "", :from => "irbno"
-    message = message "cjno", "A twitter direct message"
+    message = twitter_message "cjno", "A twitter direct message"
     assert !handler.recognize?(message)
 
     handler = Twibot::Handler.new "", :from => ["irbno", "satan"]
     assert !handler.recognize?(message)
   end
 
-  test "should recognize fixed pattern and no user" do
+  should "recognize fixed pattern and no user" do
     handler = Twibot::Handler.new "time"
-    message = message "cjno", "time oslo norway"
+    message = twitter_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  test "should recognize dynamic pattern and no user" do
+  should "recognize dynamic pattern and no user" do
     handler = Twibot::Handler.new "time :city :country"
-    message = message "cjno", "time oslo norway"
+    message = twitter_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  test "should not recognize dynamic pattern and no user" do
+  should "not recognize dynamic pattern and no user" do
     handler = Twibot::Handler.new "time :city :country"
-    message = message "cjno", "oslo norway what is the time?"
+    message = twitter_message "cjno", "oslo norway what is the time?"
     assert !handler.recognize?(message)
   end
 
-  test "should recognize fixed pattern and user" do
+  should "recognize fixed pattern and user" do
     handler = Twibot::Handler.new "time", :from => ["cjno", "irbno"]
-    message = message "cjno", "time oslo norway"
+    message = twitter_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  test "should recognize dynamic pattern and user" do
+  should "recognize dynamic pattern and user" do
     handler = Twibot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
-    message = message "cjno", "time oslo norway"
+    message = twitter_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
   end
 
-  test "should not recognize dynamic pattern and user" do
+  should "not recognize dynamic pattern and user" do
     handler = Twibot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
-    message = message "dude", "time oslo norway"
+    message = twitter_message "dude", "time oslo norway"
     assert !handler.recognize?(message)
   end
 
-  test "should recognize symbol users" do
+  should "recognize symbol users" do
     handler = Twibot::Handler.new "time :city :country", :from => [:cjno, :irbno]
-    message = message "dude", "time oslo norway"
+    message = twitter_message "dude", "time oslo norway"
     assert !handler.recognize?(message)
 
-    message = message("cjno", "time oslo norway")
+    message = twitter_message("cjno", "time oslo norway")
     assert handler.recognize?(message)
   end
 
-  test "should accept options as only argument" do
+  should "accept options as only argument" do
     handler = Twibot::Handler.new :from => :cjno
     assert_equal(:cjno, handler.instance_eval { @options[:from] })
     assert_nil handler.instance_eval { @options[:pattern] }
   end
 
-  test "should provide parameters in params hash" do
+  should "provide parameters in params hash" do
     handler = Twibot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
       assert_equal "oslo", params[:city]
       assert_equal "norway", params[:country]
     end
 
-    message = message "cjno", "time oslo norway"
+    message = twitter_message "cjno", "time oslo norway"
     assert handler.recognize?(message)
     handler.dispatch(message)
   end
 
-  test "handle should call constructor block" do
+  should "should call constructor block from handle" do
     handler = Twibot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
       raise "Boom!"
     end

data/test/test_hash.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Twibot)
 
 class TestHash < Test::Unit::TestCase
-  test "should convert string keys to symbols" do
+  should "convert string keys to symbols" do
     hash = { "one" => 1, "two" => 2 }
     hash.symbolize_keys!
 
@@ -11,7 +11,7 @@ class TestHash < Test::Unit::TestCase
     assert_nil hash["two"]
   end
 
-  test "should convert string keys and preserve symbol keys" do
+  should "convert string keys and preserve symbol keys" do
     hash = { "one" => 1, :two => 2 }
     hash.symbolize_keys!
 
@@ -21,7 +21,7 @@ class TestHash < Test::Unit::TestCase
     assert_nil hash["two"]
   end
 
-  test "should convert hashes recursively" do
+  should "convert hashes recursively" do
     hash = { "one" => 1, :two => { "three" => 3, "four" => 4 } }
     hash.symbolize_keys!
 

data/test/test_helper.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'context'
+require 'shoulda'
 require 'mocha'
 require File.join(File.dirname(__FILE__), '../lib/twibot')
 
@@ -27,7 +27,7 @@ EOT
   end
 end
 
-def message(from, text)
+def twitter_message(from, text)
   Twitter::Message.new(:id => 1,
                        :sender => Twitter::User.new(:screen_name => from),
                        :text => text,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: twibot
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Christian Johansen