escape_utils 0.2.4 → 0.3.0

data/.gitignore

@@ -6,4 +6,5 @@ doc/*
 *.rbc
 tmp/
 Gemfile.lock
-vendor/*
+vendor/*
+bin/

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - ree
+  - rbx-18mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.0 (February 26th, 2013)
+* add xml escaping support
+* in Ruby 1.9 - escape_utils now requires the input string be UTF-8
+* update upstream houdini to pull in some speed optimizations
+* a couple of other perf tweaks
+* switched to minitest
+
 ## 0.2.4 (September 7th, 2011)
 * swap out custom escaping routines for houdini - https://github.com/tanoku/houdini
 * add RSTRING_NOT_MODIFIED define for a Rubinius speedup

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2011 Brian Lopez - http://github.com/brianmario
+Copyright (c) 2010-2013 Brian Lopez - http://github.com/brianmario
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,23 +1,10 @@
-# rspec
-begin
-  require 'rspec'
-  require 'rspec/core/rake_task'
+require 'rake/testtask'
 
-  desc "Run all examples with RCov"
-  RSpec::Core::RakeTask.new('spec:rcov') do |t|
-    t.rcov = true
-  end
-  RSpec::Core::RakeTask.new('spec') do |t|
-    t.verbose = true
-  end
-
-  task :default => :spec
-rescue LoadError
-  puts "rspec, or one of its dependencies, is not available. Install it with: sudo gem install rspec"
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
 end
 
-# rake-compiler
-require 'rake' unless defined? Rake
+task :default => :test
 
 gem 'rake-compiler', '>= 0.7.5'
 require "rake/extensiontask"
@@ -29,4 +16,4 @@ Rake::ExtensionTask.new('escape_utils') do |ext|
   ext.lib_dir = File.join 'lib', 'escape_utils'
 end
 
-Rake::Task[:spec].prerequisites << :compile
+Rake::Task[:test].prerequisites << :compile

data/benchmark/html_escape.rb

@@ -19,7 +19,7 @@ end
 times = 100
 url = "http://en.wikipedia.org/wiki/Line_of_succession_to_the_British_throne"
 html = `curl -s #{url}`
-html = html.force_encoding('binary') if html.respond_to?(:force_encoding)
+html = html.force_encoding('utf-8') if html.respond_to?(:force_encoding)
 puts "Escaping #{html.bytesize} bytes of html #{times} times, from #{url}"
 
 Benchmark.bmbm do |x|
@@ -47,6 +47,13 @@ Benchmark.bmbm do |x|
     end
   end
 
+  x.report "String#gsub" do
+    html_escape = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
+    times.times do
+      html.gsub(/[&"'><]/, html_escape)
+    end
+  end
+
   x.report "fast_xs_extra#fast_xs_html" do
     times.times do
       html.fast_xs_html
@@ -58,4 +65,4 @@ Benchmark.bmbm do |x|
       EscapeUtils.escape_html(html)
     end
   end
-end
+end

data/benchmark/xml_escape.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/..')
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'benchmark'
+
+require 'builder'
+require 'escape_utils'
+
+times = 100
+url = "http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml"
+xml = `curl -s #{url}`
+xml = xml.force_encoding('binary') if xml.respond_to?(:force_encoding)
+puts "Escaping #{xml.bytesize} bytes of xml #{times} times, from #{url}"
+
+Benchmark.bmbm do |x|
+  x.report "Builder::String.to_xs" do
+    times.times do
+      xml.to_xs
+    end
+  end
+
+  x.report "EscapeUtils.escape_xml" do
+    times.times do
+      EscapeUtils.escape_xml(xml)
+    end
+  end
+end

data/escape_utils.gemspec

@@ -4,20 +4,19 @@ Gem::Specification.new do |s|
   s.name = %q{escape_utils}
   s.version = EscapeUtils::VERSION
   s.authors = ["Brian Lopez"]
-  s.date = Time.now.utc.strftime("%Y-%m-%d")
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/escape_utils/extconf.rb"]
   s.files = `git ls-files`.split("\n")
   s.homepage = %q{http://github.com/brianmario/escape_utils}
   s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib", "ext"]
+  s.require_paths = ["lib"]
   s.rubygems_version = %q{1.4.2}
   s.summary = %q{Faster string escaping routines for your web apps}
   s.test_files = `git ls-files spec`.split("\n")
 
   # tests
   s.add_development_dependency 'rake-compiler', ">= 0.7.5"
-  s.add_development_dependency 'rspec', ">= 2.0.0"
+  s.add_development_dependency 'minitest'
   # benchmarks
   s.add_development_dependency 'rack'
   s.add_development_dependency 'haml'

data/ext/escape_utils/buffer.c

@@ -1,228 +1,249 @@
 /*
- * Copyright (c) 2008, Natacha Porté
- * Copyright (c) 2011, Vicent Martí
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
  */
