blather 0.3.0 → 0.3.1

data/README.rdoc

@@ -60,7 +60,7 @@ Guards act like AND statements. Each condition must be met if the handler is to
   # Equivalent to saying (stanza.chat? && stanza.body)
   message :chat?, :body
 
-There are 5 different types of guards:
+The different types of guards are:
 
   # Symbol
   #   Checks for a non-false reply to calling the symbol on the stanza
@@ -93,9 +93,24 @@ There are 5 different types of guards:
   #   Equivalent to stanza.body == 'foo' || stanza.body == 'baz'
   message [{:body => 'foo'}, {:body => 'baz'}]
 
+== On the Command Line:
+
+Default usage is:
+
+  [blather_script] [options] node@domain.com/resource password [host] [port]
+
+Command line options:
+
+  -D, --debug                      Run in debug mode (you will see all XMPP communication)
+  -d, --daemonize                  Daemonize the process
+      --pid=[PID]                  Write the PID to this file
+      --log=[LOG]                  Write to the [LOG] file instead of stdout/stderr
+  -h, --help                       Show this message
+  -v, --version                    Show version
+
+
 = TODO
 
-* Better Documentation
 * Add XPath guard that passes the result to the handler
 * Add Disco the the DSL
 * PubSub (XEP-0060: http://xmpp.org/extensions/xep-0060.html)

data/Rakefile

@@ -16,7 +16,7 @@ begin
     gem.extensions = ['Rakefile']
 
     gem.add_dependency 'eventmachine', '>= 0.12.6'
-    gem.add_dependency 'libxml-ruby', '>= 1.1.3'
+    gem.add_dependency 'libxml-ruby', '>= 1.1.2'
 
     gem.files = FileList['examples/**/*', 'lib/**/*', 'ext/*.{rb,c}'].to_a
 

data/examples/ping_pong.rb

@@ -0,0 +1,37 @@
+require 'blather/client/dsl'
+$stdout.sync = true
+
+module Ping
+  extend Blather::DSL
+  def self.run; client.run; end
+
+  setup 'echo@jabber.local/ping', 'echo'
+
+  status :from => Blather::JID.new('echo@jabber.local/pong') do |s|
+    puts "serve!"
+    say s.from, 'ping'
+  end
+
+  message :chat?, :body => 'pong' do |m|
+    puts "ping!"
+    say m.from, 'ping'
+  end
+end
+
+module Pong
+  extend Blather::DSL
+  def self.run; client.run; end
+
+  setup 'echo@jabber.local/pong', 'echo'
+  message :chat?, :body => 'ping' do |m|
+    puts "pong!"
+    say m.from, 'pong'
+  end
+end
+
+trap(:INT) { EM.stop }
+trap(:TERM) { EM.stop }
+EM.run do
+  Ping.run
+  Pong.run
+end

data/lib/blather.rb

@@ -1,6 +1,3 @@
-$:.unshift File.dirname(__FILE__)
-$:.unshift File.join(File.dirname(__FILE__), '..')
-
 # Require the necessary files
 %w[
   rubygems
@@ -48,6 +45,6 @@ $:.unshift File.join(File.dirname(__FILE__), '..')
 XML.indent_tree_output = false
 
 module Blather
-  LOG = Logger.new(STDOUT) unless const_defined?(:LOG)
+  LOG = Logger.new($stdout) unless const_defined?(:LOG)
   LOG.level = Logger::INFO
 end

data/lib/blather/client.rb

@@ -1,13 +1,85 @@
+require 'optparse'
 require File.join(File.dirname(__FILE__), *%w[client dsl])
 
 include Blather::DSL
 
+options = {}
+optparse = OptionParser.new do |opts|
+  opts.banner = "Run with #{$0} [options] user@server/resource password [host] [port]"
+
+  opts.on('-D', '--debug', 'Run in debug mode (you will see all XMPP communication)') do |debug|
+    options[:debug] = debug
+  end
+
+  opts.on('-d', '--daemonize', 'Daemonize the process') do |daemonize|
+    options[:daemonize] = daemonize
+  end
+
+  opts.on('--pid=[PID]', 'Write the PID to this file') do |pid|
+    if !File.writable?(File.dirname(pid))
+      $stderr.puts "Unable to write log file to #{pid}"
+      exit 1
+    end
+    options[:pid] = pid
+  end
+
+  opts.on('--log=[LOG]', 'Write to the [LOG] file instead of stdout/stderr') do |log|
+    if !File.writable?(File.dirname(log))
+      $stderr.puts "Unable to write log file to #{log}"
+      exit 1
+    end
+    options[:log] = log
+  end
+
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+
+  opts.on_tail('-v', '--version', 'Show version') do
+    require 'yaml'
+    version = YAML.load_file File.join(File.dirname(__FILE__), %w[.. .. VERSION.yml])
+    puts "Blather v#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+    exit
+  end
+end
+optparse.parse!
+
 at_exit do
   unless client.setup?
     if ARGV.length < 2
-      puts "Run with #{$0} user@server/resource password [host] [port]"
-    else
-      client.setup(*ARGV).run
+      puts optparse
+      exit 1
+    end
+    client.setup(*ARGV)
+  end
+
+  def run(options)
+    $stdin.reopen "/dev/null"
+
+    if options[:log]
+      log = File.new(options[:log], 'a')
+      log.sync = options[:debug]
+      Blather::LOG.level = Logger::DEBUG if options[:debug]
+      $stdout.reopen log
+      $stderr.reopen $stdout
+    end
+    trap(:INT) { EM.stop }
+    trap(:TERM) { EM.stop }
+    EM.run { client.run }
+  end
+
+  if options[:daemonize]
+    pid = fork do
+      Process.setsid
+      exit if fork
+      File.open(options[:pid], 'w') { |f| f << Process.pid } if options[:pid]
+      run options
+      FileUtils.rm(options[:pid]) if options[:pid]
     end
+    ::Process.detach pid
+    exit
+  else
+    run options
   end
 end

data/lib/blather/client/client.rb

@@ -3,8 +3,8 @@ require File.join(File.dirname(__FILE__), *%w[.. .. blather])
 module Blather #:nodoc:
 
   class Client #:nodoc:
-    attr_accessor :jid,
-                  :roster
+    attr_reader :jid,
+                :roster
 
     def initialize
       @state = :initializing
@@ -17,6 +17,24 @@ module Blather #:nodoc:
       setup_initial_handlers
     end
 
+    def jid=(new_jid)
+      @jid = JID.new new_jid
+    end
+
+    def status
+      @status.state
+    end
+
+    def status=(state)
+      state, msg, to = state
+
+      status = Stanza::Presence::Status.new state, msg
+      status.to = to
+      @status = status unless to
+
+      write status
+    end
+
     def setup?
       @setup.is_a? Array
     end
@@ -30,11 +48,8 @@ module Blather #:nodoc:
 
     def run
       raise 'not setup!' unless setup?
-      trap(:INT) { EM.stop }
-      EM.run {
-        klass = @setup[0].node ? Blather::Stream::Client : Blather::Stream::Component
-        klass.start self, *@setup
-      }
+      klass = @setup[0].node ? Blather::Stream::Client : Blather::Stream::Component
+      @stream = klass.start self, *@setup
     end
 
     def register_tmp_handler(id, &handler)
@@ -42,62 +57,38 @@ module Blather #:nodoc:
     end
 
     def register_handler(type, *guards, &handler)
+      check_guards guards
       @handlers[type] ||= []
       @handlers[type] << [guards, handler]
     end
 
-    def status
-      @status.state
-    end
-
-    def status=(state)
-      state, msg, to = state
-
-      status = Stanza::Presence::Status.new state, msg
-      status.to = to
-      @status = status unless to
-
-      write status
-    end
-
     def write(stanza)
       stanza.from ||= jid if stanza.respond_to?(:from)
       @stream.send(stanza) if @stream
     end
 
-    def write_with_handler(stanza, &hanlder)
+    def write_with_handler(stanza, &handler)
       register_tmp_handler stanza.id, &handler
       write stanza
     end
 
-    def stream_started(stream)
-      @stream = stream
-
-      #retreive roster
-      if @stream.is_a?(Stream::Component)
-        @state = :ready
-        call_handler_for :ready, nil
-      else
-        r = Stanza::Iq::Roster.new
-        register_tmp_handler r.id do |node|
-          roster.process node
-          @state = :ready
-          write @status
-          call_handler_for :ready, nil
-        end
-        write r
+    def post_init
+      case @stream
+      when Stream::Component  then ready!
+      when Stream::Client     then client_post_init
+      else                    raise "Don't know #{@stream.class} stream type. How the hell did this happen!?"
       end
     end
 
-    def stop
+    def close
       @stream.close_connection_after_writing
     end
 
-    def stopped
-      EM.stop
+    def unbind
+      EM.stop if EM.reactor_running?
     end
 
-    def call(stanza)
+    def receive_data(stanza)
       if handler = @tmp_handlers.delete(stanza.id)
         handler.call stanza
       else
@@ -107,21 +98,14 @@ module Blather #:nodoc:
       end
     end
 
-    def call_handler_for(type, stanza)
-      if @handlers[type]
-        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
-        true
-      end
-    end
-
   protected
     def setup_initial_handlers
       register_handler :error do |err|
         raise err
       end
 
-      register_handler :iq do |iq|
-        write(StanzaError.new(iq, 'service-unavailable', :cancel).to_node) if [:set, :get].include?(iq.type)
+      register_handler :iq, :type => [:get, :set] do |iq|
+        write(StanzaError.new(iq, 'service-unavailable', :cancel).to_node)
       end
 
       register_handler :status do |status|
@@ -133,8 +117,30 @@ module Blather #:nodoc:
       end
     end
 
+    def ready!
+      @state = :ready
+      call_handler_for :ready, nil
+    end
+
+    def client_post_init
+      write_with_handler Stanza::Iq::Roster.new do |node|
+        roster.process node
+        write @status
+        ready!
+      end
+    end
+
+    def call_handler_for(type, stanza)
+      if @handlers[type]
+        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
+        true
+      end
+    end
+
     ##
     # If any of the guards returns FALSE this returns true
+    # the logic is reversed to allow short circuiting
+    # (why would anyone want to loop over more values than necessary?)
     def guarded?(guards, stanza)
       guards.find do |guard|
         case guard
@@ -158,8 +164,16 @@ module Blather #:nodoc:
           end
         when Proc
           !guard.call(stanza)
-        else
-          raise "Bad guard: #{guard.inspect}"
+        end
+      end
+    end
+
+    def check_guards(guards)
+      guards.each do |guard|
+        case guard
+        when Array              then guard.each { |g| check_guards([g]) }
+        when Symbol, Proc, Hash then nil
+        else                    raise "Bad guard: #{guard.inspect}"
         end
       end
     end

data/lib/blather/client/dsl.rb

@@ -13,14 +13,13 @@ module Blather
     # host and port are optional defaulting to the domain in the JID and 5222 respectively
     def setup(jid, password, host = nil, port = nil)
       client.setup(jid, password, host, port)
-      at_exit { client.run }
     end
 
     ##
     # Shutdown the connection.
     # Flushes the write buffer then stops EventMachine
     def shutdown
-      client.stop
+      client.close
     end
 
     ##
@@ -37,13 +36,13 @@ module Blather
 
     ##
     # Set current status
-    def status(state = nil, msg = nil)
+    def set_status(state = nil, msg = nil)
       client.status = state, msg
     end
 
     ##
     # Direct access to the roster
-    def roster
+    def my_roster
       client.roster
     end
 
@@ -51,7 +50,7 @@ module Blather
     # Write data to the stream
     # Anything that resonds to #to_s can be paseed to the stream
     def write(stanza)
-      client.write(stanza)
+      client.write stanza
     end
 
     ##
@@ -68,7 +67,9 @@ module Blather
     end
 
     ##
-    #
+    # Request items or info from an entity
+    #   discover (items|info), [jid], [node] do |response|
+    #   end
     def discover(what, who, where, &callback)
       stanza = Blather::Stanza.class_from_registration(:query, "http://jabber.org/protocol/disco##{what}").new
       stanza.to = who
@@ -78,22 +79,16 @@ module Blather
       write stanza
     end
 
-    ##
-    # PubSub proxy
-    def pubsub
-      client.pubsub
-    end
-
     ##
     # Checks to see if the method is part of the handlers list.
     # If so it creates a handler, otherwise it'll pass it back
     # to Ruby's method_missing handler
-    def method_missing(method, *args, &block)
-      if Blather::Stanza.handler_list.include?(method)
-        handle method, *args, &block
-      else
-        super
-      end
+    Blather::Stanza.handler_list.each do |handler_name|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{handler_name}(*args, &callback)
+          handle :#{handler_name}, *args, &callback
+        end
+      METHOD
     end
   end #DSL
 end #Blather