gtl-parsley-ruby 0.5.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+0.4.3
+- Added CHANGELOG
+- Only assigning ARCHFLAGS if not already specified.

data/README

@@ -0,0 +1,32 @@
+ABOUT
+
+Ruby bindings for Parsley.
+
+INSTALLATION
+
+= Get Parsley and Dependancies = 
+
+Download Parsley from http://github.com/fizx/parsley/tree/master following the installation directions located at http://github.com/fizx/parsley/blob/master/INSTALL
+
+= Install parsley-ruby =
+
+From source:
+  sudo rake install
+
+From GitHub: DEPRECATED!
+
+From GemCutter
+
+  Run the following if you haven't already:
+  gem sources -a http://gemcutter.org
+  Install the gem:
+  sudo gem install parsley-ruby
+
+PARSLETS.COM INTEGRATION
+
+We also recommend installing the free online_parselets rubygem in order to use other people's parselets and to share your own:
+  Run the following if you haven't already:
+  gem sources -a http://gems.github.com
+  Install the gem:
+  sudo gem install iterationlabs-online_parslets
+

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "gtl-parsley-ruby"
+    gem.summary = "Ruby binding for parsley (updated for 1.9 and scoped to utf-8 only)"
+    gem.description = "XML/HTML Parser"
+    gem.email = "kyle@kylemaxwell.com"
+    gem.homepage = "http://github.com/fizx/parsley-ruby"
+    gem.authors = ["Kyle Maxwell", "Brian Collins"]
+    gem.add_dependency("json", ["> 0.0.0"])
+    gem.require_paths = ["lib", "ext"]
+    gem.extensions = "ext/extconf.rb"  end
+  Jeweler::GemcutterTasks.new
+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' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    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
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "robots #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/ext/cparsley.c

