stash 1.0.0 → 2.0.0

data/ext/stash/optimize.c

@@ -0,0 +1,208 @@
+#include "intern.h"
+
+/* forward declare helper functions */
+static bool contains_node_type(mustache_node_t* root, enum mustache_node_type type);
+static void remove_node(mustache_node_t* node);
+static bool is_posfix_standalone(mustache_node_t* node);
+bool is_whitespace(mustache_node_t* text_node);
+
+bool optimize_block(mustache_node_t* node)
+{
+    mustache_node_t* child = node->first_child;
+    while (child) {
+        if (!child->optimize(child)) {
+            return false;
+        }
+        child = child->next_sibling;
+    }
+    return true;
+}
+
+bool optimize_text(mustache_node_t* node)
+{
+    // Remove indentation from starting standalone tags
+    if ((!node->prv_sibling || node->prv_sibling->type == NODE_NEWLINE) &&
+        node->next_sibling &&
+        (node->next_sibling->type == NODE_SECTION || node->next_sibling->type == NODE_INVERTED_SECTION) &&
+        contains_node_type(node->next_sibling->first_child, NODE_NEWLINE) &&
+        is_whitespace(node)) {
+        remove_node(node);
+    }
+
+    // Remove indentation from ending standalone tags if beginning tag was intented
+    if (!node->next_sibling &&
+        node->prv_sibling &&
+        node->prv_sibling->type == NODE_NEWLINE &&
+        node->parent &&
+        node->parent->parent &&
+        (node->parent->parent->type == NODE_SECTION || node->parent->parent->type == NODE_INVERTED_SECTION) &&
+        (!node->parent->parent->next_sibling || (node->parent->parent->prv_sibling && is_whitespace(node->parent->parent->prv_sibling))) &&
+        is_whitespace(node)) {
+        remove_node(node);
+    }
+
+    return true;
+}
+
+bool optimize_newline(mustache_node_t* node)
+{
+    // Remove newlines after starting standalone section tags
+    if (!node->prv_sibling &&
+        node->parent &&
+        node->parent->parent &&
+        (node->parent->parent->type == NODE_SECTION || node->parent->parent->type == NODE_INVERTED_SECTION)&&
+        (!node->parent->parent->prv_sibling || is_whitespace(node->parent->parent->prv_sibling))) {
+        remove_node(node);
+    }
+
+    // Remove newlines after ending standalone section tags
+    if (node->prv_sibling &&
+        (node->prv_sibling->type == NODE_SECTION || node->prv_sibling->type == NODE_INVERTED_SECTION) &&
+        (!node->prv_sibling->first_child->first_child || contains_node_type(node->prv_sibling->first_child, NODE_NEWLINE))) {
+        remove_node(node);
+    }
+    return true;
+}
+
+bool optimize_variable(mustache_node_t* node)
+{
+    return true;
+}
+
+bool optimize_section(mustache_node_t* node)
+{
+    return node->first_child->optimize(node->first_child);
+}
+
+bool optimize_comment(mustache_node_t* node)
+{
+    // Remove whitespace from standalone comments.
+    // Comments that satisfy any of the following conditions are considered standalone:
+    //   1. "{{!comment}}"
+    //   2. "{{!comment}}  "
+    //   3. "{{!comment}}\n"
+    //   4. "{{!comment}}  \n"
+    //   5. "  {{!comment}}"
+    //   6. "  {{!comment}}  "
+    //   7. "  {{!comment}}\n"
+    //   8. "  {{!comment}}  \n"
+    //   9. "\n{{!comment}}"
+    //  10. "\n{{!comment}}  "
+    //  11. "\n{{!comment}}\n"
+    //  12. "\n{{!comment}}  \n"
+    //  13. "\n  {{!comment}}"
+    //  14. "\n  {{!comment}}  "
+    //  15. "\n  {{!comment}}\n"
+    //  16. "\n  {{!comment}}  \n"
+
+    bool is_standalone = false;
+    mustache_node_t* tmp = NULL;
+    mustache_node_t* prv = node->prv_sibling;
+    mustache_node_t* next = node->next_sibling;
+    if (!prv) {
+        is_standalone = is_posfix_standalone(node);
+    } else if (is_whitespace(prv)) {
+        if (!prv->prv_sibling &&
+            (!node->parent || !node->parent->parent || !(node->parent->parent->type == NODE_SECTION || node->parent->parent->type == NODE_INVERTED_SECTION))) {
+            is_standalone = is_posfix_standalone(node);
+        } else if (prv->type == NODE_NEWLINE) {
+            is_standalone = is_posfix_standalone(node);
+        } else if (prv->prv_sibling && prv->prv_sibling->type == NODE_NEWLINE) {
+            is_standalone = is_posfix_standalone(node);
+        }
+    }
+
+    // if the comment is standalone, remove the unnessesary nodes.
+    if (is_standalone) {
+        if (prv && prv->type == NODE_TEXT && node->type == NODE_COMMENT) {
+            remove_node(prv);
+        }
+        if (next && next->type == NODE_TEXT) {
+            tmp = next->next_sibling;
+            remove_node(next);
+            next = tmp;
+        }
+        while (next && next->type == NODE_NEWLINE) {
+            tmp = next->next_sibling;
+            remove_node(next);
+            next = tmp;
+        }
+    }
+    return true;
+}
+
+bool optimize_partial(mustache_node_t* node)
+{
+    return optimize_comment(node);
+}
+
+
+/* helper functions */
+
+static bool contains_node_type(mustache_node_t* root, enum mustache_node_type type)
+{
+    if (root->type == type) {
+        return true;
+    }
+
+    if ((root->first_child && contains_node_type(root->first_child, type)) ||
+        (root->next_sibling && contains_node_type(root->next_sibling, type))) {
+        return true;
+    }
+
+    return false;
+}
+
+bool is_whitespace(mustache_node_t* text_node)
+{
+    if (text_node->type == NODE_NEWLINE) {
+        return true;
+    }
+
+    if (text_node->type != NODE_TEXT) {
+        return false;
+    }
+
+    char* text = text_node->token->text;
+    while (text[0]) {
+        if (!isspace(text[0])) {
+            return false;
+        }
+        text++;
+    }
+    return true;
+}
+
+static void remove_node(mustache_node_t* node)
+{
+    if (!node) {
+        return;
+    }
+
+    mustache_node_t* prv = node->prv_sibling;
+    mustache_node_t* next = node->next_sibling;
+
+    if (prv) {
+        prv->next_sibling = next;
+    } else {
+        node->parent->first_child = next;
+    }
+
+    if (next) {
+        next->prv_sibling = prv;
+    }
+
+    // TODO: free node
+    // TODO: free node's children
+}
+
+static bool is_posfix_standalone(mustache_node_t* node)
+{
+    mustache_node_t* next = node->next_sibling;
+    if (!next || next->type == NODE_NEWLINE) {
+        return true;
+    } else if (next->type == NODE_TEXT && is_whitespace(next)) {
+        return (!next->next_sibling || next->next_sibling->type == NODE_NEWLINE);
+    }
+    return false;
+}

