erbal 1.1 → 1.2.rc1

data/README.rdoc

@@ -8,21 +8,25 @@ Erbal is a lightweight ERB parser that uses the Ragel State Machine Compiler (ht
 
   >> require 'erbal'
   >> src = Erbal.new("<% a=1 -%>a is: <%= a -%>").parse
-  => "@output_buffer = ''; a=1 ;\n@output_buffer << %Q`a is: \#{ a }`;@output_buffer"
+  => "@output_buffer = ''; a=1 ;\n@output_buffer.concat(%Q`a is: \#{ a }`);@output_buffer"
   >> eval(src)
   => "a is: 1"
 
 Erbal.new takes an optional 2nd argument which is a hash of options, available options are:
 
-* :buffer                   The name of the output buffer, default is '@output_buffer'
-* :buffer_initial_value     The initial value of the output buffer, defaults to a blank string.
+* <b>:buffer</b> - The name of the output buffer. Default is '@output_buffer'.
+* <b>:buffer_initial_value</b> - The initial value of the output buffer. Default is a blank string.
+* <b>:safe_concat_method</b> - The method to call on the buffer when concatenating a string which doesn't need escaping, i.e text outside of ERB tags uses the safe concatenation method. Default is 'concat'.
+* <b>:unsafe_concat_method</b> - The method to call on the buffer when concatenating a string which DOES need escaping, i.e <%= some_method %> will result in the use of unsafe_concat_method. Default is 'concat'.
+* <b>:safe_concat_method</b> - Normally the '<%=' tag uses the unsafe_concat_method, with this option you can specify a keyword to signify that safe_concat_method should be used instead. For example if safe_concat_method is set to 'raw' then <%= raw some_method %> will result in a concatenation using the safe_concat_method. Default is blank, i.e no keyword is specified.
+
+<b>NOTE: Erbal itself does NOT perform escaping, it is the responsibility of your unsafe_concat_method to escape the string passed to it.</b>
 
 == Rails 2.3
 
 Create the file 'config/initializers/erbal.rb' containing:
 
-  require 'erbal/rails23'
-  ActionView::Template.register_template_handler :erb, ErbalTemplateHandler
+  require 'erbal/rails'
 
 == Rails 3
 
@@ -33,44 +37,46 @@ I've not looked into yet.. patches are welcome! ;)
 These benchmarks were run on a Mac OS X 10.6.4, 2.66 Ghx Intel Core i5 with 8 GB of 1067 MHz DDR3 RAM.
 
 Ruby: 1.8.7 (2010-04-19 patchlevel 253) [i686-darwin10.4.0], MBARI 0x6770, Ruby Enterprise Edition 2010.02
-Erubis: 2.6.6
-Erbal: 1.1
-
-    => Parsing Benchmark
-
-    => Erb
-    0.851 0.853 0.848 0.847 0.849 0.847
-    => Average: 0.849
-
-    => Erubis (using FastEruby engine)
-    0.442 0.442 0.444 0.442 0.441 0.442
-    => Average: 0.442
 
-    => Erubis (using default Eruby engine)
-    0.451 0.424 0.446 0.425 0.445 0.446
-    => Average: 0.439
-
-    => Erbal
-    0.036 0.039 0.066 0.038 0.067 0.039
-    => Average: 0.047
-
-    => eval() Benchmark
-
-    => Erb
-    0.203 0.192 0.180 0.180 0.179 0.191
-    => Average: 0.187
-
-    => Erubis (using FastEruby engine)
-    0.129 0.127 0.128 0.128 0.114 0.128
-    => Average: 0.125
+Erubis: 2.6.6
 
-    => Erubis (using default Eruby engine)
-    0.178 0.176 0.165 0.176 0.175 0.164
-    => Average: 0.172
+Erbal: 1.1
 
-    => Erbal
-    0.111 0.125 0.124 0.110 0.133 0.124
-    => Average: 0.121
+  => Parsing Benchmark
+  
+  => Erb
+  0.851 0.853 0.848 0.847 0.849 0.847
+  => Average: 0.849
+  
+  => Erubis (using FastEruby engine)
+  0.442 0.442 0.444 0.442 0.441 0.442
+  => Average: 0.442
+  
+  => Erubis (using default Eruby engine)
+  0.451 0.424 0.446 0.425 0.445 0.446
+  => Average: 0.439
+  
+  => Erbal
+  0.036 0.039 0.066 0.038 0.067 0.039
+  => Average: 0.047
+  
+  => eval() Benchmark
+  
+  => Erb
+  0.203 0.192 0.180 0.180 0.179 0.191
+  => Average: 0.187
+  
+  => Erubis (using FastEruby engine)
+  0.129 0.127 0.128 0.128 0.114 0.128
+  => Average: 0.125
+  
+  => Erubis (using default Eruby engine)
+  0.178 0.176 0.165 0.176 0.175 0.164
+  => Average: 0.172
+  
+  => Erbal
+  0.111 0.125 0.124 0.110 0.133 0.124
+  => Average: 0.121
 
 == Contributing
 

data/ext/erbal/erbal.c

@@ -3,12 +3,33 @@
 
 static VALUE cErbal;
 
+void rb_erbal_free(erbal_parser *parser) {
+  free(parser->state);
+  free(parser);
+}
+
 VALUE rb_erbal_alloc(VALUE klass) {
   erbal_parser *parser = ALLOC(erbal_parser);
-  VALUE obj = Data_Wrap_Struct(klass, 0, free, parser);
+  parser->state = ALLOC(parser_state);
+  VALUE obj = Data_Wrap_Struct(klass, 0, rb_erbal_free, parser);
   return obj;
 }
 
+void rb_erbal_setup_option(VALUE self, erbal_parser* parser, VALUE* parser_option, const char* key, const char* default_value) {
+  VALUE value = rb_hash_aref(parser->options, ID2SYM(rb_intern(key)));
+
+  if (!NIL_P(value)) {
+    Check_Type(value, T_STRING);
+    *(parser_option) = value;
+  } else {
+    *(parser_option) = rb_str_new2(default_value);
+  }
+
+  VALUE ivar = rb_str_new2("@");
+  ivar = rb_str_cat2(ivar, key);
+  rb_iv_set(self, RSTRING(ivar)->ptr, *(parser_option));
+}
+
 VALUE rb_erbal_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE str, options;
 
@@ -35,16 +56,10 @@ VALUE rb_erbal_initialize(int argc, VALUE *argv, VALUE self) {
     parser->debug = 0;
   }
 
-  VALUE buffer_name_val = rb_hash_aref(parser->options, ID2SYM(rb_intern("buffer")));
-
-  if (!NIL_P(buffer_name_val)) {
-    Check_Type(buffer_name_val, T_STRING);
-    parser->buffer_name = buffer_name_val;
-  } else {
-    parser->buffer_name = rb_str_new2("@output_buffer");
-  }
-
-  rb_iv_set(self, "@buffer_name", parser->buffer_name);
+  rb_erbal_setup_option(self, parser, &parser->buffer_name, "buffer", "@output_buffer");
+  rb_erbal_setup_option(self, parser, &parser->safe_concat_method, "safe_concat_method", "concat");
+  rb_erbal_setup_option(self, parser, &parser->unsafe_concat_method, "unsafe_concat_method", "concat");
+  rb_erbal_setup_option(self, parser, &parser->safe_concat_keyword, "safe_concat_keyword", "");
 
   return self;
 }

