static void test_object_iterator(void **state)
{
JsonElement *obj = JsonObjectCreate(10);
JsonObjectAppendString(obj, "first", "one");
JsonObjectAppendString(obj, "second", "two");
JsonObjectAppendInteger(obj, "third", 3);
JsonObjectAppendBool(obj, "fourth", true);
JsonObjectAppendBool(obj, "fifth", false);
{
JsonIterator it = JsonIteratorInit(obj);
assert_string_equal("first", JsonIteratorNextKey(&it));
assert_string_equal("second", JsonIteratorNextKey(&it));
assert_string_equal("third", JsonIteratorNextKey(&it));
assert_string_equal("fourth", JsonIteratorNextKey(&it));
assert_string_equal("fifth", JsonIteratorNextKey(&it));
assert_false(JsonIteratorNextKey(&it));
}
{
JsonIterator it = JsonIteratorInit(obj);
assert_string_equal("one", JsonPrimitiveGetAsString(JsonIteratorNextValue(&it)));
assert_string_equal("two", JsonPrimitiveGetAsString(JsonIteratorNextValue(&it)));
assert_int_equal(3, JsonPrimitiveGetAsInteger(JsonIteratorNextValue(&it)));
assert_true(JsonPrimitiveGetAsBool(JsonIteratorNextValue(&it)));
assert_false(JsonPrimitiveGetAsBool(JsonIteratorNextValue(&it)));
assert_false(JsonIteratorNextValue(&it));
}
JsonElementDestroy(obj);
}
static void RlistAppendContainerPrimitive(Rlist **list, const JsonElement *primitive)
{
assert(JsonGetElementType(primitive) == JSON_ELEMENT_TYPE_PRIMITIVE);
switch (JsonGetPrimitiveType(primitive))
{
case JSON_PRIMITIVE_TYPE_BOOL:
RlistAppendScalar(list, JsonPrimitiveGetAsBool(primitive) ? "true" : "false");
break;
case JSON_PRIMITIVE_TYPE_INTEGER:
{
char *str = StringFromLong(JsonPrimitiveGetAsInteger(primitive));
RlistAppendScalar(list, str);
free(str);
}
break;
case JSON_PRIMITIVE_TYPE_REAL:
{
char *str = StringFromDouble(JsonPrimitiveGetAsReal(primitive));
RlistAppendScalar(list, str);
free(str);
}
break;
case JSON_PRIMITIVE_TYPE_STRING:
RlistAppendScalar(list, JsonPrimitiveGetAsString(primitive));
break;
case JSON_PRIMITIVE_TYPE_NULL:
break;
}
}
static bool RenderVariablePrimitive(Buffer *out, const JsonElement *primitive, const bool escaped, const bool key_mode)
{
if (key_mode && JsonElementGetPropertyName(primitive))
{
if (escaped)
{
RenderHTMLContent(out, JsonElementGetPropertyName(primitive), strlen(JsonElementGetPropertyName(primitive)));
}
else
{
BufferAppendString(out, JsonElementGetPropertyName(primitive));
}
return true;
}
switch (JsonGetPrimitiveType(primitive))
{
case JSON_PRIMITIVE_TYPE_STRING:
if (escaped)
{
RenderHTMLContent(out, JsonPrimitiveGetAsString(primitive), strlen(JsonPrimitiveGetAsString(primitive)));
}
else
{
BufferAppendString(out, JsonPrimitiveGetAsString(primitive));
}
return true;
case JSON_PRIMITIVE_TYPE_INTEGER:
{
char *str = StringFromLong(JsonPrimitiveGetAsInteger(primitive));
BufferAppendString(out, str);
free(str);
}
return true;
case JSON_PRIMITIVE_TYPE_REAL:
{
char *str = StringFromDouble(JsonPrimitiveGetAsReal(primitive));
BufferAppendString(out, str);
free(str);
}
return true;
case JSON_PRIMITIVE_TYPE_BOOL:
BufferAppendString(out, JsonPrimitiveGetAsBool(primitive) ? "true" : "false");
return true;
case JSON_PRIMITIVE_TYPE_NULL:
return true;
default:
assert(!"Unrecognised JSON primitive type");
}
return false;
}
static void test_parse_primitives(void)
{
JsonElement *pri = NULL;
const char *data = "\"foo\"";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_string_equal("foo", JsonPrimitiveGetAsString(pri));
JsonDestroy(pri);
data = "-123";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_true(-123 == JsonPrimitiveGetAsInteger(pri));
JsonDestroy(pri);
data = "1.23";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_double_close(1.23, JsonPrimitiveGetAsReal(pri));
JsonDestroy(pri);
data = "true";
assert_int_equal(JSON_PARSE_OK, JsonParse(&data, &pri));
assert_true(JsonPrimitiveGetAsBool(pri));
JsonDestroy(pri);
}
static bool Render(Buffer *out, const char *start, const char *input, Seq *hash_stack,
char *delim_start, size_t *delim_start_len,
char *delim_end, size_t *delim_end_len,
bool skip_content,
const char *section,
const char **section_end)
{
while (true)
{
if (!input)
{
Log(LOG_LEVEL_ERR, "Unexpected end to Mustache template");
return false;
}
Mustache tag = NextTag(input, delim_start, *delim_start_len, delim_end, *delim_end_len);
{
const char *line_begin = NULL;
const char *line_end = NULL;
if (!IsTagTypeRenderable(tag.type) && IsTagStandalone(start, tag.begin, tag.end, &line_begin, &line_end))
{
RenderContent(out, input, line_begin - input, false, skip_content);
input = line_end;
}
else
{
RenderContent(out, input, tag.begin - input, false, skip_content);
input = tag.end;
}
}
switch (tag.type)
{
case TAG_TYPE_ERR:
return false;
case TAG_TYPE_DELIM:
if (!SetDelimiters(tag.content, tag.content_len,
delim_start, delim_start_len,
delim_end, delim_end_len))
{
return false;
}
continue;
case TAG_TYPE_COMMENT:
continue;
case TAG_TYPE_NONE:
return true;
case TAG_TYPE_VAR_SERIALIZED:
case TAG_TYPE_VAR_SERIALIZED_COMPACT:
case TAG_TYPE_VAR_UNESCAPED:
case TAG_TYPE_VAR:
if (!skip_content)
{
if (tag.content_len > 0)
{
if (!RenderVariable(out, tag.content, tag.content_len, tag.type, hash_stack))
{
return false;
}
}
else
{
RenderContent(out, delim_start, *delim_start_len, false, false);
RenderContent(out, delim_end, *delim_end_len, false, false);
}
}
continue;
case TAG_TYPE_INVERTED:
case TAG_TYPE_SECTION:
{
char *section = xstrndup(tag.content, tag.content_len);
JsonElement *var = LookupVariable(hash_stack, tag.content, tag.content_len);
SeqAppend(hash_stack, var);
if (!var)
{
const char *cur_section_end = NULL;
if (!Render(out, start, input, hash_stack, delim_start, delim_start_len, delim_end, delim_end_len,
skip_content || tag.type != TAG_TYPE_INVERTED, section, &cur_section_end))
{
free(section);
return false;
}
free(section);
input = cur_section_end;
continue;
}
switch (JsonGetElementType(var))
{
case JSON_ELEMENT_TYPE_PRIMITIVE:
switch (JsonGetPrimitiveType(var))
{
case JSON_PRIMITIVE_TYPE_BOOL:
{
bool skip = skip_content || (!JsonPrimitiveGetAsBool(var) ^ (tag.type == TAG_TYPE_INVERTED));
const char *cur_section_end = NULL;
if (!Render(out, start, input, hash_stack, delim_start, delim_start_len, delim_end, delim_end_len,
skip, section, &cur_section_end))
{
free(section);
return false;
}
free(section);
input = cur_section_end;
}
continue;
default:
Log(LOG_LEVEL_WARNING, "Mustache sections can only take a boolean or a container (array or map) value, but section '%s' isn't getting one of those.",
section);
return false;
}
break;
case JSON_ELEMENT_TYPE_CONTAINER:
switch (JsonGetContainerType(var))
{
case JSON_CONTAINER_TYPE_OBJECT:
case JSON_CONTAINER_TYPE_ARRAY:
if (JsonLength(var) > 0)
{
const char *cur_section_end = NULL;
for (size_t i = 0; i < JsonLength(var); i++)
{
JsonElement *child_hash = JsonAt(var, i);
SeqAppend(hash_stack, child_hash);
if (!Render(out, start, input,
hash_stack,
delim_start, delim_start_len, delim_end, delim_end_len,
skip_content || tag.type == TAG_TYPE_INVERTED, section, &cur_section_end))
{
free(section);
return false;
}
}
input = cur_section_end;
free(section);
}
else
{
const char *cur_section_end = NULL;
if (!Render(out, start, input, hash_stack, delim_start, delim_start_len, delim_end, delim_end_len,
tag.type != TAG_TYPE_INVERTED, section, &cur_section_end))
{
free(section);
return false;
}
free(section);
input = cur_section_end;
}
break;
}
break;
}
}
continue;
case TAG_TYPE_SECTION_END:
if (!section)
{
char *varname = xstrndup(tag.content, tag.content_len);
Log(LOG_LEVEL_WARNING, "Unknown section close in mustache template '%s'", varname);
free(varname);
return false;
}
else
{
SeqRemove(hash_stack, SeqLength(hash_stack) - 1);
*section_end = input;
return true;
}
break;
default:
assert(false);
return false;
}
}
assert(false);
}
