gtl-parsley-ruby 0.5.0

data/ext/parsley/parsley.h

@@ -0,0 +1,87 @@
+#ifndef PARSLEY_H_INCLUDED
+#define PARSLEY_H_INCLUDED
+
+#define PARSLEY_BUF_SIZE 1024
+
+#include <stdbool.h>
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/transform.h>
+#include <json/json.h>
+#include "parsed_xpath.h"
+
+
+static int parsley_debug_mode = 0;
+static char* last_parsley_error;
+
+
+typedef struct __compiled_parsley {
+	xsltStylesheetPtr stylesheet;
+	char* error;
+} compiled_parsley;
+
+typedef struct __parsed_parsley {
+  xmlDocPtr xml;
+	char *error;
+  compiled_parsley *parsley;
+} parsed_parsley;
+
+typedef compiled_parsley * parsleyPtr;
+typedef parsed_parsley * parsedParsleyPtr;
+
+typedef struct __key_node {
+	char* name;
+	char* use;
+	struct __key_node * next;
+} key_node;
+
+typedef key_node * keyPtr;
+
+typedef struct __parsley_context {
+	xmlNsPtr ns;
+ 	xmlNodePtr node;
+	struct json_object * json;
+	char* tag;
+	pxpathPtr filter;
+	pxpathPtr expr;
+	bool magic;
+	bool array;
+	bool string;
+  int flags;  //bitmask over following enum
+	struct __parsley_context * parent;
+	struct __parsley_context *child;
+	struct __parsley_context *next;
+} parsley_context;
+
+enum {
+  PARSLEY_OPTIONAL    = 1,
+  PARSLEY_BANG        = 2
+};
+
+enum {
+	PARSLEY_OPTIONS_HTML 					 = 1,
+	PARSLEY_OPTIONS_PRUNE   			 = 2,
+	PARSLEY_OPTIONS_ALLOW_NET  		 = 4,
+	PARSLEY_OPTIONS_ALLOW_LOCAL    = 8,
+	PARSLEY_OPTIONS_COLLATE        = 16,
+	PARSLEY_OPTIONS_SGWRAP         = 32,
+	PARSLEY_OPTIONS_FORCE_UTF8     = 64
+};
+
+typedef parsley_context * contextPtr;
+
+void parsed_parsley_free(parsedParsleyPtr);
+
+void killDefaultNS(xmlDocPtr doc);
+void parsley_free(parsleyPtr);
+parsleyPtr parsley_compile(char* parsley, char* incl);
+parsedParsleyPtr parsley_parse_file(parsleyPtr parsley, char* file, int flags);
+parsedParsleyPtr parsley_parse_string(parsleyPtr parsley, char* string, size_t size, char* base_uri, int flags);
+parsedParsleyPtr parsley_parse_doc(parsleyPtr, xmlDocPtr, int);
+
+void parsleyXsltError(void * ctx, const char * msg, ...);
+
+void parsley_set_user_agent(char const *agent);
+static contextPtr parsley_parsing_context;
+	
+#endif

data/ext/parsley/parsley_main.c

