evma_xmlpushparser 0.0.1

data/COPYING

@@ -0,0 +1,281 @@
+.
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+ freedom to share and change it.  By contrast, the GNU General Public
+ License is intended to guarantee your freedom to share and change free
+ software--to make sure the software is free for all its users.  This
+ General Public License applies to most of the Free Software
+ Foundation's software and to any other program whose authors commit to
+ using it.  (Some other Free Software Foundation software is covered by
+ the GNU Lesser General Public License instead.)  You can apply it to
+ your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+ price.  Our General Public Licenses are designed to make sure that you
+ have the freedom to distribute copies of free software (and charge for
+ this service if you wish), that you receive source code or can get it
+ if you want it, that you can change the software or use pieces of it
+ in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+ anyone to deny you these rights or to ask you to surrender the rights.
+ These restrictions translate to certain responsibilities for you if you
+ distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+ gratis or for a fee, you must give the recipients all the rights that
+ you have.  You must make sure that they, too, receive or can get the
+ source code.  And you must show them these terms so they know their
+ rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+ (2) offer you this license which gives you legal permission to copy,
+ distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+ that everyone understands that there is no warranty for this free
+ software.  If the software is modified by someone else and passed on, we
+ want its recipients to know that what they have is not the original, so
+ that any problems introduced by others will not reflect on the original
+ authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+ patents.  We wish to avoid the danger that redistributors of a free
+ program will individually obtain patent licenses, in effect making the
+ program proprietary.  To prevent this, we have made it clear that any
+ patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+ modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+ a notice placed by the copyright holder saying it may be distributed
+ under the terms of this General Public License.  The "Program", below,
+ refers to any such program or work, and a "work based on the Program"
+ means either the Program or any derivative work under copyright law:
+ that is to say, a work containing the Program or a portion of it,
+ either verbatim or with modifications and/or translated into another
+ language.  (Hereinafter, translation is included without limitation in
+ the term "modification".)  Each licensee is addressed as "you".
+
+ Activities other than copying, distribution and modification are not
+ covered by this License; they are outside its scope.  The act of
+ running the Program is not restricted, and the output from the Program
+ is covered only if its contents constitute a work based on the
+ Program (independent of having been made by running the Program).
+ Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+ source code as you receive it, in any medium, provided that you
+ conspicuously and appropriately publish on each copy an appropriate
+ copyright notice and disclaimer of warranty; keep intact all the
+ notices that refer to this License and to the absence of any warranty;
+ and give any other recipients of the Program a copy of this License
+ along with the Program.
+
+ You may charge a fee for the physical act of transferring a copy, and
+ you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+ of it, thus forming a work based on the Program, and copy and
+ distribute such modifications or work under the terms of Section 1
+ above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+ These requirements apply to the modified work as a whole.  If
+ identifiable sections of that work are not derived from the Program,
+ and can be reasonably considered independent and separate works in
+ themselves, then this License, and its terms, do not apply to those
+ sections when you distribute them as separate works.  But when you
+ distribute the same sections as part of a whole which is a work based
+ on the Program, the distribution of the whole must be on the terms of
+ this License, whose permissions for other licensees extend to the
+ entire whole, and thus to each and every part regardless of who wrote it.
+
+ Thus, it is not the intent of this section to claim rights or contest
+ your rights to work written entirely by you; rather, the intent is to
+ exercise the right to control the distribution of derivative or
+ collective works based on the Program.
+
+ In addition, mere aggregation of another work not based on the Program
+ with the Program (or with a work based on the Program) on a volume of
+ a storage or distribution medium does not bring the other work under
+ the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+ under Section 2) in object code or executable form under the terms of
+ Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+ The source code for a work means the preferred form of the work for
+ making modifications to it.  For an executable work, complete source
+ code means all the source code for all modules it contains, plus any
+ associated interface definition files, plus the scripts used to
+ control compilation and installation of the executable.  However, as a
+ special exception, the source code distributed need not include
+ anything that is normally distributed (in either source or binary
+ form) with the major components (compiler, kernel, and so on) of the
+ operating system on which the executable runs, unless that component
+ itself accompanies the executable.
+
+ If distribution of executable or object code is made by offering
+ access to copy from a designated place, then offering equivalent
+ access to copy the source code from the same place counts as
+ distribution of the source code, even though third parties are not
+ compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+ except as expressly provided under this License.  Any attempt
+ otherwise to copy, modify, sublicense or distribute the Program is
+ void, and will automatically terminate your rights under this License.
+ However, parties who have received copies, or rights, from you under
+ this License will not have their licenses terminated so long as such
+ parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+ signed it.  However, nothing else grants you permission to modify or
+ distribute the Program or its derivative works.  These actions are
+ prohibited by law if you do not accept this License.  Therefore, by
+ modifying or distributing the Program (or any work based on the
+ Program), you indicate your acceptance of this License to do so, and
+ all its terms and conditions for copying, distributing or modifying
+ the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+ Program), the recipient automatically receives a license from the
+ original licensor to copy, distribute or modify the Program subject to
+ these terms and conditions.  You may not impose any further
+ restrictions on the recipients' exercise of the rights granted herein.
+ You are not responsible for enforcing compliance by third parties to
+ this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+ infringement or for any other reason (not limited to patent issues),
+ conditions are imposed on you (whether by court order, agreement or
+ otherwise) that contradict the conditions of this License, they do not
+ excuse you from the conditions of this License.  If you cannot
+ distribute so as to satisfy simultaneously your obligations under this
+ License and any other pertinent obligations, then as a consequence you
+ may not distribute the Program at all.  For example, if a patent
+ license would not permit royalty-free redistribution of the Program by
+ all those who receive copies directly or indirectly through you, then
+ the only way you could satisfy both it and this License would be to
+ refrain entirely from distribution of the Program.
+
+ If any portion of this section is held invalid or unenforceable under
+ any particular circumstance, the balance of the section is intended to
+ apply and the section as a whole is intended to apply in other
+ circumstances.
+
+ It is not the purpose of this section to induce you to infringe any
+ patents or other property right claims or to contest validity of any
+ such claims; this section has the sole purpose of protecting the
+ integrity of the free software distribution system, which is
+ implemented by public license practices.  Many people have made
+ generous contributions to the wide range of software distributed
+ through that system in reliance on consistent application of that
+ system; it is up to the author/donor to decide if he or she is willing
+ to distribute software through any other system and a licensee cannot
+ impose that choice.
+
+ This section is intended to make thoroughly clear what is believed to
+ be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+ certain countries either by patents or by copyrighted interfaces, the
+ original copyright holder who places the Program under this License
+ may add an explicit geographical distribution limitation excluding
+ those countries, so that distribution is permitted only in or among
+ countries not thus excluded.  In such case, this License incorporates
+ the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+ of the General Public License from time to time.  Such new versions will
+ be similar in spirit to the present version, but may differ in detail to
+ address new problems or concerns.
+
+ Each version is given a distinguishing version number.  If the Program
+ specifies a version number of this License which applies to it and "any
+ later version", you have the option of following the terms and conditions
+ either of that version or of any later version published by the Free
+ Software Foundation.  If the Program does not specify a version number of
+ this License, you may choose any version ever published by the Free Software
+ Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+ programs whose distribution conditions are different, write to the author
+ to ask for permission.  For software which is copyrighted by the Free
+ Software Foundation, write to the Free Software Foundation; we sometimes
+ make exceptions for this.  Our decision will be guided by the two goals
+ of preserving the free status of all derivatives of our free software and
+ of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+ FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+ OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+ PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+ OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+ TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+ PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+ REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+ WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+ REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+ INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+ OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+ TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGES.
+

