fizx-parsley-ruby 0.1.1 → 0.1.2

data/ext/cparsley.c

@@ -0,0 +1,118 @@
+#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_file(VALUE, VALUE, VALUE, VALUE);
+VALUE _parse_string(VALUE, VALUE, VALUE, VALUE);
+VALUE _parse_doc(parsedParsleyPtr, VALUE);
+VALUE rubify_recurse(xmlNodePtr xml);
+VALUE c_parsley_err;
+VALUE c_parsley;
+
+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_method(c_parsley, "parse_file", _parse_file, 3);
+	rb_define_method(c_parsley, "parse_string", _parse_string, 3);
+}
+
+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 _parse_file(VALUE self, VALUE name, VALUE input, VALUE output){
+	parsleyPtr parsley;
+	Data_Get_Struct(self, parsleyPtr, parsley);
+	return _parse_doc(parsley_parse_file(parsley, STR2CSTR(name), input == ID2SYM(rb_intern("html"))), output);
+}
+
+VALUE _parse_string(VALUE self, VALUE string, VALUE input, VALUE output) {
+	parsleyPtr parsley;
+	Data_Get_Struct(self, parsleyPtr, parsley);
+	char* cstr = STR2CSTR(string);
+	return _parse_doc(parsley_parse_string(parsley, cstr, strlen(cstr), input == ID2SYM(rb_intern("html"))), output);
+}
+
+VALUE _parse_doc(parsedParsleyPtr ptr, VALUE type) {
+	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);
+		json_object_put(json);
+	} else if(type == ID2SYM(rb_intern("xml"))) {
+		char* str;
+		int size;
+		xmlDocDumpMemory(ptr->xml, &str, &size);
+		output = rb_str_new(str, size);
+	} else {
+ 		output = rubify_recurse(ptr->xml->children->children);
+		if(output == NULL) output = Qnil; 
+	}
+	
+  parsed_parsley_free(ptr);
+  
+	return output;
+}
+
+VALUE rubify_recurse(xmlNodePtr xml) {
+  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) {
+          rb_hash_aset(obj, rb_str_new2(child->name), rubify_recurse(child->children));
+          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));
+            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);
+      break;
+  }
+  // inspect(obj);
+  return obj;
+}

data/lib/parsley.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + "/../ext/cparsley"
+require "rubygems"
+require "json"
+require "thread"
+
+class Parsley
+  def initialize(parsley, incl = "")
+    if(parsley.is_a?(Hash))
+      parsley = parsley.to_json 
+    end
+    @@mutex ||= Mutex.new
+    @@mutex.synchronize do
+      @parsley = CParsley.new(parsley, incl)
+    end
+  end
+  
+  # Valid options:
+  #
+  # Requires one of:
+  # :file -- the input file path
+  # :string -- the input string
+  #
+  # And optionally:
+  # :input => [:xml, :html]
+  # :output => [:json, :xml, :ruby]
+  # :allow_empty -- If false, throws an exception if any value is empty.
+  #
+  # Defaults are :input => :html, :output => :ruby, :allow_empty => false
+  def parse(options = {})
+    options[:file] || options[:string] || throw("must specify what to parse")
+    options[:input] ||= :html
+    options[:output]||= :ruby
+    if options[:file]
+      @parsley.parse_file options[:file], options[:input], options[:output]
+    else
+      @parsley.parse_string options[:string], options[:input], options[:output]
+    end
+  end
+end

data/parsley-ruby.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name     = "parsley-ruby"
+  s.version  = "0.1.2"
+  s.date     = "2008-08-10"
+  s.summary  = "Ruby binding for parsley"
+  s.email    = "kyle@kylemaxwell.com"
+  s.homepage = "http://github.com/fizx/parsley-ruby"
+  s.description = "Ruby binding for parsley"
+  s.has_rdoc = true
+  s.require_paths = ["lib", "ext"]
+  s.extensions = "ext/extconf.rb"
+  s.authors  = ["Kyle Maxwell"]
+  s.files    = %w[
+    ext/cparsley.c
+    ext/extconf.rb
+    lib/parsley.rb
+    parsley-ruby.gemspec
+    README
+    test/test_parsley.rb
+    test/yelp-benchmark.rb
+    test/yelp-home.html
+    test/yelp-home.let
+    test/yelp.html
+    ]
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.add_dependency("json", ["> 0.0.0"])
+end