data/ext/erbal/extconf.rb

@@ -1,2 +1,2 @@
 require 'mkmf'
-create_makefile("erbal")
+create_makefile("erbal")

data/ext/erbal/parser.c

@@ -4,78 +4,99 @@
 #include "parser.h"
 
 
-#line 16 "parser.rl"
+#line 31 "parser.rl"
 
 
 
 #line 12 "parser.c"
-static const int erbal_parser_start = 1;
-static const int erbal_parser_first_final = 1;
+static const int erbal_parser_start = 3;
+static const int erbal_parser_first_final = 3;
 static const int erbal_parser_error = -1;
 
-static const int erbal_parser_en_main = 1;
+static const int erbal_parser_en_main = 3;
 
 
-#line 19 "parser.rl"
+#line 34 "parser.rl"
 
 static char *ts, *te, *p, *pe, *eof;
 static int act, cs;
 
 inline void erbal_parser_tag_open_common(erbal_parser *parser, int shift) {
-  if (parser->chars_seen != 0) {
-    if (!parser->in_buffer_shift) {
-      erbal_open_buffer_shift(parser);
+  if (parser->state->chars_seen != 0) {
+    if (!parser->state->in_concat) {
+      erbal_open_buffer_concat(parser, 1);
     }
 
     erbal_concat_chars_seen(parser, shift);
-    parser->chars_seen = 0;
+    parser->state->chars_seen = 0;
   }
 }
 
 inline void erbal_parser_tag_open(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -1);
-  parser->state = TAG_OPEN;
+  parser->state->tag = TAG_OPEN;
 }
 
 inline void erbal_parser_tag_open_with_dash(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -2);
-  parser->state = TAG_OPEN;
+  parser->state->tag = TAG_OPEN;
 }
 
-inline void erbal_parser_tag_open_for_output(erbal_parser *parser) {
+inline void erbal_parser_tag_open_choose_concat(erbal_parser *parser) {
+  if (strcmp(RSTRING(parser->keyword)->ptr, RSTRING(parser->safe_concat_keyword)->ptr) != 0) {
+    /* Keyword doesn't match, reset the buffer to the start of the expression match and act as if a keyword wasn't seen. */
+    p = parser->keyword_preceding_whitespace - 1;
+    erbal_parser_tag_open_for_unsafe_concat(parser);
+  } else {
+    /* Rewind the buffer to preserve whitespace following the keyword. */
+    p = p - (parser->keyword_trailing_whitespace - parser->keyword_end);
+    erbal_parser_tag_open_for_safe_concat(parser);
+  }
+}
+
+inline void erbal_parser_tag_open_for_unsafe_concat(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -2);
-  parser->state = TAG_OPEN_FOR_OUTPUT;
+  parser->state->tag = TAG_OPEN_FOR_UNSAFE_CONCAT;
+}
+
+inline void erbal_parser_tag_open_for_safe_concat(erbal_parser *parser) {
+  erbal_parser_tag_open_common(parser, -2);
+  parser->state->tag = TAG_OPEN_FOR_SAFE_CONCAT;
 }
 
 inline void erbal_parser_tag_open_for_comment(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -2);