data/README

@@ -0,0 +1,3 @@
+= evma_xmlpushparser
+
+This is a Ruby extension which wraps the xmlParseChunk functionality of the Gnome libxml2 library.

data/RELEASE_NOTES

@@ -0,0 +1,3 @@
+$Id: RELEASE_NOTES 3539 2006-12-31 03:05:56Z francis $
+
+

data/Rakefile

@@ -0,0 +1,66 @@
+# $Id: Rakefile 3546 2006-12-31 21:01:27Z francis $
+# Rakefile for the Bayshore configurable LDAP server.
+#
+
+require 'rake/gempackagetask'
+require 'rake/clean'
+
+$can_minitar = false
+begin
+  require 'archive/tar/minitar'
+  require 'zlib'
+  $can_minitar  = true
+rescue LoadError
+end
+
+$version = "0.0.1"
+$distdir  = "eventmachine_xmlpushparser-#{$version}"
+$tardist  = "#$distdir.tar.gz"
+$name = "eventmachine_xmlpushparser"
+
+spec = eval(File.read("evma_xmlpushparser.gemspec"))
+spec.version = $version
+desc "Build the RubyGem for EventMachine XML push-parser"
+task :gem => ["pkg/evma_xmlpushparser-#{$version}.gem"]
+Rake::GemPackageTask.new(spec) do |g|
+  if $can_minitar
+    g.need_tar    = true
+    g.need_zip    = true
+  end
+  g.package_dir = "pkg"
+end
+
+def run_test_package test, filename_array
+  require 'test/unit/testsuite'
+  require 'test/unit/ui/console/testrunner'
+
+  runner = Test::Unit::UI::Console::TestRunner
+
+  $LOAD_PATH.unshift('test')
+  $stderr.puts "Checking for test cases:" if test.verbose
+  filename_array.each do |testcase|
+    $stderr.puts "\t#{testcase}" if test.verbose
+    load testcase
+  end
+
+  suite = Test::Unit::TestSuite.new($name)
+
+  ObjectSpace.each_object(Class) do |testcase|
+    suite << testcase.suite if testcase < Test::Unit::TestCase
+  end
+
+  runner.run(suite)
+end
+
+desc "Run the tests for #$name."
+task :test do |t|
+    run_test_package t, Dir['test/*.rb']
+end
+
+desc "Run the application tests"
+task :test_application do |t|
+    run_test_package t, Dir['test/app.rb']
+end
+
+task :default => [:test]
+

