hamlit 1.7.2 → 2.0.1

data/ext/hamlit/houdini/.gitignore

@@ -0,0 +1,3 @@
+*.[ao]
+*.d
+*~

data/ext/hamlit/houdini/COPYING

@@ -0,0 +1,7 @@
+Copyright (C) 2012 Vicent Martí
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/hamlit/houdini/Makefile

@@ -0,0 +1,79 @@
+# GNU Makefile
+# Copyright (C) 2012 Przemyslaw Pawelczyk <przemoc@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+SRCS := buffer.c houdini_href_e.c houdini_html_e.c houdini_html_u.c houdini_js_e.c houdini_js_u.c houdini_uri_e.c houdini_uri_u.c houdini_xml_e.c
+OBJS := $(addsuffix .o,$(basename $(SRCS)))
+DEPS := $(addsuffix .d,$(basename $(SRCS)))
+NAME := houdini
+
+SRCDIR := $(dir $(lastword $(MAKEFILE_LIST)))
+OBJDIR ?= ./
+OBJS := $(addprefix $(OBJDIR),$(OBJS))
+SLIB := lib$(NAME).a
+
+vpath %.c $(SRCDIR)
+vpath %.h $(SRCDIR)
+
+AR ?= ar
+CC ?= gcc
+GPERF ?= gperf
+SED ?= sed
+
+CFLAGS ?= -O2
+# -Wno-missing-field-initializers - gperf's header doesn't pass on -Wextra
+MANDATORY_FLAGS := -Wall -Wextra -Wno-missing-field-initializers
+override CFLAGS := $(MANDATORY_FLAGS) $(CFLAGS)
+
+.PHONY: all clean objects package
+
+all: package
+
+objects: $(OBJS)
+package: $(SLIB)
+
+$(SLIB): $(OBJS)
+	$(AR) rcs $@ $^
+
+$(OBJS): | $(OBJDIR)
+
+$(OBJDIR):
+	mkdir -p $@
+
+$(OBJDIR)%.o: %.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c -o $@ $<
+
+%.d: %.c
+	@set -e; \
+	$(RM) $@; \
+	$(CC) -MM $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) $< >$@.tmp; \
+	$(SED) 's,\($*\)\.o[ :]*,$$(OBJDIR)\1.o $@: ,g' <$@.tmp >$@; \
+	$(RM) $@.tmp
+
+html_unescape.h: html_unescape.gperf
+	$(GPERF) -t -N find_entity -H hash_entity -K entity -C -l --null-strings -m100 $< >$@
+
+clean:
+	$(RM) $(SLIB) $(OBJS) $(DEPS)
+
+ifneq ($(MAKECMDGOALS),clean)
+-include $(DEPS)
+endif

data/ext/hamlit/houdini/README.md

