sprsquish-blather 0.3.4 → 0.4.0

data/LICENSE

@@ -1,6 +1,6 @@
 Blather
 
-Copyright (c) 2008 Jeff Smick
+Copyright (c) 2009 Jeff Smick
  
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,11 +1,11 @@
 = Blather
 
-An evented XMPP library
+XMPP DSL (and more) for Ruby written on EventMachine and Nokogiri.
 
 == Features
 
 * evented architecture
-* uses libxml
+* uses Nokogiri
 * simplified starting point
 
 == Project Pages
@@ -18,11 +18,7 @@ GitHub Docs:: http://docs.github.com/sprsquish/blather
 
 RubyForge:: http://rubyforge.org/projects/squishtech
 
-RDocs:: http://squishtech.rubyforge.org/blather/
-
-== Author
-
-Jeff Smick <sprsquish@gmail.com>
+RDocs:: http://squishtech.rubyforge.org/blather
 
 = Usage
 
@@ -32,7 +28,7 @@ Jeff Smick <sprsquish@gmail.com>
 
 == Example
 
-See the /examples directory for more advanced examples.
+See the examples directory for more advanced examples.
 
 This will auto-accept any subscription requests and echo back any chat messages.
 
@@ -73,7 +69,7 @@ The different types of guards are:
   #   Equivalent to stanza.chat?
   message :chat?
 
-  # Hash with value (:body => 'exit')
+  # Hash with any value (:body => 'exit')
   #   Calls the key on the stanza and checks for equality
   #   Equivalent to stanza.body == 'exit'
   message :body => 'exit'
@@ -99,6 +95,12 @@ The different types of guards are:
   #   Equivalent to stanza.body == 'foo' || stanza.body == 'baz'
   message [{:body => 'foo'}, {:body => 'baz'}]
 
+  # XPath
+  #   Runs the xpath query on the stanza and checks for results
+  #   This guard type cannot be combined with other guards
+  #   Equivalent to !stanza.find('/iq/ns:pubsub', :ns => 'pubsub:namespace').empty?
+  iq '/iq/ns:pubsub', :ns => 'pubsub:namespace'
+
 == On the Command Line:
 
 Default usage is:
@@ -117,11 +119,38 @@ Command line options:
 
 = TODO
 
-* 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)
 * More examples (Re-write XMPP4R examples into Blather)
 
+= Author
+
+Jeff Smick <sprsquish@gmail.com>
+
+= Contributors
+
+Nolan Darilek <nolan@thewordnerd.info>
+
 = License
 
-Please see LICENSE
+Blather
+
+Copyright (c) 2009 Jeff Smick
+ 
+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/examples/echo.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'blather/client'
-
+Blather.logger.level = Logger::DEBUG
 when_ready { puts "Connected ! send messages to #{jid.stripped}." }
 
 subscription :request? do |s|

data/examples/execute.rb

@@ -1,11 +1,6 @@
 #!/usr/bin/env ruby
 
 require 'blather/client'
-require 'blather/client/pubsub'
-
-setup 'echo@jabber.local', 'echo'
-
-Blather::LOG.level = Logger::DEBUG
 
 message :chat?, :body => 'exit' do |m|
   say m.from, 'Exiting ...'

data/examples/pubsub/cli.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'blather/client'
+
+#ls
+#cd
+#cat
+#Blather::LOG.level = Logger::DEBUG
+module CliHandler
+  include EM::Protocols::LineText2
+
+  def ls(node)
+    pubsub.node(parse_dir(node)) do |result|
+      cur = node.split('/')
+      puts
+      puts result.items.map { |i| (i.node.split('/') - cur).join('/') }.join("\n")
+      start_line
+    end
+  end
+
+  def cd(node)
+    @node = parse_dir(node)
+    start_line
+  end
+
+  def cat(item)
+  end
+
+  def connect(who)
+    @who = who
+    puts "connected to '#{who}'"
+  end
+
+  def exit(_)
+    EM.stop
+  end
+
+  def initialize
+    $stdout.sync = true
+    @node = ''
+    @who = ''
+    start_line
+  end
+
+  def start_line
+    puts "\n/#{@node}> "
+  end
+
+  def receive_line(line)
+    return unless line =~ /(connect|exit|ls|cd|cat)\s?(.*)/i
+    __send__ $1, $2
+  end
+
+  def parse_dir(list)
+    return '' if list == '/'
+    cur = @node.split('/')
+    list.split('/').each { |dir| dir == '..' ? cur.pop : (cur << dir) }
+    cur * '/'
+  end
+end
+
+setup 'echo@jabber.local', 'echo'
+pubsub_host 'pubsub.jabber.local'
+when_ready { EM.open_keyboard CliHandler }