-
-#define BUFFER_MAX_ALLOC_SIZE (1024 * 1024 * 16) //16mb
-
-#include "buffer.h"
-
+#include <stdarg.h>
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
+#include <sys/param.h>
 
-/* MSVC compat */
-#if defined(_MSC_VER)
-#	define _buf_vsnprintf _vsnprintf
-#else
-#	define _buf_vsnprintf vsnprintf
-#endif
+#include "buffer.h"
 
-int
-bufprefix(const struct buf *buf, const char *prefix)
-{
-	size_t i;
+/* 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];
 
-	for (i = 0; i < buf->size; ++i) {
-		if (prefix[i] == 0)
-			return 0;
+#define ENSURE_SIZE(b, d) \
+	if ((d) > buf->asize && gh_buf_grow(b, (d)) < 0)\
+		return -1;
 
-		if (buf->data[i] != prefix[i])
-			return buf->data[i] - prefix[i];
-	}
+void gh_buf_init(gh_buf *buf, size_t initial_size)
+{
+	buf->asize = 0;
+	buf->size = 0;
+	buf->ptr = gh_buf__initbuf;
 
-	return 0;
+	if (initial_size)
+		gh_buf_grow(buf, initial_size);
 }
 
-/* bufgrow: increasing the allocated size to the given value */
-int
-bufgrow(struct buf *buf, size_t neosz)
+int gh_buf_try_grow(gh_buf *buf, size_t target_size, bool mark_oom)
 {
-	size_t neoasz;
-	void *neodata;
-	if (!buf || !buf->unit || neosz > BUFFER_MAX_ALLOC_SIZE)
-		return BUF_ENOMEM;
+	char *new_ptr;
+	size_t new_size;
 
-	if (buf->asize >= neosz)
-		return BUF_OK;
+	if (buf->ptr == gh_buf__oom)
+		return -1;
 
-	neoasz = buf->asize + buf->unit;
-	while (neoasz < neosz)
-		neoasz += buf->unit;
+	if (target_size <= buf->asize)
+		return 0;
 
-	neodata = realloc(buf->data, neoasz);
-	if (!neodata)
-		return BUF_ENOMEM;
+	if (buf->asize == 0) {
+		new_size = target_size;
+		new_ptr = NULL;
+	} else {
+		new_size = buf->asize;
+		new_ptr = buf->ptr;
+	}
 
-	buf->data = neodata;
-	buf->asize = neoasz;
-	return BUF_OK;
-}
+	/* 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;
 
-/* bufnew: allocation of a new buffer */
-struct buf *
-bufnew(size_t unit)
-{
-	struct buf *ret;
-	ret = malloc(sizeof (struct buf));
+	new_ptr = realloc(new_ptr, new_size);
 
-	if (ret) {
-		ret->data = 0;
-		ret->size = ret->asize = 0;
-		ret->unit = unit;
+	if (!new_ptr) {
+		if (mark_oom)
+			buf->ptr = gh_buf__oom;
+		return -1;
 	}
-	return ret;
+
+	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;
 }
 
-/* bufnullterm: NULL-termination of the string array */
-const char *
-bufcstr(struct buf *buf)
+void gh_buf_free(gh_buf *buf)
 {
-	if (!buf || !buf->unit)
-		return NULL;
+	if (!buf) return;
 
-	if (buf->size < buf->asize && buf->data[buf->size] == 0)
-		return (char *)buf->data;
+	if (buf->ptr != gh_buf__initbuf && buf->ptr != gh_buf__oom)
+		free(buf->ptr);
 
-	if (buf->size + 1 <= buf->asize || bufgrow(buf, buf->size + 1) == 0) {
-		buf->data[buf->size] = 0;
-		return (char *)buf->data;
-	}
-
-	return NULL;
+	gh_buf_init(buf, 0);
 }
 
-/* bufprintf: formatted printing to a buffer */
-void
-bufprintf(struct buf *buf, const char *fmt, ...)
+void gh_buf_clear(gh_buf *buf)
 {
-	va_list ap;
-	if (!buf || !buf->unit)
-		return;
+	buf->size = 0;
+	if (buf->asize > 0)
+		buf->ptr[0] = '\0';
+}
 
-	va_start(ap, fmt);
-	vbufprintf(buf, fmt, ap);
-	va_end(ap);
+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;
 }
 
-/* bufput: appends raw data to a buffer */
-void
-bufput(struct buf *buf, const void *data, size_t len)
+int gh_buf_sets(gh_buf *buf, const char *string)
 {
-	if (!buf)
-		return;
+	return gh_buf_set(buf, string, string ? strlen(string) : 0);
+}
 
-	if (buf->size + len > buf->asize && bufgrow(buf, buf->size + len) < 0)
-		return;
+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;
+}
 
