jabbot 0.1.2

data/README.rdoc

@@ -0,0 +1,141 @@
+= Jabbot
+Official URL: http://github.com/badboy/jabbot/tree/master
+Jan-Erik Rediger (BadBoy_) (http://badboy.pytalhost.de)
+
+== Description
+
+Jabbot is a Ruby microframework for creating Jabber/MUC
+bots, heavily inspired by Sinatra and Twibot.
+I modified the code of Twibot to fit my needs.
+The original Twibot code is located at:
+http://github.com/cjohansen/twibot/tree/master
+
+A big thank you to Christian Johansen, who wrote the code for Twibot.
+Jabbot is heavily based on his code.
+
+== Usage
+
+=== Simple example
+
+  require 'jabbot'
+
+  # Receive messages, and post them publicly
+  #
+  message do |message, params|
+    post message.text
+  end
+
+  # Respond to query if they come from the right crowd
+  # post "message" => "user" is just some syntax sugar
+  # post "message", "user" will work to
+  query :from => [:cjno, :irbno] do |message, params|
+    post "#{message.user} I agree" => message.user
+  end
+
+  # Listen in and log tweets
+  # (you can use "message :all" too ;)
+  message do |message, params|
+    MyApp.log_message(message)
+  end
+
+=== Running the bot
+
+To run the bot, simply do:
+
+  ruby bot.rb
+
+=== Configuration
+
+Jabbot looks for a configuration file in ./config/bot.yml. It should contain
+atleast:
+
+  login: jabber_login
+  password: jabber_password
+  channel: channel_to_join
+  server: server_to_connect_to
+  nick: mybot
+
+You can also configure with Ruby:
+
+  configure do |conf|
+    conf.login = "my_account"
+    conf.nick = "mybot"
+  do
+
+If you don't specify login and/or password in any of these ways, Jabbot will fail
+Nick is automatically set to "jabbot" unless something different is defined
+If you want you can set the Jabber Resource:
+  conf.resource ="mybot_resource"
+Otherwise it is set to "jabbot", too
+
+=== "Routes"
+
+Like Sinatra, and other web app frameworks, Jabbot supports "routes": patterns
+to match incoming tweets and messages:
+
+  require 'jabbot'
+
+  message "time :country :city" do |message,params|
+    time = MyTimeService.lookup(params[:country], params[:city])
+    post "Time is #{time} in #{params[:city]}, #{params[:country]}"
+  end
+
+You can have several "message" blocks (or "join", "leave", "query" or "subject").
+Every matching block will be called.
+
+Jabbot also supports regular expressions as routes:
+
+  require 'jabbot'
+
+  message /^time ([^\s]*) ([^\s]*)/ do |message, params|
+    # params is an array of matches when using regexp routes
+    time = MyTimeService.lookup(params[0], params[1])
+    post "Time is #{time} in #{params[:city]}, #{params[:country]}"
+  end
+
+== Requirements
+
+xmpp4r. You'll need atleast 0.4.
+You can get it via rubygems:
+ gem install xmpp4r
+or download it from:
+http://home.gna.org/xmpp4r/
+
+== Installation
+
+ gem sources -a http://gems.github.com  # you only have to do this once
+ gem install badboy-jabbot
+
+== Is it Ruby 1.9?
+
+All tests passes even on Ruby 1.9.
+Seems like it works :)
+
+== Contributors
+
+* Christian Johansen (cjohansen) (author of Twibot) - http://www.cjohansen.no
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2009 Jan-Erik Rediger (Badboy_)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "jabbot"
+    gem.summary = %Q{Simple framework for creating Jabber/MUC bots, inspired by Sinatra and Twibot}
+    gem.email = "badboy@archlinux.us"
+    gem.homepage = "http://github.com/badboy/jabbot"
+    gem.authors = ["BadBoy_"]
+    gem.add_dependency('xmpp4r', '>=0.4')
+    gem.add_development_dependency('thoughtbot-shoulda', '>=2.10.1')
+    gem.add_development_dependency('jeweler', '>=0.10.2')
+
+    gem.rubyforge_project = 'jabbot'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = false
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "jabbot #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 2

data/lib/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  def symbolize_keys!
+    replace(inject({}) do |hash,(key,value)|
+      hash[key.to_sym] = value.is_a?(Hash) ? value.symbolize_keys! : value
+      hash
+    end)
+  end
+end

data/lib/jabbot.rb

