sprsquish-blather 0.1 → 0.2.3

data/LICENSE

@@ -1,3 +1,5 @@
+Blather
+
 Copyright (c) 2008 Jeff Smick
  
 Permission is hereby granted, free of charge, to any person obtaining

data/README.rdoc

@@ -1,3 +1,103 @@
 = Blather
 
 An evented XMPP library
+
+== Features
+
+* evented architecture
+* uses libxml
+* simplified starting point
+
+== Project Pages
+
+GitHub:: https://github.com/sprsquish/blather
+
+RubyForge:: http://rubyforge.org/projects/squishtech/
+
+== Author
+
+Jeff Smick <sprsquish@gmail.com>
+
+= Usage
+
+== Installation
+
+  sudo gem install blather
+
+== Example
+
+See the /examples directory for more advanced examples.
+
+This will auto-accept any subscription requests and echo back any chat messages.
+
+  require 'rubygems'
+  require 'blather/client'
+
+  setup 'echo@jabber.local', 'echo'
+
+  # Auto approve subscription requests
+  subscription :request? do |s|
+    write s.approve!
+  end
+
+  # Echo back what was said
+  message :chat?, :body do |m|
+    write m.reply
+  end
+
+== Handlers
+
+Setup handlers by calling their names as methods.
+
+  # Will only be called for messages where #chat? responds positively
+  # and #body == 'exit'
+  message :chat?, :body => 'exit'
+
+=== Handler Guards
+
+Guards act like AND statements. Each condition must be met if the handler is to be used.
+
+  # Equivalent to saying (stanza.chat? && stanza.body)
+  message :chat?, :body
+
+There are 5 different types of guards:
+
+  # Symbol
+  #   Checks for a non-false reply to calling the symbol on the stanza
+  #   Equivalent to stanza.chat?
+  message :chat?
+
+  # Hash with value (:body => 'exit')
+  #   Calls the key on the stanza and checks for equality
+  #   Equivalent to stanza.body == 'exit'
+  message :body => 'exit'
+
+  # Hash with regular expression (:body => /exit/)
+  #   Calls the key on the stanza and checks for a match
+  #   Equivalent to stanza.body.match /exit/
+  message :body => /exit/
+
+  # Proc
+  #   Calls the proc passing in the stanza
+  #   Checks that the ID is modulo 3
+  message proc { |m| m.id % 3 == 0 }
+
+  # Array
+  #   Use arrays with the previous types effectively turns the guard into
+  #   an OR statement.
+  #   Equivalent to stanza.body == 'foo' || stanza.body == 'baz'
+  message [{:body => 'foo'}, {:body => 'baz'}]
+
+= TODO
+
+* Cleanup API
+* Add lambda callback ability to Iq stanzas
+* Better Documentation
+* Service Discovery (XEP-0030: http://xmpp.org/extensions/xep-0030.html)
+* PubSub (XEP-0060: http://xmpp.org/extensions/xep-0060.html)
+* More examples (Re-write XMPP4R examples into Blather)
+
+= License
+
+Please see LICENSE
+The LibXML-Ruby license can be found in its directory

data/Rakefile

@@ -0,0 +1,110 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'blather'
+    gem.summary = 'An evented XMPP library written on EventMachine and libxml-ruby'
+
+    gem.email = 'sprsquish@gmail.com'
+    gem.homepage = 'http://github.com/sprsquish/blather'
+    gem.authors = ['Jeff Smick']
+
+    gem.rubyforge_project = 'squishtech'
+
+    gem.extensions = ['Rakefile']
+
+    gem.add_dependency 'eventmachine', '>= 0.12.6'
+    gem.add_dependency 'libxml-ruby', '>= 1.1.3'
+
+    gem.files = FileList['examples/**/*', 'lib/**/*', 'ext/*'].to_a
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'spec'
+    test.pattern = 'spec/**/*_spec.rb'
+    test.rcov_opts += ['--exclude \/Library\/Ruby\/Gems,spec\/', '--xrefs']
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+begin
+  require 'hanna/rdoctask'
+
+  Rake::RDocTask.new do |rdoc|
+    if File.exist?('VERSION.yml')
+      config = YAML.load(File.read('VERSION.yml'))
+      version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+    else
+      version = ""
+    end
+
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title = "blather #{version}"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+    rdoc.options += %w[-S -T hanna --main README.rdoc --exclude autotest --exclude vendor]
+  end
+rescue LoadError
+  task :rdoc do
+    abort "Hanna is not available. In order to use the Hanna, you must: sudo gem install mislav-hanna"
+  end
+end
+
+MAKE = ENV['MAKE'] || (RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make')
+
+namespace :ext do
+  ext_sources = FileList['ext/*.{rb,c}']
+
+  desc 'Compile the makefile'
+  file 'ext/Makefile' => ext_sources do
+    chdir('ext') { ruby 'extconf.rb' }
+  end
+
+  desc "make extension"
+  task :make => ext_sources + ['ext/Makefile'] do
+    chdir('ext') { sh MAKE }
+  end
+
+  desc 'Build push parser'
+  task :build => :make
+
+  desc 'Clean extensions'
+  task :clean do
+    chdir 'ext' do
+      sh "rm -f Makefile"
+      sh "rm -f *.{o,so,bundle,log}"
+    end
+  end
+end
+
+# If running under rubygems...
+__DIR__ ||= File.expand_path(File.dirname(__FILE__))
+if Gem.path.any? {|path| %r(^#{Regexp.escape path}) =~ __DIR__}
+  task :default => :gem_build
+else
+  task :default => ['ext:build', :test]
+end
+ 
+desc ":default build when running under rubygems."
+task :gem_build => 'ext:build'

data/examples/drb_client.rb

@@ -0,0 +1,5 @@
+%w[rubygems lib/blather/client drb/drb].each { |r| require r }
+
+setup 'drb_client@jabber.local', 'drb_client'
+
+when_ready { DRb.start_service 'druby://localhost:99843', self }

data/examples/echo.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'blather/client'
+
+when_ready { puts "Connected ! send messages to #{jid.stripped}." }
+
+subscription :request? do |s|
+  write s.approve!
+end
+
+message :chat?, :body => 'exit' do |m|
+  say m.from, 'Exiting ...'
+  shutdown
+end
+
+message :chat?, :body do |m|
+  say m.from, "You sent: #{m.body}"
+end

data/ext/extconf.rb

@@ -0,0 +1,65 @@
+require 'mkmf'
+
+flags = []
+
+case RUBY_PLATFORM.split('-',2)[1]
+when 'mswin32', 'mingw32', 'bccwin32'
+  unless have_header('windows.h') and
+      have_header('winsock.h') and
+      have_library('kernel32') and
+      have_library('rpcrt4') and
+      have_library('gdi32')
+    exit
+  end
+
+  flags << "-D OS_WIN32"
+  flags << '-D BUILD_FOR_RUBY'
+  flags << "-EHs"
+  flags << "-GR"
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && have_header('libxml/parser.h')
+
+when /solaris/
+  unless have_library('pthread') and
+	have_library('nsl') and
+	have_library('socket')
+	  exit
+  end
+
+  flags << '-D OS_UNIX'
+  flags << '-D OS_SOLARIS8'
+  flags << '-D BUILD_FOR_RUBY'
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && find_header('libxml/parser.h', '/usr/include/libxml2')
+
+  # on Unix we need a g++ link, not gcc.
+  #CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+when /darwin/
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && find_header('libxml/parser.h', '/usr/include/libxml2')
+  # on Unix we need a g++ link, not gcc.
+  #CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+else
+  unless have_library('pthread')
+	  exit
+  end
+
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && find_header('libxml/parser.h', '/usr/include/libxml2')
+  # on Unix we need a g++ link, not gcc.
+  #CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+$CFLAGS += ' ' + flags.join(' ')
+
+create_makefile "push_parser"

data/ext/push_parser.c

@@ -0,0 +1,231 @@
+/*
+ * Most of this was ripped from libxml-ruby's SAX handler
+ */
+
+#include <libxml/parser.h>
+#include <ruby.h>
+
+xmlSAXHandler saxHandler;
+
+static VALUE
+push_parser_raise_error (
+  xmlErrorPtr error)
+{
+  rb_raise(rb_eStandardError, "%s", rb_str_new2((const char*)error->message));
+  return Qnil;
+}
+
+static VALUE
+push_parser_initialize (
+  VALUE self,
+  VALUE handler)
+{
+  xmlParserCtxtPtr ctxt;
+  ctxt = xmlCreatePushParserCtxt(&saxHandler, (void *)handler, NULL, 0, NULL);
+  
+  if (!ctxt)
+    return push_parser_raise_error(&xmlLastError);
+
+  ctxt->sax2 = 1;
+
+  rb_iv_set(self, "@__libxml_push_parser", Data_Wrap_Struct(rb_cData, 0, xmlFreeParserCtxt, ctxt));
+
+  return self;
+}
+
+static VALUE
+push_parser_close (
+  VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(rb_iv_get(self, "@__libxml_push_parser"), xmlParserCtxt, ctxt);
+  
+  if (xmlParseChunk(ctxt, "", 0, 1)) {
+    return push_parser_raise_error(&xmlLastError);
+  }
+  else {
+    return Qtrue;
+  }
+}
+
+static VALUE
+push_parser_receive (
+  VALUE self,
+  VALUE chunk)
+{
+  const char *data = StringValuePtr(chunk);
+  int length = RSTRING_LEN(chunk);
+
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(rb_iv_get(self, "@__libxml_push_parser"), xmlParserCtxt, ctxt);
+
+  // Chunk through in 4KB chunks so as not to overwhelm the buffers
+  int i;
+  int chunkSize = length < 4096 ? length : 4096;
+  for (i = 0; i < length; i += chunkSize) {
+    xmlParseChunk(ctxt, data+i, chunkSize, 0);
+  }
+  if ((i -= length) > 0)
+    xmlParseChunk(ctxt, data+(length-i), i, 0);
+
+  return self;
+}
+
+/*********
+ CALLBACKS
+**********/
+static void
+push_parser_start_document_callback (
+  void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+  if (handler != Qnil)
+    rb_funcall (handler, rb_intern("on_start_document"), 0);
+}
+
+static void
+push_parser_end_document_callback (
+  void *ctx)
+{
+  VALUE handler = (VALUE) ctx;
+  if (handler != Qnil)
+    rb_funcall (handler, rb_intern("on_end_document"), 0);
+}
+
+static void
+push_parser_start_element_ns_callback (
+  void * ctx,
+  const xmlChar * localname,
+  const xmlChar * prefix,
+  const xmlChar * URI,
+  int nb_namespaces,
+  const xmlChar ** namespaces,
+  int nb_attributes,
+  int nb_defaulted,
+  const xmlChar ** attributes)
+{
+  VALUE handler = (VALUE) ctx;
+  if (handler == Qnil)
+    return;
+
+  VALUE attrHash = rb_hash_new();
+  VALUE nsHash = rb_hash_new();
+
+  if (attributes)
+  {
+    /* Each attribute is an array of [localname, prefix, URI, value, end] */
+    int i;
+    for (i = 0; i < nb_attributes * 5; i += 5)
+    {
+      rb_hash_aset( attrHash,
+                    rb_str_new2((const char*)attributes[i+0]),
+                    rb_str_new((const char*)attributes[i+3], attributes[i+4] - attributes[i+3]));
+    }
+  }
+
+  if (namespaces)
+  {
+    int i;
+    for (i = 0; i < nb_namespaces * 2; i += 2)
+    {
+      rb_hash_aset( nsHash,
+                    namespaces[i+0] ? rb_str_new2((const char*)namespaces[i+0]) : Qnil,
+                    namespaces[i+1] ? rb_str_new2((const char*)namespaces[i+1]) : Qnil);
+    }
+  }
+
+  rb_funcall(handler, rb_intern("on_start_element_ns"), 5, 
+             rb_str_new2((const char*)localname),
+             attrHash,
+             prefix ? rb_str_new2((const char*)prefix) : Qnil,
+             URI ? rb_str_new2((const char*)URI) : Qnil,
+             nsHash);
+}
+
+static void
+push_parser_end_element_ns_callback (
+  void * ctx,
+  const xmlChar * localname,
+  const xmlChar * prefix,
+  const xmlChar * URI)
+{
+  VALUE handler = (VALUE) ctx;
+  if (handler == Qnil)
+    return;
+
+  rb_funcall(handler, rb_intern("on_end_element_ns"), 3, 
+             rb_str_new2((const char*)localname),
+             prefix ? rb_str_new2((const char*)prefix) : Qnil,
+             URI ? rb_str_new2((const char*)URI) : Qnil);
+}
+
+
+static void
+push_parser_characters_callback (
+  void *ctx,
+  const char *chars,
+  int len)
+{
+  VALUE handler = (VALUE) ctx;
+  if (handler != Qnil)
+    rb_funcall (handler, rb_intern("on_characters"), 1, rb_str_new(chars, len));
+}
+
+static void
+push_parser_structured_error_callback (
+  void *ctx,
+  xmlErrorPtr error)
+{
+  VALUE handler = (VALUE) ctx;
+  if (handler != Qnil)
+    rb_funcall (handler, rb_intern("on_error"), 1, rb_str_new2((const char*)error->message));
+}
+
+xmlSAXHandler saxHandler = {
+  0, //internalSubset
+  0, //isStandalone
+  0, //hasInternalSubset
+  0, //hasExternalSubset
+  0, //resolveEntity
+  0, //getEntity
+  0, //entityDecl
+  0, //notationDecl
+  0, //attributeDecl
+  0, //elementDecl
+  0, //unparsedEntityDecl
+  0, //setDocumentLocator
+  (startDocumentSAXFunc) push_parser_start_document_callback,
+  (endDocumentSAXFunc) push_parser_end_document_callback,
+  0, //startElement
+  0, //endElement
+  0, //reference
+  (charactersSAXFunc) push_parser_characters_callback,
+  0, //ignorableWhitespace
+  0, //processingInstruction
+  0, //comment
+  0, //warning
+  (errorSAXFunc) push_parser_structured_error_callback,
+  0, //fatalError
+  0, //getParameterEntity
+  0, //cdataBlock
+  0, //externalSubset
+  XML_SAX2_MAGIC,
+  0, //_private
+  (startElementNsSAX2Func) push_parser_start_element_ns_callback,
+  (endElementNsSAX2Func) push_parser_end_element_ns_callback,
+  (xmlStructuredErrorFunc) push_parser_structured_error_callback
+};
+
+void
+Init_push_parser()
+{
+  /* SaxPushParser */
+  VALUE mLibXML = rb_define_module("LibXML");
+  VALUE mXML = rb_define_module_under(mLibXML, "XML");
+  VALUE cXMLSaxPushParser = rb_define_class_under(mXML, "SaxPushParser", rb_cObject);
+
+  /* Instance Methods */
+  rb_define_method(cXMLSaxPushParser, "initialize", push_parser_initialize, 1);
+  rb_define_method(cXMLSaxPushParser, "receive", push_parser_receive, 1);
+  rb_define_method(cXMLSaxPushParser, "close", push_parser_close, 0);
+}