@@ -0,0 +1,59 @@
+Houdini - The Escapist
+======================
+
+Houdini doesn't quite qualify as a library. In fact, I didn't even bother
+to write a Makefile (well, others did). It's zero-dependency and modular.
+Just stick the files you need in your project. Or go with all of them
+(e.g. via git submodule) and use the static library that is built by
+default when GNU make is invoked. Now you can freely escape some shit.
+
+Houdini is a simple API for escaping text for the web. And unescaping it.
+But that kind of breaks the joke in the name so nevermind.
+
+- HTML escaping follows the OWASP suggestion. All other entities are left
+as-is.
+
+        & --> &
+        < --> &lt;
+        > --> &gt;
+        " --> &quot;
+        ' --> &#x27;     &apos; is not recommended
+        / --> &#x2F;     forward slash is included as it helps end an HTML entity
+
+- HTML unescaping is fully RFC-compliant. Yes, that's the 253 different entities
+for you, and decimal/hex code point specifiers.
+
+- URI escaping and unescaping is fully RFC-compliant.
+
+- URL escaping and unescaping is the same as generic URIs,
+    but spaces are changed to `+`.
+
+**WARNING:** Houdini parses **only** UTF-8 strings, and generates **only**
+UTF-8 strings. If you are using another encoding, you should probably transcode
+*before* passing the buffer to Houdini.
+
+### Current API:
+
+Do you really need docs for this?
+
+~~~~ c
+int houdini_escape_html(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_escape_html0(gh_buf *ob, const uint8_t *src, size_t size, int secure);
+int houdini_unescape_html(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_escape_xml(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_escape_uri(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_escape_url(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_escape_href(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_unescape_uri(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_unescape_url(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_escape_js(gh_buf *ob, const uint8_t *src, size_t size);
+int houdini_unescape_js(gh_buf *ob, const uint8_t *src, size_t size);
+~~~~
+
+Pass your string. It'll get escaped/unescaped in the target buffer, and the call will return 1.
+If the given string has nothing to escape/unescape, the call will return 0 and the
+output buffer will be empty.
+
+### Questions?
+
+Open an issue. Or shout angrily at me on Twitter ([@vmg](https://twitter.com/vmg)).

data/ext/hamlit/houdini/buffer.c

@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#include <stdarg.h>
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/param.h>
+
+#include "buffer.h"
+
+/* Used as default value for gh_buf->ptr so that people can always
+ * assume ptr is non-NULL and zero terminated even for new gh_bufs.
+ */
+char gh_buf__initbuf[1];
+char gh_buf__oom[1];
+
+#define ENSURE_SIZE(b, d) \
+	if ((d) > buf->asize && gh_buf_grow(b, (d)) < 0)\
+		return -1;
+
+void gh_buf_init(gh_buf *buf, size_t initial_size)
+{
+	buf->asize = 0;
+	buf->size = 0;
+	buf->ptr = gh_buf__initbuf;
+
+	if (initial_size)
+		gh_buf_grow(buf, initial_size);
+}
+
+int gh_buf_try_grow(gh_buf *buf, size_t target_size, bool mark_oom)
+{
+	char *new_ptr;
+	size_t new_size;
+
+	if (buf->ptr == gh_buf__oom)
+		return -1;
+
+	if (target_size <= buf->asize)
+		return 0;
+
+	if (buf->asize == 0) {
+		new_size = target_size;
+		new_ptr = NULL;
+	} else {
+		new_size = buf->asize;
+		new_ptr = buf->ptr;
+	}
+
+	/* grow the buffer size by 1.5, until it's big enough
+	 * to fit our target size */
+	while (new_size < target_size)
+		new_size = (new_size << 1) - (new_size >> 1);
+
+	/* round allocation up to multiple of 8 */
+	new_size = (new_size + 7) & ~7;
+
+	new_ptr = realloc(new_ptr, new_size);
+
+	if (!new_ptr) {
+		if (mark_oom)
+			buf->ptr = gh_buf__oom;
+		return -1;
+	}
+
+	buf->asize = new_size;
+	buf->ptr   = new_ptr;
+
+	/* truncate the existing buffer size if necessary */
+	if (buf->size >= buf->asize)
+		buf->size = buf->asize - 1;
+	buf->ptr[buf->size] = '\0';
+
+	return 0;
+}
+
+void gh_buf_free(gh_buf *buf)
+{
+	if (!buf) return;
+
+	if (buf->ptr != gh_buf__initbuf && buf->ptr != gh_buf__oom)
+		free(buf->ptr);
+
+	gh_buf_init(buf, 0);
+}
+
+void gh_buf_clear(gh_buf *buf)
+{
+	buf->size = 0;
+	if (buf->asize > 0)
+		buf->ptr[0] = '\0';
+}
+
+int gh_buf_set(gh_buf *buf, const char *data, size_t len)
+{
+	if (len == 0 || data == NULL) {
+		gh_buf_clear(buf);
+	} else {
+		if (data != buf->ptr) {
+			ENSURE_SIZE(buf, len + 1);
+			memmove(buf->ptr, data, len);
+		}
+		buf->size = len;
+		buf->ptr[buf->size] = '\0';
+	}
+	return 0;
+}
+
+int gh_buf_sets(gh_buf *buf, const char *string)
+{
+	return gh_buf_set(buf, string, string ? strlen(string) : 0);
+}
+
+int gh_buf_putc(gh_buf *buf, char c)
+{
+	ENSURE_SIZE(buf, buf->size + 2);
+	buf->ptr[buf->size++] = c;
+	buf->ptr[buf->size] = '\0';
+	return 0;
+}
+
+int gh_buf_put(gh_buf *buf, const void *data, size_t len)
+{
+	ENSURE_SIZE(buf, buf->size + len + 1);
+	memmove(buf->ptr + buf->size, data, len);
+	buf->size += len;
+	buf->ptr[buf->size] = '\0';
+	return 0;
+}
+
+int gh_buf_puts(gh_buf *buf, const char *string)
+{
+	assert(string);
+	return gh_buf_put(buf, string, strlen(string));
+}
+
+int gh_buf_vprintf(gh_buf *buf, const char *format, va_list ap)
+{
+	int len;
+	const size_t expected_size = buf->size + (strlen(format) * 2);
+
+	ENSURE_SIZE(buf, expected_size);
+
+	while (1) {
+		va_list args;
+		va_copy(args, ap);
+
+		len = vsnprintf(
+			buf->ptr + buf->size,
+			buf->asize - buf->size,
+			format, args
+		);
+
+		if (len < 0) {
+			free(buf->ptr);
+			buf->ptr = gh_buf__oom;
+			return -1;
+		}
+
+		if ((size_t)len + 1 <= buf->asize - buf->size) {
+			buf->size += len;
+			break;
+		}
+
+		ENSURE_SIZE(buf, buf->size + len + 1);
+	}
+
+	return 0;
+}
+
+int gh_buf_printf(gh_buf *buf, const char *format, ...)
+{
+	int r;
+	va_list ap;
+
+	va_start(ap, format);
+	r = gh_buf_vprintf(buf, format, ap);
+	va_end(ap);
+
+	return r;
+}
+
+void gh_buf_copy_cstr(char *data, size_t datasize, const gh_buf *buf)
+{
+	size_t copylen;
+
+	assert(data && datasize && buf);
+
+	data[0] = '\0';
+
+	if (buf->size == 0 || buf->asize <= 0)
+		return;
+
+	copylen = buf->size;
+	if (copylen > datasize - 1)
+		copylen = datasize - 1;
+	memmove(data, buf->ptr, copylen);
+	data[copylen] = '\0';
+}
+
+void gh_buf_swap(gh_buf *buf_a, gh_buf *buf_b)
+{
+	gh_buf t = *buf_a;
+	*buf_a = *buf_b;
+	*buf_b = t;
+}
+
+char *gh_buf_detach(gh_buf *buf)
+{
+	char *data = buf->ptr;
+
+	if (buf->asize == 0 || buf->ptr == gh_buf__oom)
+		return NULL;
+
+	gh_buf_init(buf, 0);
+
+	return data;
+}
+
+void gh_buf_attach(gh_buf *buf, char *ptr, size_t asize)
+{
+	gh_buf_free(buf);
+
+	if (ptr) {
+		buf->ptr = ptr;
+		buf->size = strlen(ptr);
+		if (asize)
+			buf->asize = (asize < buf->size) ? buf->size + 1 : asize;
+		else /* pass 0 to fall back on strlen + 1 */
+			buf->asize = buf->size + 1;
+	} else {
+		gh_buf_grow(buf, asize);
+	}
+}
+
+int gh_buf_cmp(const gh_buf *a, const gh_buf *b)
+{
+	int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size));
+	return (result != 0) ? result :
+		(a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
+}
+

data/ext/hamlit/houdini/buffer.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_buffer_h__
+#define INCLUDE_buffer_h__
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <stdint.h>
+
+typedef struct {
+	char *ptr;
+	size_t asize, size;
+} gh_buf;
+
+extern char gh_buf__initbuf[];
+extern char gh_buf__oom[];
+
+#define GH_BUF_INIT { gh_buf__initbuf, 0, 0 }
+
+/**
+ * Initialize a gh_buf structure.
+ *
+ * For the cases where GH_BUF_INIT cannot be used to do static
+ * initialization.
+ */
+extern void gh_buf_init(gh_buf *buf, size_t initial_size);
+
+/**
+ * Attempt to grow the buffer to hold at least `target_size` bytes.
+ *
+ * If the allocation fails, this will return an error.  If mark_oom is true,
+ * this will mark the buffer as invalid for future operations; if false,
+ * existing buffer content will be preserved, but calling code must handle
+ * that buffer was not expanded.
+ */
+extern int gh_buf_try_grow(gh_buf *buf, size_t target_size, bool mark_oom);
+
+/**
+ * Grow the buffer to hold at least `target_size` bytes.
+ *
+ * If the allocation fails, this will return an error and the buffer will be
+ * marked as invalid for future operations, invaliding contents.
+ *
+ * @return 0 on success or -1 on failure
+ */
+static inline int gh_buf_grow(gh_buf *buf, size_t target_size)
+{
+	return gh_buf_try_grow(buf, target_size, true);
+}
+
+extern void gh_buf_free(gh_buf *buf);
+extern void gh_buf_swap(gh_buf *buf_a, gh_buf *buf_b);
+
+/**
+ * Test if there have been any reallocation failures with this gh_buf.
+ *
+ * Any function that writes to a gh_buf can fail due to memory allocation
+ * issues.  If one fails, the gh_buf will be marked with an OOM error and
+ * further calls to modify the buffer will fail.  Check gh_buf_oom() at the
+ * end of your sequence and it will be true if you ran out of memory at any
+ * point with that buffer.
+ *
+ * @return false if no error, true if allocation error
+ */
+static inline bool gh_buf_oom(const gh_buf *buf)
+{
+	return (buf->ptr == gh_buf__oom);
+}
+
+
+static inline size_t gh_buf_len(const gh_buf *buf)
+{
+	return buf->size;
+}
+
+extern int gh_buf_cmp(const gh_buf *a, const gh_buf *b);
+
+extern void gh_buf_attach(gh_buf *buf, char *ptr, size_t asize);
+extern char *gh_buf_detach(gh_buf *buf);
+extern void gh_buf_copy_cstr(char *data, size_t datasize, const gh_buf *buf);
+
+static inline const char *gh_buf_cstr(const gh_buf *buf)
+{
+	return buf->ptr;
+}
+
+/*
+ * Functions below that return int value error codes will return 0 on
+ * success or -1 on failure (which generally means an allocation failed).
+ * Using a gh_buf where the allocation has failed with result in -1 from
+ * all further calls using that buffer.  As a result, you can ignore the
+ * return code of these functions and call them in a series then just call
+ * gh_buf_oom at the end.
+ */
+extern int gh_buf_set(gh_buf *buf, const char *data, size_t len);
+extern int gh_buf_sets(gh_buf *buf, const char *string);
+extern int gh_buf_putc(gh_buf *buf, char c);
+extern int gh_buf_put(gh_buf *buf, const void *data, size_t len);
+extern int gh_buf_puts(gh_buf *buf, const char *string);
+extern int gh_buf_printf(gh_buf *buf, const char *format, ...)
+	__attribute__((format (printf, 2, 3)));
+extern int gh_buf_vprintf(gh_buf *buf, const char *format, va_list ap);
+extern void gh_buf_clear(gh_buf *buf);
+
+#define gh_buf_PUTS(buf, str) gh_buf_put(buf, str, sizeof(str) - 1)
+
+#endif