blather 0.2.2 → 0.2.3

data/examples/rosterprint.rb

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-# Prints out each roster entry
-
-require 'blather/client'
-
-when_ready do
-  roster.grouped.each do |group, items|
-    puts "#{'*'*3} #{group || 'Ungrouped'} #{'*'*3}"
-    items.each { |item| puts "- #{item.name} (#{item.jid})" }
-    puts
-  end
-  shutdown
-end

data/examples/xmpp4r/echo.rb

@@ -1,35 +0,0 @@
-#!/usr/bin/ruby
-
-# This bot will reply to every message it receives. To end the game, send 'exit'
-
-require 'xmpp4r/client'
-include Jabber
-
-# settings
-if ARGV.length != 2
-  puts "Run with ./echo_thread.rb user@server/resource password"
-  exit 1
-end
-myJID = JID.new(ARGV[0])
-myPassword = ARGV[1]
-cl = Client.new(myJID)
-cl.connect
-cl.auth(myPassword)
-cl.send(Presence.new)
-puts "Connected ! send messages to #{myJID.strip.to_s}."
-mainthread = Thread.current
-cl.add_message_callback do |m|
-  if m.type != :error
-    m2 = Message.new(m.from, "You sent: #{m.body}")
-    m2.type = m.type
-    cl.send(m2)
-    if m.body == 'exit'
-      m2 = Message.new(m.from, "Exiting ...")
-      m2.type = m.type
-      cl.send(m2)
-      mainthread.wakeup
-    end
-  end
-end
-Thread.stop
-cl.close

data/lib/blather/client/client.rb

@@ -1,165 +0,0 @@
-require File.join(File.dirname(__FILE__), *%w[.. .. blather])
-require File.join(File.dirname(__FILE__), 'pubsub')
-
-module Blather #:nodoc:
-
-  class Client #:nodoc:
-    attr_accessor :jid,
-                  :roster
-
-    def initialize
-      @state = :initializing
-
-      @status = Stanza::Presence::Status.new
-      @handlers = {}
-      @tmp_handlers = {}
-      @roster = Roster.new self
-
-      setup_initial_handlers
-    end
-
-    def setup?
-      @setup.is_a? Array
-    end
-
-    def setup(jid, password, host = nil, port = nil)
-      @setup = [JID.new(jid), password]
-      @setup << host if host
-      @setup << port if port
-      self
-    end
-
-    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
-      }
-    end
-
-    def register_tmp_handler(id, &handler)
-      @tmp_handlers[id] = handler
-    end
-
-    def register_handler(type, *guards, &handler)
-      @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)
-      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
-      end
-    end
-
-    def stop
-      @stream.close_connection_after_writing
-    end
-
-    def stopped
-      EM.stop
-    end
-
-    def call(stanza)
-      if handler = @tmp_handlers.delete(stanza.id)
-        handler.call stanza
-      else
-        stanza.handler_heirarchy.each do |type|
-          break if call_handler_for(type, stanza) && (stanza.is_a?(BlatherError) || stanza.type == :iq)
-        end
-      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::ServiceUnavailable.new(iq, :cancel).to_node) if [:set, :get].include?(iq.type)
-      end
-
-      register_handler :status do |status|
-        roster[status.from].status = status if roster[status.from]
-      end
-
-      register_handler :roster do |node|
-        roster.process node
-      end
-    end
-
-    ##
-    # If any of the guards returns FALSE this returns true
-    def guarded?(guards, stanza)
-      guards.find do |guard|
-        case guard
-        when Symbol
-          !stanza.__send__(guard)
-        when Array
-          # return FALSE if any item is TRUE
-          !guard.detect { |condition| !guarded?([condition], stanza) }
-        when Hash
-          # return FALSE unless any inequality is found
-          guard.find do |method, value|
-            if value.is_a?(Regexp)
-              !stanza.__send__(method).to_s.match(value)
-            else
-              stanza.__send__(method) != value
-            end
-          end
-        when Proc
-          !guard.call(stanza)
-        else
-          raise "Bad guard: #{guard.inspect}"
-        end
-      end
-    end
-
-  end #Client
-end #Blather

data/lib/blather/client/dsl.rb

@@ -1,99 +0,0 @@
-require File.join(File.dirname(__FILE__), 'client')
-
-module Blather
-  module DSL
-    def client
-      @client ||= Client.new
-    end
-    module_function :client
-
-    ##
-    # Prepare server settings
-    #   setup [node@domain/resource], [password], [host], [port]
-    # 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
-    end
-
-    ##
-    # Set handler for a stanza type
-    def handle(stanza_type, *guards, &block)
-      client.register_handler stanza_type, *guards, &block
-    end
-
-    ##
-    # Wrapper for "handle :ready" (just a bit of syntactic sugar)
-    def when_ready(&block)
-      handle :ready, &block
-    end
-
-    ##
-    # Set current status
-    def status(state = nil, msg = nil)
-      client.status = state, msg
-    end
-
-    ##
-    # Direct access to the roster
-    def roster
-      client.roster
-    end
-
-    ##
-    # Write data to the stream
-    # Anything that resonds to #to_s can be paseed to the stream
-    def write(stanza)
-      client.write(stanza)
-    end
-
-    ##
-    # Helper method to make sending basic messages easier
-    #   say [jid], [msg]
-    def say(to, msg)
-      client.write Blather::Stanza::Message.new(to, msg)
-    end
-
-    ##
-    # Wrapper to grab the current JID
-    def jid
-      client.jid
-    end
-
-    ##
-    #
-    def discover(what, who, where, &callback)
-      stanza = Blather::Stanza.class_from_registration(:query, "http://jabber.org/protocol/disco##{what}").new
-      stanza.to = who
-      stanza.node = where
-
-      client.temporary_handler stanza.id, &callback
-      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
-    end
-  end #DSL
-end #Blather