@@ -0,0 +1,152 @@
+#include "ruby.h"
+#include <stdio.h>
+#include <libxslt/xslt.h>
+#include <libexslt/exslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/transform.h>
+#include <libxml/parser.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/xmlwriter.h>
+#include <parsley.h>
+#include <json/json.h>
+#include <xml2json.h>
+
+VALUE _new(VALUE, VALUE, VALUE);
+VALUE _parse(VALUE, VALUE);
+VALUE _rb_set_user_agent(VALUE self, VALUE agent);
+VALUE c_parsley_err;
+VALUE c_parsley;
+
+#ifndef STR2CSTR
+char *STR2CSTR(VALUE v) {
+  return StringValuePtr(v);
+}
+#endif
+
+void Init_cparsley()
+{
+	c_parsley = rb_define_class("CParsley", rb_cObject);
+	c_parsley_err = rb_define_class("ParsleyError", rb_eRuntimeError);
+	rb_define_singleton_method(c_parsley, "new", _new, 2);
+	rb_define_singleton_method(c_parsley, "set_user_agent", _rb_set_user_agent, 1);
+	rb_define_method(c_parsley, "parse", _parse, 1);
+}
+
+VALUE 
+_new(VALUE self, VALUE parsley, VALUE incl){
+	parsleyPtr ptr = parsley_compile(STR2CSTR(parsley), STR2CSTR(incl));
+
+	if(ptr->error != NULL) {
+	  rb_raise(c_parsley_err, ptr->error);
+    parsley_free(ptr);
+    return Qnil;
+	}
+	
+ 	return Data_Wrap_Struct(c_parsley, 0, parsley_free, ptr);
+}
+
+VALUE 
+_rb_set_user_agent(VALUE self, VALUE agent) {
+  parsley_set_user_agent(STR2CSTR(agent));
+  return Qtrue;
+}
+
+
+static VALUE 
+rubify_recurse(xmlNodePtr xml, int encoding) {
+  if(xml == NULL) return NULL;
+  xmlNodePtr child;
+  VALUE obj = Qnil;
+
+  switch(xml->type) {
+    case XML_ELEMENT_NODE:
+      child = xml->children;
+      if(xml->ns == NULL) {
+        child = xml;
+        obj = rb_hash_new();
+        while(child != NULL) {
+          VALUE key = rb_str_new2(child->name);
+          rb_enc_associate_index(key, encoding);
+          rb_hash_aset(obj, key, rubify_recurse(child->children, encoding));
+          child = child->next;
+        }
+      } else if(!strcmp(xml->ns->prefix, "parsley")) {
+        if(!strcmp(xml->name, "groups")) {
+          obj = rb_ary_new();
+          while(child != NULL) {
+            rb_ary_push(obj, rubify_recurse(child->children, encoding));
+            child = child->next;
+          }          
+        } else if(!strcmp(xml->name, "group")) {
+          // Implicitly handled by parsley:groups handler
+        }
+      }
+      break;
+    case XML_TEXT_NODE:
+      obj = rb_str_new2(xml->content);
+      rb_enc_associate_index(obj, encoding);
+      break;
+  }
+  // inspect(obj);
+  return obj;
+}
+
+static VALUE 
+_parse_doc(parsedParsleyPtr ptr, VALUE type, int encoding) {
+	if(ptr->error != NULL || ptr->xml == NULL) {
+    if(ptr->error == NULL) ptr->error = strdup("Unknown parsley error");
+		rb_raise(c_parsley_err, ptr->error);
+    parsed_parsley_free(ptr);
+		return Qnil;
+	}
+	
+	VALUE output;
+	if(type == ID2SYM(rb_intern("json"))) {
+		struct json_object *json = xml2json(ptr->xml->children->children);
+		char* str = json_object_to_json_string(json);
+		output = rb_str_new2(str);
+    rb_enc_associate_index(output, encoding);
+		json_object_put(json);
+	} else if(type == ID2SYM(rb_intern("xml"))) {
+		xmlChar* str;
+		int size;
+		xmlDocDumpMemory(ptr->xml, &str, &size);
+		output = rb_str_new(str, size);
+    rb_enc_associate_index(output, encoding);
+	} else {
+ 		output = rubify_recurse(ptr->xml->children->children, encoding);
+		if((void*)output == NULL) output = Qnil; 
+	}
+	
+  parsed_parsley_free(ptr);
+  
+	return output;
+}
+
+#define OPT(A) rb_hash_aref(options, ID2SYM(rb_intern(A)))
+#define OPT_BOOL(A) (OPT(A) != Qnil && OPT(A) != Qfalse)
+#define OPT_MATCH(A, B) (rb_hash_aref(options, ID2SYM(rb_intern(A))) == ID2SYM(rb_intern(B)))
+
+VALUE _parse(VALUE self, VALUE options){
+	parsleyPtr parsley;
+	Data_Get_Struct(self, parsleyPtr, parsley);
+  int flags = PARSLEY_OPTIONS_FORCE_UTF8;
+  char *base = NULL;
+  if(OPT_MATCH("input", "html"))    flags |= PARSLEY_OPTIONS_HTML;
+  if(OPT_BOOL("prune"))             flags |= PARSLEY_OPTIONS_PRUNE;
+  if(OPT_BOOL("collate"))           flags |= PARSLEY_OPTIONS_COLLATE;
+  if(OPT_BOOL("allow_net"))         flags |= PARSLEY_OPTIONS_ALLOW_NET;
+  if(OPT_BOOL("allow_local"))       flags |= PARSLEY_OPTIONS_ALLOW_LOCAL;
+  if(OPT_BOOL("sgwrap"))            flags |= PARSLEY_OPTIONS_SGWRAP;
+  if(OPT_BOOL("has_base"))          base = STR2CSTR(OPT("base"));
+  
+  // printf("prune: %d\nallow_net: %d\nallow_local: %d\nhas_base: %d\nflags: %d\n", OPT_BOOL("prune"), OPT_BOOL("allow_net"), OPT_BOOL("allow_local"), OPT_BOOL("has_base"), flags);
+  
+  if(OPT_BOOL("is_file")) {
+    return _parse_doc(parsley_parse_file(parsley, STR2CSTR(OPT("file")), flags), OPT("output"), rb_enc_find_index("UTF-8"));
+  } else {
+    char * str = STR2CSTR(OPT("string"));
+    return _parse_doc(parsley_parse_string(parsley, str, strlen(str), base, flags), OPT("output"), rb_enc_find_index("UTF-8"));
+  }
+}

data/ext/extconf.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# ENV["ARCHFLAGS"] ||= "-arch #{`uname -p` =~ /powerpc/ ? 'ppc' : 'i386'}"
+
+require 'mkmf'
+
+EXT = File.expand_path(File.dirname(__FILE__))
+
+LIBDIR = Config::CONFIG['libdir']
+INCLUDEDIR = Config::CONFIG['includedir']
+
+system "cd #{EXT}/parsley && ./configure && make"
+
+$CFLAGS << " -g -DXP_UNIX"
+$CFLAGS << " -O3 -Wall -Wextra -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline"
+
+
+if Config::CONFIG['target_os'] =~ /mswin32/
+  lib_prefix = 'lib'
+
+  # There's no default include/lib dir on Windows. Let's just add the Ruby ones
+  # and resort on the search path specified by INCLUDE and LIB environment
+  # variables
+  HEADER_DIRS = [INCLUDEDIR]
+  LIB_DIRS = [LIBDIR]
+  XML2_HEADER_DIRS = [File.join(INCLUDEDIR, "libxml2"), INCLUDEDIR]
+
+else
+  lib_prefix = ''
+
+  HEADER_DIRS = [
+    # First search /opt/local for macports
+    '/opt/local/include',
+
+    # Then search /usr/local for people that installed from source
+    '/usr/local/include',
+
+    # Check the ruby install locations
+    INCLUDEDIR,
+
+    # Finally fall back to /usr
+    '/usr/include',
+    '/usr/include/libxml2',
+  ]
+
+  LIB_DIRS = [
+    # First search /opt/local for macports
+    '/opt/local/lib',
+
+    # Then search /usr/local for people that installed from source
+    '/usr/local/lib',
+
+    # Check the ruby install locations
+    LIBDIR,
+
+    # Finally fall back to /usr
+    '/usr/lib',
+  ]
+
+  XML2_HEADER_DIRS = [
+    '/opt/local/include/libxml2',
+    '/usr/local/include/libxml2',
+    File.join(INCLUDEDIR, "libxml2")
+  ] + HEADER_DIRS
+end
+
+dir_config('xml2', XML2_HEADER_DIRS, LIB_DIRS)
+dir_config('xslt', HEADER_DIRS, LIB_DIRS)
+
+find_library("#{lib_prefix}xml2", 'xmlParseDoc') or abort "need -lxml2"
+find_library("#{lib_prefix}xslt", 'xsltParseStylesheetDoc') or abort "need -lxslt"
+find_header('libxml/xmlversion.h') or abort "need libxml headers"
+find_header('libxslt/xslt.h') or abort "need libxslt headers"
+find_header('ruby.h', INCLUDEDIR) or abort "need ruby.h"
+
+find_header("#{EXT}/parsley/json-c-0.9/json.h", INCLUDEDIR) or abort "need json/json.h"
+find_library("#{lib_prefix}json", "json_object_new_string", "#{EXT}/parsley/json-c-0.9/") or abort "need libjson"
+
+find_header("#{EXT}/parsley/parsley.h", INCLUDEDIR) or abort "need parsley.h"
+find_library("#{lib_prefix}parsley", 'parsley_compile', "#{EXT}/parsley/") or abort "need libparsley"
+
+create_makefile('cparsley')
+

