agoo 2.5.4 → 2.5.5

data/ext/agoo/response.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_RESPONSE_H__
-#define __AGOO_RESPONSE_H__
+#ifndef AGOO_RESPONSE_H
+#define AGOO_RESPONSE_H
 
 #include <stdatomic.h>
 #include <stdbool.h>
@@ -25,4 +25,4 @@ typedef struct _Response {
 extern int	response_len(Response res);
 extern void	response_fill(Response res, char *buf);
 
-#endif // __AGOO_RESPONSE_H__
+#endif // AGOO_RESPONSE_H

data/ext/agoo/rhook.c

@@ -22,7 +22,7 @@ resolve_classname(VALUE mod, const char *classname) {
     return clas;
 }
 
-static VALUE
+VALUE
 resolve_classpath(const char *name, size_t len) {
     char	class_name[1024];
     VALUE	clas;
@@ -55,7 +55,7 @@ resolve_classpath(const char *name, size_t len) {
 
 Hook
 rhook_create(Method method, const char *pattern, VALUE handler, Queue q) {
-    Hook	hook = hook_create(method,pattern, NULL, RACK_HOOK, q);
+    Hook	hook = hook_create(method, pattern, NULL, RACK_HOOK, q);
 
     if (NULL != hook) {
 	if (T_STRING == rb_type(handler)) {

data/ext/agoo/rhook.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_RHOOK_H__
-#define __AGOO_RHOOK_H__
+#ifndef AGOO_RHOOK_H
+#define AGOO_RHOOK_H
 
 #include <ruby.h>
 
@@ -9,5 +9,6 @@
 #include "method.h"
 
 extern Hook	rhook_create(Method method, const char *pattern, VALUE handler, Queue q);
+extern VALUE	resolve_classpath(const char *name, size_t len);
 
-#endif // __AGOO_RHOOK_H__
+#endif // AGOO_RHOOK_H

data/ext/agoo/rlog.h

@@ -1,11 +1,11 @@
 // Copyright 2018 by Peter Ohler, All Rights Reserved
 
-#ifndef __AGOO_RLOG_H__
-#define __AGOO_RLOG_H__
+#ifndef AGOO_RLOG_H
+#define AGOO_RLOG_H
 
 #include <ruby.h>
 #include "log.h"
 
 extern void	rlog_init(VALUE mod);
 
-#endif /* __AGOO_RLOG_H__ */
+#endif /* AGOO_RLOG_H */

data/ext/agoo/rresponse.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_RRESPONSE_H__
-#define __AGOO_RRESPONSE_H__
+#ifndef AGOO_RRESPONSE_H
+#define AGOO_RRESPONSE_H
 
 #include <ruby.h>
 
@@ -11,4 +11,4 @@ extern void	response_init(VALUE mod);
 extern VALUE	response_new();
 extern Text	response_text(VALUE self);
 
-#endif // __AGOO_RRESPONSE_H__
+#endif // AGOO_RRESPONSE_H

data/ext/agoo/rserver.c

@@ -15,6 +15,7 @@
 #include "debug.h"
 #include "dtime.h"
 #include "err.h"
+#include "graphql.h"
 #include "http.h"
 #include "log.h"
 #include "page.h"
@@ -173,6 +174,32 @@ configure(Err err, int port, const char *root, VALUE options) {
 		break;
 	    }
 	}
+	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("graphql"))))) {
+	    const char	*path;
+	    Hook	hook;
+	    char	schema_path[256];
+	    long	plen;
+
+	    rb_check_type(v, T_STRING);
+	    if (ERR_OK != gql_init(err)) {
+		return err->code;
+	    }
+	    path = StringValuePtr(v);
+	    plen = (long)RSTRING_LEN(v);
+	    if ((int)sizeof(schema_path) - 8 < plen) {
+		rb_raise(rb_eArgError, "A graphql schema path is limited to %d characters.", (int)(sizeof(schema_path) - 8));
+	    }
+	    memcpy(schema_path, path, plen);
+	    memcpy(schema_path + plen, "/schema", 8);
+
+	    hook = hook_func_create(GET, schema_path, gql_dump_hook, &the_server.eval_queue);
+	    hook->next = the_server.hooks;
+	    the_server.hooks = hook;
+
+	    hook = hook_func_create(GET, path, gql_eval_hook, &the_server.eval_queue);
+	    hook->next = the_server.hooks;
+	    the_server.hooks = hook;
+	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("quiet"))))) {
 	    if (Qtrue == v) {
 		info_cat.on = false;
@@ -838,6 +865,7 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
     Hook	hook;
     Method	meth = ALL;
     const char	*pat;
+    ID		static_id = rb_intern("static?");
 
     rb_check_type(pattern, T_STRING);
     pat = StringValuePtr(pattern);
@@ -861,6 +889,42 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
     } else {
 	rb_raise(rb_eArgError, "invalid method");
     }
+    if (T_STRING == rb_type(handler)) {
+	handler = resolve_classpath(StringValuePtr(handler), RSTRING_LEN(handler));
+    }
+    if (rb_respond_to(handler, static_id)) {
+	if (Qtrue == rb_funcall(handler, static_id, 0, Qnil)) {
+	    VALUE	res = rb_funcall(handler, call_id, 1, Qnil);
+	    VALUE	bv;
+	    
+	    rb_check_type(res, T_ARRAY);
+	    if (3 != RARRAY_LEN(res)) {
+		rb_raise(rb_eArgError, "a rack call() response must be an array of 3 members.");
+	    }
+	    bv = rb_ary_entry(res, 2);
+	    if (T_ARRAY == rb_type(bv)) {
+		int		i;
+		int		bcnt = (int)RARRAY_LEN(bv);
+		Text		t = text_allocate(1024);
+		struct _Err	err = ERR_INIT;
+		VALUE		v;
+
+		if (NULL == t) {
+		    rb_raise(rb_eArgError, "failed to allocate response.");
+		}
+		for (i = 0; i < bcnt; i++) {
+		    v = rb_ary_entry(bv, i);
+		    t = text_append(t, StringValuePtr(v), (int)RSTRING_LEN(v));
+		}
+		if (NULL == page_immutable(&err, pat, t->text, t->len)) {
+		    rb_raise(rb_eArgError, "%s", err.msg);
+		}
+		text_release(t);
+
+		return Qnil;
+	    }
+	}
+    }
     if (NULL == (hook = rhook_create(meth, pat, handler, &the_server.eval_queue))) {
 	rb_raise(rb_eStandardError, "out of memory.");
     } else {

data/ext/agoo/rserver.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_RSERVER_H__
-#define __AGOO_RSERVER_H__
+#ifndef AGOO_RSERVER_H
+#define AGOO_RSERVER_H
 
 #include <ruby.h>
 
@@ -18,4 +18,4 @@ extern struct _RServer	the_rserver;
 extern void	server_init(VALUE mod);
 extern VALUE	rserver_shutdown(VALUE self);
 
-#endif // __AGOO_RSERVER_H__
+#endif // AGOO_RSERVER_H

data/ext/agoo/rupgraded.c

@@ -47,7 +47,7 @@ extract_subject(VALUE subject, int *slen) {
 	break;
     case T_SYMBOL:
 	subj = rb_id2name(rb_sym2id(subject));
-	*slen = strlen(subj);
+	*slen = (int)strlen(subj);
 	break;
     default:
 	subject = rb_funcall(subject, to_s_id, 0);

data/ext/agoo/rupgraded.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_RUPGRADED_H__
-#define __AGOO_RUPGRADED_H__
+#ifndef AGOO_RUPGRADED_H
+#define AGOO_RUPGRADED_H
 
 #include <ruby.h>
 
@@ -14,4 +14,4 @@ extern Upgraded	rupgraded_create(struct _Con *c, VALUE obj, VALUE env);
 
 extern const char*	extract_subject(VALUE subject, int *slen);
 
-#endif // __AGOO_RUPGRADED_H__
+#endif // AGOO_RUPGRADED_H

data/ext/agoo/sdl.c

@@ -0,0 +1,334 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdio.h>
+#include <string.h>
+
+#include "doc.h"
+#include "gqlvalue.h"
+#include "graphql.h"
+#include "sdl.h"
+
+static int
+extract_name(Err err, Doc doc, const char *key, int klen, char *name, size_t max) {
+    const char	*start;
+    size_t	nlen;
+
+    if (0 != strncmp(doc->cur, key, klen)) {
+	return doc_err(doc, err, "Expected %s key word", key);
+    }
+    doc->cur += klen;
+    if (0 == doc_skip_white(doc)) {
+	return doc_err(doc, err, "Expected %s key word", key);
+    }
+    start = doc->cur;
+    doc_read_token(doc);
+    if (doc->cur == start) {
+	return doc_err(doc, err, "Name not provided");
+    }
+    nlen = doc->cur - start;
+    if (max <= nlen) {
+	return doc_err(doc, err, "Name too long");
+    }
+    strncpy(name, start, nlen);
+    name[nlen] = '\0';
+    
+    return ERR_OK;
+}
+
+static int
+make_scalar(Err err, Doc doc, const char *desc, int len) {
+    char	name[256];
+
+    if (ERR_OK != extract_name(err, doc, "scalar", 6, name, sizeof(name))) {
+	return err->code;
+    }
+    gql_scalar_create(err, name, desc, len, false);
+    
+    return ERR_OK;
+}
+
+static int
+make_enum(Err err, Doc doc, const char *desc, int len) {
+    char	name[256];
+    const char	*start;
+    gqlType	type;
+    
+    if (ERR_OK != extract_name(err, doc, "enum", 4, name, sizeof(name))) {
+	return err->code;
+    }
+    doc_skip_white(doc);
+    if ('{' != *doc->cur) {
+	return doc_err(doc, err, "Expected '{'");
+    }
+    doc->cur++;
+
+    if (NULL == (type = gql_enum_create(err, name, desc, len, false))) {
+	return err->code;
+    }
+    while (doc->cur < doc->end) {
+	doc_skip_white(doc);
+	start = doc->cur;
+	doc_read_token(doc);
+	if (doc->cur == start) {
+	    if ('}' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	    return doc_err(doc, err, "Invalid Enum value");
+	}
+	if (ERR_OK != gql_enum_add(err, type, start, (int)(doc->cur - start))) {
+	    return err->code;
+	}
+    }
+    return ERR_OK;
+}
+
+static int
+make_union(Err err, Doc doc, const char *desc, int len) {
+    char	name[256];
+    const char	*start;
+    gqlType	type;
+    
+    if (ERR_OK != extract_name(err, doc, "union", 5, name, sizeof(name))) {
+	return err->code;
+    }
+    doc_skip_white(doc);
+    if ('=' != *doc->cur) {
+	return doc_err(doc, err, "Expected '='");
+    }
+    doc->cur++;
+    doc_skip_white(doc);
+
+    if (NULL == (type = gql_union_create(err, name, desc, len, false))) {
+	return err->code;
+    }
+    while (doc->cur < doc->end) {
+	doc_skip_white(doc);
+	start = doc->cur;
+	doc_read_token(doc);
+	if (ERR_OK != gql_union_add(err, type, start, (int)(doc->cur - start))) {
+	    return err->code;
+	}
+	doc_skip_white(doc);
+	if ('|' != *doc->cur) {
+	    break;
+	}
+	doc->cur++; // skip |
+    }
+    return ERR_OK;
+}
+
+static int
+make_arg(Err err, Doc doc, gqlDir dir) {
+    char	name[256];
+    char	type_name[256];
+    const char	*start;
+    const char	*desc = NULL;
+    const char	*desc_end = NULL;
+    size_t	nlen;
+    bool	required = false;
+    gqlValue	dv = NULL;
+    
+    doc_skip_white(doc);
+    if ('"' == *doc->cur) {
+	desc = doc->cur + 1;
+	if (ERR_OK != doc_read_string(err, doc)) {
+	    return err->code;
+	}
+	if ('"' == *desc) { // must be a """
+	    desc += 2;
+	    desc_end = doc->cur - 3;
+	} else {
+	    desc_end = doc->cur - 1;
+	}
+    }
+    doc_skip_white(doc);
+    start = doc->cur;
+    doc_read_token(doc);
+    if (doc->cur == start) {
+	return doc_err(doc, err, "Argument name not provided");
+    }
+    if (':' != *doc->cur) {
+	return doc_err(doc, err, "Expected ':'");
+    }
+    nlen = doc->cur - start;
+    if (sizeof(name) <= nlen) {
+	return doc_err(doc, err, "Name too long");
+    }
+    strncpy(name, start, nlen);
+    name[nlen] = '\0';
+    doc->cur++;
+
+    // read type
+    doc_skip_white(doc);
+    start = doc->cur;
+    doc_read_token(doc);
+    if (doc->cur == start) {
+	return doc_err(doc, err, "Argument type not provided");
+    }
+    nlen = doc->cur - start;
+    if (sizeof(type_name) <= nlen) {
+	return doc_err(doc, err, "Type name too long");
+    }
+    strncpy(type_name, start, nlen);
+    type_name[nlen] = '\0';
+
+    doc_skip_white(doc);
+    if ('!' == *doc->cur) {
+	required = true;
+    } else if ('=' == *doc->cur) {
+	if (NULL == (dv = doc_read_value(err, doc))) {
+	    return err->code;
+	}
+    }
+    doc_skip_white(doc);
+    if ('@' == *doc->cur) {
+	// TBD directive
+    }
+    if (NULL == gql_dir_arg(err, dir, name, type_name, desc, (int)(desc_end - desc), dv, required)) {
+	return err->code;
+    }
+    return ERR_OK;
+}
+
+static int
+make_directive(Err err, Doc doc, const char *desc, int len) {
+    char	name[256];
+    const char	*start;
+    gqlDir	dir;
+    size_t	nlen;
+
+    if (0 != strncmp(doc->cur, "directive", 9)) {
+	return doc_err(doc, err, "Expected directive key word");
+    }
+    doc->cur += 9;
+    if (0 == doc_skip_white(doc)) {
+	return doc_err(doc, err, "Expected directive key word");
+    }
+    if ('@' != *doc->cur) {
+	return doc_err(doc, err, "Expected '@'");
+    }
+    doc->cur++;
+    start = doc->cur;
+    doc_read_token(doc);
+    if (doc->cur == start) {
+	return doc_err(doc, err, "Name not provided");
+    }
+    nlen = doc->cur - start;
+    if (sizeof(name) <= nlen) {
+	return doc_err(doc, err, "Name too long");
+    }
+    strncpy(name, start, nlen);
+    name[nlen] = '\0';
+    if (NULL == (dir = gql_directive_create(err, name, desc, len, false))) {
+	return err->code;
+    }
+    if ('(' == *doc->cur) {
+	while (doc->cur < doc->end) {
+	    if (ERR_OK != make_arg(err, doc, dir)) {
+		return err->code;
+	    }
+	    doc_skip_white(doc);
+	    if (')' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	}
+    }
+    doc_skip_white(doc);
+    start = doc->cur;
+    doc_read_token(doc);
+
+    if (2 != doc->cur - start || 0 != strncmp(start, "on", 2)) {
+	return doc_err(doc, err, "Expected 'on'");
+    }
+    while (doc->cur < doc->end) {
+	doc_skip_white(doc);
+	start = doc->cur;
+	doc_read_token(doc);
+	if (ERR_OK != gql_directive_on(err, dir, start, (int)(doc->cur - start))) {
+	    return err->code;
+	}
+	doc_skip_white(doc);
+	if ('|' != *doc->cur) {
+	    break;
+	}
+	doc->cur++; // skip |
+    }
+    return ERR_OK;
+}
+
+int
+sdl_parse(Err err, const char *str, int len) {
+    struct _Doc	doc;
+    const char	*desc = NULL;
+    const char	*desc_end = NULL;
+    
+    doc_init(&doc, str, len);
+
+    while (doc.cur < doc.end) {
+	doc_next_token(&doc);
+	switch (*doc.cur) {
+	case '"':
+	    desc = doc.cur + 1;
+	    if (ERR_OK != doc_read_string(err, &doc)) {
+		return err->code;
+	    }
+	    if ('"' == *desc) { // must be a """
+		desc += 2;
+		desc_end = doc.cur - 3;
+	    } else {
+		desc_end = doc.cur - 1;
+	    }
+	    break;
+	case 's': // scalar
+	    if (ERR_OK != make_scalar(err, &doc, desc, (int)(desc_end - desc))) {
+		return err->code;
+	    }
+	    break;
+	case 'e': // enum, and extend interface or type
+	    if (4 < (doc.end - doc.cur)) {
+		if ('n' == doc.cur[1]) {
+		    if (ERR_OK != make_enum(err, &doc, desc, (int)(desc_end - desc))) {
+			return err->code;
+		    }
+		    break;
+		} else {
+		    // TBD extend
+		    break;
+		}
+	    }
+	    return doc_err(&doc, err, "Unknown directive");
+	case 'u': // union
+	    if (ERR_OK != make_union(err, &doc, desc, (int)(desc_end - desc))) {
+		return err->code;
+	    }
+	    break;
+	case 'd': // directive
+	    if (ERR_OK != make_directive(err, &doc, desc, (int)(desc_end - desc))) {
+		return err->code;
+	    }
+	    break;
+	case 't': // type
+	    break;
+	case 'i': // interface, input
+	    if (5 < (doc.end - doc.cur) && 'n' == doc.cur[1]) {
+		if ('p' == doc.cur[2]) {
+		    // input
+		    break;
+		} else {
+		    // TBD interface
+		    break;
+		}
+	    }
+	    return doc_err(&doc, err, "Unknown directive");
+	case 'f': // fragment
+	    break;
+	case '\0':
+	    return ERR_OK;
+	default:
+	    return doc_err(&doc, err, "Unknown directive");
+	}
+    }
+    return ERR_OK;
+}