data/examples/pubsub/ping_pong.rb

@@ -0,0 +1,18 @@
+setup 'ping-pong@jabber.local', 'ping-pong'
+
+pubsub.host = 'pubsub.jabber.local'
+
+pubsub_event :node => 'ping' do |node|
+  pubsub.publish 'pong', node.payload
+end
+
+pubsub_event :node => 'pong' do |node|
+  x = node.payload.to_i
+  if x > 0
+    pubsub.publish 'ping', (x - 1)
+  else
+    shutdown
+  end
+end
+
+when_ready { pubsub.publish 'ping', 3 }

data/examples/rosterprint.rb

@@ -0,0 +1,14 @@
+#!/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

@@ -0,0 +1,35 @@
+#!/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

@@ -40,7 +40,8 @@ module Blather #:nodoc:
     end
 
     def setup(jid, password, host = nil, port = nil)
-      @setup = [JID.new(jid), password]
+      @jid = JID.new(jid)
+      @setup = [@jid, password]
       @setup << host if host
       @setup << port if port
       self
@@ -63,7 +64,6 @@ module Blather #:nodoc:
     end
 
     def write(stanza)
-      stanza.from ||= jid if stanza.respond_to?(:from)
       @stream.send(stanza) if @stream
     end
 
@@ -73,11 +73,7 @@ module Blather #:nodoc:
     end
 
     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
+      self.jid.node ? client_post_init : ready!
     end
 
     def close
@@ -93,7 +89,7 @@ module Blather #:nodoc:
         handler.call stanza
       else
         stanza.handler_heirarchy.each do |type|
-          break if call_handler_for(type, stanza) && (stanza.is_a?(BlatherError) || stanza.type == :iq)
+          break if call_handler_for(type, stanza)# && (stanza.is_a?(BlatherError) || stanza.type == :iq)
         end
       end
     end
@@ -132,8 +128,15 @@ module Blather #:nodoc:
 
     def call_handler_for(type, stanza)
       if @handlers[type]
-        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
-        true
+        @handlers[type].find do |guards, handler|
+          if guards.first.is_a?(String)
+            unless (result = stanza.find(*guards)).empty?
+              handler.call(stanza, result)
+            end
+          elsif !guarded?(guards, stanza)
+            handler.call(stanza)
+          end
+        end
       end
     end
 
@@ -171,9 +174,12 @@ module Blather #:nodoc:
     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}"
+        when Array
+          guard.each { |g| check_guards([g]) }
+        when Symbol, Proc, Hash, String
+          nil
+        else
+          raise "Bad guard: #{guard.inspect}"
         end
       end
     end

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

