fast_xs 0.3 → 0.4

data/Rakefile

@@ -3,18 +3,23 @@ require 'rake/clean'
 require 'rake/gempackagetask'
 require 'rake/rdoctask'
 require 'rake/testtask'
-require 'hoe'
+require 'hoe' if ENV['VERSION']
 require 'fileutils'
 include FileUtils
 
 name = "fast_xs"
-rev = `git describe 2>/dev/null`.chomp rescue nil
-version = ENV['VERSION'] || "0.2" + (rev && rev.length > 0 ? "-#{rev}" : "")
+begin
+  rev = `git rev-list -1 HEAD --pretty=format:%ct`
+  rev = Time.at(rev.split("\n")[1].to_i).strftime('%Y%m%d.%H%M%S')
+rescue
+end
+version ||= ENV['VERSION'] || '0.4' + (rev && rev.length > 0 ? ".#{rev}" : '')
 pkg = "#{name}-#{version}"
 bin = "*.{so,o}"
 archlib = "lib/#{::Config::CONFIG['arch']}"
 CLEAN.include ["ext/fast_xs/#{bin}", "lib/**/#{bin}",
-               'ext/fast_xs/Makefile', '**/.*.sw?', '*.gem', '.config']
+               'ext/fast_xs/Makefile', '**/.*.sw?', '*.gem', '.config',
+               'pkg']
 rdoc_opts = ['--quiet', '--title', 'fast_xs notes', '--main', 'README',
              '--inline-source']
 pkg_files = %w(CHANGELOG COPYING README Rakefile) +
@@ -29,7 +34,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.rdoc_options += rdoc_opts
   s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
-  s.summary = "escape faster!"
+  s.summary = "excessively fast escaping"
   s.description = s.summary
   s.author = "Eric Wong"
   s.email = 'normalperson@yhbt.net'
@@ -39,13 +44,16 @@ spec = Gem::Specification.new do |s|
   s.extensions = FileList["ext/**/extconf.rb"].to_a
 end
 
-hoe = Hoe.new(name, version) do |p|
-  p.author = spec.author
-  p.description = spec.description
-  p.email = spec.email
-  p.summary = spec.summary
-  p.url = spec.homepage
-  p.rubyforge_name = 'fast-xs'
+if ENV['VERSION']
+  sh('git ls-files > Manifest.txt')
+  hoe = Hoe.new(name, version) do |p|
+    p.author = spec.author
+    p.description = spec.description
+    p.email = spec.email
+    p.summary = spec.summary
+    p.url = spec.homepage
+    p.rubyforge_name = 'fast-xs'
+  end
 end
 
 desc "Does a full compile, test run"

data/ext/fast_xs/fast_xs.c

@@ -2,9 +2,12 @@
 
 #include <ruby.h>
 #include <assert.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 static ID unpack_id;
 static VALUE U_fmt, C_fmt;
+static rlim_t alloca_limit = 4096; /* very small default */
 
 /* give GCC hints for better branch prediction
  * (we layout branches so that ASCII characters are handled faster) */
@@ -157,18 +160,24 @@ static VALUE fast_xs(VALUE self)
 	char *s, *c;
 	size_t s_len = 0;
 	VALUE *tmp;
+	VALUE rv;
 
 	array = RARRAY(rb_rescue(unpack_utf8, self, unpack_uchar, self));
 
 	for (tmp = array->ptr, i = array->len; --i >= 0; tmp++)
 		s_len += escaped_len(NUM2INT(*tmp));
 
-	c = s = alloca(s_len);
+	c = s = unlikely(s_len > alloca_limit) ? malloc(s_len) : alloca(s_len);
 
 	for (tmp = array->ptr, i = array->len; --i >= 0; tmp++)
 		c += escape(c, NUM2INT(*tmp));
 
