xmpp4r 0.3

data/data/doc/xmpp4r/examples/buggy/miniedgarr_cgi.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+#
+# cp /usr/local/share/psi/iconsets/roster/lightbulb/{away,online,offline,xa,chat,dnd}.png .
+
+$:.unshift '../lib'
+
+require 'GD'
+require 'cgi'
+require 'digest/md5'
+        
+require 'rexml/document'
+
+require 'xmpp4r'
+require 'xmpp4r/iqqueryroster'
+
+# Handle CGI parameters
+cgi = CGI.new
+jid = Jabber::JID.new(cgi['jid']).strip
+jidhash = cgi['hash']
+transparency = (cgi['transparency'] == 'true')
+
+# Create data
+
+roster = Jabber::IqQueryRoster.new
+presences = {}
+
+# Load state
+
+doc = REXML::Document.new(File.new('edgarrstate.xml'))
+
+doc.root.each_element { |e|
+  if (e.name == 'query') && (e.namespace == 'jabber:iq:roster')
+    roster.import(e)
+  elsif e.name == 'presence'
+    pres = Jabber::Presence.new.import(e)
+
+    if (pres.from.strip == jid) || (Digest::MD5.new(pres.from.strip.to_s).to_s == jidhash)
+      if (jid == '') && !jidhash.nil?
+        jid = pres.from.strip
+      end
+      presences[pres.from] = pres
+    end
+  end
+}
+
+resources = (presences.size < 1) ? 1 : presences.size
+
+
+class BannerTable
+  def initialize
+    @lines = []
+  end
+
+  def last
+    @lines[@lines.size - 1]
+  end
+  
+  def add_line
+    @lines.push(BannerLine.new)
+  end
+
+  def paint
+    width = 0
+    height = 0
+    @lines.each do |line|
+      if width < line.w
+        width = line.w
+      end
+      height += line.h
+    end
+    
+    gd = GD::Image.new(width + 6, height + 6)
+    white = gd.colorAllocate(255,255,255)
+    black = gd.colorAllocate(0,0,0)       
+
+    gd.fill(0, 0, black)
+    gd.interlace = true
+    gd.rectangle(0,0,width + 5,height + 5,white)
+    y = 2
+
+    @lines.each do |line|
+      line.paint(gd, 3, y + (line.h / 2))
+      y += line.h
+    end
+    
+    gd
+  end
+end
+
+class BannerLine
+  def initialize
+    @items = []
+  end
+
+  def add(type, text)
+    @items.push(BannerItem.new(type, text))
+  end
+
+  def w
+    w = 1
+    @items.each do |item|
+      w += item.w
+    end
+    w
+  end
+
+  def h
+    h = 0
+    @items.each do |item|
+      if h < item.h
+        h = item.h
+      end
+    end
+    h
+  end
+
+  def paint(gd, x_start, y_center)
+    x = x_start
+    @items.each do |item|
+      item.paint(gd, x, y_center - (item.h / 2))
+      x += item.w
+    end
+  end
+end
+
+class BannerItem
+  def initialize(type, text)
+    @type = type
+    @text = text
+  end
+
+  def w
+    if @type.kind_of?(GD::Font)
+      (@type.width * @text.size) + 2
+    elsif @type.kind_of?(GD::Image)
+      @type.width + 2
+    end
+  end
+
+  def h
+    if @type.kind_of?(GD::Font) || @type.kind_of?(GD::Image)
+      @type.height + 2
+    end
+  end
+
+  def paint(gd, x, y)
+    if @type.kind_of?(GD::Font) && (@text.size > 0)
+      gd.string(@type, x + 1, y + 1, @text, gd.colorAllocate(255,255,255))
+    elsif @type.kind_of?(GD::Image)
+      type = @type.to_paletteImage(false, 256)
+      type.copy(gd, x + 1, y + 1, 0, 0, type.height, type.height)
+    end
+  end
+end
+
+# Paint the image
+
+table = BannerTable.new
+table.add_line
+
+# Put JID at top
+if roster[jid.strip].nil?
+  iname = 'Unknown'
+else
+  iname = roster[jid.strip].iname.to_s
+end
+table.last.add(GD::Font::MediumFont, iname == '' ? jid.to_s : iname)
+
+if (presences.size < 1)
+  table.add_line
+  table.last.add(GD::Font::SmallFont, 'Unavailable')
+else
+  presences.each { |jid,pres|
+    show = pres.show.to_s
+    if pres.type == :unavailable
+      show = 'offline'
+    elsif pres.show.nil?
+      show = 'online'
+    end
+
+    table.add_line
+    table.last.add(GD::Image.newFromPng(File.new("miniedgarr_bulbs/#{show}.png")), nil)
+    prio = pres.priority.nil? ? 0 : pres.priority
+    table.last.add(GD::Font::SmallFont, "#{pres.from.resource} (#{prio})")
+    table.add_line
+    table.last.add(GD::Font::TinyFont, pres.status.to_s.strip)
+  }
+end
+
+# Convert the image to PNG and print it on standard output
+print "Content-type: image/png\r\n\r\n"
+table.paint.png STDOUT