data/ext/stash/stash.c

@@ -0,0 +1,177 @@
+#include <ruby.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include "mustache.h"
+#include "stash.h"
+
+
+
+extern void log_template_execution_time(mustache_context_t* m_ctx, double time);
+extern double get_time();
+
+VALUE cTemplate = Qnil;
+
+static VALUE cTemplate_init(VALUE self, VALUE rb_template_string)
+{
+    mustache_node_t* c_template;
+    Data_Get_Struct(self, mustache_node_t, c_template);
+
+    char* c_template_string;
+    long c_template_string_length;
+    mustache_error_t* error = NULL;
+
+    c_template_string = strdup(rb_str2cstr(rb_template_string, &c_template_string_length));
+    mustache_build_template(c_template_string, c_template, &error);
+
+    if (error) {
+        rb_raise(rb_eSyntaxError, error->error_text);
+    }
+
+    return self;
+}
+
+static VALUE cTemplate_render(int argc, VALUE* argv, VALUE self)
+{
+    VALUE data = Qnil;
+    VALUE partials = Qnil;
+    VALUE debug = Qnil;
+
+    if (argc > 0) {
+        VALUE type = TYPE(argv[0]);
+        if (type != T_OBJECT && type != T_HASH) {
+            rb_raise(rb_eArgError, "Expected an object or hash as argument 1");
+            return Qnil;
+        }
+        data = argv[0];
+    }
+
+    if (argc > 1) {
+        VALUE type = TYPE(argv[1]);
+        if (type != T_HASH) {
+            rb_raise(rb_eArgError, "Expected a hash as argument 2");
+            return Qnil;
+        }
+        partials = argv[1];
+    }
+
+    if (argc > 2) {
+        if (strcmp(rb_obj_classname(argv[2]), "Template::Debug") != 0) {
+            rb_raise(rb_eArgError, "Expected an instance of Template::Debug as argument 3");
+            return Qnil;
+        }
+        debug = argv[2];
+    }
+
+    // Get the template
+    mustache_node_t* c_template;
+    Data_Get_Struct(self, mustache_node_t, c_template);
+
+    // Create the context
+    mustache_context_t* m_ctx = create_mustache_context(NULL);
+    mustache_ruby_context_t* r_ctx = (mustache_ruby_context_t*) m_ctx->custom;
+    m_ctx->data = (void*) data;
+    m_ctx->partials = (void*) partials;
+    m_ctx->debug_mode = debug != Qnil;
+
+    double start = 0;
+    if (m_ctx->debug_mode) {
+        start = get_time();
+        r_ctx->debugObject = debug;
+    }
+
+    // Execute the template
+    mustache_execute_template(c_template, m_ctx);
+
+    if (m_ctx->debug_mode) {
+        log_template_execution_time(m_ctx, get_time() - start);
+    }
+
+    // Return the buffer
+    VALUE result = rb_str_resize(r_ctx->buffer, r_ctx->buffer_length);
+    m_ctx->destroy(m_ctx);
+    return result;
+}
+
+static void template_mark(mustache_node_t* node)
+{
+}
+
+static void template_free(mustache_node_t* node)
+{
+}
+
+static VALUE template_allocate(VALUE klass)
+{
+    mustache_node_t* c_template = mustache_create_node();
+    return Data_Wrap_Struct(cTemplate, template_mark, template_free, c_template);
+}
+
+void Init_stash()
+{
+    // Define the Template class
+    cTemplate = rb_define_class("Template", rb_cObject);
+    rb_define_alloc_func(cTemplate, template_allocate);
+    rb_define_method(cTemplate, "initialize", cTemplate_init, 1);
+    rb_define_method(cTemplate, "render", cTemplate_render, -1);
+}
+
+bool mustache_write_to_buffer(mustache_context_t* m_ctx, char* data, size_t data_length)
+{
+    if (data_length == 0) {
+        return true;
+    }
+
+    mustache_ruby_context_t* r_ctx = (mustache_ruby_context_t*) m_ctx->custom;
+    rb_str_buf_cat(r_ctx->buffer, data, data_length);
+    r_ctx->buffer_length += data_length;
+    return true;
+}
+
+void* mustache_malloc(long size)
+{
+    return ruby_xmalloc(size);
+}
+
+void mustache_free(void* ptr)
+{
+    ruby_xfree(ptr);
+}
+
+mustache_node_t* get_partial(char* key, void* partials)
+{
+    VALUE rb_partials = (VALUE) partials;
+    Check_Type(rb_partials, T_HASH);
+
+    VALUE rb_value;
+    if (NIL_P(rb_value = rb_hash_aref(rb_partials, ID2SYM(rb_intern(key))))) {
+        return NULL;
+    }
+
+    if (rb_class_of(rb_value) != cTemplate) {
+        rb_raise(rb_eTypeError, "Expected Template");
+    }
+
+    mustache_node_t* template = NULL;
+    Data_Get_Struct(rb_value, mustache_node_t, template);
+    return template;
+}
+
+double get_time()
+{
+    struct timeval t;
+    struct timezone tzp;
+    gettimeofday(&t, &tzp);
+    return t.tv_sec + t.tv_usec*1e-6;
+}
+
+void log_template_execution_time(mustache_context_t* m_ctx, double time)
+{
+    mustache_ruby_context_t* r_ctx = (mustache_ruby_context_t*) m_ctx->custom;
+    rb_ivar_set(r_ctx->debugObject, rb_intern("@total_time"), rb_float_new(time));
+}
+
+void log_ruby_callback_execution_time(mustache_context_t* m_ctx, ID callback_name, double time)
+{
+    mustache_ruby_context_t* r_ctx = (mustache_ruby_context_t*) m_ctx->custom;
+    rb_funcall(r_ctx->debugObject, rb_intern("log_callback"), 2, ID2SYM(callback_name), rb_float_new(time));
+}