-	return rb_str_new(s, s_len);
+	rv = rb_str_new(s, s_len);
+
+	if (unlikely(s_len > alloca_limit))
+		free(s);
+
+	return rv;
 }
 
 /*
@@ -184,6 +193,7 @@ static VALUE fast_xs_html(VALUE self)
 	char *s;
 	size_t new_len = 0;
 	char *new_str;
+	VALUE rv;
 
 	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
 		if (unlikely(*s == '&'))
@@ -196,7 +206,8 @@ static VALUE fast_xs_html(VALUE self)
 			new_len += 1;
 	}
 
-	new_str = alloca(new_len);
+	new_str = unlikely(new_len > alloca_limit) ? malloc(new_len)
+	                                           : alloca(new_len);
 
 #define append_const(buf, x) do { \
 	buf = memcpy(buf, x, sizeof(x) - 1) + sizeof(x) - 1; \
@@ -217,7 +228,12 @@ static VALUE fast_xs_html(VALUE self)
 
 #undef append_const
 
-	return rb_str_new(new_str - new_len, new_len);
+	rv = rb_str_new(new_str - new_len, new_len);
+
+	if (unlikely(new_len > alloca_limit))
+		free(new_str - new_len);
+
+	return rv;
 }
 
 #define CGI_URI_OK(x) \
@@ -226,31 +242,29 @@ static VALUE fast_xs_html(VALUE self)
 	 (x >= '0' && x <= '9') || \
 	 (x == '.' || x == '-' || x == '_'))
 
-/*
- * Compatible with CGI::escape(), this iterates through each byte, so
- * multibyte character sets may not supported (but UTF-8 should be).
- */
-static VALUE fast_xs_cgi(VALUE self)
+static inline VALUE _xs_uri_encode(VALUE self, const unsigned int space_to_plus)
 {
 	struct RString *string = RSTRING(self);
 	long i;
 	char *s;
 	size_t new_len = 0;
 	char *new_str;
+	VALUE rv;
 
 	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
-		if (likely(CGI_URI_OK(*s) || *s == ' '))
+		if (likely(CGI_URI_OK(*s) || (space_to_plus && *s == ' ')))
 			++new_len;
 		else /* we'll only get <= "%FF" here */
 			new_len += 3;
 	}
 
-	new_str = alloca(new_len);
+	new_str = unlikely(new_len > alloca_limit) ? malloc(new_len)
+	                                           : alloca(new_len);
 
 	for (s = string->ptr, i = string->len; --i >= 0; ++s) {
 		if (likely(CGI_URI_OK(*s)))
 			*new_str++ = *s;
-		else if (*s == ' ')
+		else if (space_to_plus && *s == ' ')
 			*new_str++ = '+';
 		else {
 			static const char cgi_digitmap[] = "0123456789ABCDEF";
@@ -260,13 +274,44 @@ static VALUE fast_xs_cgi(VALUE self)
 			new_str += 3;
 		}
 	}
-	return rb_str_new(new_str - new_len, new_len);
+
+	rv = rb_str_new(new_str - new_len, new_len);
+
+	if (unlikely(new_len > alloca_limit))
+		free(new_str - new_len);
+
+	return rv;
+}
+
+/*
+ * Compatible with ERB::Util::url_encode / ERB::Util::u, this iterates
+ * through each byte, so multibyte character sets may not supported (but
+ * UTF-8 should be).
+ */
+static VALUE fast_xs_url(VALUE self)
+{
+	return _xs_uri_encode(self, 0);
+}
+
+/*
+ * Compatible with CGI::escape(), this iterates through each byte, so
+ * multibyte character sets may not supported (but UTF-8 should be).
+ */
+static VALUE fast_xs_cgi(VALUE self)
+{
+	return _xs_uri_encode(self, 1);
 }
 
 void Init_fast_xs(void)
 {
+	struct rlimit rlim;
+
 	assert(cp_1252[159 - 128] == 376); /* just in case I skipped a line */
 
+	/* fairly conservative stack estimation IMHO... */
+	if (!getrlimit(RLIMIT_STACK, &rlim) && (rlim.rlim_cur > 0x80000))
+		alloca_limit = rlim.rlim_cur - (rlim.rlim_cur / 16);
+
 	unpack_id = rb_intern("unpack");
 	U_fmt = rb_str_new("U*", 2);
 	C_fmt = rb_str_new("C*", 2);
@@ -276,4 +321,5 @@ void Init_fast_xs(void)
 	rb_define_method(rb_cString, "fast_xs", fast_xs, 0);
 	rb_define_method(rb_cString, "fast_xs_html", fast_xs_html, 0);
 	rb_define_method(rb_cString, "fast_xs_cgi", fast_xs_cgi, 0);
+	rb_define_method(rb_cString, "fast_xs_url", fast_xs_url, 0);
 }