data/ext/extconf.rb

@@ -0,0 +1,113 @@
+# $Id: extconf.rb 63 2006-05-17 06:03:18Z blackhedd $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# Gmail: garbagecat20
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+# We have to munge LDSHARED because this code needs a C++ link.
+#
+
+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')
+  unless have_library('xml2') and
+	  have_header('libxml/parser.h') and
+	  have_header('libxml/tree.h')
+    exit
+  end
+
+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')
+  unless have_library('xml2') and
+	  find_header('libxml/parser.h', '/usr/include/libxml2') and
+	  find_header('libxml/tree.h', '/usr/include/libxml2')
+    exit
+  end
+
+  # 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')
+  unless have_library('xml2') and
+	  find_header('libxml/parser.h', '/usr/include/libxml2') and
+	  find_header('libxml/tree.h', '/usr/include/libxml2')
+    exit
+  end
+  # 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')
+  unless have_library('xml2') and
+	  find_header('libxml/parser.h', '/usr/include/libxml2') and
+	  find_header('libxml/tree.h', '/usr/include/libxml2')
+      exit
+  end
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+if $CPPFLAGS
+  $CPPFLAGS += ' ' + flags.join(' ')
+else
+  $CFLAGS += ' ' + flags.join(' ')
+end
+
+
+create_makefile "rubyxmlpushparser"

data/ext/rubymain.cpp