data/test/test_parsley.rb

@@ -0,0 +1,56 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../lib/parsley"
+
+class TestParsley < Test::Unit::TestCase
+  def setup
+    @page = File.expand_path(File.dirname(__FILE__) + "/yelp.html")
+    @home = File.expand_path(File.dirname(__FILE__) + "/yelp-home.html")
+    @let  = File.expand_path(File.dirname(__FILE__) + "/yelp-home.let")
+  end
+  
+  def test_yelp
+    @parsley = Parsley.new(File.read(@let))
+    out = @parsley.parse(:file => @home)
+    assert_equal "/c/sf/shopping", out["categories"][0]["href"]
+  end
+  
+  def test_yelp_xml
+    @parsley = Parsley.new(File.read(@let))
+    out = @parsley.parse(:file => @home, :output => :xml)
+  end
+  
+  def test_simple
+    @parsley = Parsley.new("hi" => "h1")
+    assert_equal({"hi" => "Nick's Crispy Tacos"}, @parsley.parse(:file => @page))
+  end
+  
+  def test_simple_string
+    @parsley = Parsley.new("hi" => "h1")
+    assert_equal({"hi" => "Nick's Crispy Tacos"}, @parsley.parse(:string => "<html><body><h1>Nick's Crispy Tacos</h1></body></html>"))
+  end  
+  
+  def test_xml
+    @parsley = Parsley.new("hi" => "h1")
+    xml = "<?xml version=\"1.0\"?>\n<parsley:root xmlns:parsley=\"http://parslets.com/json\"><hi>Nick's Crispy Tacos</hi></parsley:root>\n"
+    assert_equal(xml, @parsley.parse(:file => @page, :output => :xml))
+  end
+  
+  def test_json
+    @parsley = Parsley.new("hi" => "h1")
+    assert_equal('{ "hi": "Nick\'s Crispy Tacos" }', @parsley.parse(:file => @page, :output => :json))
+  end
+  
+  def test_rescuable_file_error
+    @parsley = Parsley.new("hi" => "h1")
+    @nonexistant_file = File.dirname(__FILE__) + "/../fixtures/yelp.html"
+    assert_equal({"hi" => "Nick's Crispy Tacos"}, @parsley.parse(:file => @nonexistant_file)) rescue nil
+  end
+  
+  def test_array_string
+    @parsley = Parsley.new({"foo" => ["li"]})
+    out = @parsley.parse(:file => @page)
+    assert_kind_of Hash, out
+    assert_kind_of Array, out["foo"], out.inspect
+    assert out["foo"].length > 1
+  end
+end

data/test/yelp-benchmark.rb

@@ -0,0 +1,53 @@
+require "rubygems"
+require "nokogiri"
+require "hpricot"
+require "parsley"
+require "benchmark"
+require "pp"
+
+YELP_HTML = File.dirname(__FILE__) + "/yelp.html"
+
+def noko
+  parse Nokogiri.Hpricot(File.open(YELP_HTML))
+end
+
+def hpri
+  parse Hpricot(File.open(YELP_HTML))  
+end
+
+def parse(doc)
+  out = {}
+  out["name"] = (doc / "h1").first.inner_text
+  out["phone"] = (doc / "#bizPhone").first.inner_text
+  out["address"] = (doc / "address").first.inner_text
+  out["reviews"] = (doc / ".nonfavoriteReview").map do |node|
+    review = {}
+    review["date"] = (node / ".ieSucks .smaller").first.inner_text
+    review["user_name"] = (node / ".reviewer_info a").first.inner_text
+    review["comment"] = (node / ".review_comment").first.inner_text
+    review
+  end
+end
+
+def pars
+  parslet = Parsley.new({
+    "name" => "h1",
+    "phone" => "#bizPhone",
+    "address" => "address",
+    "reviews(.nonfavoriteReview)" => [
+      {
+        "date" => ".ieSucks .smaller",
+        "user_name" => ".reviewer_info a",
+        "comment" => ".review_comment"
+      }
+    ]
+  })
+  pp parslet.parse(:file => YELP_HTML)
+end
+
+Benchmark.bm do |x|
+  x.report("nokogiri: ")  { 3.times { noko } }
+  x.report("hpricot: ")   { 3.times { hpri } }
+  x.report("parsley: ") { 3.times { pars } }
+end
+