-  parser->state = TAG_OPEN_FOR_COMMENT;
+  parser->state->tag = TAG_OPEN_FOR_COMMENT;
 }
 
 inline void erbal_parser_non_tag(erbal_parser *parser) {
-  parser->chars_seen += 1;
+  parser->state->chars_seen += 1;
 }
 
 inline void erbal_parser_tag_close_common(erbal_parser *parser, int tag_size) {
-  if (parser->state == TAG_OPEN_FOR_OUTPUT) {
-    if (!parser->in_buffer_shift) {
-      erbal_open_buffer_shift(parser);
+  if (parser->state->tag == TAG_OPEN_FOR_UNSAFE_CONCAT || parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
+    if (!parser->state->in_concat) {
+      if (parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
+        erbal_open_buffer_concat(parser, 1);
+      } else {
+        erbal_open_buffer_concat(parser, 0);
+      }
     }
 
     rb_str_buf_cat(parser->src, "#{", 2);
     erbal_concat_chars_seen(parser, -tag_size);
     rb_str_buf_cat(parser->src, "}", 1);
-  } else if (parser->state == TAG_OPEN) {
-    if (parser->in_buffer_shift) {
-      erbal_close_buffer_shift(parser);
+  } else if (parser->state->tag == TAG_OPEN) {
+    if (parser->state->in_concat) {
+      erbal_close_buffer_concat(parser);
     }
 
     erbal_concat_chars_seen(parser, -tag_size);
     rb_str_buf_cat(parser->src, ";\n", 2);
   }
 
-  parser->state = OUTSIDE_TAG;
-  parser->chars_seen = 0;
+  parser->state->tag = OUTSIDE_TAG;
+  parser->state->chars_seen = 0;
 }
 
 inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
@@ -95,8 +116,8 @@ inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
   int i, n, slashes_seen = 0;
   char *current_char;
 
-  for (i = 0; i < parser->chars_seen; i++) {
-    current_char = (((p + shift) - parser->chars_seen) + i);
+  for (i = 0; i < parser->state->chars_seen; i++) {
+    current_char = (((p + shift) - parser->state->chars_seen) + i);
 
     if (*current_char == '#' || *current_char == '`') {
       if (slashes_seen == 0) {
@@ -122,39 +143,48 @@ inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
 }
 
 inline void erbal_concat_chars_seen(erbal_parser *parser, int shift) {
-  if (parser->chars_seen != 0) {
-    if (parser->in_buffer_shift && parser->state == OUTSIDE_TAG) {
+  if (parser->state->chars_seen != 0) {
+    if (parser->state->in_concat && parser->state->tag == OUTSIDE_TAG) {
       rb_str_concat(parser->src, erbal_escape_special_chars(parser, shift));
     } else {
-    	rb_str_buf_cat(parser->src, ((p + shift) - parser->chars_seen), parser->chars_seen);
+    	rb_str_buf_cat(parser->src, ((p + shift) - parser->state->chars_seen), parser->state->chars_seen);
     }
   }
 
-  parser->chars_seen = 0;
+  parser->state->chars_seen = 0;
 }
 
-inline void erbal_open_buffer_shift(erbal_parser *parser) {
+inline void erbal_open_buffer_concat(erbal_parser *parser, int safe_concat) {
   rb_str_concat(parser->src, parser->buffer_name);
-  rb_str_buf_cat(parser->src, " << %Q`", 7);
-  parser->in_buffer_shift = 1;
+  rb_str_buf_cat(parser->src, ".", 1);
+
+  if (safe_concat) {
+    rb_str_concat(parser->src, parser->safe_concat_method);
+  } else {
+    rb_str_concat(parser->src, parser->unsafe_concat_method);
+  }
+
+  rb_str_buf_cat(parser->src, "(", 1);
+  rb_str_buf_cat(parser->src, "%Q`", 3);
+  parser->state->in_concat = 1;
 }
 
-inline void erbal_close_buffer_shift(erbal_parser *parser) {
-  rb_str_buf_cat(parser->src, "`;", 2);
-  parser->in_buffer_shift = 0;
+inline void erbal_close_buffer_concat(erbal_parser *parser) {
+  rb_str_buf_cat(parser->src, "`);", 3);
+  parser->state->in_concat = 0;
 }
 
 inline void erbal_parser_finish(erbal_parser *parser) {
-  if (parser->chars_seen != 0) {
-    if (!parser->in_buffer_shift) {
-      erbal_open_buffer_shift(parser);
+  if (parser->state->chars_seen != 0) {
+    if (!parser->state->in_concat) {
+      erbal_open_buffer_concat(parser, 1);
     }
 
     erbal_concat_chars_seen(parser, 0);
   }
 
-  if (parser->in_buffer_shift) {
-    erbal_close_buffer_shift(parser);
+  if (parser->state->in_concat) {
+    erbal_close_buffer_concat(parser);
   }
 
   rb_str_concat(parser->src, parser->buffer_name);
@@ -165,9 +195,9 @@ inline void erbal_parser_finish(erbal_parser *parser) {
 }
 
 void erbal_parser_init(VALUE self, erbal_parser *parser) {
-  parser->chars_seen = 0;
-  parser->in_buffer_shift = 0;
-	parser->state = OUTSIDE_TAG;
+  parser->state->chars_seen = 0;
+  parser->state->in_concat = 0;
+	parser->state->tag = OUTSIDE_TAG;
   parser->src = rb_str_dup(parser->buffer_name);
 
   rb_iv_set(self, "@src", parser->src);
@@ -184,7 +214,7 @@ void erbal_parser_init(VALUE self, erbal_parser *parser) {
   }
 
   
-#line 188 "parser.c"
+#line 218 "parser.c"
 	{
 	cs = erbal_parser_start;
 	ts = 0;
@@ -192,89 +222,99 @@ void erbal_parser_init(VALUE self, erbal_parser *parser) {
 	act = 0;
 	}
 
-#line 186 "parser.rl"
+#line 231 "parser.rl"
 }
 
 void erbal_parser_exec(erbal_parser *parser) {
   p = RSTRING(parser->str)->ptr;
   pe = p + strlen(p);
   
-#line 203 "parser.c"
+#line 233 "parser.c"
 	{
 	if ( p == pe )
 		goto _test_eof;
 	switch ( cs )
 	{
 tr0:
-#line 14 "parser.rl"
+#line 23 "parser.rl"
 	{{p = ((te))-1;}{ erbal_parser_non_tag(parser); }}
-	goto st1;
+	goto st3;
 tr1:
-#line 12 "parser.rl"
+#line 21 "parser.rl"
 	{te = p+1;{ erbal_parser_tag_close_with_trim(parser); }}
-	goto st1;
+	goto st3;
 tr2:
-#line 14 "parser.rl"
+#line 20 "parser.rl"
+	{{p = ((te))-1;}{ erbal_parser_tag_open_for_unsafe_concat(parser); }}
+	goto st3;
+tr7:
+#line 23 "parser.rl"
 	{te = p+1;{ erbal_parser_non_tag(parser); }}
-	goto st1;
-tr6:
-#line 14 "parser.rl"
+	goto st3;
+tr11:
+#line 23 "parser.rl"
 	{te = p;p--;{ erbal_parser_non_tag(parser); }}
-	goto st1;
-tr7:
-#line 13 "parser.rl"
+	goto st3;
+tr12:
+#line 22 "parser.rl"
 	{te = p+1;{ erbal_parser_tag_close(parser); }}
-	goto st1;
-tr10:
-#line 8 "parser.rl"
+	goto st3;
+tr15:
+#line 17 "parser.rl"
 	{te = p;p--;{ erbal_parser_tag_open(parser); }}
-	goto st1;
-tr11:
-#line 10 "parser.rl"
+	goto st3;
+tr16:
+#line 19 "parser.rl"
 	{te = p+1;{ erbal_parser_tag_open_for_comment(parser); }}
-	goto st1;
-tr12:
-#line 9 "parser.rl"
+	goto st3;
+tr17:
+#line 18 "parser.rl"
 	{te = p+1;{ erbal_parser_tag_open_with_dash(parser); }}
-	goto st1;
-tr13:
-#line 11 "parser.rl"
-	{te = p+1;{ erbal_parser_tag_open_for_output(parser); }}
-	goto st1;
-st1:
+	goto st3;
+tr19:
+#line 20 "parser.rl"
+	{te = p;p--;{ erbal_parser_tag_open_for_unsafe_concat(parser); }}
+	goto st3;
+tr22:
+#line 9 "parser.rl"
+	{ parser->keyword_trailing_whitespace = p; }
+#line 29 "parser.rl"
+	{te = p;p--;{ erbal_parser_tag_open_choose_concat(parser); }}
+	goto st3;
+st3:
 #line 1 "NONE"
 	{ts = 0;}
 	if ( ++p == pe )
-		goto _test_eof1;
-case 1:
+		goto _test_eof3;
+case 3:
 #line 1 "NONE"
 	{ts = p;}
-#line 253 "parser.c"
+#line 293 "parser.c"
 	switch( (*p) ) {
-		case 37: goto st2;
-		case 45: goto tr4;
-		case 60: goto st4;
+		case 37: goto st4;
+		case 45: goto tr9;
+		case 60: goto st6;
 	}
-	goto tr2;
-st2:
+	goto tr7;
+st4:
 	if ( ++p == pe )
-		goto _test_eof2;
-case 2:
+		goto _test_eof4;
+case 4:
 	if ( (*p) == 62 )
-		goto tr7;
-	goto tr6;
-tr4:
+		goto tr12;
+	goto tr11;
+tr9:
 #line 1 "NONE"
 	{te = p+1;}
-	goto st3;
-st3:
+	goto st5;
+st5:
 	if ( ++p == pe )
-		goto _test_eof3;
-case 3:
-#line 275 "parser.c"
+		goto _test_eof5;
+case 5:
+#line 315 "parser.c"
 	if ( (*p) == 37 )
 		goto st0;
-	goto tr6;
+	goto tr11;
 st0:
 	if ( ++p == pe )
 		goto _test_eof0;
@@ -282,45 +322,116 @@ case 0:
 	if ( (*p) == 62 )
 		goto tr1;
 	goto tr0;
-st4:
+st6:
 	if ( ++p == pe )
-		goto _test_eof4;
-case 4:
+		goto _test_eof6;
+case 6:
 	if ( (*p) == 37 )
-		goto st5;
-	goto tr6;
-st5:
+		goto st7;
+	goto tr11;
+st7:
 	if ( ++p == pe )
-		goto _test_eof5;
-case 5:
+		goto _test_eof7;
+case 7:
 	switch( (*p) ) {
-		case 35: goto tr11;
-		case 45: goto tr12;
-		case 61: goto tr13;
+		case 35: goto tr16;
+		case 45: goto tr17;
+		case 61: goto tr18;
 	}
-	goto tr10;
+	goto tr15;
+tr18:
+#line 1 "NONE"
+	{te = p+1;}
+	goto st8;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+#line 351 "parser.c"
+	if ( (*p) == 32 )
+		goto tr20;
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr21;
+	goto tr19;
+tr20:
+#line 8 "parser.rl"
+	{ parser->keyword_preceding_whitespace = p; }
+	goto st1;
+st1:
+	if ( ++p == pe )
+		goto _test_eof1;
+case 1:
+#line 365 "parser.c"
+	if ( (*p) == 32 )
+		goto st1;
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr4;
+	goto tr2;
+tr4:
+#line 7 "parser.rl"
+	{ parser->keyword_start = p; }
+	goto st2;
+tr21:
+#line 8 "parser.rl"
+	{ parser->keyword_preceding_whitespace = p; }
+#line 7 "parser.rl"
+	{ parser->keyword_start = p; }
+	goto st2;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+#line 385 "parser.c"
+	if ( (*p) == 32 )
+		goto tr5;
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto st2;
+	goto tr2;
+tr5:
+#line 11 "parser.rl"
+	{
+    parser->keyword_end = p;
+    parser->keyword = rb_str_new(parser->keyword_start, (p - parser->keyword_start));
+  }
+	goto st9;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+#line 402 "parser.c"
+	if ( (*p) == 32 )
+		goto st9;
+	goto tr22;
 	}
-	_test_eof1: cs = 1; goto _test_eof; 
-	_test_eof2: cs = 2; goto _test_eof; 
 	_test_eof3: cs = 3; goto _test_eof; 
-	_test_eof0: cs = 0; goto _test_eof; 
 	_test_eof4: cs = 4; goto _test_eof; 
 	_test_eof5: cs = 5; goto _test_eof; 
+	_test_eof0: cs = 0; goto _test_eof; 
+	_test_eof6: cs = 6; goto _test_eof; 
+	_test_eof7: cs = 7; goto _test_eof; 
+	_test_eof8: cs = 8; goto _test_eof; 
+	_test_eof1: cs = 1; goto _test_eof; 
+	_test_eof2: cs = 2; goto _test_eof; 
+	_test_eof9: cs = 9; goto _test_eof; 
 
 	_test_eof: {}
 	if ( p == eof )
 	{
 	switch ( cs ) {
-	case 2: goto tr6;
-	case 3: goto tr6;
+	case 4: goto tr11;
+	case 5: goto tr11;
 	case 0: goto tr0;
-	case 4: goto tr6;
-	case 5: goto tr10;
+	case 6: goto tr11;
+	case 7: goto tr15;
+	case 8: goto tr19;
+	case 1: goto tr2;
+	case 2: goto tr2;
+	case 9: goto tr22;
 	}
 	}
 
 	}
 
-#line 192 "parser.rl"
+#line 237 "parser.rl"
   erbal_parser_finish(parser);
 }

data/ext/erbal/parser.h

@@ -3,29 +3,40 @@
 
 #include "ruby.h"
 
+typedef struct parser_state {
+  unsigned int tag;
+  unsigned int chars_seen;
+  unsigned int in_concat;
+} parser_state;
+
 typedef struct erbal_parser {
-  unsigned int state, chars_seen, in_buffer_shift, debug;
-  VALUE str, src, buffer_name, options;
+  parser_state *state;
+  unsigned int debug;
+  VALUE str, src, buffer_name, options, safe_concat_method, unsafe_concat_method, keyword, safe_concat_keyword;
+  char *keyword_start, *keyword_end, *keyword_trailing_whitespace, *keyword_preceding_whitespace;
 } erbal_parser;
 
 inline void erbal_parser_tag_open(erbal_parser*);
 inline void erbal_parser_tag_open_with_dash(erbal_parser*);
 inline void erbal_parser_tag_open_for_comment(erbal_parser*);
-inline void erbal_parser_tag_open_for_output(erbal_parser*);
+inline void erbal_parser_tag_open_choose_concat(erbal_parser*);
+inline void erbal_parser_tag_open_for_unsafe_concat(erbal_parser*);
+inline void erbal_parser_tag_open_for_safe_concat(erbal_parser*);
 inline void erbal_parser_non_tag(erbal_parser*);
 inline void erbal_parser_tag_close(erbal_parser*);
 inline void erbal_parser_tag_close_with_trim(erbal_parser*);
-inline void erbal_parser_tag_close_common(erbal_parser*, int shift);
+inline void erbal_parser_tag_close_common(erbal_parser*, int);
 inline void erbal_parser_finish(erbal_parser*);
-inline void erbal_concat_chars_seen(erbal_parser*, int shift);
-inline void erbal_parser_tag_open_common(erbal_parser*, int shift);
-inline void erbal_open_buffer_shift(erbal_parser*);
-inline void erbal_close_buffer_shift(erbal_parser*);
-inline VALUE erbal_escape_special_chars(erbal_parser*, int shift);
+inline void erbal_concat_chars_seen(erbal_parser*, int);
+inline void erbal_parser_tag_open_common(erbal_parser*, int);
+inline void erbal_open_buffer_concat(erbal_parser*, int);
+inline void erbal_close_buffer_concat(erbal_parser*);
+inline VALUE erbal_escape_special_chars(erbal_parser*, int);
 
-#define TAG_OPEN                1
-#define TAG_OPEN_FOR_COMMENT    2
-#define TAG_OPEN_FOR_OUTPUT     3
-#define OUTSIDE_TAG             4
+#define TAG_OPEN                    1
+#define TAG_OPEN_FOR_COMMENT        2
+#define TAG_OPEN_FOR_SAFE_CONCAT    3
+#define TAG_OPEN_FOR_UNSAFE_CONCAT  4
+#define OUTSIDE_TAG                 5
 
 #endif

data/ext/erbal/parser.rl

@@ -4,14 +4,29 @@
 %%{
   machine erbal_parser;
 
+  action keyword_start { parser->keyword_start = fpc; }
+  action keyword_preceding_whitespace { parser->keyword_preceding_whitespace = fpc; }
+  action keyword_trailing_whitespace { parser->keyword_trailing_whitespace = fpc; }
+
+  action keyword_end {
+    parser->keyword_end = fpc;
+    parser->keyword = rb_str_new(parser->keyword_start, (fpc - parser->keyword_start));
+  }
+
   main := |*
     '<%'  => { erbal_parser_tag_open(parser); };
     '<%-' => { erbal_parser_tag_open_with_dash(parser); };
     '<%#' => { erbal_parser_tag_open_for_comment(parser); };
-    '<%=' => { erbal_parser_tag_open_for_output(parser); };
+    '<%=' => { erbal_parser_tag_open_for_unsafe_concat(parser); };
     '-%>' => { erbal_parser_tag_close_with_trim(parser); };
     '%>'  => { erbal_parser_tag_close(parser); };
     any   => { erbal_parser_non_tag(parser); };
+
+    '<%=' (
+            [ ]* >keyword_preceding_whitespace
+            [a-z]+ >keyword_start %keyword_end
+            [ ]+ %keyword_trailing_whitespace
+          ) => { erbal_parser_tag_open_choose_concat(parser); };
   *|;
 }%%
 
@@ -21,60 +36,81 @@ static char *ts, *te, *p, *pe, *eof;
 static int act, cs;
 
 inline void erbal_parser_tag_open_common(erbal_parser *parser, int shift) {
-  if (parser->chars_seen != 0) {
-    if (!parser->in_buffer_shift) {
-      erbal_open_buffer_shift(parser);
+  if (parser->state->chars_seen != 0) {
+    if (!parser->state->in_concat) {
+      erbal_open_buffer_concat(parser, 1);
     }
 
     erbal_concat_chars_seen(parser, shift);
-    parser->chars_seen = 0;
+    parser->state->chars_seen = 0;
   }
 }
 
 inline void erbal_parser_tag_open(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -1);
-  parser->state = TAG_OPEN;
+  parser->state->tag = TAG_OPEN;
 }
 
 inline void erbal_parser_tag_open_with_dash(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -2);
-  parser->state = TAG_OPEN;
+  parser->state->tag = TAG_OPEN;
 }
 
-inline void erbal_parser_tag_open_for_output(erbal_parser *parser) {
+inline void erbal_parser_tag_open_choose_concat(erbal_parser *parser) {
+  if (strcmp(RSTRING(parser->keyword)->ptr, RSTRING(parser->safe_concat_keyword)->ptr) != 0) {
+    /* Keyword doesn't match, reset the buffer to the start of the expression match and act as if a keyword wasn't seen. */
+    p = parser->keyword_preceding_whitespace - 1;
+    erbal_parser_tag_open_for_unsafe_concat(parser);
+  } else {
+    /* Rewind the buffer to preserve whitespace following the keyword. */
+    p = p - (parser->keyword_trailing_whitespace - parser->keyword_end);
+    erbal_parser_tag_open_for_safe_concat(parser);
+  }
+}
+
+inline void erbal_parser_tag_open_for_unsafe_concat(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -2);
-  parser->state = TAG_OPEN_FOR_OUTPUT;
+  parser->state->tag = TAG_OPEN_FOR_UNSAFE_CONCAT;
+}
+
+inline void erbal_parser_tag_open_for_safe_concat(erbal_parser *parser) {
+  erbal_parser_tag_open_common(parser, -2);
+  parser->state->tag = TAG_OPEN_FOR_SAFE_CONCAT;
 }
 
 inline void erbal_parser_tag_open_for_comment(erbal_parser *parser) {
   erbal_parser_tag_open_common(parser, -2);
-  parser->state = TAG_OPEN_FOR_COMMENT;
+  parser->state->tag = TAG_OPEN_FOR_COMMENT;
 }
 
 inline void erbal_parser_non_tag(erbal_parser *parser) {
-  parser->chars_seen += 1;
+  parser->state->chars_seen += 1;
 }
 
 inline void erbal_parser_tag_close_common(erbal_parser *parser, int tag_size) {
-  if (parser->state == TAG_OPEN_FOR_OUTPUT) {
-    if (!parser->in_buffer_shift) {
-      erbal_open_buffer_shift(parser);
+  if (parser->state->tag == TAG_OPEN_FOR_UNSAFE_CONCAT || parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
+    if (!parser->state->in_concat) {
+      if (parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
+        erbal_open_buffer_concat(parser, 1);
+      } else {
+        erbal_open_buffer_concat(parser, 0);
+      }
     }
 
     rb_str_buf_cat(parser->src, "#{", 2);
     erbal_concat_chars_seen(parser, -tag_size);
     rb_str_buf_cat(parser->src, "}", 1);
-  } else if (parser->state == TAG_OPEN) {
-    if (parser->in_buffer_shift) {
-      erbal_close_buffer_shift(parser);
+  } else if (parser->state->tag == TAG_OPEN) {
+    if (parser->state->in_concat) {
+      erbal_close_buffer_concat(parser);
     }
 
     erbal_concat_chars_seen(parser, -tag_size);
     rb_str_buf_cat(parser->src, ";\n", 2);
   }
 
-  parser->state = OUTSIDE_TAG;
-  parser->chars_seen = 0;
+  parser->state->tag = OUTSIDE_TAG;
+  parser->state->chars_seen = 0;
 }
 
 inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
@@ -94,8 +130,8 @@ inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
   int i, n, slashes_seen = 0;
   char *current_char;
 
-  for (i = 0; i < parser->chars_seen; i++) {
-    current_char = (((p + shift) - parser->chars_seen) + i);
+  for (i = 0; i < parser->state->chars_seen; i++) {
+    current_char = (((p + shift) - parser->state->chars_seen) + i);
 
     if (*current_char == '#' || *current_char == '`') {
       if (slashes_seen == 0) {
@@ -121,39 +157,48 @@ inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
 }
 
 inline void erbal_concat_chars_seen(erbal_parser *parser, int shift) {
-  if (parser->chars_seen != 0) {
-    if (parser->in_buffer_shift && parser->state == OUTSIDE_TAG) {
+  if (parser->state->chars_seen != 0) {
+    if (parser->state->in_concat && parser->state->tag == OUTSIDE_TAG) {
       rb_str_concat(parser->src, erbal_escape_special_chars(parser, shift));
     } else {
-    	rb_str_buf_cat(parser->src, ((p + shift) - parser->chars_seen), parser->chars_seen);
+    	rb_str_buf_cat(parser->src, ((p + shift) - parser->state->chars_seen), parser->state->chars_seen);
     }
   }
 
-  parser->chars_seen = 0;
+  parser->state->chars_seen = 0;
 }
 
-inline void erbal_open_buffer_shift(erbal_parser *parser) {
+inline void erbal_open_buffer_concat(erbal_parser *parser, int safe_concat) {
   rb_str_concat(parser->src, parser->buffer_name);
-  rb_str_buf_cat(parser->src, " << %Q`", 7);
-  parser->in_buffer_shift = 1;
+  rb_str_buf_cat(parser->src, ".", 1);
+
+  if (safe_concat) {
+    rb_str_concat(parser->src, parser->safe_concat_method);
+  } else {
+    rb_str_concat(parser->src, parser->unsafe_concat_method);
+  }
+
+  rb_str_buf_cat(parser->src, "(", 1);
+  rb_str_buf_cat(parser->src, "%Q`", 3);
+  parser->state->in_concat = 1;
 }
 
-inline void erbal_close_buffer_shift(erbal_parser *parser) {
-  rb_str_buf_cat(parser->src, "`;", 2);
-  parser->in_buffer_shift = 0;
+inline void erbal_close_buffer_concat(erbal_parser *parser) {
+  rb_str_buf_cat(parser->src, "`);", 3);
+  parser->state->in_concat = 0;
 }
 
 inline void erbal_parser_finish(erbal_parser *parser) {
-  if (parser->chars_seen != 0) {
-    if (!parser->in_buffer_shift) {
-      erbal_open_buffer_shift(parser);
+  if (parser->state->chars_seen != 0) {
+    if (!parser->state->in_concat) {
+      erbal_open_buffer_concat(parser, 1);
     }
 
     erbal_concat_chars_seen(parser, 0);
   }
 
-  if (parser->in_buffer_shift) {
-    erbal_close_buffer_shift(parser);
+  if (parser->state->in_concat) {
+    erbal_close_buffer_concat(parser);
   }
 
   rb_str_concat(parser->src, parser->buffer_name);
@@ -164,9 +209,9 @@ inline void erbal_parser_finish(erbal_parser *parser) {
 }
 
 void erbal_parser_init(VALUE self, erbal_parser *parser) {
-  parser->chars_seen = 0;
-  parser->in_buffer_shift = 0;
-	parser->state = OUTSIDE_TAG;
+  parser->state->chars_seen = 0;
+  parser->state->in_concat = 0;
+	parser->state->tag = OUTSIDE_TAG;
   parser->src = rb_str_dup(parser->buffer_name);
 
   rb_iv_set(self, "@src", parser->src);

data/lib/erbal/rails.rb

@@ -0,0 +1,42 @@
+require 'erbal'
+
+class Erbal
+  module Rails
+    class Rails_2_3_10_TemplateHandler < ActionView::TemplateHandler
+      include ActionView::TemplateHandlers::Compilable
+      def compile(template)
+        ::Erbal.new("<% __in_erb_template=true %>#{template.source}", {:buffer => '@output_buffer', :buffer_initial_value => 'ActiveSupport::SafeBuffer.new',
+          :safe_concat_method => 'safe_concat', :unsafe_concat_method => 'concat', :safe_concat_keyword => 'raw'}).parse
+      end
+    end
+
+    def self.version_unsupported
+      raise "Sorry, this version of Erbal doesn't support Rails #{ActionPack::VERSION::MAJOR}.#{ActionPack::VERSION::MINOR}.#{ActionPack::VERSION::TINY}."
+    end
+
+    def self.register_template_handler(handler_class)
+      ActionView::Template.register_template_handler :erb, handler_class
+    end
+
+    def self.register_template_handler_for_2_3_10
+      register_template_handler(Rails_2_3_10_TemplateHandler)
+    end
+  end
+end
+
+case ActionPack::VERSION::MAJOR
+when 2
+  case ActionPack::VERSION::MINOR
+  when 3
+    case ActionPack::VERSION::TINY
+    when 10
+      Erbal::Rails.register_template_handler_for_2_3_10
+    else
+      Erbal::Rails.version_unsupported
+    end
+  else
+    Erbal::Rails.version_unsupported
+  end
+else
+  Erbal::Rails.version_unsupported
+end

data/spec/erbal_spec.rb

@@ -40,7 +40,7 @@ describe Erbal do
   end
 
   it "should parse content without any tags" do
-    erbal_parse("I love unicorns!").should == "@out = '';@out << %Q`I love unicorns!`;@out"
+    erbal_parse("I love unicorns!").should == "@out = '';@out.concat(%Q`I love unicorns!`);@out"
   end
 
   it "should parse the <% tag" do
@@ -48,68 +48,112 @@ describe Erbal do
   end
 
   it "should parse the <%- tag" do
-    erbal_parse("1 + 1 is <%- 1 + 1 %>").should == "@out = '';@out << %Q`1 + 1 is `; 1 + 1 ;\n@out"
+    erbal_parse("1 + 1 is <%- 1 + 1 %>").should == "@out = '';@out.concat(%Q`1 + 1 is `); 1 + 1 ;\n@out"
   end
 
   it "should add a line break after <% %> tags incase the tags ended with a comment" do
-    erbal_parse("<% 1 + 1 # eeek comment! %> hi mom").should == "@out = ''; 1 + 1 # eeek comment! ;\n@out << %Q` hi mom`;@out"
+    erbal_parse("<% 1 + 1 # eeek comment! %> hi mom").should == "@out = ''; 1 + 1 # eeek comment! ;\n@out.concat(%Q` hi mom`);@out"
   end
 
   it "should parse the <%= tag" do
-    erbal_parse("<%= 1 + 1 %>").should == "@out = '';@out << %Q`\#{ 1 + 1 }`;@out"
+    erbal_parse("<%= 1 + 1 %>").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 }`);@out"
   end
 
   it "should parse the comment tag <%#" do
-    erbal_parse("Something:<br />\n<%# I'm a comment %>").should == "@out = '';@out << %Q`Something:<br />\n`;@out"
+    erbal_parse("Something:<br />\n<%# I'm a comment %>").should == "@out = '';@out.concat(%Q`Something:<br />\n`);@out"
   end
 
   it "should swallow the following newline if the -%> tag is used" do
-    erbal_parse("<%= 1 + 1 -%>\n\n").should == "@out = '';@out << %Q`\#{ 1 + 1 }\n`;@out"
+    erbal_parse("<%= 1 + 1 -%>\n\n").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 }\n`);@out"
   end
 
   it "should not swallow the following character if the -%> tag is used and the following character is not a newline" do
-    erbal_parse("<%= 1 + 1 -%>Z").should == "@out = '';@out << %Q`\#{ 1 + 1 }Z`;@out"
+    erbal_parse("<%= 1 + 1 -%>Z").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 }Z`);@out"
   end
 
   it "should concat text surrounding the tags when the opening tag is <%" do
-    erbal_parse("1 + 1 is <% 1 + 1 %>. Easy!").should == "@out = '';@out << %Q`1 + 1 is `; 1 + 1 ;\n@out << %Q`. Easy!`;@out"
+    erbal_parse("1 + 1 is <% 1 + 1 %>. Easy!").should == "@out = '';@out.concat(%Q`1 + 1 is `); 1 + 1 ;\n@out.concat(%Q`. Easy!`);@out"
   end
 
   it "should concat text surrounding the tags when the opening tag is <%=" do
-    erbal_parse("1 + 1 is <%= 1 + 1 %>. Easy!").should == "@out = '';@out << %Q`1 + 1 is \#{ 1 + 1 }. Easy!`;@out"
+    erbal_parse("1 + 1 is <%= 1 + 1 %>. Easy!").should == "@out = '';@out.concat(%Q`1 + 1 is \#{ 1 + 1 }. Easy!`);@out"
   end
 
   it "should not open a new buffer shift when there is more than one consecutive <%= tag" do
-    erbal_parse("1 + 1 is <%= 1 + 1 %>, and 2 + 2 is <%= 2 + 2 %>. Easy!").should == "@out = '';@out << %Q`1 + 1 is \#{ 1 + 1 }, and 2 + 2 is \#{ 2 + 2 }. Easy!`;@out"
+    erbal_parse("1 + 1 is <%= 1 + 1 %>, and 2 + 2 is <%= 2 + 2 %>. Easy!").should == "@out = '';@out.concat(%Q`1 + 1 is \#{ 1 + 1 }, and 2 + 2 is \#{ 2 + 2 }. Easy!`);@out"
   end
 
-  it "should escape a hash character that signifies the start of a string interpolation when outside tags" do
-    erbal_parse("<%= 1 + 1 -%> wee \#{1 + 3}").should == "@out = '';@out << %Q`\#{ 1 + 1 } wee \\\#{1 + 3}`;@out"
-    eval(erbal_parse("<%= 1 + 1 -%> wee \#{1 + 3}")).should == eval(erubis_parse("<%= 1 + 1 -%> wee \#{1 + 3}"))
+  describe "when escaping special characters" do
+    it "should escape a hash character that signifies the start of a string interpolation when outside tags" do
+      erbal_parse("<%= 1 + 1 -%> wee \#{1 + 3}").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 } wee \\\#{1 + 3}`);@out"
+      eval(erbal_parse("<%= 1 + 1 -%> wee \#{1 + 3}")).should == eval(erubis_parse("<%= 1 + 1 -%> wee \#{1 + 3}"))
 
-    erbal_parse("<%= 1 + 1 -%> wee \\\#{1 + 3}").should == "@out = '';@out << %Q`\#{ 1 + 1 } wee \\\\\\\#{1 + 3}`;@out"
-    eval(erbal_parse("<%= 1 + 1 -%> wee \\\#{1 + 3}")).should == eval(erubis_parse("<%= 1 + 1 -%> wee \\\#{1 + 3}"))
+      erbal_parse("<%= 1 + 1 -%> wee \\\#{1 + 3}").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 } wee \\\\\\\#{1 + 3}`);@out"
+      eval(erbal_parse("<%= 1 + 1 -%> wee \\\#{1 + 3}")).should == eval(erubis_parse("<%= 1 + 1 -%> wee \\\#{1 + 3}"))
 
-    erbal_parse("<%= 1 + 1 -%> wee \\\\\\\#{1 + 3}").should == "@out = '';@out << %Q`\#{ 1 + 1 } wee \\\\\\\\\\\\\\\#{1 + 3}`;@out"
-    eval(erbal_parse("<%= 1 + 1 -%> wee \\\\\\\#{1 + 3}")).should == eval(erubis_parse("<%= 1 + 1 -%> wee \\\\\\\#{1 + 3}"))
+      erbal_parse("<%= 1 + 1 -%> wee \\\\\\\#{1 + 3}").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 } wee \\\\\\\\\\\\\\\#{1 + 3}`);@out"
+      eval(erbal_parse("<%= 1 + 1 -%> wee \\\\\\\#{1 + 3}")).should == eval(erubis_parse("<%= 1 + 1 -%> wee \\\\\\\#{1 + 3}"))
 
-    erbal_parse('<%= 1 + 1 -%> wee #{1 + 3}').should == "@out = '';@out << %Q`\#{ 1 + 1 } wee \\\#{1 + 3}`;@out"
-    eval(erbal_parse('<%= 1 + 1 -%> wee #{1 + 3}')).should == eval(erubis_parse('<%= 1 + 1 -%> wee #{1 + 3}'))
-  end
+      erbal_parse('<%= 1 + 1 -%> wee #{1 + 3}').should == "@out = '';@out.concat(%Q`\#{ 1 + 1 } wee \\\#{1 + 3}`);@out"
+      eval(erbal_parse('<%= 1 + 1 -%> wee #{1 + 3}')).should == eval(erubis_parse('<%= 1 + 1 -%> wee #{1 + 3}'))
+    end
+
+    it "should not escape a hash character that signifies the start of a string interpolation when inside tags" do
+      erbal_parse('<%= "#{1 + 1}" -%>').should == "@out = '';@out.concat(%Q`\#{ \"\#{1 + 1}\" }`);@out"
+      eval(erbal_parse('<%= "#{1 + 1}" -%>')).should == eval(erubis_parse('<%= "#{1 + 1}" -%>'))
+    end
+
+    it "should escape a backtick character that signifies the end off a buffer shift" do
+      erbal_parse("weeee `").should == "@out = '';@out.concat(%Q`weeee \\``);@out"
+      eval(erbal_parse("weeee `")).should == eval(erubis_parse("weeee `"));
 
-  it "should not escape a hash character that signifies the start of a string interpolation when inside tags" do
-    erbal_parse('<%= "#{1 + 1}" -%>').should == "@out = '';@out << %Q`\#{ \"\#{1 + 1}\" }`;@out"
-    eval(erbal_parse('<%= "#{1 + 1}" -%>')).should == eval(erubis_parse('<%= "#{1 + 1}" -%>'))
+      erbal_parse("weeee \\`").should == "@out = '';@out.concat(%Q`weeee \\\\\\``);@out"
+      eval(erbal_parse("weeee \\`")).should == eval(erubis_parse("weeee \\`"))
+
+      erbal_parse("weeee \\\\\\\`").should == "@out = '';@out.concat(%Q`weeee \\\\\\\\\\\\\\``);@out"
+      eval(erbal_parse("weeee \\\\\\\`")).should == eval(erubis_parse("weeee \\\\\\\`"))
+    end
   end
 
-  it "should escape a backtick character that signifies the end off a buffer shift" do
-    erbal_parse("weeee `").should == "@out = '';@out << %Q`weeee \\``;@out"
-    eval(erbal_parse("weeee `")).should == eval(erubis_parse("weeee `"));
+  describe "when using the safe_concat_method, unsafe_concat_method and safe_concat_keyword options" do
+    it "should default to using 'concat' if the :safe_concat_method option is not specified" do
+      erbal_parse("hello").should == "@out = '';@out.concat(%Q`hello`);@out"
+    end
+
+    it "should default to using 'concat' if the :unsafe_concat_method option is not specified" do
+      erbal_parse("<%= 1 + 1 %>").should == "@out = '';@out.concat(%Q`\#{ 1 + 1 }`);@out"
+    end
+
+    it "should use the safe concat method for text outside of tags" do
+      erbal_parse("hello", :safe_concat_method => 'safe_concat').should == "@output_buffer = '';@output_buffer.safe_concat(%Q`hello`);@output_buffer"
+    end
+
+    it "should use the unsafe concat method for the <%= tag" do
+      erbal_parse("<%= 1 + 1 %>", :unsafe_concat_method => 'unsafe_concat').should == "@output_buffer = '';@output_buffer.unsafe_concat(%Q`\#{ 1 + 1 }`);@output_buffer"
+    end
+
+    it "should use the safe concat method for the <%= tag if the safe_concat_keyword option is also used" do
+      erbal_parse("<%= raw 1 + 1 %>", :safe_concat_method => 'safe_concat', :safe_concat_keyword => 'raw').should == "@output_buffer = '';@output_buffer.safe_concat(%Q`\#{ 1 + 1 }`);@output_buffer"
+    end
+
+    it "should not use the safe concat method for the <%= tag if the safe_concat_keyword option is also used but not applicable" do
+      erbal_parse("<%= blah 1 + 1 %>", :unsafe_concat_method => 'unsafe_concat').should == "@output_buffer = '';@output_buffer.unsafe_concat(%Q`\#{ blah 1 + 1 }`);@output_buffer"
+    end
+
+    it "should not set a default safe_concat_keyword option" do
+      erbal_parse("<%= raw 1 + 1 %>", :unsafe_concat_method => 'unsafe_concat', :safe_concat_keyword => nil).should == "@output_buffer = '';@output_buffer.unsafe_concat(%Q`\#{ raw 1 + 1 }`);@output_buffer"
+    end
+
+    it "should preserve the whitespace following the safe_concat_keyword" do
+      erbal_parse("<%= raw     1 + 1 %>", :safe_concat_method => 'safe_concat', :safe_concat_keyword => 'raw').should == "@output_buffer = '';@output_buffer.safe_concat(%Q`\#{     1 + 1 }`);@output_buffer"
+    end
 
-    erbal_parse("weeee \\`").should == "@out = '';@out << %Q`weeee \\\\\\``;@out"
-    eval(erbal_parse("weeee \\`")).should == eval(erubis_parse("weeee \\`"))
+    it "should use the safe concat method for the <%= tag if the safe_concat_keyword option is also used and the keyword has no preceding whitespace" do
+      erbal_parse("<%=raw 1 + 1 %>", :safe_concat_method => 'safe_concat', :safe_concat_keyword => 'raw').should == "@output_buffer = '';@output_buffer.safe_concat(%Q`\#{ 1 + 1 }`);@output_buffer"
+    end
 
-    erbal_parse("weeee \\\\\\\`").should == "@out = '';@out << %Q`weeee \\\\\\\\\\\\\\``;@out"
-    eval(erbal_parse("weeee \\\\\\\`")).should == eval(erubis_parse("weeee \\\\\\\`"))
+    it "should not use the safe concat method for the <%= tag if the safe_concat_keyword option is also used but not applicable and the keyword has no preceding whitespace" do
+      erbal_parse("<%=blah 1 + 1 %>", :unsafe_concat_method => 'unsafe_concat').should == "@output_buffer = '';@output_buffer.unsafe_concat(%Q`\#{blah 1 + 1 }`);@output_buffer"
+    end
   end
 end

data/tasks/gem.rake

@@ -2,7 +2,7 @@ require 'rake/gempackagetask'
 require 'yaml'
 
 WIN_SUFFIX = ENV['WIN_SUFFIX'] || 'i386-mswin32'
-ERBAL_VERSION = '1.1'
+ERBAL_VERSION = '1.2.rc1'
 
 task :clean => :clobber_package
 

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: erbal
 version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: false
+  hash: 977940510
+  prerelease: true
   segments: 
   - 1
-  - 1
-  version: "1.1"
+  - 2
+  - rc1
+  version: 1.2.rc1
 platform: ruby
 authors: 
 - Ian Leitch
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-30 00:00:00 +11:00
+date: 2011-01-05 00:00:00 +11:00
 default_executable: 
 dependencies: []
 
@@ -31,7 +32,7 @@ files:
 - CHANGELOG
 - README.rdoc
 - Rakefile
-- lib/erbal/rails23.rb
+- lib/erbal/rails.rb
 - spec/erbal_spec.rb
 - spec/spec_helper.rb
 - tasks/ext.rake
@@ -66,12 +67,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 

data/lib/erbal/rails23.rb

@@ -1,21 +0,0 @@
-require 'erbal'
-
-if ActiveSupport.const_defined?('SafeBuffer')
-
-  class ErbalTemplateHandler < ActionView::TemplateHandler
-    include ActionView::TemplateHandlers::Compilable
-    def compile(template)
-      ::Erbal.new("<% __in_erb_template=true %>#{template.source}", {:buffer => '@output_buffer', :buffer_initial_value => 'ActiveSupport::SafeBuffer.new'}).parse
-    end
-  end
-
-else
-
-  class ErbalTemplateHandler < ActionView::TemplateHandler
-    include ActionView::TemplateHandlers::Compilable
-    def compile(template)
-      ::Erbal.new("<% __in_erb_template=true %>#{template.source}", {:buffer => '@output_buffer'}).parse
-    end
-  end
-
-end