data/ext/stash/stash.h

@@ -0,0 +1,17 @@
+typedef struct mustache_ruby_context {
+    VALUE buffer;
+    long buffer_length;
+    VALUE debugObject;
+} mustache_ruby_context_t;
+
+mustache_context_t* create_mustache_context(mustache_context_t* parent);
+
+mustache_value_t* convert_type(
+  char* key,
+  void* context,
+  mustache_context_t* m_lookup_context,
+  mustache_context_t* m_exection_context);
+
+mustache_node_t* get_partial(char* key, void* partials);
+void log_ruby_callback_execution_time(mustache_context_t* m_ctx, ID callback_name, double time);
+double get_time();

data/ext/stash/tokens.c

@@ -0,0 +1,151 @@
+#include "intern.h"
+
+void set_start_delimiter(char* delimiter, scanner_data_t* data)
+{
+    data->statement_start = strdup(delimiter);
+}
+
+void use_next_end_delimiter(scanner_data_t* data)
+{
+    data->statement_end = data->next_statement_end;
+    data->next_statement_end = "";
+}
+
+void set_next_end_delimiter(char* delimiter, scanner_data_t* data)
+{
+    data->statement_end = strdup(delimiter);
+}
+
+mustache_token_t* pop_token(mustache_token_t** head)
+{
+    mustache_token_t* token = *head;
+    *head = token->next;
+    return token;
+}
+
+void reverse(mustache_token_t** head)
+{
+    mustache_token_t* prv = NULL;
+    mustache_token_t* current = *head;
+
+    while (current) {
+        mustache_token_t* next = current->next;
+        current->next = prv;
+        prv = current;
+        current = next;
+    }
+
+    *head = prv;
+}
+
+bool is_token(mustache_token_t* head, enum mustache_token_type type)
+{
+    if (!head) {
+        return false;
+    }
+
+    return head->type == type;
+}
+
+void free_token(mustache_token_t* token)
+{
+    if (!token) {
+        return;
+    }
+
+    if (*token->text) {
+        free(token->text);
+    }
+
+    free(token);
+}
+
+bool is_string_in_buffer(char* string, int string_len, char* buffer, int buffer_len)
+{
+    if (buffer_len < string_len) {
+        return false;
+    }
+
+    return strncmp(&buffer[buffer_len - string_len], string, string_len) == 0;
+}
+
+mustache_token_t* create_token(enum mustache_token_type type, char* text)
+{
+    mustache_token_t* token = malloc(sizeof(mustache_token_t));
+    char* copied_text = strdup(text);
+
+    if (token) {
+        token->type = type;
+        token->text = copied_text;
+        token->next = NULL;
+    }
+
+    return token;
+}
+
+void push_token(enum mustache_token_type type, char* text, yyscan_t yyscanner)
+{
+    scanner_data_t* data = (scanner_data_t*) yyget_extra(yyscanner);
+    mustache_token_t* token = create_token(type, text);
+
+    if (data->head_token) {
+        token->next = data->head_token;
+    }
+
+    data->head_token = token;
+}
+
+void push_text(yyscan_t yyscanner)
+{
+    // Get the accumulated text
+    scanner_data_t* data = (scanner_data_t*) yyget_extra(yyscanner);
+
+    // If the buffer contains text, push the token and reset buffer
+    if (data->buffer[0]) {
+        push_token(TOKEN_TEXT, data->buffer, yyscanner);
+        memset(data->buffer, '\0', data->buffer_size);
+        data->buffer_index = 0;
+    }
+}
+
+void push_comment(yyscan_t yyscanner)
+{
+    // Get the accumulated text
+    scanner_data_t* data = (scanner_data_t*) yyget_extra(yyscanner);
+
+    // If the buffer contains text, push the token and reset buffer
+    if (data->buffer[0]) {
+        push_token(TOKEN_COMMENT, data->buffer, yyscanner);
+        memset(data->buffer, '\0', data->buffer_size);
+        data->buffer_index = 0;
+    }
+}
+
+void push_error(yyscan_t yyscanner)
+{
+    return;
+}
+
+int get_tokens(char* input, mustache_token_t** tokens)
+{
+    yyscan_t scanner;
+    scanner_data_t data;
+    data.head_token = NULL;
+    data.buffer_size = sizeof(char) * strlen(input) + 1;
+    data.buffer = malloc(data.buffer_size);
+    memset(data.buffer, '\0', data.buffer_size);
+    data.buffer_index = 0;
+    data.statement_start = "{{";
+    data.statement_end = "}}";
+    data.next_statement_end = "";
+
+    yylex_init_extra(&data, &scanner);
+    yy_scan_string(input, scanner);
+    yylex(scanner);
+    yylex_destroy(scanner);
+    *tokens = data.head_token;
+    free(data.buffer);
+    reverse(tokens);
+
+    return true;
+}