stash 1.0.0 → 2.0.0

data/ext/stash/build.c

@@ -0,0 +1,267 @@
+#include "intern.h"
+
+/* forward declare helper functions */
+static void append_node(mustache_node_t* parent, mustache_node_t* src);
+static mustache_error_t* create_error(mustache_token_t* last_token, enum mustache_token_type expected_token, char* error_text);
+
+/*
+
+template         := block
+block            := statement | block
+statement        := [text] | [newline] | command
+command          := variable | section | inverse_section | partial | comment
+variable         := [raw] [identifier] | [identifier]
+section          := [section_start] [identifier] block [section_end]
+inverse_section  := [inverse_section_start] [identifier] block [section_end]
+partial          := [partial] [identifier]
+
+*/
+
+void build_template(mustache_token_t* tokens, mustache_node_t* root, mustache_error_t** error)
+{
+    root->type = NODE_BLOCK;
+    root->execute = execute_block;
+    root->optimize = optimize_block;
+    append_node(root, build_block(&tokens, error));
+
+    if (tokens) {
+        *error = create_error(tokens, TOKEN_ERROR, tokens->text);
+    }
+}
+
+mustache_node_t* build_block(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* block;
+    mustache_node_t* next;
+
+    block = mustache_create_node();
+    block->type = NODE_BLOCK;
+    block->execute = execute_block;
+    block->optimize = optimize_block;
+
+    while ((next = build_statement(tokens, error))) {
+        append_node(block, next);
+    }
+
+    return block;
+}
+
+mustache_node_t* build_statement(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* next = build_text(tokens, error);
+
+    if (!next) {
+        next = build_newline(tokens, error);
+    }
+
+    if (!next) {
+        next = build_command(tokens, error);
+    }
+
+    return next;
+}
+
+mustache_node_t* build_text(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* next;
+
+    if (!is_token(*tokens, TOKEN_TEXT)) {
+        return NULL;
+    }
+
+    next = mustache_create_node();
+    next->type = NODE_TEXT;
+    next->token = pop_token(tokens);
+    next->execute = execute_text;
+    next->optimize = optimize_text;
+    return next;
+}
+
+mustache_node_t* build_newline(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* next;
+
+    if (!is_token(*tokens, TOKEN_NEWLINE)) {
+        return NULL;
+    }
+
+    next = mustache_create_node();
+    next->type = NODE_NEWLINE;
+    next->token = pop_token(tokens);
+    next->execute = execute_newline;
+    next->optimize = optimize_newline;
+    return next;
+}
+
+mustache_node_t* build_command(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* next = build_raw_variable(tokens, error);
+
+    if (!next) {
+        next = build_variable(tokens, error);
+    }
+
+    if (!next) {
+        next = build_section(tokens, error);
+    }
+
+    if (!next) {
+        next = build_partial(tokens, error);
+    }
+
+    if (!next) {
+        next = build_comment(tokens, error);
+    }
+
+    return next;
+}
+
+mustache_node_t* build_raw_variable(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* next;
+
+    if (!is_token(*tokens, TOKEN_RAW)) {
+        return NULL;
+    }
+
+    free_token(pop_token(tokens));
+
+    if (!is_token(*tokens, TOKEN_IDENTIFIER)) {
+        *error = create_error(*tokens, TOKEN_IDENTIFIER, "Expected identifier");
+    }
+
+    next = mustache_create_node();
+    next->type = NODE_RAW_VARIABLE;
+    next->token = pop_token(tokens);
+    next->execute = execute_raw_variable;
+    next->optimize = optimize_variable;
+    return next;
+}
+
+mustache_node_t* build_variable(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* next;
+
+    if (!is_token(*tokens, TOKEN_IDENTIFIER)) {
+        return NULL;
+    }
+
+    next = mustache_create_node();
+    next->type = NODE_VARIABLE;
+    next->token = pop_token(tokens);
+    next->execute = execute_variable;
+    next->optimize = optimize_variable;
+    return next;
+}
+
+mustache_node_t* build_section(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* section;
+    mustache_token_t* token;
+    bool is_inverted;
+
+    if (!is_token(*tokens, TOKEN_SECTION_START) &&
+        !is_token(*tokens, TOKEN_ISECTION_START)) {
+        return NULL;
+    }
+
+    token = pop_token(tokens);
+    is_inverted = token->type == TOKEN_ISECTION_START;
+    free_token(token);
+
+    if (!is_token(*tokens, TOKEN_IDENTIFIER)) {
+        *error = create_error(*tokens, TOKEN_IDENTIFIER, "Expected identifier");
+        return NULL;
+    }
+
+    section = mustache_create_node();
+    section->type = is_inverted ? NODE_INVERTED_SECTION : NODE_SECTION;
+    section->token = pop_token(tokens);
+    section->execute = execute_section;
+    section->optimize = optimize_section;
+    append_node(section, build_block(tokens, error));
+
+    if (!is_token(*tokens, TOKEN_SECTION_END)) {
+        *error = create_error(*tokens, TOKEN_SECTION_END, "Expected section end");
+        return NULL;
+    }
+
+    free_token(pop_token(tokens));
+
+    if (!is_token(*tokens, TOKEN_IDENTIFIER)) {
+        *error = create_error(*tokens, TOKEN_IDENTIFIER, "Expected identifier");
+        return NULL;
+    }
+
+    free_token(pop_token(tokens));
+
+    return section;
+}
+
+mustache_node_t* build_partial(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* node;
+
+    if (!is_token(*tokens, TOKEN_PARTIAL)) {
+        return NULL;
+    }
+
+    free_token(pop_token(tokens));
+
+    if (!is_token(*tokens, TOKEN_IDENTIFIER)) {
+        *error = create_error(*tokens, TOKEN_IDENTIFIER, "Expected identifier");
+        return NULL;
+    }
+
+    node = mustache_create_node();
+    node->type = NODE_PARTIAL;
+    node->token = pop_token(tokens);
+    node->execute = execute_partial;
+    node->optimize = optimize_partial;
+    return node;
+}
+
+mustache_node_t* build_comment(mustache_token_t** tokens, mustache_error_t** error)
+{
+    mustache_node_t* node;
+
+    if (!is_token(*tokens, TOKEN_COMMENT)) {
+        return NULL;
+    }
+
+    node = mustache_create_node();
+    node->type = NODE_COMMENT;
+    node->token = pop_token(tokens);
+    node->execute = execute_comment;
+    node->optimize = optimize_comment;
+    return node;
+}
+
+
+/* Helper functions */
+
+static void append_node(mustache_node_t* parent, mustache_node_t* src)
+{
+    mustache_node_t* child = parent->first_child;
+
+    if (!child) {
+        parent->first_child = src;
+    }
+    else {
+        while (child->next_sibling) {
+            child = child->next_sibling;
+        }
+        child->next_sibling = src;
+        src->prv_sibling = child;
+    }
+
+    src->parent = parent;
+}
+
+static mustache_error_t* create_error(mustache_token_t* last_token, enum mustache_token_type expected_token, char* error_text)
+{
+    mustache_error_t* error = mustache_malloc(sizeof(mustache_error_t));
+    error->last_token = last_token;
+    error->error_text = error_text;
+    return error;
+}

data/ext/stash/execute.c

@@ -0,0 +1,248 @@
+#include "intern.h"
+
+/* forward declare helper functions */
+static bool html_encode(char* non_terminated_input, size_t length, mustache_context_t* ctx);
+static mustache_value_t* get_variable_value(char* key, mustache_context_t* ctx);
+static mustache_value_t* get_value(char* key, mustache_context_t* ctx);
+bool is_whitespace(mustache_node_t* text_node);
+
+bool execute_block(mustache_node_t* node, mustache_context_t* ctx)
+{
+    mustache_node_t* child = node->first_child;
+
+    while (child) {
+        if (!child->execute(child, ctx)) {
+            return false;
+        }
+        child = child->next_sibling;
+    }
+    return true;
+}
+
+bool execute_text(mustache_node_t* node, mustache_context_t* ctx)
+{
+    return mustache_write_to_buffer(ctx, node->token->text, strlen(node->token->text));
+}
+
+bool execute_newline(mustache_node_t* node, mustache_context_t* ctx)
+{
+    if (!mustache_write_to_buffer(ctx, node->token->text, strlen(node->token->text))) {
+        return false;
+    }
+
+    if (*ctx->prefix && node->next_sibling) {
+        if (!mustache_write_to_buffer(ctx, ctx->prefix, strlen(ctx->prefix))) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool execute_raw_variable(mustache_node_t* node, mustache_context_t* ctx)
+{
+    mustache_value_t* value = get_variable_value(node->token->text, ctx);
+    if (value) {
+        if (value->type == VALUE_VALUE) {
+            if (!mustache_write_to_buffer(ctx, value->data.value, value->length)) {
+                value->destroy(value);
+                return false;
+            }
+        }
+        value->destroy(value);
+    }
+
+    return true;
+}
+
+bool execute_variable(mustache_node_t* node, mustache_context_t* ctx)
+{
+    mustache_value_t* value = get_variable_value(node->token->text, ctx);
+    if (value) {
+        if (value->type == VALUE_VALUE) {
+            if (!html_encode(value->data.value, value->length, ctx)) {
+                printf("html_encode failed\n");
+                value->destroy(value);
+                return false;
+            }
+        }
+        value->destroy(value);
+    }
+
+    return true;
+}
+size_t foo = 0;
+
+bool execute_section(mustache_node_t* node, mustache_context_t* ctx)
+{
+    mustache_value_t* value = get_variable_value(node->token->text, ctx);
+    mustache_context_t** list_contexts = NULL;
+    mustache_context_t* list_context = NULL;
+    bool response = true;
+
+    bool is_true;
+
+    // If the variable doesn't exist, don't execute the template
+    if (!value && node->type == NODE_SECTION) {
+        return true;
+    } else if (!value && node->type == NODE_INVERTED_SECTION) {
+        return node->first_child->execute(node->first_child, ctx);
+    }
+
+    switch (value->type) {
+        case VALUE_LIST:
+            list_contexts = value->data.list;
+
+            if (node->type == NODE_INVERTED_SECTION) {
+                if (value->length) {
+                    return true;
+                } else {
+                    return node->first_child->execute(node->first_child, ctx);
+                }
+            }
+
+            for (size_t i = 0; i < value->length; i++) {
+                list_context = list_contexts[i];
+                list_context->parent = ctx;
+                list_context->partials = ctx->partials;
+                list_context->get_partial = ctx->get_partial;
+                response = node->first_child->execute(node->first_child, list_context);
+
+                if (!response) {
+                    break;
+                }
+            }
+
+            break;
+        case VALUE_OBJECT:
+            is_true = value->data.object != NULL;
+            if (is_true == (node->type == NODE_SECTION)) {
+                value->data.object->parent = ctx;
+                response = node->first_child->execute(node->first_child, value->data.object);
+                value->data.object->parent = NULL;
+            }
+            break;
+        case VALUE_VALUE:
+            is_true = value->length > 0;
+            if (is_true == (node->type == NODE_SECTION)) {
+                response = node->first_child->execute(node->first_child, ctx);
+            } else {
+                response = true;
+            }
+            break;
+    }
+
+    value->destroy(value);
+
+    if (!response) {
+        // TODO: truncate
+    }
+    return true;
+}
+
+bool execute_partial(mustache_node_t* node, mustache_context_t* ctx)
+{
+    mustache_node_t* partial = ctx->get_partial(node->token->text, ctx->partials);
+
+    // add indentation
+    char* indentation = NULL;
+
+    if (node->prv_sibling &&
+        node->prv_sibling->type == NODE_TEXT &&
+        is_whitespace(node->prv_sibling) &&
+        (!node->prv_sibling->prv_sibling || node->prv_sibling->prv_sibling->type == NODE_NEWLINE)) {
+
+        // Save existing indentation, it will be replaced after partial execution
+        indentation = ctx->prefix;
+        size_t current_length = *ctx->prefix ? strlen(ctx->prefix) : 0;
+        size_t sibling_length = strlen(node->prv_sibling->token->text);
+
+        ctx->prefix = malloc(sizeof(char) * (current_length + sibling_length + 1));
+
+        if (current_length) {
+            strncpy(ctx->prefix, ctx->prefix, current_length);
+        }
+        strncpy(ctx->prefix + current_length, node->prv_sibling->token->text, sibling_length);
+    }
+
+    bool ret_val = true;
+    if (partial) {
+        ret_val = partial->execute(partial, ctx);
+    }
+
+    // restore indentation
+    if (indentation) {
+        free(ctx->prefix);
+        ctx->prefix = indentation;
+    }
+
+    return ret_val;
+}
+
+bool execute_comment(mustache_node_t* node, mustache_context_t* ctx)
+{
+    return true;
+}
+
+/* helper functions */
+
+static bool html_encode(
+    char* non_terminated_input,
+    size_t length,
+    mustache_context_t* ctx)
+{
+    char current;
+    char* replacement;
+    size_t replacement_length;
+
+    for (int i = 0; i < length; i++) {
+        current = non_terminated_input[i];
+
+        switch (current) {
+            case '&': replacement = "&amp;";  replacement_length = 5; break;
+            case '"': replacement = "&quot;"; replacement_length = 6; break;
+            case '<': replacement = "&lt;";   replacement_length = 4; break;
+            case '>': replacement = "&gt;";   replacement_length = 4; break;
+            default:
+                replacement = &current;
+                replacement_length = 1;
+                break;
+        }
+
+        if (!mustache_write_to_buffer(ctx, replacement, replacement_length)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static mustache_value_t* get_variable_value(char* key, mustache_context_t* ctx)
+{
+    // special case for implicit variables
+    if (key[0] == '.') {
+        return ctx->get_data(key, ctx->data, ctx, ctx);
+    }
+
+    char* context_identifier = strtok(key, ".");
+    mustache_value_t* result = NULL;
+    while (context_identifier) {
+        result = get_value(context_identifier, ctx);
+        if (result && result->type == VALUE_OBJECT) {
+            ctx = result->data.object;
+        }
+        context_identifier = strtok(NULL, ".");
+    }
+    return result;
+}
+
+static mustache_value_t* get_value(char* key, mustache_context_t* ctx)
+{
+    mustache_value_t* value = ctx->get_data(key, ctx->data, ctx, ctx);
+    mustache_context_t* current_context = ctx;
+    while (!value && current_context->parent) {
+        current_context = current_context->parent;
+        value = current_context->get_data(key, current_context->data, current_context, ctx);
+    }
+    return value;
+}