fizx-parsley-ruby 0.2.0 → 0.3.0

data/ext/cparsley.c

@@ -13,10 +13,8 @@
 #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 _parse(VALUE, VALUE);
+VALUE _rb_set_user_agent(VALUE self, VALUE agent);
 VALUE c_parsley_err;
 VALUE c_parsley;
 
@@ -25,11 +23,12 @@ 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);
+	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){
+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);
@@ -40,49 +39,15 @@ VALUE _new(VALUE self, VALUE parsley, VALUE incl){
  	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")), 1), output);
+VALUE 
+_rb_set_user_agent(VALUE self, VALUE agent) {
+  parsley_set_user_agent(STR2CSTR(agent));
+  return Qtrue;
 }
 
-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")), 1), 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) {
+static VALUE 
+rubify_recurse(xmlNodePtr xml) {
   if(xml == NULL) return NULL;
   xmlNodePtr child;
   VALUE obj = Qnil;
@@ -115,4 +80,59 @@ VALUE rubify_recurse(xmlNodePtr xml) {
   }
   // inspect(obj);
   return obj;
+}
+
+static 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"))) {
+		xmlChar* str;
+		int size;
+		xmlDocDumpMemory(ptr->xml, &str, &size);
+		output = rb_str_new(str, size);
+	} else {
+ 		output = rubify_recurse(ptr->xml->children->children);
+		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 = 0;
+  char *base = NULL;
+  if(OPT_MATCH("input", "html"))    flags |= PARSLEY_OPTIONS_HTML;
+  if(OPT_BOOL("prune"))             flags |= PARSLEY_OPTIONS_PRUNE;
+  if(OPT_BOOL("allow_net"))         flags |= PARSLEY_OPTIONS_ALLOW_NET;
+  if(OPT_BOOL("allow_local"))       flags |= PARSLEY_OPTIONS_ALLOW_LOCAL;
+  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"));
+  } else {
+    char * str = STR2CSTR(OPT("string"));
+    return _parse_doc(parsley_parse_string(parsley, str, strlen(str), base, flags), OPT("output"));
+  }
 }

data/ext/extconf.rb

@@ -58,6 +58,8 @@ end
 myincl = %w[/usr/local/include /opt/local/include /usr/include]
 mylib = %w[/usr/local/lib /opt/local/lib /usr/lib]
 
+find_header('ruby.h', INCLUDEDIR, *myincl) or abort "need ruby.h"
+
 find_header('json/json.h', INCLUDEDIR, *myincl) or abort "need json/json.h"
 find_library('json', 'json_object_new_string', LIBDIR, *mylib) or abort "need libjson"
 

data/lib/parsley.rb

@@ -4,6 +4,16 @@ require "json"
 require "thread"
 
 class Parsley
+  
+  def self.user_agent=(agent)
+    @user_agent = agent
+    CParsley.set_user_agent(agent.to_s)
+  end
+  
+  def self.user_agent
+    @user_agent
+  end
+  
   def initialize(parsley, incl = "")
     if(parsley.is_a?(Hash))
       parsley = parsley.to_json 
@@ -17,23 +27,37 @@ class Parsley
   # Valid options:
   #
   # Requires one of:
-  # :file -- the input file path
+  # :file -- the input file path or url
   # :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
+  # And optionally (default is the first listed value):
+  # :input => [:html, :xml]
+  # :output => [:ruby, :json, :xml]
+  # :prune => [true, false]
+  # :base => "http://some/base/href"
+  # :allow_net => [true, false]
+  # :allow_local => [true, 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
+    options[:file] || options[:string] || (raise ParsleyError.new("must specify what to parse"))
+    
+    options[:is_file] = !!options[:file]
+    options[:has_base] = !!options[:base]
+    
+    options[:base] = options[:base].to_s
+    options[:file] = options[:file].to_s
+    options[:string] = options[:string].to_s
+    
+    options[:input]  ||= :html
+    options[:output] ||= :ruby
+    
+    options[:prune] = true unless options.has_key?(:prune)
+    options[:allow_net] = true unless options.has_key?(:allow_net)
+    options[:allow_local] = true unless options.has_key?(:allow_local)
+    
+    options[:prune] = !!options[:prune]
+    options[:allow_net] = !!options[:allow_net]
+    options[:allow_local] = !!options[:allow_local]
+    
+    @parsley.parse(options)
   end
 end

data/parsley-ruby.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "parsley-ruby"
-  s.version  = "0.2.0"
-  s.date     = "2008-08-10"
+  s.version  = "0.3.0"
+  s.date     = "2009-03-23"
   s.summary  = "Ruby binding for parsley"
   s.email    = "kyle@kylemaxwell.com"
   s.homepage = "http://github.com/fizx/parsley-ruby"

data/test/test_parsley.rb

@@ -19,6 +19,13 @@ class TestParsley < Test::Unit::TestCase
     out = @parsley.parse(:file => @home, :output => :xml)
   end
   
+  def test_broken
+    @parsley = Parsley.new("hi" => "no-ns:match(h1)")
+    assert_raises(ParsleyError) {
+      @parsley.parse(:file => @page)
+    }
+  end
+  
   def test_simple
     @parsley = Parsley.new("hi" => "h1")
     assert_equal({"hi" => "Nick's Crispy Tacos"}, @parsley.parse(:file => @page))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fizx-parsley-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Kyle Maxwell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-10 00:00:00 -07:00
+date: 2009-03-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency