gtl-parsley-ruby 0.5.0

data/ext/parsley/test/youtube.let

@@ -0,0 +1,11 @@
+{
+  "video(.video-cell)": [ {
+      "thumbnail": ".vimg120 @src",
+      "title": ".video-short-title a",
+      "link": ".video-short-title a @href",
+      "posted": ".video-date-added",
+      "views": ".video-view-count",
+      "length": ".video-time span",
+      "rating": ".ratingVS @title"
+    } ]
+}

data/ext/parsley/util.c

@@ -0,0 +1,237 @@
+#include "util.h"
+
+static bool parsley_exslt_registered = false;
+
+#define BUF 128
+
+FILE* parsley_fopen(char* name, char* mode) {
+	FILE* fo;
+	if(!strcmp("-", name)) {
+		if(!strcmp("w", mode)) {
+			fo = stdout;
+		} else {
+			fo = stdin;
+		}
+	} else {
+		fo = fopen(name, mode);
+	}
+	if(fo == NULL) {		
+    fprintf(stderr, "Cannot open file %s, error %d, %s\n", name, errno, strerror(errno));
+		exit(1);
+	}
+	return fo;	
+}
+
+static int parsley_io_mode = 0;
+static char *parsley_user_agent_header = NULL;
+
+int
+parsley_io_get_mode() {
+  return parsley_io_mode;
+}
+
+static xsltStylesheetPtr span_wrap_sheet = NULL;
+
+xmlDocPtr 
+parsley_apply_span_wrap(xmlDocPtr doc) {
+  if(span_wrap_sheet == NULL) {
+    char * sheet = "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" xmlns:sg=\"http://selectorgadget.com/\"> \
+      <xsl:template match=\"text()[(following-sibling::* or preceding-sibling::*) and normalize-space(.) != '']\"> \
+        <sg_wrap><xsl:value-of select=\".\" /></sg_wrap> \
+      </xsl:template> \
+    	<xsl:template match=\"@*|node()\"> \
+    	  <xsl:copy> \
+          <xsl:apply-templates select=\"@*|node()\"/> \
+    	  </xsl:copy> \
+    	</xsl:template> \
+    </xsl:stylesheet>";
+    
+    xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
+ 		xmlDocPtr xml = xmlCtxtReadMemory(ctxt, sheet, strlen(sheet), NULL, NULL, 0);
+    span_wrap_sheet = xsltParseStylesheetDoc(xml);
+  }  
+  xsltTransformContextPtr ctxt = xsltNewTransformContext(span_wrap_sheet, doc);
+  xmlSetGenericErrorFunc(ctxt, parsleyXsltError);
+  xmlDocPtr out = xsltApplyStylesheetUser(span_wrap_sheet, doc, NULL, NULL, NULL, ctxt);
+  xsltFreeTransformContext(ctxt);
+  return out;
+}
+
+void
+_parsley_set_user_agent(char * agent) {
+  if(parsley_user_agent_header != NULL) free(parsley_user_agent_header);
+  if(agent == NULL) {
+    parsley_user_agent_header = NULL;
+  } else {
+    asprintf(&parsley_user_agent_header, "User-Agent: %s\n", agent);
+  }
+}
+
+static void *
+xmlUserAgentIOHTTPOpen(const char * file_name) {
+  return (void *)(xmlNanoHTTPMethod(file_name, NULL, NULL, NULL, parsley_user_agent_header, 0));
+}
+
+void
+parsley_io_set_mode(int mode) {
+  if(mode == parsley_io_mode) return;
+  parsley_io_mode = mode;
+  
+  xmlCleanupInputCallbacks();
+  
+  if(parsley_io_mode & PARSLEY_OPTIONS_ALLOW_LOCAL) {
+  
+    xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen,
+  	                      xmlFileRead, xmlFileClose);
+    #ifdef HAVE_ZLIB_H
+        xmlRegisterInputCallbacks(xmlGzfileMatch, xmlGzfileOpen,
+    	                      xmlGzfileRead, xmlGzfileClose);
+    #endif /* HAVE_ZLIB_H */
+  }
+  if(parsley_io_mode & PARSLEY_OPTIONS_ALLOW_NET) {
+    #ifdef LIBXML_HTTP_ENABLED
+        xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlUserAgentIOHTTPOpen,
+    	                      xmlIOHTTPRead, xmlIOHTTPClose);
+    #endif /* LIBXML_HTTP_ENABLED */
+
+    #ifdef LIBXML_FTP_ENABLED
+        xmlRegisterInputCallbacks(xmlIOFTPMatch, xmlIOFTPOpen,
+    	                      xmlIOFTPRead, xmlIOFTPClose);
+    #endif /* LIBXML_FTP_ENABLED */
+  }
+}
+
+void
+printbuf_file_read(FILE *f, struct printbuf *buf) {
+  char chars[BUF];
+  while(fgets(chars, BUF, f) != NULL){
+    sprintbuf(buf, "%s", chars);
+  }
+}
+
+void registerEXSLT() {
+  if(!parsley_exslt_registered) {
+    exsltRegisterAll();
+		parsley_register_all();
+		init_xpath_alias();
+		exslt_org_regular_expressions_init();
+    parsley_exslt_registered = true;
+  }
+}
+
+int parsley_key_flags(char* key) {
+  char* ptr = key;
+  char* last_alnum = key;
+  char* last_paren = key;
+  while(*ptr++ != '\0'){
+    if(isalnum(*ptr)) {
+      last_alnum = ptr;
+    } else if (*ptr == ')') {
+      last_paren = ptr;
+    }
+  }
+  ptr = (last_alnum > last_paren ? last_alnum : last_paren);
+  int flags = 0;
+  while(*ptr++ != '\0'){
+    switch(*ptr){
+    case '?':
+      flags |= PARSLEY_OPTIONAL;
+      break;
+    case '!':
+      flags |= PARSLEY_BANG;
+      break;
+    }
+  }
+  return flags;
+}
+
+char* parsley_key_tag(char* key) {
+	char *tag = strdup(key);
+	char *ptr = tag;
+	while(*ptr++ != '\0'){
+		if(!isalnum(*ptr) && *ptr != '_' && *ptr != '-') {
+			*ptr = 0;
+			return tag;
+		}
+	}
+	return tag;
+}
+
+pxpathPtr parsley_key_filter(char* key) {
+	char *expr = strdup(key);
+	char *ptr = expr;
+	char *orig = expr;
+  char *last_paren;
+
+	int offset = 0;
+	bool has_expr = false;
+
+	while(*ptr++ != '\0'){
+		if(!has_expr)     offset++;
+		if(*ptr == '(')   has_expr = true;
+    if(*ptr == ')')   last_paren = ptr;
+	}
+	if(!has_expr) return NULL;
+  *last_paren = 0; // clip ")"
+	expr += offset + 1; // clip "("
+
+	pxpathPtr out = strlen(expr) == 0 ? NULL : myparse(expr);
+	free(orig);
+	// free(expr);
+	return out;
+}
+
+static xmlNodePtr
+_xmlLastElementChild(xmlNodePtr node) {
+  xmlNodePtr child = node->children;
+  xmlNodePtr elem = NULL;
+  while(child != NULL) {
+    if(child->type == XML_ELEMENT_NODE) elem = child;
+    child = child->next;
+  }
+  return elem;
+}
+
+xmlNodePtr new_stylesheet_skeleton(char *incl) {
+	struct printbuf *buf = printbuf_new();
+	sprintbuf(buf, "%s", "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"");
+	sprintbuf(buf, "%s", " xmlns:lib=\"http://parselets.com/stdlib\"");
+	sprintbuf(buf, "%s", " xmlns:parsley=\"http://parselets.com/json\"");
+	sprintbuf(buf, "%s", " xmlns:str=\"http://exslt.org/strings\"");
+	sprintbuf(buf, "%s", " xmlns:set=\"http://exslt.org/sets\"");
+	sprintbuf(buf, "%s", " xmlns:math=\"http://exslt.org/math\"");
+	sprintbuf(buf, "%s", " xmlns:func=\"http://exslt.org/functions\"");
+	sprintbuf(buf, "%s", " xmlns:user=\"http://parselets.com/usre\"");
+	sprintbuf(buf, "%s", " xmlns:dyn=\"http://exslt.org/dynamic\"");
+	sprintbuf(buf, "%s", " xmlns:date=\"http://exslt.org/dates-and-times\"");
+	sprintbuf(buf, "%s", " xmlns:exsl=\"http://exslt.org/common\"");
+	sprintbuf(buf, "%s", " xmlns:saxon=\"http://icl.com/saxon\"");
+	sprintbuf(buf, "%s", " xmlns:regexp=\"http://exslt.org/regular-expressions\"");
+	sprintbuf(buf, "%s", " xmlns:regex=\"http://exslt.org/regular-expressions\"");
+	sprintbuf(buf, "%s", " extension-element-prefixes=\"lib str math set func dyn exsl saxon user date regexp regex\"");
+	sprintbuf(buf, "%s", ">\n");
+  sprintbuf(buf, "%s", "<xsl:variable name=\"nbsp\">&#160;</xsl:variable>\n");
+	sprintbuf(buf, "%s", "<xsl:output method=\"xml\" indent=\"yes\"/>\n");
+	sprintbuf(buf, "%s", "<xsl:strip-space elements=\"*\"/>\n");
+	sprintbuf(buf, "%s", "<func:function name=\"lib:nl\"><xsl:param name=\"in\" select=\".\"/>");
+	sprintbuf(buf, "%s", "<xsl:variable name=\"out\"><xsl:apply-templates mode=\"innertext\" select=\"exsl:node-set($in)\"/></xsl:variable>");
+	sprintbuf(buf, "%s", "<func:result select=\"$out\" /></func:function>");
+	sprintbuf(buf, "%s", "<xsl:template match=\"text()\" mode=\"innertext\"><xsl:value-of select=\".\" /></xsl:template>");
+	sprintbuf(buf, "%s", "<xsl:template match=\"script|style\" mode=\"innertext\"/>");
+	sprintbuf(buf, "%s", "<xsl:template match=\"br|address|blockquote|center|dir|div|form|h1|h2|h3|h4|h5|h6|hr|menu|noframes|noscript|p|pre|li|td|th|p\" mode=\"innertext\"><xsl:apply-templates mode=\"innertext\" /><xsl:text>\n</xsl:text></xsl:template>");
+	sprintbuf(buf, "%s\n", incl);
+	sprintbuf(buf, "%s\n", "<xsl:template match=\"/\">\n");
+	sprintbuf(buf, "%s\n", "<parsley:root />\n");
+	sprintbuf(buf, "%s\n", "</xsl:template>\n");
+	sprintbuf(buf, "%s\n", "</xsl:stylesheet>\n");
+	xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
+	xmlDocPtr doc = xmlCtxtReadMemory(ctxt, buf->buf, buf->size, "http://parselets.com/compiled", NULL, 3);
+	xmlFreeParserCtxt(ctxt);
+	printbuf_free(buf);
+	
+	xmlNodePtr node = xmlDocGetRootElement(doc);
+	while(_xmlLastElementChild(node) != NULL) {
+		node = _xmlLastElementChild(node);
+	}
+	return node;
+}

data/ext/parsley/util.h

@@ -0,0 +1,34 @@
+#ifndef UTIL_H_INCLUDED
+#define UTIL_H_INCLUDED
+
+#include <stdio.h>
+#include <json/json.h>
+#include "parsed_xpath.h"
+#include "parsley.h"
+#include "parser.h"
+#include "regexp.h"
+#include <json/printbuf.h>
+#include "functions.h"
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <libexslt/exslt.h>
+#include <libxml/xmlIO.h>
+
+FILE* parsley_fopen(char*, char*);
+xmlNodePtr new_stylesheet_skeleton(char *incl);
+void registerEXSLT();
+void printbuf_file_read(FILE *f, struct printbuf *buf);
+
+int parsley_key_flags(char*);
+char* parsley_key_tag(char*);
+pxpathPtr parsley_key_filter(char*);
+int parsley_io_get_mode();
+void parsley_io_set_mode(int mode);
+void _parsley_set_user_agent(char *agent);
+
+xmlDocPtr parsley_apply_span_wrap(xmlDocPtr ptr);
+
+#endif

data/ext/parsley/xml2json.c

@@ -0,0 +1,47 @@
+#include "xml2json.h"
+
+static struct json_object * _xml2json(xmlNodePtr xml) {
+  if(xml == NULL) return NULL;
+  
+  xmlNodePtr child;
+  struct json_object * json = NULL;
+  
+  switch(xml->type) {
+    case XML_ELEMENT_NODE:
+      child = xml->children;
+      if(xml->ns == NULL) {
+        child = xml;
+        // json_object_put(json);
+        json = json_object_new_object();
+        while(child != NULL) {
+          json_object_object_add(json, child->name, xml2json(child->children));
+          child = child->next;
+        }
+      } else if(!strcmp(xml->ns->prefix, "parsley")) {
+        if(!strcmp(xml->name, "groups")) {
+          // json_object_put(json);
+          json = json_object_new_array();          
+          while(child != NULL) {
+            json_object_array_add(json, xml2json(child->children));
+            child = child->next;
+          }          
+        } else if(!strcmp(xml->name, "group")) {
+          // Implicitly handled by parsley:groups handler
+        }
+      }
+      break;
+    case XML_TEXT_NODE:  
+      json = json_object_new_string(xml->content);
+      break;
+  }
+  return json;
+}
+
+/**
+ * Handles a simplified xml
+ */
+struct json_object * xml2json(xmlNodePtr xml) {
+	struct json_object * json = _xml2json(xml);
+	if(json == NULL) json = json_object_new_object();
+	return json;
+}

data/ext/parsley/xml2json.h

@@ -0,0 +1,14 @@
+#ifndef XML2JSON_H_INCLUDED
+#define XML2JSON_H_INCLUDED
+
+#include <string.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/debugXML.h>
+#include <json/json.h>
+
+struct json_object * xml2json(xmlNodePtr);
+
+#endif

data/ext/parsley/y.tab.h

@@ -0,0 +1,222 @@
+/* A Bison parser, made by GNU Bison 2.3.  */
+
+/* Skeleton interface for Bison GLR parsers in C
+
+   Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+
+   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, 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 Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     NUMBER = 258,
+     S = 259,
+     AT = 260,
+     LPAREN = 261,
+     RPAREN = 262,
+     PIPE = 263,
+     LT = 264,
+     SLASH = 265,
+     DBLSLASH = 266,
+     BANG = 267,
+     COLON = 268,
+     DBLCOLON = 269,
+     QUERY = 270,
+     HASH = 271,
+     COMMA = 272,
+     DOT = 273,
+     DBLDOT = 274,
+     GT = 275,
+     LBRA = 276,
+     RBRA = 277,
+     TILDE = 278,
+     SPLAT = 279,
+     PLUS = 280,
+     DASH = 281,
+     EQ = 282,
+     LTE = 283,
+     GTE = 284,
+     DOLLAR = 285,
+     BSLASHLIT = 286,
+     OTHER = 287,
+     XANCESTOR = 288,
+     XANCESTORSELF = 289,
+     XATTR = 290,
+     XCHILD = 291,
+     XDESC = 292,
+     XDESCSELF = 293,
+     XFOLLOW = 294,
+     XFOLLOWSIB = 295,
+     XNS = 296,
+     XPARENT = 297,
+     XPRE = 298,
+     XPRESIB = 299,
+     XSELF = 300,
+     XOR = 301,
+     XAND = 302,
+     XDIV = 303,
+     XMOD = 304,
+     XCOMMENT = 305,
+     XTEXT = 306,
+     XPI = 307,
+     XNODE = 308,
+     CXEQUATION = 309,
+     CXOPHE = 310,
+     CXOPNE = 311,
+     CXOPSTARTEQ = 312,
+     CXOPENDEQ = 313,
+     CXOPCONTAINS = 314,
+     CXOPCONTAINS2 = 315,
+     CXFIRST = 316,
+     CXLAST = 317,
+     CXNOT = 318,
+     CXEVEN = 319,
+     CXODD = 320,
+     CXEQ = 321,
+     CXGT = 322,
+     CXLT = 323,
+     CXHEADER = 324,
+     CXCONTAINS = 325,
+     CXEMPTY = 326,
+     CXHAS = 327,
+     CXPARENT = 328,
+     CXNTHCH = 329,
+     CXNTHLASTCH = 330,
+     CXNTHTYPE = 331,
+     CXNTHLASTTYPE = 332,
+     CXFIRSTCH = 333,
+     CXLASTCH = 334,
+     CXFIRSTTYPE = 335,
+     CXLASTTYPE = 336,
+     CXONLYCH = 337,
+     CXONLYTYPE = 338,
+     CXINPUT = 339,
+     CXTEXT = 340,
+     CXPASSWORD = 341,
+     CXRADIO = 342,
+     CXCHECKBOX = 343,
+     CXSUBMIT = 344,
+     CXIMAGE = 345,
+     CXRESET = 346,
+     CXBUTTON = 347,
+     CXFILE = 348,
+     CXENABLED = 349,
+     CXDISABLED = 350,
+     CXCHECKED = 351,
+     CXSELECTED = 352,
+     NAME = 353,
+     STRING = 354
+   };
+#endif
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "parser.y"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "parsed_xpath.h"
+#include <libxml/hash.h>
+
+#ifndef PARSER_Y_H_INCLUDED
+#define PARSER_Y_H_INCLUDED
+
+static pxpathPtr parsed_answer;
+
+int yylex (void);
+void yyerror (char const *);
+
+void prepare_parse(char*);
+void cleanup_parse(void);
+void start_debugging(void);
+
+static xmlHashTablePtr alias_hash;
+
+char* xpath_alias(char*);
+void init_xpath_alias();
+
+int yyparse(void);
+pxpathPtr myparse(char*);
+void answer(pxpathPtr);
+
+#define LIT_BIN_OP(A, B, C)           pxpath_cat_literals(3, A, LIT(B), C)
+#define BIN_OP(A, B, C)               pxpath_cat_paths(3, A, OP(B), C)
+#define PREP_OP(A, B)                 pxpath_cat_paths(2, OP(A), B)
+#define PXP(A)                        pxpath_new_path(1, A)
+#define LIT(A)                        pxpath_new_literal(1, A)
+#define OP(A)   	                    pxpath_new_operator(1, A)
+#define APPEND(A, S)                  pxpath_cat_paths(2, A, PXP(S)); 
+#define PREPEND(A, S)                 pxpath_cat_paths(2, PXP(S), A); 
+#define PXPWRAP(A, B, C)              pxpath_cat_paths(3, PXP(A), B, PXP(C))
+#define P4E(A, B, C, D)               pxpath_cat_paths(4, A, PXP(B), C, PXP(D))
+#define P4O(A, B, C, D)               pxpath_cat_paths(4, PXP(A), B, PXP(C), D)
+#define P6E(A, B, C, D, E, F)         pxpath_cat_paths(6, A, PXP(B), C, PXP(D), E, PXP(F));
+#define INPUT_TYPE(A, S)              APPEND(A, "[lower-case(name())='input' and lower-case(@type)='" #S "']")
+#define TRACE(A, B)                   fprintf(stderr, "trace(%s): ", A); fprintf(stderr, "%s\n", pxpath_to_string(B));
+
+#endif
+  
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE 
+#line 53 "parser.y"
+{
+  int empty;
+	char* string;
+  pxpathPtr node;
+}
+/* Line 2616 of glr.c.  */
+#line 202 "y.tab.h"
+	YYSTYPE;
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+
+  char yydummy;
+
+} YYLTYPE;
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+
+