@@ -0,0 +1,185 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <json/printbuf.h>
+#include "parsley.h"
+#include "xml2json.h"
+#include <libxslt/xslt.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 <json/json.h>
+#include <argp.h>
+#include "util.h"
+
+struct arguments
+{
+	struct list_elem *include_files;
+	int flags;
+	int output_xml;
+	char *parsley;
+	char *user_agent;
+  char *input_file;
+  char *output_file;
+};
+
+struct list_elem {
+	int has_next;
+	struct list_elem *next;
+	char *string;
+};
+
+const char *argp_program_version = "parsley 0.1";
+const char *argp_program_bug_address = "<kyle@kylemaxwell.com>";
+static char args_doc[] = "PARSELET FILE_TO_PARSE";
+static char doc[] = "Parsley is a parselet parser.";
+
+static struct argp_option options[] = {
+	{"input-xml",       'x', 0, 0, 	"Use the XML parser (not HTML)" },
+	{"output-xml",      'X', 0, 0, 	"Output XML (not JSON)" },
+	{"output",   				'o', "FILE", 0, 	"Output to FILE instead of standard output" },
+  {"include",  				'i', "FILE", 0, 	"Include the contents of FILE in the compiled XSLT" },
+	{"no-prune",        'n', 0, 0, 	"Don't prune empty subtrees" },
+	{"no-collate",      'N', 0, 0, 	"Don't collate array entries" },
+	{"sg-wrap",         's', 0, 0, 	"Wrap text nodes for SelectorGadget compatibility" },
+	{"user-agent",      'U', "USER_AGENT", 0, 	"Value of HTTP User-Agent header" },
+	{"utf8",            'u', 0, 0, 	"Force input to be read as UTF-8" },
+	{"no-net",          'z', 0, 0, 	"Disable ftp and http access for parselets" },
+	{"no-filesystem",   'Z', 0, 0, 	"Disable filesystem access for parselets" },
+  { 0 }
+};
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state)
+{
+  struct arguments *arguments = state->input;
+	struct list_elem *base = arguments->include_files;
+	struct list_elem *e;
+
+  switch (key)
+    {	
+    case 'x':
+      arguments->flags &= ~PARSLEY_OPTIONS_HTML;
+			break;
+    case 'u':
+      arguments->flags |= PARSLEY_OPTIONS_FORCE_UTF8;
+			break;
+		case 'U':
+      parsley_set_user_agent(arg);
+    case 'n':
+			arguments->flags &= ~PARSLEY_OPTIONS_PRUNE;
+			break;
+    case 'N':
+			arguments->flags &= ~PARSLEY_OPTIONS_COLLATE;
+			break;
+    case 'z':
+			arguments->flags &= ~PARSLEY_OPTIONS_ALLOW_NET;
+			break;
+    case 's':
+			arguments->flags |= PARSLEY_OPTIONS_SGWRAP;
+			break;
+    case 'Z':
+			arguments->flags &= ~PARSLEY_OPTIONS_ALLOW_LOCAL;
+			break;
+    case 'X':
+			arguments->output_xml = 1;
+			break;
+    case 'i':
+			e = (struct list_elem *) calloc(1, sizeof(e));
+			e->string = arg;
+			while(base->has_next) base = base->next;
+			base->next = e;
+			base->has_next = 1;
+      break;
+    case 'o':
+      arguments->output_file = arg;
+      break;
+    case ARGP_KEY_ARG:
+			switch(state->arg_num){
+			case 0:
+				arguments->parsley = arg;
+				break;
+			case 1:
+				arguments->input_file = arg;
+				break;
+			default:
+				argp_usage (state);
+			}
+      break;
+    case ARGP_KEY_END:
+      if (state->arg_num < 2) argp_usage (state);
+      break;
+    default:
+      return ARGP_ERR_UNKNOWN;
+    }
+  return 0;
+}
+
+static struct argp argp = { options, parse_opt, args_doc, doc };
+
+int main (int argc, char **argv) {
+	struct arguments arguments;
+	struct list_elem elem;
+	struct list_elem *elemptr = &elem;
+	elem.has_next = 0;
+	arguments.output_xml = 0;
+  arguments.flags = ~0 & ~PARSLEY_OPTIONS_SGWRAP & ~PARSLEY_OPTIONS_FORCE_UTF8;
+	arguments.include_files = elemptr;
+	arguments.output_file = "-";
+	argp_parse (&argp, argc, argv, 0, 0, &arguments);
+	
+ 	struct printbuf *buf = printbuf_new();
+ 	struct printbuf *incl = printbuf_new();
+  sprintbuf(buf, "");
+  sprintbuf(incl, "");
+  
+  FILE * fd = parsley_fopen(arguments.parsley, "r");
+  printbuf_file_read(fd, buf);
+  fclose(fd);
+
+	while(elemptr->has_next) {
+		elemptr = elemptr->next;
+		FILE* f = parsley_fopen(elemptr->string, "r");
+		printbuf_file_read(f, incl);
+		fclose(f);
+	}
+	
+  // printf("a\n"); 
+	parsleyPtr compiled = parsley_compile(buf->buf, incl->buf);
+  // printf("b\n");
+
+	if(compiled->error != NULL) {
+		fprintf(stderr, "%s\n", compiled->error);
+		exit(1);
+	}
+	
+	parsedParsleyPtr ptr = parsley_parse_file(compiled, arguments.input_file, arguments.flags);
+
+	if(ptr->error != NULL) {
+		fprintf(stderr, "Parsing failed: %s\n", ptr->error);
+		exit(1);
+	}
+	
+	if(arguments.output_xml) {
+		xmlSaveFormatFile(arguments.output_file, ptr->xml, 1);	
+	} else {
+	  struct json_object *json = xml2json(ptr->xml->children->children);
+    if(json == NULL) {
+      fprintf(stderr, "xml2json unknown error");
+      exit(1);
+    }
+    char * json_string = json_object_to_json_string(json);
+		FILE* f = parsley_fopen(arguments.output_file, "w");
+	  fprintf(f, "%s\n", json_string);
+    json_object_put(json);
+		fclose(f);
+	}
+	
+  printbuf_free(buf);
+  printbuf_free(incl);
+	parsley_free(compiled);
+	parsed_parsley_free(ptr);
+	return 0;
+}

