erbal 1.2.rc1 → 1.2.rc2

data/ext/erbal/parser.c

@@ -21,29 +21,31 @@ static const int erbal_parser_en_main = 3;
 static char *ts, *te, *p, *pe, *eof;
 static int act, cs;
 
-inline void erbal_parser_tag_open_common(erbal_parser *parser, int shift) {
+inline void erbal_parser_tag_open_common(erbal_parser *parser) {
   if (parser->state->chars_seen != 0) {
-    if (!parser->state->in_concat) {
+    if (parser->state->concat == OUTSIDE_CONCAT) {
       erbal_open_buffer_concat(parser, 1);
+    } else if (parser->state->concat == UNSAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 1);
     }
 
-    erbal_concat_chars_seen(parser, shift);
+    erbal_concat_chars_seen(parser);
     parser->state->chars_seen = 0;
   }
 }
 
 inline void erbal_parser_tag_open(erbal_parser *parser) {
-  erbal_parser_tag_open_common(parser, -1);
+  erbal_parser_tag_open_common(parser);
   parser->state->tag = TAG_OPEN;
 }
 
 inline void erbal_parser_tag_open_with_dash(erbal_parser *parser) {
-  erbal_parser_tag_open_common(parser, -2);
+  erbal_parser_tag_open_common(parser);
   parser->state->tag = TAG_OPEN;
 }
 
 inline void erbal_parser_tag_open_choose_concat(erbal_parser *parser) {
-  if (strcmp(RSTRING(parser->keyword)->ptr, RSTRING(parser->safe_concat_keyword)->ptr) != 0) {
+  if (strcmp(RSTRING(parser->safe_concat_keyword)->ptr, "") == 0 || 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);
@@ -55,43 +57,51 @@ inline void erbal_parser_tag_open_choose_concat(erbal_parser *parser) {
 }
 
 inline void erbal_parser_tag_open_for_unsafe_concat(erbal_parser *parser) {
-  erbal_parser_tag_open_common(parser, -2);
+  erbal_parser_tag_open_common(parser);
   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);
+  erbal_parser_tag_open_common(parser);
   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);
+  erbal_parser_tag_open_common(parser);
   parser->state->tag = TAG_OPEN_FOR_COMMENT;
 }
 
 inline void erbal_parser_non_tag(erbal_parser *parser) {
+  if (parser->state->chars_seen == 0) {
+    parser->state->chars_seen_start = p;
+  }
+
   parser->state->chars_seen += 1;
 }
 
-inline void erbal_parser_tag_close_common(erbal_parser *parser, int tag_size) {
+inline void erbal_parser_tag_close_common(erbal_parser *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->concat == OUTSIDE_CONCAT) {
       if (parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
         erbal_open_buffer_concat(parser, 1);
       } else {
         erbal_open_buffer_concat(parser, 0);
       }
+    } else if (parser->state->concat == SAFE_CONCAT && parser->state->tag == TAG_OPEN_FOR_UNSAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 0);
+    } else if (parser->state->concat == UNSAFE_CONCAT && parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 1);
     }
 
     rb_str_buf_cat(parser->src, "#{", 2);