@@ -0,0 +1,84 @@
+require 'time'
+require 'xmpp4r'
+require 'xmpp4r/muc/helper/simplemucclient'
+#require 'xmpp4r/muc/helper/mucclient'
+require 'xmpp4r/version/helper/simpleresponder'
+require 'yaml'
+require File.join(File.dirname(__FILE__), 'hash')
+
+module Jabbot
+
+  # :stopdoc:
+  VERSION = '0.1.2'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= File.basename(fname, '.*')
+    search_me = File.expand_path(File.join(File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb| require rb }
+  end
+
+  @@app_file = lambda do
+    ignore = [
+      /lib\/twibot.*\.rb/, # Library
+      /\(.*\)/,            # Generated code
+      /custom_require\.rb/ # RubyGems require
+    ]
+
+    path = caller.map { |line| line.split(/:\d/, 2).first }.find do |file|
+      next if ignore.any? { |pattern| file =~ pattern }
+      file
+    end
+
+    path || $0
+  end.call
+
+  #
+  # File name of the application file. Inspired by Sinatra
+  #
+  def self.app_file
+    @@app_file
+  end
+
+  #
+  # Runs application if application file is the script being executed
+  #
+  def self.run?
+    self.app_file == $0
+  end
+
+end  # module Jabbot
+
+Thread.abort_on_exception = true
+Jabbot.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/jabbot/bot.rb

@@ -0,0 +1,244 @@
+require 'logger'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'macros')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'handlers')
+
+module Jabbot
+  #
+  # Main bot "controller" class
+  #
+  class Bot
+    include Jabbot::Handlers
+    attr_reader :client
+    attr_reader :user
+
+    Message = Struct.new(:user, :text, :time) do
+      def to_s
+        "#{user}: #{text}"
+      end
+    end
+
+    def initialize(options = nil)
+      @conf = nil
+      @config = options || Jabbot::Config.default << Jabbot::FileConfig.new
+      @log = nil
+      @abort = false
+      @user = []
+
+    rescue Exception => krash
+      raise SystemExit.new(krash.message)
+    end
+
+    #
+    # connect to Jabber and join channel
+    #
+    def connect
+      @jid = Jabber::JID.new(login)
+      @mucjid = Jabber::JID.new("#{channel}@#{server}")
+
+      if @jid.node.nil?
+        raise "Your Jabber ID must contain a user name and therefore contain one @ character."
+      elsif @jid.resource
+        raise "If you intend to set a custom resource, put that in the right text field. Remove the slash!"
+      elsif @mucjid.node.nil?
+        raise "Please set a room name, e.g. myroom@conference.jabber.org"
+      elsif @mucjid.resource
+        raise "The MUC room must not contain a resource. Remove the slash!"
+      else
+        @jid.resource = config[:resource] || "jabbot"
+        @mucjid.resource = config[:nick] || "jabbot"
+        @user << config[:nick]
+      end
+
+      @client = Jabber::Client.new(@jid)
+      @connected = true
+      begin
+        @client.connect
+        @client.auth(password)
+        @muc = Jabber::MUC::SimpleMUCClient.new(@client)
+        muc_handlers.call(@muc)
+        @muc.join(@mucjid)
+       rescue => errmsg
+        STDERR.write "#{errmsg.class}\n#{errmsg}, #{errmsg.backtrace.join("\n")}"
+        exit 1
+      end
+    end
+
+    #
+    # Run application
+    #
+    def run!
+      puts "Jabbot #{Jabbot::VERSION} imposing as #{login} on #{channel}@#{server}"
+
+      trap(:INT) do
+        puts "\nAnd it's a wrap. See ya soon!"
+        exit
+      end
+
+      connect
+      poll
+    end
+
+    #
+    # just a lame infinite loop to keep the bot alive while he is connected
+    # :)
+    #
+    def poll
+      while connected?
+        break unless connected?
+        sleep 1
+      end
+    end
+
+    #
+    # still connected?
+    #
+    def connected?
+      @connected
+    end
+
+    #
+    # close connection
+    #
+    def close
+      if connected?
+        @connected = false
+        client.close
+      end
+    end
+    alias_method :quit, :close
+
+    #
+    # send message
+    # alternative: send query to user
+    #
+    def send_message(msg, to=nil)
+      @muc.say(msg.to_s, to)
+    end
+
+    #
+    # defines what to do on different actions
+    #
+    def muc_handlers
+      Proc.new do |muc|
+        muc.on_message do |time, nick, text|
+          if time.nil?
+            begin
+              dispatch_messages(:message, [Message.new(nick, text, Time.now)]) unless nick == config[:nick]
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+
+        muc.on_private_message do |time, nick, text|
+          if time.nil?
+            begin
+              dispatch_messages(:private, [Message.new(nick, text, Time.now)]) unless nick == config[:nick]
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+
+        muc.on_join do |time, nick|
+          unless @user.include? nick
+            @user << nick
+          end
+          if time.nil?
+            begin
+              dispatch_messages(:join, [Message.new(nick, "join", Time.now)]) unless nick == config[:nick]
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+        
+        muc.on_leave do |time, nick|
+          @user.delete(nick)
+          if time.nil?
+            begin
+              dispatch_messages(:leave, [Message.new(nick, "leave", Time.now)])
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+        
+        muc.on_subject do |time, nick, subject|
+          if time.nil?
+            begin
+              dispatch_messages(:subject, [Message.new(nick, subject, Time.now)])
+            rescue Exception => boom
+              log.fatal boom.inspect
+              log.fatal boom.backtrace[0..5].join("\n")
+            end
+          end
+        end
+
+        # not working
+        #muc.on_self_leave  do |*args|
+        #  p args
+        #end
+      end
+    end
+
+    #
+    # Dispatch a collection of messages
+    #
+    def dispatch_messages(type, messages)
+      messages.each { |message| dispatch(type, message) }
+      messages.length
+    end
+
+    #
+    # Return logger instance
+    #
+    def log
+      return @log if @log
+      os = config[:log_file] ? File.open(config[:log_file], "a") : $stdout
+      @log = Logger.new(os)
+      @log.level = Logger.const_get(config[:log_level] ? config[:log_level].upcase : "INFO")
+      @log
+    end
+
+    #
+    # Configure bot
+    #
+    def configure
+      yield @config
+      @conf = nil
+    end
+
+   private
+    #
+    # Map configuration settings
+    #
+    def method_missing(name, *args, &block)
+      return super unless config.key?(name)
+
+      self.class.send(:define_method, name) { config[name] }
+      config[name]
+    end
+
+    #
+    # Return configuration
+    #
+    def config
+      return @conf if @conf
+      @conf = @config.to_hash
+    end
+  end
+end
+
+# Expose DSL
+include Jabbot::Macros
+
+# Run bot if macros has been used
+at_exit do
+  raise $! if $!
+  @@bot.run! if run?
+end