data/ext/parsley/parsleyc_main.c

@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <argp.h>
+#include <string.h>
+#include <json/printbuf.h>
+#include "parsley.h"
+#include "util.h"
+
+struct list_elem {
+	int has_next;
+	struct list_elem *next;
+	char *string;
+};
+
+struct arguments
+{
+	struct list_elem *include_files;
+	char *parsley;
+  char *output_file;
+};
+
+const char *argp_program_version = "parsleyc 0.1";
+const char *argp_program_bug_address = "<kyle@kylemaxwell.com>";
+static char args_doc[] = "DEX_FILE";
+static char doc[] = "Parsleyc is a parselet to XSLT compiler";
+
+static struct argp_option options[] = {
+  {"debug",    'd', 0, 0, 	"Turn on Bison parser debugging" },
+	{"output",   'o', "FILE", 0, 	"Output to FILE instead of standard output" },
+  {"include",  'i', "FILE", 0, 	"Include the contents of FILE in the produced XSLT" },
+  { 0 }
+};
+
+static error_t parse_opt (int key, char *arg, struct argp_state *state)
+{
+  struct arguments *arguments = state->input;
+	struct list_elem *base = arguments->include_files;
+	struct list_elem *e;
+
+  switch (key)
+    {
+    case 'i':
+			e = (struct list_elem *) calloc(1, sizeof(e));
+			e->string = arg;
+			while(base->has_next) base = base->next;
+			base->next = e;
+			base->has_next = 1;
+      break;
+    case 'd':	
+			// parsley_set_debug_mode(1);
+			break;
+    case 'o':
+      arguments->output_file = arg;
+      break;
+    case ARGP_KEY_ARG:
+      if (state->arg_num >= 1) argp_usage (state);
+      arguments->parsley = arg;
+      break;
+    case ARGP_KEY_END:
+      if (state->arg_num < 1) argp_usage (state);
+      break;
+    default:
+      return ARGP_ERR_UNKNOWN;
+    }
+  return 0;
+}
+
+static struct argp argp = { options, parse_opt, args_doc, doc };
+
+int main (int argc, char **argv) {
+	struct arguments arguments;
+	struct list_elem elem;
+	struct list_elem *elemptr = &elem;
+	elem.has_next = 0;
+	
+	arguments.include_files = elemptr;
+	arguments.output_file = "-";
+	arguments.parsley = "-";
+	argp_parse (&argp, argc, argv, 0, 0, &arguments);
+	
+	struct printbuf* parsley = printbuf_new();
+	struct printbuf* incl = printbuf_new();
+  sprintbuf(parsley, "");
+  sprintbuf(incl, "");
+
+	FILE* in = parsley_fopen(arguments.parsley, "r");
+	
+	printbuf_file_read(in, parsley);
+	while(elemptr->has_next) {
+		elemptr = elemptr->next;
+		FILE* f = parsley_fopen(elemptr->string, "r");
+		printbuf_file_read(f, incl);
+		fclose(f);
+	}
+	
+	parsleyPtr compiled = parsley_compile(parsley->buf, incl->buf);
+	if(compiled->error != NULL) {
+		fprintf(stderr, "%s\n", compiled->error);
+	 	exit(1);
+	}
+	
+  FILE* fo = parsley_fopen(arguments.output_file, "w");
+  xmlDocFormatDump(fo, compiled->stylesheet->doc, 1);
+  fclose(fo);
+  
+	return 0;
+}
+

