rumpy 0.9.8

data/README.rdoc

@@ -0,0 +1,53 @@
+== Welcome to Rumpy
+
+Rumpy is some kind of framework to make up your own jabber bot quickly.
+It uses {ActiveRecord}[https://github.com/rails/rails/tree/master/activerecord] and {XMPP4R}[http://home.gna.org/xmpp4r/].
+
+Our goal is 'DO NOT REINVENT THE WHEEL'.
+
+== Features
+
+* Forget about xmpp-related things. Just set your login & password.
+* Forget about database-related things. Just set your database preferences.
+* Write logic using ActiveRecord and callback functions.
+
+== Getting started
+
+* Rumpy uses 3 configs:
+  database.yml  ::  Your bot's database preferences.
+  lang.yml      ::  Your bot's responces. Append to existing keys more answers and use them like @lang['someanswer]. **There must be at least 3 keys : hello /used when somebody add bot/, stranger /when somebody trying talk to bot without authorization/, authorized /when bot get authorized/.
+  xmpp.yml      ::  Your bot's account settings.
+  Look at Examples section to see this configs.
+* Implement your ActiveRecord models in one directory. You have to implement at least one model, for users.
+* Prepare your database.
+* Start writing your class:
+  * Mix in Rumpy::Bot module:
+    include Rumpy::Bot
+  * Define 3 instance variables:
+    @models_path  ::  Path to directory, containing all ruby files with models.
+    @config_path  ::  Path to directory, containing all ruby config files
+    @main_model   ::  Symbol, that stands for main model. If your main model is, e.g. User, set @main_model to :user
+    @pid_file     ::  Optional variable, sets location of the file to which pid of detached process will be saved. If not set, it equals NameOfYourBotClass.downcase + '.pid'.
+    @errfile      ::  Optional variable, sets location of the file for errors. If not set, standard error stream will be used.
+  * Write 3 methods:
+    backend_func() -> [[receiver, message]*] :: This optional method is running all the time in the loop. Returns array of pairs [receiver, message].
+    parser_func(msg) -> pars_result :: This method parses any incoming message and returs results.
+    do_func(usermodel, pars_results) -> msg :: This method uses results from parser_func, doing some stuff with model of user, from whom message was received. Returns message to be send to this user
+* Run bot:
+  You can run your bot without detaching:
+    Rumpy.run YourBotClassName
+  Or with detaching:
+    To start your bot:
+      Rumpy.start YourBotClassName
+    To stop it:
+      Rumpy.stop YourBotClassName
+
+== Example
+
+Look at {CuteBot}[https://github.com/MPogoda/CuteBot], {yatodo}[https://github.com/MPogoda/yatodo], {Noty}[https://github.com/Ximik/Noty].
+
+Feel free to contact us about any questions related to Rumpy.
+
+== License
+
+Rumpy is released under the MIT license.

data/lib/rumpy.rb

@@ -0,0 +1,195 @@
+require 'rubygems'
+require 'xmpp4r/client'
+require 'xmpp4r/roster'
+require 'active_record'
+require 'active_record/validations'
+
+module Rumpy
+
+  def self.start(botclass)
+    bot = botclass.new
+    pf = pid_file bot
+    return false if File.exist? pf
+    pid = fork do
+      bot.start
+    end
+    Process.detach pid
+    File.open(pf, 'w') do |file|
+      file.puts pid
+    end
+    true
+  end
+
+  def self.stop(botclass)
+    pf = pid_file botclass.new
+    return false unless File.exist? pf
+    begin
+      File.open(pf) do |file|
+        Process.kill :TERM, file.gets.strip.to_i
+      end
+    ensure
+      File.unlink pf
+    end
+    true
+  end
+
+  def self.run(botclass)
+    botclass.new.start
+  end
+
+  def self.pid_file(bot)
+    pid_file = bot.pid_file
+    pid_file = bot.class.to_s.downcase + '.pid' if pid_file.nil?
+    pid_file
+  end
+
+  module Bot
+    attr_reader :pid_file
+
+    def start
+      @err_file = if @err_file then
+                   File.open(@err_file, 'w')
+                 else
+                   $stderr
+                 end
+      Signal.trap :TERM do |signo|
+        @err_file.close
+        exit
+      end
+
+      init
+      connect
+      clear_users
+      start_subscription_callback
+      start_message_callback
+      @client.send Jabber::Presence.new
+      Thread.new do
+        begin
+          loop do
+            backend_func().each do |result|
+              send_msg *result
+            end
+          end
+        rescue => e
+          $err_file.puts e.inspect
+          $err_file.puts e.backtrace
+        end
+      end if self.respond_to? :backend_func
+      Thread.stop
+    end
+
+    private
+
+    def init
+
+      xmppconfig  = YAML::load_file @config_path + '/xmpp.yml'
+      @lang       = YAML::load_file @config_path + '/lang.yml'
+      @jid        = Jabber::JID.new xmppconfig['jid']
+      @password   = xmppconfig['password']
+      @client     = Jabber::Client.new @jid
+
+      if @models_path then
+        dbconfig  = YAML::load_file @config_path + '/database.yml'
+        ActiveRecord::Base.establish_connection dbconfig
+        Dir[@models_path].each do |file|
+          self.class.require file
+        end
+      end
+
+      @main_model = Object.const_get @main_model.to_s.capitalize
+      def @main_model.find_by_jid(jid)
+        super jid.strip.to_s
+      end
+
+      @mutexes = Hash.new do |h, k|
+        h[k] = Mutex.new
+      end
+    end
+
+    def connect
+      @client.connect
+      @client.auth @password
+      @roster = Jabber::Roster::Helper.new @client
+      @roster.wait_for_roster
+    end
+
+    def clear_users
+      @main_model.find_each do |user|
+        items = @roster.find user.jid
+        user.destroy if items.count != 1
+      end
+      @roster.items.each do |jid, item|
+        user = @main_model.find_by_jid jid
+        if user.nil? then
+          item.remove
+          next
+        elsif item.subscription != :both then
+          item.remove
+          user.destroy
+        end
+      end
+    end
+
+    def start_subscription_callback
+      @roster.add_subscription_request_callback do |item, presence|
+        jid = presence.from
+        @roster.accept_subscription jid
+        @client.send Jabber::Presence.new.set_type(:subscribe).set_to(jid)
+        send_msg jid, @lang['hello']
+      end
+      @roster.add_subscription_callback do |item, presence|
+        case presence.type
+        when :unsubscribed, :unsubscribe
+          item.remove
+          remove_jid item.jid
+        when :subscribed
+          add_jid item.jid
+          send_msg item.jid, @lang['authorized']
+        end
+      end
+    end
+
+    def start_message_callback
+      @client.add_message_callback do |msg|
+        begin
+          if msg.type != :error and msg.body and msg.from then
+            if user = @main_model.find_by_jid(msg.from) then
+              pars_results = parser_func msg.body
+
+              message = ""
+              @mutexes[user.jid].synchronize do
+                message = do_func user, pars_results
+              end
+              send_msg msg.from, message
+            else
+              send_msg msg.from, @lang['stranger']
+              items = @roster.find msg.from.strip.to_s
+              items.first.last.remove unless items.empty?
+            end
+          end
+        rescue => e
+          @err_file.puts e.inspect
+          @err_file.puts e.backtrace
+        end
+      end
+    end
+
+    def send_msg(destination, text)
+      return if destination.nil? or text.nil?
+      msg = Jabber::Message.new destination, text
+      msg.type = :chat
+      @client.send msg
+    end
+
+    def add_jid(jid)
+      user = @main_model.new
+      user.jid = jid.strip.to_s
+      user.save
+    end
+
+    def remove_jid(jid)
+      user = @main_model.find_by_jid jid
+      user.destroy unless user.nil?
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: rumpy
+version: !ruby/object:Gem::Version 
+  hash: 43
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 8
+  version: 0.9.8
+platform: ruby
+authors: 
+- Tsokurov A.G.
+- Pogoda M.V.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-17 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 0
+        - 5
+        version: "0.5"
+  type: :runtime
+  version_requirements: *id002
+description: Rumpy is some kind of framework to make up your own jabber bot quickly.
+email: 
+- mpogoda@lavabit.com
+- me@ximik.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/rumpy.rb
+- README.rdoc
+has_rdoc: true
+homepage: https://github.com/Ximik/Rumpy
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rumpy == jabber bot framework
+test_files: []
+