-	memcpy(buf->data + buf->size, data, len);
+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;
 }
 
-/* bufputs: appends a NUL-terminated string to a buffer */
-void
-bufputs(struct buf *buf, const char *str)
+int gh_buf_puts(gh_buf *buf, const char *string)
 {
-	bufput(buf, str, strlen(str));
+	assert(string);
+	return gh_buf_put(buf, string, strlen(string));
 }
 
-
-/* bufputc: appends a single uint8_t to a buffer */
-void
-bufputc(struct buf *buf, int c)
+int gh_buf_vprintf(gh_buf *buf, const char *format, va_list ap)
 {
-	if (!buf)
-		return;
+	int len;
+	const size_t expected_size = buf->size + (strlen(format) * 2);
 
-	if (buf->size + 1 > buf->asize && bufgrow(buf, buf->size + 1) < 0)
-		return;
+	ENSURE_SIZE(buf, expected_size);
 
-	buf->data[buf->size] = c;
-	buf->size += 1;
-}
+	while (1) {
+		va_list args;
+		va_copy(args, ap);
 
-/* bufrelease: decrease the reference count and free the buffer if needed */
-void
-bufrelease(struct buf *buf)
-{
-	if (!buf)
-		return;
+		len = vsnprintf(
+			buf->ptr + buf->size,
+			buf->asize - buf->size,
+			format, args
+		);
 
-	free(buf->data);
-	free(buf);
-}
+		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);
+	}
 
-/* bufreset: frees internal data of the buffer */
-void
-bufreset(struct buf *buf)
+	return 0;
+}
+
+int gh_buf_printf(gh_buf *buf, const char *format, ...)
 {
-	if (!buf)
-		return;
+	int r;
+	va_list ap;
 
-	free(buf->data);
-	buf->data = NULL;
-	buf->size = buf->asize = 0;
+	va_start(ap, format);
+	r = gh_buf_vprintf(buf, format, ap);
+	va_end(ap);
+
+	return r;
 }
 
-/* bufslurp: removes a given number of bytes from the head of the array */
-void
-bufslurp(struct buf *buf, size_t len)
+void gh_buf_copy_cstr(char *data, size_t datasize, const gh_buf *buf)
 {
-	if (!buf || !buf->unit || len <= 0)
-		return;
+	size_t copylen;
+
+	assert(data && datasize && buf);
 
-	if (len >= buf->size) {
-		buf->size = 0;
+	data[0] = '\0';
+
+	if (buf->size == 0 || buf->asize <= 0)
 		return;
-	}
 
-	buf->size -= len;
-	memmove(buf->data, buf->data + len, buf->size);
+	copylen = buf->size;
+	if (copylen > datasize - 1)
+		copylen = datasize - 1;
+	memmove(data, buf->ptr, copylen);
+	data[copylen] = '\0';
 }
 
-/* vbufprintf: stdarg variant of formatted printing into a buffer */
-void
-vbufprintf(struct buf *buf, const char *fmt, va_list ap)
+void gh_buf_swap(gh_buf *buf_a, gh_buf *buf_b)
 {
-	int n;
+	gh_buf t = *buf_a;
+	*buf_a = *buf_b;
+	*buf_b = t;
+}
 
-	if (buf == 0 || (buf->size >= buf->asize && bufgrow(buf, buf->size + 1)) < 0)
-		return;
+char *gh_buf_detach(gh_buf *buf)
+{
+	char *data = buf->ptr;
 
-	n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+	if (buf->asize == 0 || buf->ptr == gh_buf__oom)
+		return NULL;
 
-	if (n < 0) {
-#ifdef _MSC_VER
-		n = _vscprintf(fmt, ap);
-#else
-		return;
-#endif
-	}
+	gh_buf_init(buf, 0);
 
-	if ((size_t)n >= buf->asize - buf->size) {
-		if (bufgrow(buf, buf->size + n + 1) < 0)
-			return;
+	return data;
+}
 
-		n = _buf_vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+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);
 	}
+}
 
-	if (n < 0)
-		return;
-
-	buf->size += n;
+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;
 }