jabbot 0.1.2

data/test/test_handler.rb

@@ -0,0 +1,191 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper')) unless defined?(Jabbot)
+
+class TestHandler < Test::Unit::TestCase
+  context "pattern writer" do
+    should "abort on empty values" do
+      handler = Jabbot::Handler.new
+
+      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
+
+    should "turn regular pattern into regex" do
+      handler = Jabbot::Handler.new
+      handler.pattern = "command"
+
+      assert_equal(/command(\s.+)?/, handler.instance_eval { @options[:pattern] })
+      assert_equal 0, handler.instance_eval { @options[:tokens] }.length
+    end
+
+    should "convert single named switch to regex" do
+      handler = Jabbot::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
+
+    should "convert several named switches to regexen" do
+      handler = Jabbot::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
+
+    should "convert several named switches to regexen specified by options" do
+      handler = Jabbot::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] }
+    end
+  end
+
+  should "recognize empty pattern" do
+    handler = Jabbot::Handler.new
+    message = message "cjno", "A jabber message"
+
+    assert handler.recognize?(message)
+  end
+
+  should "recognize empty pattern and allowed user" do
+    handler = Jabbot::Handler.new "", :from => "cjno"
+    message = message "cjno", "A jabber message"
+    assert handler.recognize?(message)
+
+    handler = Jabbot::Handler.new "", :from => ["cjno", "irbno"]
+    assert handler.recognize?(message)
+  end
+
+  should "not recognize empty pattern and disallowed user" do
+    handler = Jabbot::Handler.new "", :from => "irbno"
+    message = message "cjno", "A jabber message"
+    assert !handler.recognize?(message)
+
+    handler = Jabbot::Handler.new "", :from => ["irbno", "satan"]
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize fixed pattern and no user" do
+    handler = Jabbot::Handler.new "time"
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "recognize dynamic pattern and no user" do
+    handler = Jabbot::Handler.new "time :city :country"
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "not recognize dynamic pattern and no user" do
+    handler = Jabbot::Handler.new "time :city :country"
+    message = message "cjno", "oslo norway what is the time?"
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize fixed pattern and user" do
+    handler = Jabbot::Handler.new "time", :from => ["cjno", "irbno"]
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "recognize dynamic pattern and user" do
+    handler = Jabbot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+
+  should "not recognize dynamic pattern and user" do
+    handler = Jabbot::Handler.new "time :city :country", :from => ["cjno", "irbno"]
+    message = message "dude", "time oslo norway"
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize symbol users" do
+    handler = Jabbot::Handler.new "time :city :country", :from => [:cjno, :irbno]
+    message = message "dude", "time oslo norway"
+    assert !handler.recognize?(message)
+
+    message = message("cjno", "time oslo norway")
+    assert handler.recognize?(message)
+  end
+
+  should "recognize messages from allowed users" do
+    handler = Jabbot::Handler.new :from => [:cjno, :irbno]
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+  end
+  
+  should "not recognize messages from unallowed users with capital screen names" do
+    handler = Jabbot::Handler.new :from => [:cjno, :irbno]
+    message = message "Cjno", "time oslo norway"
+    assert !handler.recognize?(message)
+  end
+
+  should "accept options as only argument" do
+    handler = Jabbot::Handler.new :from => :cjno
+    assert_equal(['cjno'], handler.instance_eval { @options[:from] })
+    assert_nil handler.instance_eval { @options[:pattern] }
+  end
+
+  should "provide parameters in params hash" do
+    handler = Jabbot::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"
+    assert handler.recognize?(message)
+    handler.dispatch(message)
+  end
+
+  should "call constructor block from handle" do
+    handler = Jabbot::Handler.new("time :city :country", :from => ["cjno", "irbno"]) do |message, params|
+      raise "Boom!"
+    end
+
+    assert_raise(RuntimeError) do
+      handler.handle(nil, nil)
+    end
+  end
+
+  should "recognize regular expressions" do
+    handler = Jabbot::Handler.new /(?:what|where) is (.*)/i
+    message = message "dude", "Where is this shit?"
+    assert handler.recognize?(message)
+
+    message = message "dude", "How is this shit?"
+    assert !handler.recognize?(message)
+  end
+
+  should "recognize regular expressions from specific users" do
+    handler = Jabbot::Handler.new /(?:what|where) is (.*)/i, :from => "cjno"
+    message = message "dude", "Where is this shit?"
+    assert !handler.recognize?(message)
+
+    message = message "cjno", "Where is this shit?"
+    assert handler.recognize?(message)
+  end
+
+  should "provide parameters as arrays when matching regular expressions" do
+    handler = Jabbot::Handler.new(/time ([^\s]*) ([^\s]*)/) do |message, params|
+      assert_equal "oslo", params[0]
+      assert_equal "norway", params[1]
+    end
+
+    message = message "cjno", "time oslo norway"
+    assert handler.recognize?(message)
+    handler.dispatch(message)
+  end
+end

data/test/test_hash.rb

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

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+if RUBY_VERSION =~ /1\.9/
+  Gem.all_load_paths
+  gem "thoughtbot-shoulda"
+  gem "xmpp4r"
+end
+require 'test/unit'
+require 'shoulda'
+require File.join(File.dirname(__FILE__), '../lib/jabbot')
+
+module Test::Unit::Assertions
+  def assert_hashes_equal(expected, actual, message = nil)
+    full_message = build_message(message, <<EOT, expected.inspect, actual.inspect)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) do
+      break false if expected.keys.length != actual.keys.length
+      expected.keys.all? { |k| expected[k] == actual[k] }
+    end
+  end
+
+  def assert_hashes_not_equal(expected, actual, message = nil)
+    full_message = build_message(message, <<EOT, expected.inspect, actual.inspect)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) do
+      break false if expected.keys.length != actual.keys.length
+      expected.keys.any? { |k| expected[k] != actual[k] }
+    end
+  end
+end
+
+Message = Struct.new(:user, :text, :time)
+def message(user, text)
+  Message.new(user, text, Time.now)
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: jabbot
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- BadBoy_
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-27 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.10.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.2
+    version: 
+description: 
+email: badboy@archlinux.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/hash.rb
+- lib/jabbot.rb
+- lib/jabbot/bot.rb
+- lib/jabbot/config.rb
+- lib/jabbot/handlers.rb
+- lib/jabbot/macros.rb
+- lib/jabbot/message.rb
+- test/test_bot.rb
+- test/test_config.rb
+- test/test_handler.rb
+- test/test_hash.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/badboy/jabbot
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jabbot
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: Simple framework for creating Jabber/MUC bots, inspired by Sinatra and Twibot
+test_files: 
+- test/test_helper.rb
+- test/test_bot.rb
+- test/test_hash.rb
+- test/test_config.rb
+- test/test_handler.rb