data/data/doc/xmpp4r/examples/buggy/miniedgarr_watch.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'rexml/document'
+
+require 'xmpp4r'
+require 'xmpp4r/iqqueryroster'
+
+# Command line argument checking
+
+if ARGV.size != 3
+  puts("Usage: ./rosterwatch.rb <jid> <password> <statefile>")
+  exit
+end
+
+
+def write_state(statefile, roster, presences)
+  doc = REXML::Document.new
+  state = doc.add(REXML::Element.new('state'))
+  state.add(roster)
+  presences.each { |jid,pres| state.add(pres) }
+
+  file = File.new(statefile, "w")
+  doc.write(file, 0)
+  file.close
+end
+
+
+# Building up the connection
+
+Jabber::debug = true
+
+jid = Jabber::JID.new(ARGV[0])
+
+cl = Jabber::Client.new(jid, false)
+cl.connect
+cl.auth(ARGV[1])
+
+
+roster = Jabber::IqQueryRoster.new
+presences = {}
+
+cl.add_iq_callback { |iq|
+  if (iq.type == :result) && iq.query.kind_of?(Jabber::IqQueryRoster)
+    roster.import(iq.query)
+    write_state(ARGV[2], roster, presences)
+  end
+}
+
+# TODO: <presence><x xmlns='jabber:x:delay'>...</x></presence>
+cl.add_presence_callback { |pres|
+  # Handle subscription request
+  if pres.type == :subscribe
+    # Accept subscription
+    cl.send(Jabber::Presence.new.set_to(pres.from).set_type(:subscribed))
+    # Subscribe to sender
+    cl.send(Jabber::Presence.new.set_to(pres.from).set_type(:subscribe))
+    # Add to roster
+    # TODO: Resolve Nickname from vCard
+    roster_set_iq = Jabber::Iq.new(:set)
+    roster_set_iq.add(Jabber::IqQueryRoster.new).add(Jabber::RosterItem.new(pres.from.strip))
+    cl.send(roster_set_iq)
+  end
+  
+  presences[pres.from] = pres
+  write_state(ARGV[2], roster, presences)
+}
+
+# Send request for roster
+cl.send(Jabber::Iq.new_rosterget)
+# Send initial presence
+# This is important as it ensures reception of
+# further <presence/> stanzas
+cl.send(Jabber::Presence.new.set_show(:dnd).set_status('Watching my roster change...'))
+
+loop do
+  cl.process
+  sleep(1)
+end
+
+cl.close

data/lib/callbacks.rb