data/ext/parsley/regexp.c

@@ -0,0 +1,359 @@
+/*
+ * regexp.c: Implementation of the EXSLT -- Regular Expressions module
+ *
+ * References:
+ *   http://exslt.org/regexp/index.html
+ *
+ * See Copyright for the status of this software.
+ *
+ * Authors:
+ *   Joel W. Reed <joelwreed@gmail.com>
+ *   Some modification by Kyle Maxwell
+ *
+ * TODO:
+ * functions:
+ *   regexp:match
+ *   regexp:replace
+ *   regexp:test
+ */
+#include "regexp.h"
+
+static void
+exsltRegexpFlagsFromString(const xmlChar* flagstr, 
+                           int* global, int* flags)
+{
+  const xmlChar* i = flagstr;
+
+  /* defaults */
+  (*flags) = PCRE_UTF8;
+  (*global) =  0;
+
+  while (*i != '\0')
+    {
+      if (*i == 'i') (*flags) |= PCRE_CASELESS;
+      else if (*i == 'g') (*global)= 1;
+      /* TODO: support other flags? */
+      i++;
+    }
+}
+
+static int
+exsltRegexpExecute(xmlXPathParserContextPtr ctxt, 
+                   const xmlChar* haystack, const xmlChar* regexp,
+                   int flags, int ovector[], int ovector_len)
+{
+  int haystack_len = 0;
+  pcre *compiled_regexp = NULL;
+  int rc = 0, erroffset = 0;
+  const char *error = 0;
+
+  compiled_regexp = pcre_compile(regexp,      /* the pattern */
+                                 flags,       /* default options */
+                                 &error,      /* for error message */
+                                 &erroffset,  /* for error offset */
+                                 NULL);       /* use default character tables */
+
+  if (compiled_regexp == NULL) {
+    xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+                        "exslt:regexp failed to compile %s (char: %d). %s", regexp, erroffset, error);
+    return -1;
+  }
+
+  haystack_len = xmlUTF8Strlen (haystack);
+
+  rc = pcre_exec(compiled_regexp,               /* result of pcre_compile() */
+                 NULL,                          /* we didn't study the pattern */
+                 haystack,                      /* the subject string */
+                 haystack_len,                  /* the length of the subject string */
+                 0,                             /* start at offset 0 in the subject */
+                 0,                             /* default options */
+                 (int*)ovector,                       /* vector of integers for substring information */
+                 ovector_len);  /* number of elements in the vector  (NOT size in bytes) */
+
+  if (rc < -1) {
+    xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
+                        "exslt:regexp failed to execute %s for %s", regexp, haystack);
+    rc = 0;
+  }
+  
+  if (compiled_regexp != NULL) 
+    pcre_free(compiled_regexp);
+
+  return rc;
+}
+
+/**
+ * exsltRegexpMatchFunction:
+ * @ns:     
+ *
+ * Returns a node set of string matches
+ */
+
+static void
+exsltRegexpMatchFunction (xmlXPathParserContextPtr ctxt, int nargs)
+{
+    xsltTransformContextPtr tctxt;
+    xmlNodePtr node;
+    xmlDocPtr container;
+    xmlXPathObjectPtr ret = NULL;
+    xmlChar *haystack, *regexp, *flagstr, *working, *match;
+    int rc, x, flags, global, ovector[30];
+
+    if ((nargs < 1) || (nargs > 3)) {
+        xmlXPathSetArityError(ctxt);
+        return;
+    }
+
+
+    if (nargs > 2) {
+      flagstr = xmlXPathPopString(ctxt);
+      if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) {
+          return;
+      }
+    } else {
+     flagstr = xmlStrdup("");
+    }
+    
+    regexp = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (regexp == NULL)) {
+        xmlFree(flagstr);
+        return;
+    }
+
+    haystack = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (haystack == NULL)) {
+        xmlFree(regexp);
+        xmlFree(flagstr);
+        return;
+    }
+
+    /* Return a result tree fragment */
+    tctxt = xsltXPathGetTransformContext(ctxt);
+    if (tctxt == NULL) {
+      xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
+                         "exslt:regexp : internal error tctxt == NULL\n");
+      goto fail;
+    }
+
+    container = xsltCreateRVT(tctxt);
+    if (container != NULL) {
+      xsltRegisterTmpRVT(tctxt, container);
+      ret = xmlXPathNewNodeSet(NULL);
+      if (ret != NULL) {
+        ret->boolval = 0; 
+
+        exsltRegexpFlagsFromString(flagstr, &global, &flags);
+        working = haystack;
+        rc = exsltRegexpExecute(ctxt, working, regexp, flags, 
+                                ovector, sizeof(ovector)/sizeof(int));
+
+        while (rc > 0) {
+					for(int group = 0; group < rc; group++) {
+          	match = xmlStrsub(working, ovector[group*2], ovector[group*2+1]-ovector[group*2]);
+          	if (NULL == match) goto fail;
+
+	          node = xmlNewDocRawNode(container, NULL, "match", match);
+	          xmlFree(match);
+
+	          xmlAddChild((xmlNodePtr) container, node);
+	          xmlXPathNodeSetAddUnique(ret->nodesetval, node);
+					}
+          if (!global) break;
+
+          working = working + ovector[1];
+          rc = exsltRegexpExecute(ctxt, working, regexp, flags, 
+                                  ovector, sizeof(ovector)/sizeof(int));
+        }
+      }
+    }
+    
+ fail:
+    if (flagstr != NULL)
+      xmlFree(flagstr);
+    if (regexp != NULL)
+      xmlFree(regexp);
+    if (haystack != NULL)
+      xmlFree(haystack);
+
+    if (ret != NULL)
+      valuePush(ctxt, ret);
+    else
+      valuePush(ctxt, xmlXPathNewNodeSet(NULL));
+}
+
+/**
+ * exsltRegexpReplaceFunction:
+ * @ns:     
+ *
+ * Returns a node set of string matches
+ */
+
+static void
+exsltRegexpReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs)
+{
+    xmlChar *haystack, *regexp, *flagstr, *replace, *tmp;
+    xmlChar *result = NULL, *working, *end;
+    int rc, x, flags, global, ovector[3];
+
+    if ((nargs < 1) || (nargs > 4)) {
+        xmlXPathSetArityError(ctxt);
+        return;
+    }
+
+    replace = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (replace == NULL)) {
+        return;
+    }
+
+    flagstr = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) {
+        xmlFree(replace);
+        return;
+    }
+
+    regexp = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (regexp == NULL)) {
+        xmlFree(flagstr);
+        xmlFree(replace);
+        return;
+    }
+
+    haystack = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (haystack == NULL)) {
+        xmlFree(regexp);
+        xmlFree(flagstr);
+        xmlFree(replace);
+        return;
+    }
+
+    exsltRegexpFlagsFromString(flagstr, &global, &flags);
+
+    working = haystack;
+    rc = exsltRegexpExecute(ctxt, working, regexp, flags, 
+                            ovector, sizeof(ovector)/sizeof(int));
+
+    while (rc > 0 ) {
+      if (0==ovector[0]) {
+        if (NULL==result) result = xmlStrdup(replace);
+        else result = xmlStrcat(result, replace);
+      }
+      else {
+        tmp = xmlStrsub(working, 0, ovector[0]);
+        if (NULL==result) result = tmp;
+        else {
+          result = xmlStrcat(result, tmp);
+          xmlFree(tmp);
+        }
+        result = xmlStrcat(result, replace);
+      }
+      
+      working = working + ovector[1];
+
+      if (!global) break;
+      rc = exsltRegexpExecute(ctxt, working, regexp, flags, 
+                              ovector, sizeof(ovector)/sizeof(int));
+    }
+
+    end = haystack + xmlUTF8Strlen(haystack);
+    if (working < end ) {
+        if (NULL==result) result = xmlStrdup(working);
+        else {
+          result = xmlStrcat(result, working);
+        }
+    }
+
+fail:
+    if (replace != NULL)
+            xmlFree(replace);
+    if (flagstr != NULL)
+            xmlFree(flagstr);
+    if (regexp != NULL)
+            xmlFree(regexp);
+    if (haystack != NULL)
+            xmlFree(haystack);
+
+    xmlXPathReturnString(ctxt, result);
+}
+
+/**
+ * exsltRegexpTestFunction:
+ * @ns:     
+ *
+ * returns true if the string given as the first argument 
+ * matches the regular expression given as the second argument
+ * 
+ */
+
+static void
+exsltRegexpTestFunction (xmlXPathParserContextPtr ctxt, int nargs)
+{
+    xmlChar *haystack, *regexp_middle, *regexp, *flagstr;
+    int rc = 0, flags, global, ovector[3];
+
+    if ((nargs < 1) || (nargs > 3)) {
+        xmlXPathSetArityError(ctxt);
+        return;
+    }
+
+    if(nargs > 2) {
+    flagstr = xmlXPathPopString(ctxt);
+      if (xmlXPathCheckError(ctxt) || (flagstr == NULL)) {
+          return;
+      }
+    } else {
+      flagstr = xmlStrdup("");
+    }
+
+    regexp_middle = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (regexp_middle == NULL)) {
+        xmlFree(flagstr);
+        return;
+    }
+
+    haystack = xmlXPathPopString(ctxt);
+    if (xmlXPathCheckError(ctxt) || (haystack == NULL)) {
+        xmlFree(regexp_middle);
+        xmlFree(flagstr);
+        return;
+    }
+
+    /* build the regexp */
+    regexp = xmlStrdup("\\A");
+    regexp = xmlStrcat(regexp, regexp_middle);
+    regexp = xmlStrcat(regexp, "\\Z");
+
+    exsltRegexpFlagsFromString(flagstr, &global, &flags);
+    rc = exsltRegexpExecute(ctxt, haystack, regexp, flags, 
+                            ovector, sizeof(ovector)/sizeof(int));
+
+fail:
+    if (flagstr != NULL)
+            xmlFree(flagstr);
+    if (regexp != NULL)
+            xmlFree(regexp);
+    if (regexp_middle != NULL)
+            xmlFree(regexp_middle);
+    if (haystack != NULL)
+            xmlFree(haystack);
+
+    xmlXPathReturnBoolean(ctxt, (rc > 0));
+}
+
+/**
+ * exsltRegexpRegister:
+ *
+ * Registers the EXSLT - Regexp module
+ */
+void
+PLUGINPUBFUN exslt_org_regular_expressions_init (void)
+{
+    xsltRegisterExtModuleFunction ((const xmlChar *) "match",
+                                   (const xmlChar *) EXSLT_REGEXP_NAMESPACE,
+                                   exsltRegexpMatchFunction);
+    xsltRegisterExtModuleFunction ((const xmlChar *) "replace",
+                                   (const xmlChar *) EXSLT_REGEXP_NAMESPACE,
+                                   exsltRegexpReplaceFunction);
+    xsltRegisterExtModuleFunction ((const xmlChar *) "test",
+                                   (const xmlChar *) EXSLT_REGEXP_NAMESPACE,
+                                   exsltRegexpTestFunction);
+}