@@ -0,0 +1,133 @@
+module Blather
+module DSL
+
+  class PubSub
+    attr_accessor :host
+
+    def initialize(host)
+      @host = host
+    end
+
+    ##
+    # Retrieve Affiliations
+    # Yields a hash of affiliations in the form:
+    #   {:aff_type => ['node1', 'node2']}
+    def affiliations(host = nil, &callback)
+      request Stanza::PubSub::Affiliations.new(:get, send_to(host)), :list, callback
+    end
+
+    ##
+    # Retrieve Subscriptions
+    # Yields a hash of subscriptions in the form:
+    #   {:sub_type => [{:node => 'node1', :jid => 'j@d'}]}
+    def subscriptions(host = nil, &callback)
+      request Stanza::PubSub::Subscriptions.new(:get, send_to(host)), :list, callback
+    end
+
+    ##
+    # Discover Nodes
+    # Yields a list of DiscoItem::Item objects
+    #   +path+ is the node's path. Default is '/'
+    def nodes(path = nil, host = nil, &callback)
+      path ||= '/'
+      stanza = Stanza::DiscoItems.new(:get, path)
+      stanza.to = send_to(host)
+      request stanza, :items, callback
+    end
+
+    ##
+    # Discover node information
+    # Yields a DiscoInfo node
+    #   +path+ is the node's path
+    def node(path, host = nil, &callback)
+      stanza = Stanza::DiscoInfo.new(:get, path)
+      stanza.to = send_to(host)
+      request stanza, nil, callback
+    end
+
+    ##
+    # Retrieve items for a node
+    #   +path+ is the node's path
+    #   +list+ can be an array of items to retrieve
+    #   +max+ can be the maximum number of items to return
+    def items(path, list = [], max = nil, host = nil, &callback)
+      request Stanza::PubSub::Items.request(send_to(host), path, list, max), :items, callback
+    end
+
+    ##
+    # Subscribe to a node
+    # Yields the resulting Subscription object
+    #   +node+ is the node to subscribe to
+    #   +jid+ is the jid that should be used. Defaults to the stripped current JID
+    def subscribe(node, jid = nil, host = nil)
+      jid ||= DSL.client.jid.stripped
+      request(Stanza::PubSub::Subscribe.new(:set, send_to(host), node, jid)) { |n| yield n if block_given? }
+    end
+
+    ##
+    # Unsubscribe from a node
+    # Yields the resulting Unsubscribe object
+    #   +node+ is the node to subscribe to
+    #   +jid+ is the jid that should be used. Defaults to the stripped current JID
+    def unsubscribe(node, jid = nil, host = nil)
+      jid ||= DSL.client.jid.stripped
+      request(Stanza::PubSub::Unsubscribe.new(:set, send_to(host), node, jid)) { |n| yield n if block_given? }
+    end
+
+    ##
+    # Publish an item to a node
+    # Yields the resulting Publish node
+    #   +node+ is the node to publish to
+    #   +payload+ is the payload to send (see Blather::Stanza::PubSub::Publish for details)
+    def publish(node, payload, host = nil)
+      request(Stanza::PubSub::Publish.new(send_to(host), node, :set, payload)) { |n| yield n if block_given? }
+    end
+
+    ##
+    # Delete items from a node
+    # Yields the resulting node
+    #   +node+ is the node to retract items from
+    #   +ids+ is a list of ids to retract. This can also be a single id
+    def retract(node, ids = [], host = nil)
+      request(Stanza::PubSub::Retract.new(send_to(host), node, :set, ids)) { |n| yield n if block_given? }
+    end
+
+    ##
+    # Create a node
+    # Yields the resulting node
+    # This does not (yet) handle configuration
+    #   +node+ is the node to create
+    def create(node, host = nil)
+      request(Stanza::PubSub::Create.new(:set, send_to(host), node)) { |n| yield n if block_given? }
+    end
+
+    ##
+    # Purge all node items
+    # Yields the resulting node
+    #   +node+ is the node to purge
+    def purge(node, host = nil)
+      request(Stanza::PubSubOwner::Purge.new(:set, send_to(host), node)) { |n| yield n if block_given? }
+    end
+
+    ##
+    # Delete a node
+    # Yields the resulting node
+    #   +node+ is the node to delete
+    def delete(node, host = nil)
+      request(Stanza::PubSubOwner::Delete.new(:set, send_to(host), node)) { |n| yield n if block_given? }
+    end
+
+  private
+    def request(node, method = nil, callback = nil, &block)
+      block = lambda { |node| callback.call(method ? node.__send__(method) : node) } unless block_given?
+      DSL.client.write_with_handler(node, &block)
+    end
+
+    def send_to(host = nil)
+      raise 'You must provide a host' unless (host ||= @host)
+      host
+    end
+  end
+
+end
+end

data/lib/blather/client/dsl.rb

@@ -2,11 +2,27 @@ require File.join(File.dirname(__FILE__), 'client')
 
 module Blather
   module DSL
+
+    autoload :PubSub, File.expand_path(File.join(File.dirname(__FILE__), *%w[dsl pubsub]))
+
     def client
       @client ||= Client.new
     end
     module_function :client
 
+    def pubsub
+      @pubsub ||= PubSub.new jid.domain
+    end
+
+    ##
+    # Push data to the stream
+    # This works such that it can be chained:
+    #   self << stanza1 << stanza2 << "raw data"
+    def <<(stanza)
+      write stanza
+      self
+    end
+
     ##
     # Prepare server settings
     #   setup [node@domain/resource], [password], [host], [port]

data/lib/blather/client.rb

@@ -60,7 +60,7 @@ at_exit do
     if options[:log]
       log = File.new(options[:log], 'a')
       log.sync = options[:debug]
-      Blather::LOG.level = Logger::DEBUG if options[:debug]
+      Blather.logger.level = Logger::DEBUG if options[:debug]
       $stdout.reopen log
       $stderr.reopen $stdout
     end

data/lib/blather/core_ext/active_support/inheritable_attributes.rb

@@ -0,0 +1,117 @@
+# Thanks to Rails ActiveSupport for everything in this file
+
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => value.duplicable? ? value.dup : value)
+        end
+      end
+
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end #Class