@@ -0,0 +1,122 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+##
+# This class manages a list of callbacks.
+#
+# ==Callbacks management and priority
+#
+# Callbacks are managed by the class CallbackList. When they are added, a
+# priority (just a number or anything Comparable with other priorities) is
+# specified. The biggest the priority is, the earliest the callback will be
+# considered.
+#
+# Callbacks are processed for a given set of objects as long as they return
+# false. If you want to stop processing, you must return true. Example :
+#  cbl = CallbackList::new
+#  c1 = false
+#  c2 = false
+#  c3 = false
+#  cbl.add(10) { c1 = true; 1 }
+#  cbl.add(5) { c2 = true; true }
+#  cbl.add(0) { c3 = true }
+#  cbl.process('aa')
+#  puts "#{c1} #{c2} #{c3}"
+# This example would display "true true false" as callbacks processing was
+# stopped after the second callback returned true.
+#
+# In XMPP4R, callbacks' priorities are quite normalized since we want to be
+# able to "cascade" callbacks in a clean way. Here are values your code should
+# take into account :
+# 
+# >= 200::  logging & debugging callbacks. Those callbacks should not consume
+#           elements.
+# 100-199:: Where Helpers register their callbacks. The normal value is 100,
+#           and Helpers shouldn't register something else unless there's a
+#           very good reason to.
+# < 100::   all those numbers are normally available for your application.
+#           That's enough, don't you think ?
+class CallbackList
+
+  # Create a new list of callbacks
+  def initialize
+    @list = []
+  end
+
+  ##
+  # Add a callback to the list
+  #
+  # List will be sorted afterwards
+  #
+  # prio:: [Integer] the callback's priority, the higher, the sooner.
+  # ref:: [String] the callback's reference
+  # block:: [Block] a block to execute
+  # return:: [Jabber::CallbackList] The list, for chaining
+  def add(prio = 0, ref = nil, proc = nil, &block)
+    block = proc if proc
+    @list.push(Callback::new(prio, ref, block))
+    @list.sort! { |a, b| b.priority <=> a.priority }
+    self
+  end
+
+  ##
+  # Delete a callback by reference
+  # ref:: [String] the reference of the callback to delete
+  # return:: [CallBackList] The list, for chaining
+  def delete(ref)
+    @list.delete_if { |item| item.ref == ref }
+    self
+  end
+
+  ##
+  # Number of elements in the list
+  # return:: [Integer] The number of elements
+  def length
+    @list.length
+  end
+
+  ##
+  # Process an element through all my callbacks. returns e.consumed?
+  # e:: [Object] The elements to pass to the callback. You can pass
+  # several, but of course, you block must know how to handle them.
+  # return:: [Boolean] true if the element has been consumed
+  def process(*e)
+    # If somebody adds a new callback the list will get modified
+    # and sorted(!) while still iterating through it. So we use a
+    # local copy of @list. Any freshly added callback will receive
+    # the next stanzas, not the current.
+    list = @list.dup
+
+    # process through callbacks
+    list.each do |item|
+      return true if item.block.call(*e) == true
+    end
+    false
+  end
+end
+
+# This class is used to store callbacks inside CallbackList. See the
+# CallbackList class for more detailed explanations.
+class Callback
+
+  # The Callback's priority
+  attr_reader :priority
+
+  # The Callback's reference, using for deleting purposes
+  attr_reader :ref
+
+  # The Callback's block to execute 
+  attr_reader :block
+
+  ##
+  # Create a new callback
+  # priority:: [Integer] the callback's priority. The higher, the sooner it
+  # will be executed
+  # ref:: [String] The callback's reference
+  def initialize(priority = 0, ref = nil, block = Proc::new {})
+    @priority = priority
+    @ref = ref
+    @block = block
+  end
+end

data/lib/xmpp4r/authenticationfailure.rb

@@ -0,0 +1,13 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+module Jabber
+  ##
+  # The AuthenticationFailure is an Exception to be raised
+  # when Client or Component authentication fails
+  #
+  # There are no special arguments
+  class AuthenticationFailure < RuntimeError
+  end
+end