@@ -0,0 +1,466 @@
+/*****************************************************************************
+
+$Id: rubymain.cpp 307 2007-04-28 13:52:16Z blackhedd $
+
+File:     libmain.cpp
+Date:     06Apr06
+
+Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat20
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+
+#include <iostream>
+#include <stdexcept>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <ruby.h>
+
+
+static xmlSAXHandler saxHandler;
+
+/*************************
+class RubyXmlPushParser_t
+*************************/
+
+class RubyXmlPushParser_t
+{
+	public:
+		RubyXmlPushParser_t (VALUE v);
+
+		void ConsumeData (const char *, int);
+		void Close();
+		void ScheduleReset();
+
+		void SaxStartDocument();
+		void SaxEndDocument();
+		void SaxStartElement (const xmlChar*, const xmlChar**);
+		void SaxEndElement (const xmlChar*);
+		void SaxCharacters (const xmlChar*, int);
+		void SaxError();
+
+	private:
+		VALUE Myself;
+		xmlParserCtxtPtr Context;
+		bool bReset;
+};
+
+
+
+/*****************
+rubyStartDocument
+*****************/
+
+static void rubyStartDocument (void *ctx)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*) ctx;
+	if (!pp)
+		throw std::runtime_error ("bad ptr in rubyStartDocument");
+	pp->SaxStartDocument();
+}
+
+/***************
+rubyEndDocument
+***************/
+
+static void rubyEndDocument (void *ctx)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*) ctx;
+	if (!pp)
+		throw std::runtime_error ("bad ptr in rubyEndDocument");
+	pp->SaxEndDocument();
+}
+
+/****************
+rubyStartElement
+****************/
+
+static void rubyStartElement (void *ctx, const xmlChar *name, const xmlChar **attrs)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*) ctx;
+	if (!pp)
+		throw std::runtime_error ("bad ptr in rubyStartElement");
+	pp->SaxStartElement (name, attrs);
+}
+
+/**************
+rubyEndElement
+**************/
+
+static void rubyEndElement (void *ctx, const xmlChar *name)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*) ctx;
+	if (!pp)
+		throw std::runtime_error ("bad ptr in rubyEndElement");
+	pp->SaxEndElement (name);
+}
+
+
+/**************
+rubyCharacters
+**************/
+
+static void rubyCharacters (void *ctx, const xmlChar *val, int len)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*) ctx;
+	if (!pp)
+		throw std::runtime_error ("bad ptr in rubyCharacters");
+	pp->SaxCharacters (val, len);
+}
+
+/*********
+rubyError
+*********/
+
+static void rubyError (void *ctx, const char *msg, ...)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*) ctx;
+	if (!pp)
+		throw std::runtime_error ("bad ptr in rubyError");
+	pp->SaxError();
+}
+
+
+/****************************************
+RubyXmlPushParser_t::RubyXmlPushParser_t
+****************************************/
+
+RubyXmlPushParser_t::RubyXmlPushParser_t (VALUE v):
+	Myself (v),
+	bReset (false)
+{
+	/* Note that we're bypassing the typical convention of passing the
+	 * first four bytes of the document to the parser-create function.
+	 * Obviously we may not have them yet. We could delay calling this
+	 * until the bytes are available but this seems to work fine.
+	 * Note that passing in a SAX2 handler means that this parser
+	 * will NOT accumulate a document tree, which in turn means we
+	 * don't need to worry about freeing the document tree later.
+	 * (We will of course need to free the parser itself.)
+	 */
+	Context = xmlCreatePushParserCtxt (&saxHandler, (void*)this, "", 0, "");
+	if (!Context)
+		throw std::runtime_error ("no push-parser context");
+}
+
+
+/********************************
+RubyXmlPushParser_t::ConsumeData
+********************************/
+
+void RubyXmlPushParser_t::ConsumeData (const char *data, int length)
+{
+	/* Avoid passing more than a few bytes to xmlParseChunk at a time.
+	 * We know that at some points (such as while initially determining
+	 * the encoding of a new document), the library's internal buffers
+	 * are very small.
+	 */
+	for (int i=0; i < length; i++) {
+		if (bReset) {
+			// don't send a good-bye kiss to the existing context because it'll
+			// probably kick out a malformation error.
+			xmlFreeParserCtxt (Context);
+			Context = xmlCreatePushParserCtxt (&saxHandler, (void*)this, "", 0, "");
+			if (!Context)
+				throw std::runtime_error ("no push-parser context");
+			bReset = false;
+		}
+		xmlParseChunk (Context, data+i, 1, 0);
+	}
+}
+
+
+/**********************************
+RubyXmlPushParser_t::ScheduleReset
+**********************************/
+
+void RubyXmlPushParser_t::ScheduleReset()
+{
+	bReset = true;
+}
+
+/**************************
+RubyXmlPushParser_t::Close
+**************************/
+
+void RubyXmlPushParser_t::Close()
+{
+	/* We come here automatically when a connection gets an unbind event.
+	 * User code can inadvertently cut this off and leak memory by implementing #unbind.
+	 * All user code that implements unbind MUST call super within the unbind.
+	 *
+	 * It's a requirement that this code be called. We're relying on the (hopefully
+	 * reliable) fact that a network connection will always get closed sometime.
+	 * If this extension ever needs to handle cases that are not matched to a network
+	 * connection, then we'll need to arrange some other way for this to get called.
+	 */
+	xmlParseChunk (Context, "", 0, 1);
+	xmlFreeParserCtxt (Context);
+	// No need to call xmlFreeDoc (Content->myDoc) because it's always NULL when a SAX handler is present.
+}
+
+
+/*************************************
+RubyXmlPushParser_t::SaxStartDocument
+*************************************/
+
+void RubyXmlPushParser_t::SaxStartDocument()
+{
+	rb_funcall (Myself, rb_intern ("start_document"), 0);
+}
+
+/***********************************
+RubyXmlPushParser_t::SaxEndDocument
+***********************************/
+
+void RubyXmlPushParser_t::SaxEndDocument()
+{
+	/* It's problematical for user code to rely on receiving this event.
+	 * If a network peer sends a complete XML document but then sends
+	 * nothing more beyond the closing tag of the root element, then
+	 * libxml does NOT call endDocument. endDocument will be called in the
+	 * following two cases: first, if the caller sends at least one byte beyond
+	 * the end of the actual document (this may be a syntactically-valid "Misc"
+	 * paragraph at the tail of the document, or the start of a new document, or
+	 * erroneous matter); and second, if the remote peer closes the network connection,
+	 * which causes us to receive and respond to the unbind event, and in turn
+	 * resulting in a call to xmlParseChunk with the terminate flag set.
+	 *
+	 * This is probably not a problem for a protocol like XMPP, in which the
+	 * whole stream is syntactically a single document. But other protocols
+	 * might have problems.
+	 */
+	rb_funcall (Myself, rb_intern ("end_document"), 0);
+}
+
+/************************************
+RubyXmlPushParser_t::SaxStartElement
+************************************/
+
+void RubyXmlPushParser_t::SaxStartElement (const xmlChar *name, const xmlChar **attribs)
+{
+	if (!name)
+		name = (const xmlChar*)"";
+
+	VALUE atts = rb_hash_new();
+	if (attribs) {
+		while (attribs[0] && attribs[1]) {
+			rb_hash_aset (atts, rb_str_new2((const char*)attribs[0]), rb_str_new2((const char*)attribs[1]));
+			attribs += 2;
+		}
+	}
+	rb_funcall (Myself, rb_intern ("start_element"), 2, rb_str_new2((const char*)name), atts);
+}
+
+/**********************************
+RubyXmlPushParser_t::SaxEndElement
+**********************************/
+
+void RubyXmlPushParser_t::SaxEndElement (const xmlChar *name)
+{
+	if (!name)
+		name = (const xmlChar*)"";
+	rb_funcall (Myself, rb_intern ("end_element"), 1, rb_str_new2((const char*)name));
+}
+
+/**********************************
+RubyXmlPushParser_t::SaxCharacters
+**********************************/
+
+void RubyXmlPushParser_t::SaxCharacters (const xmlChar *name, int length)
+{
+	if (!name) {
+		name = (const xmlChar*)"";
+		length = 0;
+	}
+	rb_funcall (Myself, rb_intern ("characters"), 1, rb_str_new((const char*)name, length));
+}
+
+/*****************************
+RubyXmlPushParser_t::SaxError
+*****************************/
+
+void RubyXmlPushParser_t::SaxError()
+{
+	int e = xmlCtxtGetLastError (Context)->code;
+	if (e == XML_ERR_DOCUMENT_END)
+		;
+	else {
+		rb_funcall (Myself, rb_intern ("error"), 1, INT2FIX (e));
+		rb_funcall (Myself, rb_intern ("close_connection"), 0);
+	}
+}
+
+/***********
+t_post_init
+***********/
+
+static VALUE t_post_init (VALUE self)
+{
+	RubyXmlPushParser_t *pp = new RubyXmlPushParser_t (self);
+	if (!pp)
+		throw std::runtime_error ("no xml push-parser object");
+
+	rb_ivar_set (self, rb_intern ("@xml__push__parser__object"), INT2NUM ((long)pp));
+	return Qnil;
+}
+
+/**************
+t_receive_data
+**************/
+
+static VALUE t_receive_data (VALUE self, VALUE data)
+{
+	int length = NUM2INT (rb_funcall (data, rb_intern ("length"), 0));
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@xml__push__parser__object"))));
+	if (!pp)
+		throw std::runtime_error ("bad push-parser object");
+	pp->ConsumeData (StringValuePtr (data), length);
+
+	return Qnil;
+}
+
+/********
+t_unbind
+********/
+
+static VALUE t_unbind (VALUE self)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@xml__push__parser__object"))));
+	if (!pp)
+		throw std::runtime_error ("no xml push-parser object");
+	pp->Close();
+	return Qnil;
+}
+
+
+/**************
+t_reset_parser
+**************/
+
+static VALUE t_reset_parser (VALUE self)
+{
+	RubyXmlPushParser_t *pp = (RubyXmlPushParser_t*)(NUM2INT (rb_ivar_get (self, rb_intern ("@xml__push__parser__object"))));
+	if (!pp)
+		throw std::runtime_error ("no xml push-parser object");
+	pp->ScheduleReset();
+
+	return Qnil;
+}
+
+/****************
+t_start_document
+****************/
+
+static VALUE t_start_document (VALUE self)
+{
+	// STUB. Override this in user code if needed.
+	return Qnil;
+}
+
+/**************
+t_end_document
+**************/
+
+static VALUE t_end_document (VALUE self)
+{
+	// STUB. Override this in user code if needed.
+	return Qnil;
+}
+
+/***************
+t_start_element
+***************/
+
+static VALUE t_start_element (VALUE self, VALUE name, VALUE attributes)
+{
+	// STUB. Override this in user code if needed.
+	return Qnil;
+}
+
+/*************
+t_end_element
+*************/
+
+static VALUE t_end_element (VALUE self, VALUE name)
+{
+	// STUB. Override this in user code if needed.
+	return Qnil;
+}
+
+/************
+t_characters
+************/
+
+static VALUE t_characters (VALUE self, VALUE data)
+{
+	// STUB. Override this in user code if needed.
+	return Qnil;
+}
+
+/*******
+t_error
+*******/
+
+static VALUE t_error (VALUE self, VALUE code)
+{
+	// STUB. Override this in user code if needed.
+	return Qnil;
+}
+
+
+/**********************
+Init_rubyxmlpushparser
+**********************/
+
+extern "C" void Init_rubyxmlpushparser()
+{
+	LIBXML_TEST_VERSION
+	#ifndef LIBXML_PUSH_ENABLED
+		throw std::runtime_error ("XML push not enabled on this system");
+	#endif
+
+	// saxHandler is statically defined and readonly after we initialize it here.
+	// We DEPEND on the fact that the C runtime will zero-initialize it.
+	saxHandler.startDocument = rubyStartDocument;
+	saxHandler.startElement = rubyStartElement;
+	saxHandler.endElement = rubyEndElement;
+	saxHandler.characters = rubyCharacters;
+	saxHandler.endDocument = rubyEndDocument;
+	saxHandler.error = rubyError;
+	saxHandler.warning = rubyError;
+
+	// Define a module XmlPushParser that can be used standalone and modified,
+	// or else included into EventMachine::Connection or a subclass of same.
+	// NB that we define #post_init and #unbind here. This means that any user
+	// subclass that includes EventMachine::XmlPushParser MUST call super
+	// inside subclassed implementations of these two methods.
+
+	VALUE EmModule = rb_define_module ("EventMachine");
+	VALUE XmlModule = rb_define_module_under (EmModule, "XmlPushParser");
+	rb_define_method (XmlModule, "post_init", (VALUE(*)(...))t_post_init, 0);
+	rb_define_method (XmlModule, "receive_data", (VALUE(*)(...))t_receive_data, 1);
+	rb_define_method (XmlModule, "unbind", (VALUE(*)(...))t_unbind, 0);
+	rb_define_method (XmlModule, "start_document", (VALUE(*)(...))t_start_document, 0);
+	rb_define_method (XmlModule, "end_document", (VALUE(*)(...))t_end_document, 0);
+	rb_define_method (XmlModule, "start_element", (VALUE(*)(...))t_start_element, 2);
+	rb_define_method (XmlModule, "end_element", (VALUE(*)(...))t_end_element, 1);
+	rb_define_method (XmlModule, "characters", (VALUE(*)(...))t_characters, 1);
+	rb_define_method (XmlModule, "error", (VALUE(*)(...))t_error, 1);
+	rb_define_method (XmlModule, "reset_parser", (VALUE(*)(...))t_reset_parser, 0);
+}