-    erbal_concat_chars_seen(parser, -tag_size);
+    erbal_concat_chars_seen(parser);
     rb_str_buf_cat(parser->src, "}", 1);
   } else if (parser->state->tag == TAG_OPEN) {
-    if (parser->state->in_concat) {
+    if (parser->state->concat != OUTSIDE_CONCAT) {
       erbal_close_buffer_concat(parser);
     }
 
-    erbal_concat_chars_seen(parser, -tag_size);
+    erbal_concat_chars_seen(parser);
     rb_str_buf_cat(parser->src, ";\n", 2);
   }
 
@@ -100,7 +110,7 @@ inline void erbal_parser_tag_close_common(erbal_parser *parser, int tag_size) {
 }
 
 inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
-  erbal_parser_tag_close_common(parser, 2);
+  erbal_parser_tag_close_common(parser);
 
   if (*(p + 1) == '\n') {
     p++;
@@ -108,16 +118,16 @@ inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
 }
 
 inline void erbal_parser_tag_close(erbal_parser *parser) {
-  erbal_parser_tag_close_common(parser, 1);
+  erbal_parser_tag_close_common(parser);
 }
 
-inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
+inline VALUE erbal_escape_special_chars(erbal_parser *parser) {
   VALUE buf = rb_str_buf_new(0);
   int i, n, slashes_seen = 0;
   char *current_char;
 
   for (i = 0; i < parser->state->chars_seen; i++) {
-    current_char = (((p + shift) - parser->state->chars_seen) + i);
+    current_char = (parser->state->chars_seen_start + i);
 
     if (*current_char == '#' || *current_char == '`') {
       if (slashes_seen == 0) {
@@ -142,48 +152,58 @@ inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
   return buf;
 }
 
-inline void erbal_concat_chars_seen(erbal_parser *parser, int shift) {
+inline void erbal_concat_chars_seen(erbal_parser *parser) {
   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));
+    if (parser->state->concat != OUTSIDE_CONCAT && parser->state->tag == OUTSIDE_TAG) {
+      rb_str_concat(parser->src, erbal_escape_special_chars(parser));
     } else {
-    	rb_str_buf_cat(parser->src, ((p + shift) - parser->state->chars_seen), parser->state->chars_seen);
+    	rb_str_buf_cat(parser->src, parser->state->chars_seen_start, parser->state->chars_seen);
     }
   }
 
   parser->state->chars_seen = 0;
 }
 
+inline void erbal_close_and_open_buffer_concat_if_needed(erbal_parser *parser, int safe_concat) {
+  if (!parser->concat_methods_identical) {
+    erbal_close_buffer_concat(parser);
+    erbal_open_buffer_concat(parser, safe_concat);
+  }
+}
+
 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, ".", 1);
 
   if (safe_concat) {
     rb_str_concat(parser->src, parser->safe_concat_method);
+    parser->state->concat = SAFE_CONCAT;
   } else {
     rb_str_concat(parser->src, parser->unsafe_concat_method);
+    parser->state->concat = UNSAFE_CONCAT;
   }
 
   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_concat(erbal_parser *parser) {
   rb_str_buf_cat(parser->src, "`);", 3);
-  parser->state->in_concat = 0;
+  parser->state->concat = OUTSIDE_CONCAT;
 }
 
 inline void erbal_parser_finish(erbal_parser *parser) {
   if (parser->state->chars_seen != 0) {
-    if (!parser->state->in_concat) {
+    if (parser->state->concat == OUTSIDE_CONCAT) {
       erbal_open_buffer_concat(parser, 1);
+    } else if (parser->state->concat == UNSAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 1);
     }
 
-    erbal_concat_chars_seen(parser, 0);
+    erbal_concat_chars_seen(parser);
   }
 
-  if (parser->state->in_concat) {
+  if (parser->state->concat != OUTSIDE_CONCAT) {
     erbal_close_buffer_concat(parser);
   }
 
@@ -196,8 +216,15 @@ inline void erbal_parser_finish(erbal_parser *parser) {
 
 void erbal_parser_init(VALUE self, erbal_parser *parser) {
   parser->state->chars_seen = 0;
-  parser->state->in_concat = 0;
+  parser->state->concat = OUTSIDE_CONCAT;
 	parser->state->tag = OUTSIDE_TAG;
+
+	if (strcmp(RSTRING(parser->safe_concat_method)->ptr, RSTRING(parser->unsafe_concat_method)->ptr) == 0) {
+    parser->concat_methods_identical = 1;
+	} else {
+	  parser->concat_methods_identical = 0;
+	}
+
   parser->src = rb_str_dup(parser->buffer_name);
 
   rb_iv_set(self, "@src", parser->src);
@@ -214,7 +241,7 @@ void erbal_parser_init(VALUE self, erbal_parser *parser) {
   }
 
   
-#line 218 "parser.c"
+#line 245 "parser.c"
 	{
 	cs = erbal_parser_start;
 	ts = 0;
@@ -222,14 +249,14 @@ void erbal_parser_init(VALUE self, erbal_parser *parser) {
 	act = 0;
 	}
 
-#line 231 "parser.rl"
+#line 258 "parser.rl"
 }
 
 void erbal_parser_exec(erbal_parser *parser) {
   p = RSTRING(parser->str)->ptr;
   pe = p + strlen(p);
   
-#line 233 "parser.c"
+#line 260 "parser.c"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -289,7 +316,7 @@ st3:
 case 3:
 #line 1 "NONE"
 	{ts = p;}
-#line 293 "parser.c"
+#line 320 "parser.c"
 	switch( (*p) ) {
 		case 37: goto st4;
 		case 45: goto tr9;
@@ -311,7 +338,7 @@ st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 315 "parser.c"
+#line 342 "parser.c"
 	if ( (*p) == 37 )
 		goto st0;
 	goto tr11;
@@ -347,7 +374,7 @@ st8:
 	if ( ++p == pe )
 		goto _test_eof8;
 case 8:
-#line 351 "parser.c"
+#line 378 "parser.c"
 	if ( (*p) == 32 )
 		goto tr20;
 	if ( 97 <= (*p) && (*p) <= 122 )
@@ -361,7 +388,7 @@ st1:
 	if ( ++p == pe )
 		goto _test_eof1;
 case 1:
-#line 365 "parser.c"
+#line 392 "parser.c"
 	if ( (*p) == 32 )
 		goto st1;
 	if ( 97 <= (*p) && (*p) <= 122 )
@@ -381,7 +408,7 @@ st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 385 "parser.c"
+#line 412 "parser.c"
 	if ( (*p) == 32 )
 		goto tr5;
 	if ( 97 <= (*p) && (*p) <= 122 )
@@ -398,7 +425,7 @@ st9:
 	if ( ++p == pe )
 		goto _test_eof9;
 case 9:
-#line 402 "parser.c"
+#line 429 "parser.c"
 	if ( (*p) == 32 )
 		goto st9;
 	goto tr22;
@@ -432,6 +459,6 @@ case 9:
 
 	}
 
-#line 237 "parser.rl"
+#line 264 "parser.rl"
   erbal_parser_finish(parser);
 }

data/ext/erbal/parser.h

@@ -6,12 +6,13 @@
 typedef struct parser_state {
   unsigned int tag;
   unsigned int chars_seen;
-  unsigned int in_concat;
+  unsigned int concat;
+  char *chars_seen_start;
 } parser_state;
 
 typedef struct erbal_parser {
   parser_state *state;
-  unsigned int debug;
+  unsigned int debug, concat_methods_identical;
   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;
@@ -25,13 +26,14 @@ 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);
+inline void erbal_parser_tag_close_common(erbal_parser*);
 inline void erbal_parser_finish(erbal_parser*);
-inline void erbal_concat_chars_seen(erbal_parser*, int);
-inline void erbal_parser_tag_open_common(erbal_parser*, int);
+inline void erbal_concat_chars_seen(erbal_parser*);
+inline void erbal_parser_tag_open_common(erbal_parser*);
 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);
+inline void erbal_close_and_open_buffer_concat_if_needed(erbal_parser*, int);
+inline VALUE erbal_escape_special_chars(erbal_parser*);
 
 #define TAG_OPEN                    1
 #define TAG_OPEN_FOR_COMMENT        2
@@ -39,4 +41,8 @@ inline VALUE erbal_escape_special_chars(erbal_parser*, int);
 #define TAG_OPEN_FOR_UNSAFE_CONCAT  4
 #define OUTSIDE_TAG                 5
 
+#define SAFE_CONCAT     1
+#define UNSAFE_CONCAT   2
+#define OUTSIDE_CONCAT  3
+
 #endif

data/ext/erbal/parser.rl

@@ -35,29 +35,31 @@
 static char *ts, *te, *p, *pe, *eof;
 static int act, cs;
 
-inline void erbal_parser_tag_open_common(erbal_parser *parser, int shift) {
+inline void erbal_parser_tag_open_common(erbal_parser *parser) {
   if (parser->state->chars_seen != 0) {
-    if (!parser->state->in_concat) {
+    if (parser->state->concat == OUTSIDE_CONCAT) {
       erbal_open_buffer_concat(parser, 1);
+    } else if (parser->state->concat == UNSAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 1);
     }
 
-    erbal_concat_chars_seen(parser, shift);
+    erbal_concat_chars_seen(parser);
     parser->state->chars_seen = 0;
   }
 }
 
 inline void erbal_parser_tag_open(erbal_parser *parser) {
-  erbal_parser_tag_open_common(parser, -1);
+  erbal_parser_tag_open_common(parser);
   parser->state->tag = TAG_OPEN;
 }
 
 inline void erbal_parser_tag_open_with_dash(erbal_parser *parser) {
-  erbal_parser_tag_open_common(parser, -2);
+  erbal_parser_tag_open_common(parser);
   parser->state->tag = TAG_OPEN;
 }
 
 inline void erbal_parser_tag_open_choose_concat(erbal_parser *parser) {
-  if (strcmp(RSTRING(parser->keyword)->ptr, RSTRING(parser->safe_concat_keyword)->ptr) != 0) {
+  if (strcmp(RSTRING(parser->safe_concat_keyword)->ptr, "") == 0 || 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);
@@ -69,43 +71,51 @@ inline void erbal_parser_tag_open_choose_concat(erbal_parser *parser) {
 }
 
 inline void erbal_parser_tag_open_for_unsafe_concat(erbal_parser *parser) {
-  erbal_parser_tag_open_common(parser, -2);
+  erbal_parser_tag_open_common(parser);
   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);
+  erbal_parser_tag_open_common(parser);
   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);
+  erbal_parser_tag_open_common(parser);
   parser->state->tag = TAG_OPEN_FOR_COMMENT;
 }
 
 inline void erbal_parser_non_tag(erbal_parser *parser) {
+  if (parser->state->chars_seen == 0) {
+    parser->state->chars_seen_start = p;
+  }
+
   parser->state->chars_seen += 1;
 }
 
-inline void erbal_parser_tag_close_common(erbal_parser *parser, int tag_size) {
+inline void erbal_parser_tag_close_common(erbal_parser *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->concat == OUTSIDE_CONCAT) {
       if (parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
         erbal_open_buffer_concat(parser, 1);
       } else {
         erbal_open_buffer_concat(parser, 0);
       }
+    } else if (parser->state->concat == SAFE_CONCAT && parser->state->tag == TAG_OPEN_FOR_UNSAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 0);
+    } else if (parser->state->concat == UNSAFE_CONCAT && parser->state->tag == TAG_OPEN_FOR_SAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 1);
     }
 
     rb_str_buf_cat(parser->src, "#{", 2);
-    erbal_concat_chars_seen(parser, -tag_size);
+    erbal_concat_chars_seen(parser);
     rb_str_buf_cat(parser->src, "}", 1);
   } else if (parser->state->tag == TAG_OPEN) {
-    if (parser->state->in_concat) {
+    if (parser->state->concat != OUTSIDE_CONCAT) {
       erbal_close_buffer_concat(parser);
     }
 
-    erbal_concat_chars_seen(parser, -tag_size);
+    erbal_concat_chars_seen(parser);
     rb_str_buf_cat(parser->src, ";\n", 2);
   }
 
@@ -114,7 +124,7 @@ inline void erbal_parser_tag_close_common(erbal_parser *parser, int tag_size) {
 }
 
 inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
-  erbal_parser_tag_close_common(parser, 2);
+  erbal_parser_tag_close_common(parser);
 
   if (*(p + 1) == '\n') {
     p++;
@@ -122,16 +132,16 @@ inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
 }
 
 inline void erbal_parser_tag_close(erbal_parser *parser) {
-  erbal_parser_tag_close_common(parser, 1);
+  erbal_parser_tag_close_common(parser);
 }
 
-inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
+inline VALUE erbal_escape_special_chars(erbal_parser *parser) {
   VALUE buf = rb_str_buf_new(0);
   int i, n, slashes_seen = 0;
   char *current_char;
 
   for (i = 0; i < parser->state->chars_seen; i++) {
-    current_char = (((p + shift) - parser->state->chars_seen) + i);
+    current_char = (parser->state->chars_seen_start + i);
 
     if (*current_char == '#' || *current_char == '`') {
       if (slashes_seen == 0) {
@@ -156,48 +166,58 @@ inline VALUE erbal_escape_special_chars(erbal_parser *parser, int shift) {
   return buf;
 }
 
-inline void erbal_concat_chars_seen(erbal_parser *parser, int shift) {
+inline void erbal_concat_chars_seen(erbal_parser *parser) {
   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));
+    if (parser->state->concat != OUTSIDE_CONCAT && parser->state->tag == OUTSIDE_TAG) {
+      rb_str_concat(parser->src, erbal_escape_special_chars(parser));
     } else {
-    	rb_str_buf_cat(parser->src, ((p + shift) - parser->state->chars_seen), parser->state->chars_seen);
+    	rb_str_buf_cat(parser->src, parser->state->chars_seen_start, parser->state->chars_seen);
     }
   }
 
   parser->state->chars_seen = 0;
 }
 
+inline void erbal_close_and_open_buffer_concat_if_needed(erbal_parser *parser, int safe_concat) {
+  if (!parser->concat_methods_identical) {
+    erbal_close_buffer_concat(parser);
+    erbal_open_buffer_concat(parser, safe_concat);
+  }
+}
+
 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, ".", 1);
 
   if (safe_concat) {
     rb_str_concat(parser->src, parser->safe_concat_method);
+    parser->state->concat = SAFE_CONCAT;
   } else {
     rb_str_concat(parser->src, parser->unsafe_concat_method);
+    parser->state->concat = UNSAFE_CONCAT;
   }
 
   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_concat(erbal_parser *parser) {
   rb_str_buf_cat(parser->src, "`);", 3);
-  parser->state->in_concat = 0;
+  parser->state->concat = OUTSIDE_CONCAT;
 }
 
 inline void erbal_parser_finish(erbal_parser *parser) {
   if (parser->state->chars_seen != 0) {
-    if (!parser->state->in_concat) {
+    if (parser->state->concat == OUTSIDE_CONCAT) {
       erbal_open_buffer_concat(parser, 1);
+    } else if (parser->state->concat == UNSAFE_CONCAT) {
+      erbal_close_and_open_buffer_concat_if_needed(parser, 1);
     }
 
-    erbal_concat_chars_seen(parser, 0);
+    erbal_concat_chars_seen(parser);
   }
 
-  if (parser->state->in_concat) {
+  if (parser->state->concat != OUTSIDE_CONCAT) {
     erbal_close_buffer_concat(parser);
   }
 
@@ -210,8 +230,15 @@ inline void erbal_parser_finish(erbal_parser *parser) {
 
 void erbal_parser_init(VALUE self, erbal_parser *parser) {
   parser->state->chars_seen = 0;
-  parser->state->in_concat = 0;
+  parser->state->concat = OUTSIDE_CONCAT;
 	parser->state->tag = OUTSIDE_TAG;
+
+	if (strcmp(RSTRING(parser->safe_concat_method)->ptr, RSTRING(parser->unsafe_concat_method)->ptr) == 0) {
+    parser->concat_methods_identical = 1;
+	} else {
+	  parser->concat_methods_identical = 0;
+	}
+
   parser->src = rb_str_dup(parser->buffer_name);
 
   rb_iv_set(self, "@src", parser->src);

data/spec/erbal_spec.rb

@@ -141,11 +141,15 @@ describe Erbal do
     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"
+      erbal_parse("1 + 1 is <%= raw 1 + 1 %>", :unsafe_concat_method => 'unsafe_concat', :safe_concat_keyword => nil).should == "@output_buffer = '';@output_buffer.concat(%Q`1 + 1 is `);@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"
+      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 swallow the text preceding the safe concat" do
+      erbal_parse("omg don't eat me! <%= raw   1 + 1 %>", :safe_concat_method => 'safe_concat', :safe_concat_keyword => 'raw').should == "@output_buffer = '';@output_buffer.safe_concat(%Q`omg don't eat me! \#{   1 + 1 }`);@output_buffer"
     end
 
     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
@@ -153,7 +157,37 @@ describe Erbal do
     end
 
     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"
+      erbal_parse("omglololo <%=blah 1 + 1 %>", :unsafe_concat_method => 'unsafe_concat').should == "@output_buffer = '';@output_buffer.concat(%Q`omglololo `);@output_buffer.unsafe_concat(%Q`\#{blah 1 + 1 }`);@output_buffer"
+    end
+
+    it "should end the current safe concat and begin a new unsafe concat" do
+      erbal_parse("hello <%= \"world\" %>", :unsafe_concat_method => 'unsafe_concat', :safe_concat_method => 'safe_concat').should == "@output_buffer = '';@output_buffer.safe_concat(%Q`hello `);@output_buffer.unsafe_concat(%Q`\#{ \"world\" }`);@output_buffer"
+    end
+
+    it "should end the current unsafe concat and begin a new safe concat when at the end of the source" do
+      erbal_parse("<%= \"hello\" %> world", :unsafe_concat_method => 'unsafe_concat', :safe_concat_method => 'safe_concat').should == "@output_buffer = '';@output_buffer.unsafe_concat(%Q`\#{ \"hello\" }`);@output_buffer.safe_concat(%Q` world`);@output_buffer"
+    end
+
+    it "should end the current unsafe concat and begin a new safe concat when inbetween two unsafe concats" do
+      erbal_parse("<%= \"hello\" %> world <%= \"woot\" %>", :unsafe_concat_method => 'unsafe_concat', :safe_concat_method => 'safe_concat').should == "@output_buffer = '';@output_buffer.unsafe_concat(%Q`\#{ \"hello\" }`);@output_buffer.safe_concat(%Q` world `);@output_buffer.unsafe_concat(%Q`\#{ \"woot\" }`);@output_buffer"
+    end
+
+    describe "when preserving string interpolation optimizations if safe and unsafe concat methods are the same" do
+      it "should use interpolation if we switch from a safe concat to an unsafe concat" do
+        erbal_parse("hello <%= \"world\" %>", :unsafe_concat_method => 'concat', :safe_concat_method => 'concat').should == "@output_buffer = '';@output_buffer.concat(%Q`hello \#{ \"world\" }`);@output_buffer"
+      end
+
+      it "should use interpolation if we switch from an unsafe concat to a safe concat" do
+        erbal_parse("<%= \"hello\" %> world", :unsafe_concat_method => 'concat', :safe_concat_method => 'concat').should == "@output_buffer = '';@output_buffer.concat(%Q`\#{ \"hello\" } world`);@output_buffer"
+      end
+
+      it "should use interpolation if we switch from a safe concat to an unsafe concat and then back again" do
+        erbal_parse("hello <%= \"world\" %> woot", :unsafe_concat_method => 'concat', :safe_concat_method => 'concat').should == "@output_buffer = '';@output_buffer.concat(%Q`hello \#{ \"world\" } woot`);@output_buffer"
+      end
+
+      it "should use interpolation if we switch from an unsafe concat to a safe concat and then back again" do
+        erbal_parse("omg <%= \"hello\" %> world", :unsafe_concat_method => 'concat', :safe_concat_method => 'concat').should == "@output_buffer = '';@output_buffer.concat(%Q`omg \#{ \"hello\" } world`);@output_buffer"
+      end
     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.2.rc1'
+ERBAL_VERSION = '1.2.rc2'
 
 task :clean => :clobber_package
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: erbal
 version: !ruby/object:Gem::Version 
-  hash: 977940510
+  hash: 977940511
   prerelease: true
   segments: 
   - 1
   - 2
-  - rc1
-  version: 1.2.rc1
+  - rc2
+  version: 1.2.rc2
 platform: ruby
 authors: 
 - Ian Leitch