data/lib/blather/client/pubsub.rb

@@ -1,53 +0,0 @@
-module Blather
-class Client
-
-  class PubSub
-    attr_accessor :host
-
-    def affiliations(&callback)
-      request Stanza::PubSub::Affiliations.new(:get, @host), :affiliates, callback
-    end
-
-    def subscriptions(&callback)
-      request Stanza::PubSub::Subscriptions.new(:get, @host), :subscriptions, callback
-    end
-
-    def nodes(path, &callback)
-      stanza = Stanza::DiscoItems.new(:get, path)
-      stanza.to = @host
-      request stanza, :items, callback
-    end
-
-    def node(path)
-      stanza = Stanza::DiscoInfo.new(:get, path)
-      stanza.to = @host
-      request(stanza) { |node| yield Stanza::PubSub::Node.import(node) }
-    end
-
-    def items(path, list = [], max = nil, &callback)
-      request Stanza::PubSub.items(@host, path, list, max), :items, callback
-    end
-=begin
-    def create(node)
-    end
-
-    def publish(node, payload)
-    end
-
-    def subscribe(node)
-      DSL.client.write Stanza::PubSub::Subscribe.new(:set, host, node, DSL.client.jid)
-    end
-
-    def unsubscribe(node)
-      DSL.client.write Stanza::PubSub::Unsubscribe.new(:set, host, node, DSL.client.jid)
-    end
-=end
-  private
-    def request(node, method = nil, callback, &block)
-      block = lambda { |node| callback.call node.__send__(method) } unless block_given?
-      DSL.client.write_with_handler(node, &block)
-    end
-  end
-
-end
-end

data/lib/blather/client/pubsub/node.rb

@@ -1,27 +0,0 @@
-module Blather
-class Client
-class PubSub
-
-  class Node
-    attr_accessor :path
-
-    def initialize(path)
-      @path = path
-    end
-
-    def info(&block)
-      DSL.client.write_with_handler Stanza::DiscoInfo.new(:get, path), &block
-    end
-
-    def items(&block)
-      DSL.client.write_with_handler Stanza::PubSub.items(path), &block
-    end
-
-    def nodes(&block)
-      DSL.client.write_with_handler Stanza::DiscoItems.new(:get, path), &block
-    end
-  end
-
-end #PubSub
-end #Client
-end #Blather

data/lib/blather/stanza/pubsub.rb

@@ -1,33 +0,0 @@
-module Blather
-class Stanza
-
-  class PubSub < Iq
-    register :pubsub, :pubsub, 'http://jabber.org/protocol/pubsub'
-
-    ##
-    # Ensure the namespace is set to the query node
-    def initialize(type = nil, host = nil)
-      super type
-      self.to = host
-      pubsub.namespace = self.class.ns unless pubsub.namespace
-    end
-
-    ##
-    # Kill the pubsub node before running inherit
-    def inherit(node)
-      pubsub.remove!
-      super
-    end
-
-    def pubsub
-      unless p = find_first('//pubsub', Stanza::PubSub::Affiliations.ns)
-        p = XMPPNode.new('pubsub')
-        p.namespace = self.class.ns
-        self << p
-      end
-      p
-    end
-  end
-
-end #Stanza
-end #Blather

data/lib/blather/stanza/pubsub/affiliations.rb

@@ -1,52 +0,0 @@
-module Blather
-class Stanza
-class PubSub
-
-  class Affiliations < PubSub
-    register :pubsub_affiliations, :pubsub_affiliations, self.ns
-
-    include Enumerable
-
-    def initialize(type = nil, host = nil)
-      super
-      affiliations
-    end
-
-    ##
-    # Kill the affiliations node before running inherit
-    def inherit(node)
-      affiliations.remove!
-      super
-    end
-
-    def affiliations
-      aff = pubsub.find_first('//pubsub_ns:affiliations', :pubsub_ns => self.class.ns)
-      (self.pubsub << (aff = XMPPNode.new('affiliations'))) unless aff
-      aff
-    end
-
-    def [](affiliation)
-      list[affiliation]
-    end
-
-    def each(&block)
-      list.each &block
-    end
-
-    def size
-      list.size
-    end
-
-    def list
-      items = affiliations.find('//pubsub_ns:affiliation', :pubsub_ns => self.class.ns)
-      items.inject({}) do |hash, item|
-        hash[item.attributes[:affiliation].to_sym] ||= []
-        hash[item.attributes[:affiliation].to_sym] << item.attributes[:node]
-        hash
-      end
-    end
-  end #Affiliations
-
-end #PubSub
-end #Stanza
-end #Blather