data/lib/evma_xmlpushparser.rb

@@ -0,0 +1,2 @@
+require 'rubyxmlpushparser'
+

data/test/app.rb

@@ -0,0 +1,67 @@
+# $Id: app.rb 3893 2007-03-06 20:12:09Z francis $
+#
+#
+
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'eventmachine'
+require 'evma_xmlpushparser'
+
+
+class TestApp < Test::Unit::TestCase
+
+	Host = "127.0.0.1"
+	Port = 9250
+
+	class Xml < EventMachine::Connection
+		include EventMachine::XmlPushParser
+		attr_reader :elements, :element_ends
+		def initialize *args
+			super
+			@elements = {}
+			@element_ends = []
+		end
+		def start_document
+		end
+		def start_element nm, attrs
+			if ["aaa","bbb"].include?(nm)
+				@elements[nm] = attrs
+			else
+				raise "error"
+			end
+		end
+		def end_element nm
+			@element_ends << nm
+		end
+		def end_document
+			EventMachine.stop
+		end
+	end
+
+	module XmlClient
+		def post_init
+			send_data '<?xml version="1.0"?><aaa'
+			send_data ' attr1="1" attr2="2">chars<bbb/'
+			send_data '></a'
+			send_data 'aa>'
+			close_connection_after_writing
+		end
+	end
+
+	def test_a
+		obj = nil
+		EventMachine.run {
+			EventMachine.start_server(Host, Port, Xml) {|xml| obj = xml}
+			EventMachine.connect Host, Port, XmlClient
+			EventMachine.add_timer(2) {EventMachine.stop} # avoid hang in case of error
+		}
+
+		assert_equal( ["aaa","bbb"], obj.elements.keys.sort )
+		assert_equal( {"attr1"=>"1","attr2"=>"2"}, obj.elements["aaa"] )
+		assert_equal( {}, obj.elements["bbb"] )
+		assert_equal( ["bbb","aaa"], obj.element_ends)
+	end
+end
+
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: evma_xmlpushparser
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Francis Cianfrocca
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-21 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: This is a Ruby extension which wraps the xmlParseChunk functionality of the Gnome libxml2 library.
+email: garbagecat10@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README
+- RELEASE_NOTES
+- COPYING
+- Rakefile
+files: 
+- test/app.rb
+- ext/extconf.rb
+- ext/rubymain.cpp
+- lib/evma_xmlpushparser.rb
+- README
+- RELEASE_NOTES
+- COPYING
+- Rakefile
+has_rdoc: true
+homepage: http://www.eventmachine.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- EventMachine_XMLPushParser
+- --main
+- README
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: EventMachine XML Push Parser
+test_files: []
+