data/ext/parsley/.gitignore

@@ -0,0 +1,32 @@
+.libs/
+json-c-0.8/config.h
+json-c-0.8/json.pc
+json-c-0.8/libjson.la
+json-c-0.8/libtool
+json-c-0.8/stamp-h1
+json-c-0.8/test1
+json-c-0.8/test2
+json-c-0.8/test3
+printbuf.loT
+*.o
+*.lo
+dexterc
+dexter
+parsleyc
+parsley
+.deps/
+Makefile
+autom4te.cache/
+autoscan.log
+config.log
+config.status
+configure.scan
+libparsley.la
+test.log
+ruby/parsley*.gem
+ruby/ext/cparsley.bundle
+ruby/ext/cparsley.so
+ruby/ext/Makefile
+ruby/ext/conftest.dSYM/
+work
+ruby/ext/mkmf.log

data/ext/parsley/AUTHORS

@@ -0,0 +1 @@
+Kyle Maxwell

data/ext/parsley/HACKING

@@ -0,0 +1,4 @@
+These notes are intended for people hacking on the Parsley source.
+
+Some gotchas:
+- The parser.y is known to work with Bison 2.3, and known to break on Bison 2.4.1.  This has something to do with the Bison prologue being moved from the generated parser.h file to the parser.c file.  I'd love to hear anyone's solution for this.

data/ext/parsley/INSTALL

@@ -0,0 +1,73 @@
+Welcome to Parsley!
+
+Parsley depends on 
+- argp (standard with Linux, other platforms use argp-standalone package)
+- the JSON C library from http://oss.metaparadigm.com/json-c/ (I used 0.8)
+- pcre (with dev headers)
+- libxml2	(>= 2.7)
+- libxslt (with exslt)
+
+
+Here's how to install it:
+
+1. Get the release
+------------------------------------------------------------------------
+Parsley is currently still being tracked in git, and isn't ready to make a 
+formal release. So you need to either clone or download the latest tarball:
+
+git clone git://github.com/fizx/parsley.git
+or 
+wget http://github.com/fizx/parsley/tarball/master
+
+
+2. Build for your platform
+------------------------------------------------------------------------
+Enter your parsley working directory, (from the clone or download you 
+just made) and, based on your platform, do the following:
+
+
+Debian/Ubuntu
+------------------------------------------------------------------------
+sudo apt-get install libxslt1-dev libpcre3-dev build-essential wget
+wget http://oss.metaparadigm.com/json-c/json-c-0.8.tar.gz
+tar -zxf json-c-0.8.tar.gz
+cd json-c-0.8
+./configure
+make
+sudo make install
+cd -
+./configure
+make
+sudo make install
+
+
+Mac OS X with MacPorts:
+------------------------------------------------------------------------
+sudo port install argp-standalone pcre wget libxslt
+wget http://oss.metaparadigm.com/json-c/json-c-0.8.tar.gz
+tar -zxf json-c-0.8.tar.gz
+cd json-c-0.8
+./configure
+make
+sudo make install
+cd -
+./configure
+make
+sudo make install
+
+If you have a few extra minutes, consider replacing the last make with a
+'make check' and let us know if it reports any failures from the test 
+suite - thanks!
+
+3. Ruby Binding (via Gems)
+------------------------------------------------------------------------
+http://github.com/fizx/parsley-ruby
+
+4. Python Binding
+------------------------------------------------------------------------
+http://github.com/fizx/pyparsley
+
+Other OS/Configurations:
+------------------------------------------------------------------------
+Haven't tried.
+