data/lib/fast_xs_monkey_patcher.rb

@@ -5,11 +5,11 @@ if defined?(CGI)
   class CGI
 
     def CGI::escapeHTML(value)
-      value.to_s.fast_xs_html
+      value.fast_xs_html
     end
 
     def CGI::escape(value)
-      value.to_s.fast_xs_cgi
+      value.fast_xs_cgi
     end
 
   end
@@ -27,6 +27,14 @@ if defined?(ERB::Util)
     module_function :h
     module_function :html_escape
 
+    def url_encode(value)
+      value.to_s.fast_xs_url
+    end
+    alias u url_encode
+    module_function :u
+    module_function :url_encode
+
+
   end
 
 end

data/test/test_cgi_class_overrides.rb

@@ -31,5 +31,13 @@ class TestCgiClassOverrides < Test::Unit::TestCase
     assert_equal 'H3LL0+W0RLD', CGI::escape('H3LL0 W0RLD')
   end
 
+  def test_large_strings
+    if ENV['LARGE_STRING_TEST']
+      assert CGI::escape('&' * (8192 * 1024))
+      assert CGI::escapeHTML('&' * (8192 * 1024))
+    end
+  end
+
+
 end
 

data/test/test_erb_util_module_overrides.rb

@@ -24,6 +24,22 @@ class TestErbUtilModuleOverrides < Test::Unit::TestCase
     assert_equal "\xEF\xBF\xBF", html_escape("\xEF\xBF\xBF")
   end
 
+  def test_escape_url
+    assert_equal 'hello%3Dworld', url_encode('hello=world')
+    assert_equal '%20', url_encode(' ')
+    assert_equal '%2B', url_encode('+')
+    assert_equal '%2C', url_encode(',')
+    assert_equal 'hello-world', url_encode('hello-world')
+    assert_equal 'H3LL0%20W0RLD', url_encode('H3LL0 W0RLD')
+  end
+
+  def test_large_strings
+    if ENV['LARGE_STRING_TEST']
+      assert u('&' * (8192 * 1024))
+      assert h('&' * (8192 * 1024))
+    end
+  end
+
 end
 
 

data/test/test_xml_escaping.rb

@@ -36,4 +36,11 @@ class TestXmlEscaping < Test::Unit::TestCase
     assert_equal '&#169;',  "\xC2\xA9".fast_xs     # copy
   end
 
+  def test_large_document
+    if ENV['LARGE_STRING_TEST']
+      assert ('&' * (8192 * 1024)).fast_xs
+      assert ('a' * (8192 * 1024)).fast_xs
+    end
+  end
+
 end

metadata

@@ -3,16 +3,16 @@ rubygems_version: 0.9.4.7
 specification_version: 2
 name: fast_xs
 version: !ruby/object:Gem::Version 
-  version: "0.3"
-date: 2007-12-07 00:00:00 -08:00
-summary: escape faster!
+  version: "0.4"
+date: 2007-12-12 00:00:00 -08:00
+summary: excessively fast escaping
 require_paths: 
 - lib/i486-linux
 - lib
 email: normalperson@yhbt.net
 homepage: http://bogonips.org/fast_xs/
 rubyforge_project: 
-description: escape faster!
+description: excessively fast escaping
 autorequire: 
 default_executable: 
 bindir: bin