diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..f1d7f5e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+*.gem
+.DS_Store
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 0000000..cba44f6
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in cookie_store.gemspec
+gemspec
diff --git a/Gemfile.lock b/Gemfile.lock
new file mode 100644
index 0000000..d68b861
--- /dev/null
+++ b/Gemfile.lock
@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    ruby-ejs (1.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.2)
+    execjs (2.7.0)
+    minitest (5.11.3)
+    minitest-reporters (1.2.0)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    rake (12.3.1)
+    ruby-progressbar (1.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  execjs
+  minitest
+  minitest-reporters
+  rake
+  ruby-ejs!
+
+BUNDLED WITH
+   1.16.0
diff --git a/README.md b/README.md
index b5db320..437f31e 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-EJS (Embedded JavaScript) template compiler for Ruby
+EJS (Embedded JavaScript) template compiler for Ruby [![Circle CI](https://circleci.com/gh/malomalo/ruby-ejs.svg?style=svg)](https://circleci.com/gh/malomalo/ruby-ejs)
 ====================================================
 
 EJS templates embed JavaScript code inside `<% ... %>` tags, much like
@@ -25,6 +25,25 @@ The EJS tag syntax is as follows:
   its string value into the template output.
 * `<%- ... %>` behaves like `<%= ... %>` but HTML-escapes its output.
 
+If a evalation tag (`<%=`) ends with an open function, the function
+return a compiled template. For example:
+
+```erb
+<% formTag = function(template) { return '<form>\n'+template()+'\n</form>'; } %>
+
+<%= formTag(function () { %>
+  <input type="submit" />
+<% }) %>
+```
+
+generates:
+
+```html
+<form>
+  <input type="submit" />
+</form>
+```
+
 If you have the [ExecJS](https://github.com/sstephenson/execjs/)
 library and a suitable JavaScript runtime installed, you can pass a
 template and an optional hash of local variables to `EJS.evaluate`:
diff --git a/Rakefile b/Rakefile
index 2b9add8..67b47de 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,8 +1,10 @@
+require 'bundler/setup'
+require "bundler/gem_tasks"
 require "rake/testtask"
 
 task :default => :test
 
 Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.warning = true
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
 end
diff --git a/ejs.gemspec b/ejs.gemspec
deleted file mode 100644
index 7db0406..0000000
--- a/ejs.gemspec
+++ /dev/null
@@ -1,14 +0,0 @@
-Gem::Specification.new do |s|
-  s.name = "ejs"
-  s.version = "1.1.1"
-  s.summary = "EJS (Embedded JavaScript) template compiler"
-  s.description = "Compile and evaluate EJS (Embedded JavaScript) templates from Ruby."
-
-  s.files = Dir["README.md", "LICENSE", "lib/**/*.rb"]
-
-  s.add_development_dependency "execjs", "~> 0.4"
-
-  s.authors = ["Sam Stephenson"]
-  s.email = ["sstephenson@gmail.com"]
-  s.homepage = "https://github.com/sstephenson/ruby-ejs/"
-end
diff --git a/lib/ejs.rb b/lib/ejs.rb
index 686649a..140ae90 100644
--- a/lib/ejs.rb
+++ b/lib/ejs.rb
@@ -1,26 +1,28 @@
-# EJS (Embedded JavaScript) template compiler for Ruby
-# This is a port of Underscore.js' `_.template` function:
-# http://documentcloud.github.com/underscore/
-
 module EJS
-  JS_UNESCAPES = {
-    '\\' => '\\',
-    "'" => "'",
-    'r' => "\r",
-    'n' => "\n",
-    't' => "\t",
-    'u2028' => "\u2028",
-    'u2029' => "\u2029"
-  }
-  JS_ESCAPES = JS_UNESCAPES.invert
-  JS_UNESCAPE_PATTERN = /\\(#{Regexp.union(JS_UNESCAPES.keys)})/
-  JS_ESCAPE_PATTERN = Regexp.union(JS_ESCAPES.keys)
 
+  DEFAULTS = {
+    open_tag: '<%',
+    close_tag: '%>',
+    
+    open_tag_modifiers: {
+      escape: '=',
+      unescape: '-',
+      comment: '#',
+      literal: '%'
+    },
+  
+    close_tag_modifiers: {
+      trim: '-',
+      literal: '%'
+    },
+    
+    escape: nil
+  }
+  
+  ASSET_DIR = File.join(__dir__, 'ruby', 'ejs', 'assets')
+  
   class << self
-    attr_accessor :evaluation_pattern
-    attr_accessor :interpolation_pattern
-    attr_accessor :escape_pattern
-
+    
     # Compiles an EJS template to a JavaScript function. The compiled
     # function takes an optional argument, an object specifying local
     # variables in the template.  You can optionally pass the
@@ -31,71 +33,255 @@ class << self
     #     EJS.compile("Hello <%= name %>")
     #     # => "function(obj){...}"
     #
+    def transform(source, options = {})
+      options = default(options)
+      
+      output = if options[:escape]
+        "import {" + options[:escape].split('.').reverse.join(" as escape} from '") + "';\n"
+      else
+        "import {escape} from 'ejs';\n"
+      end
+      
+      fs = function_source(source, options)
+      output << fs[1]
+      output << "export default function (locals) {\n"
+      output << fs[0]
+      output << "}"
+
+      output
+    end
+
     def compile(source, options = {})
-      source = source.dup
-
-      js_escape!(source)
-      replace_escape_tags!(source, options)
-      replace_interpolation_tags!(source, options)
-      replace_evaluation_tags!(source, options)
-      "function(obj){var __p=[],print=function(){__p.push.apply(__p,arguments);};" +
-        "with(obj||{}){__p.push('#{source}');}return __p.join('');}"
+      options = default(options)
+      
+      output = "function(locals, escape) {\n"
+      output << function_source(source, options)[0]
+      output << "}"
+      output
     end
 
+
     # Evaluates an EJS template with the given local variables and
     # compiler options. You will need the ExecJS
     # (https://github.com/sstephenson/execjs/) library and a
     # JavaScript runtime available.
     #
-    #     EJS.evaluate("Hello <%= name %>", :name => "world")
+    #     EJS.evaluate("Hello <%= name %>", name: "world")
     #     # => "Hello world"
     #
     def evaluate(template, locals = {}, options = {})
       require "execjs"
-      context = ExecJS.compile("var evaluate = #{compile(template, options)}")
+      context = ExecJS.compile(<<-JS)
+        #{escape_function}
+        
+        var template = #{compile(template, options)}
+        var evaluate = function(locals) {
+          return template(locals, escape);
+        }
+      JS
       context.call("evaluate", locals)
     end
 
     protected
-      def js_escape!(source)
-        source.gsub!(JS_ESCAPE_PATTERN) { |match| '\\' + JS_ESCAPES[match] }
-        source
+    
+      def default(options)
+        options = DEFAULTS.merge(options)
+      
+        [:open_tag_modifiers, :close_tag_modifiers].each do |k|
+          DEFAULTS[k].each do |sk, v|
+            next if options[k].has_key?(sk)
+            options[k] = v
+          end
+        end
+      
+        options
       end
 
-      def js_unescape!(source)
-        source.gsub!(JS_UNESCAPE_PATTERN) { |match| JS_UNESCAPES[match[1..-1]] }
-        source
+      def escape_module
+        escape_function.sub('function', 'export function')
       end
 
-      def replace_escape_tags!(source, options)
-        source.gsub!(options[:escape_pattern] || escape_pattern) do
-          "',(''+#{js_unescape!($1)})#{escape_function},'"
-        end
+      def escape_function(name='escape')
+        <<-JS
+          function #{name}(string) {
+            if (string !== undefined && string != null) {
+              return String(string).replace(/[&<>'"\\/]/g, function (c) {
+                return '&#' + c.codePointAt(0) + ';';
+              });
+            } else {
+              return '';
+            }
+          }
+        JS
       end
+      
+      def chars_balanced?(str, chars)
+        a = chars[0]
+        b = chars[1]
+        str = str.sub(/"(\\.|[^"])+"/, '')
+        str = str.sub(/'(\\.|[^'])+'/, '')
+        a_count = str.scan(/#{a}/).length
+        b_count = str.scan(/#{b}/).length
+      
+        a_count - b_count
+      end
+    
+
+      def digest(source, options)
+        open_tag_count = 0
+        close_tag_count = 0
+        tag_length = nil
+        # var index, tagType, tagModifier, tagModifiers, matchingModifier, prefix;
+        index = nil
+        tag_type = nil
+        tag_modifiers = nil
+        tag_modifier = nil
+        prefix =nil
+        matching_modifier = nil
+        last_tag_modifier = nil
+        next_open_index = source.index(options[:open_tag])
+        next_close_index = source.index(options[:close_tag])
+  
+        while next_open_index || next_close_index
+          if (next_close_index && (!next_open_index || next_close_index < next_open_index))
+            index = next_close_index
+            tag_type = :close
+            tag_length = options[:close_tag].length
+            tag_modifiers = options[:close_tag_modifiers]
+            close_tag_count += 1
+            matching_modifier = tag_modifiers.find do |k, v|
+              source[index - v.length, v.length] == v
+            end
+          else
+            index = next_open_index
+            tag_type = :open
+            tag_length = options[:open_tag].length
+            tag_modifiers = options[:open_tag_modifiers]
+            open_tag_count += 1
+            matching_modifier = tag_modifiers.find do |k, v|
+              source[index + tag_length, v.length] == v
+            end
+          end
+
+          if matching_modifier
+            tag_length += matching_modifier[1].length
+            tag_modifier = matching_modifier[0]
+          else
+            tag_modifier = :default
+          end
+
+          if tag_modifier == :literal
+            if tag_type == :open
+              source = source[0, tag_length - matching_modifier[1].length] + source[(index + tag_length)..-1]
+              # source = source.slice(0, index + tagLength - matchingModifier[1].length) + source.slice(index + tagLength);
+              open_tag_count -= 1
+            else
+              close_tag_count -= 1
+              if index == 0
+                source = source[(index + matching_modifier[1].length)..-1]
+              else
+                source = source[0..index] + source[(index + matching_modifier[1].length)..-1]
+              end
+            end
+
+            next_open_index = source.index(options.openTag, index + tag_length - matching_modifier[1].length);
+            next_close_index = source.index(options.closeTag, index + tag_length - matching_modifier[1].length);
+            next
+          end
+    
+          if index != 0
+            if tag_type == :close
+              if matching_modifier
+                yield(source[0...(matching_modifier[1].length)], :js, last_tag_modifier)
+              else
+                yield(source[0...index], :js, last_tag_modifier)
+              end
+            else
+              yield(source[0...index], :text, last_tag_modifier)
+            end
+      
+            source = source[index..-1]
+          end
 
-      def replace_evaluation_tags!(source, options)
-        source.gsub!(options[:evaluation_pattern] || evaluation_pattern) do
-          "'); #{js_unescape!($1)}; __p.push('"
+          if tag_type == :close && matching_modifier
+            source = source[(tag_length - matching_modifier[1].length)..-1]
+            source.lstrip!
+          else
+            source = source[tag_length..-1]
+          end
+          next_open_index = source.index(options[:open_tag])
+          next_close_index = source.index(options[:close_tag])
+          last_tag_modifier = tag_modifier
         end
+      
+        if open_tag_count != close_tag_count
+          raise "Could not find closing tag for \"#{options[(tag_type.to_s + '_tag').to_sym]}\"."
+        end
+  
+        yield(source, :text, tag_modifier)
       end
 
-      def replace_interpolation_tags!(source, options)
-        source.gsub!(options[:interpolation_pattern] || interpolation_pattern) do
-          "', #{js_unescape!($1)},'"
+
+      def function_source(source, options)
+        stack = []
+        imports = ""
+        output =  "    var __output = [], __append = __output.push.bind(__output);\n"
+        output << "    with (locals || {}) {\n" unless options[:strict]
+
+        digest(source, options) do |segment, type, modifier|
+          if type == :js
+            if segment.match(/\A\s*\}.*\{\s*\Z/m)
+              output << "        " << segment << "\n"
+            elsif segment.match(/\A\s*\}/m)
+              case stack.pop
+              when :escape
+                output << "\n            return __output.join(\"\");\n"
+                output << segment << "        ));\n"
+              when :unescape
+                output << "\n            return __output.join(\"\");\n"
+                output << segment << "        );\n"
+              else
+                output << "        " << segment << "\n"
+              end
+            elsif segment.match(/\)\s*\{\s*\Z/m)
+              stack << modifier
+              case modifier
+              when :escape
+                output << "        __append(escape(" << segment
+                output << "\n            var __output = [], __append = __output.push.bind(__output);\n"
+              when :unescape
+                output << "        __append(" << segment
+                output << "\n            var __output = [], __append = __output.push.bind(__output);\n"
+              else
+                output << "        " << segment << "\n"
+              end
+            else
+              case modifier
+              when :escape
+                output << "        __append(escape(" << segment << "));\n"
+              when :unescape
+                output << "        __append(" << segment << ");\n"
+              else
+                if segment =~ /\A\s*import/
+                  imports << segment.strip
+                  imports << ';' unless segment =~ /;\s*\Z/
+                  imports << "\n"
+                else
+                  output << "        " << segment << "\n"
+                end
+              end
+            end
+          elsif segment.length > 0
+            output << '        __append("' + segment.gsub("\\"){"\\\\"}.gsub(/\n/, '\\n').gsub(/\r/, '\\r').gsub('"', '\\"') + "\");\n"
+          end
         end
-      end
 
-      def escape_function
-        ".replace(/&/g, '&amp;')" +
-        ".replace(/</g, '&lt;')" +
-        ".replace(/>/g, '&gt;')" +
-        ".replace(/\"/g, '&quot;')" +
-        ".replace(/'/g, '&#x27;')" +
-        ".replace(/\\//g,'&#x2F;')"
+        output << "    }\n" unless options[:strict]
+        output << "    return __output.join(\"\");\n"
+        imports << "\n"
+        
+        [output, imports]
       end
+      
   end
-
-  self.evaluation_pattern = /<%([\s\S]+?)%>/
-  self.interpolation_pattern = /<%=([\s\S]+?)%>/
-  self.escape_pattern = /<%-([\s\S]+?)%>/
 end
diff --git a/lib/ruby/ejs.rb b/lib/ruby/ejs.rb
new file mode 100644
index 0000000..4ddb7e9
--- /dev/null
+++ b/lib/ruby/ejs.rb
@@ -0,0 +1 @@
+require File.expand_path(File.join(__dir__, '..', 'ejs'))
\ No newline at end of file
diff --git a/lib/ruby/ejs/assets/ejs.js b/lib/ruby/ejs/assets/ejs.js
new file mode 100644
index 0000000..f7714b8
--- /dev/null
+++ b/lib/ruby/ejs/assets/ejs.js
@@ -0,0 +1,9 @@
+export function escape(string) {
+    if (string !== undefined && string != null) {
+        return String(string).replace(/[&<>'"\\/]/g, function (c) {
+            return '&#' + c.codePointAt(0) + ';';
+        });
+    } else {
+        return '';
+    }
+}
\ No newline at end of file
diff --git a/ruby-ejs.gemspec b/ruby-ejs.gemspec
new file mode 100644
index 0000000..a08b3e9
--- /dev/null
+++ b/ruby-ejs.gemspec
@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name = "ruby-ejs"
+  s.version = "1.2.0"
+  s.licenses    = ['MIT']
+  s.summary = "EJS (Embedded JavaScript) template compiler"
+  s.description = "Compile EJS (Embedded JavaScript) templates in Ruby."
+
+  s.files = Dir["README.md", "LICENSE", "lib/**/*.{rb,js}"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "minitest-reporters"
+  s.add_development_dependency "execjs"
+
+  s.authors = ["Jonathan Bracy"]
+  s.email = ["jonbracy@gmail.com"]
+  s.homepage = "https://github.com/malomalo/ruby-ejs"
+end
\ No newline at end of file
diff --git a/test/compilation_test.rb b/test/compilation_test.rb
new file mode 100644
index 0000000..96ec7fb
--- /dev/null
+++ b/test/compilation_test.rb
@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class CompilationTest < Minitest::Test
+  
+  test "compile" do
+    result = EJS.compile("Hello <%= name %>")
+    
+    assert_match FUNCTION_PATTERN, result
+    assert_no_match(/Hello \<%= name %\>/, result)
+    assert_equal(<<~JS.strip, result)
+      function(locals, escape) {
+          var __output = [], __append = __output.push.bind(__output);
+          with (locals || {}) {
+              __append("Hello ");
+              __append(escape( name ));
+          }
+          return __output.join("");
+      }
+    JS
+  end
+  
+end
diff --git a/test/custom_pattern_test.rb b/test/custom_pattern_test.rb
new file mode 100644
index 0000000..40564bc
--- /dev/null
+++ b/test/custom_pattern_test.rb
@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class CustomPatternTest < Minitest::Test
+
+  test "compile with custom defults" do
+    old_defaults = EJS::DEFAULTS
+    EJS::DEFAULTS = {
+      open_tag: '{{',
+      close_tag: '}}',
+  
+      open_tag_modifiers: {
+        escape: '=',
+        unescape: '-',
+        comment: '#',
+        literal: '%'
+      },
+
+      close_tag_modifiers: {
+        trim: '-',
+        literal: '%'
+      },
+  
+      escape: nil
+    }
+
+    result = EJS.compile("Hello {{= name }}")
+    assert_equal(<<~JS.strip, result)
+      function(locals, escape) {
+          var __output = [], __append = __output.push.bind(__output);
+          with (locals || {}) {
+              __append("Hello ");
+              __append(escape( name ));
+          }
+          return __output.join("");
+      }
+    JS
+  ensure
+    EJS::DEFAULTS = old_defaults
+  end
+
+  test "compile with custom syntax" do
+    standard_result = EJS.compile("Hello <%= name %>")
+    question_result = EJS.compile("Hello <?= name ?>", open_tag: '<?', close_tag: '?>')
+    assert_equal standard_result, question_result
+  end
+end
\ No newline at end of file
diff --git a/test/evaluation_test.rb b/test/evaluation_test.rb
new file mode 100644
index 0000000..5defd12
--- /dev/null
+++ b/test/evaluation_test.rb
@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class EvaluationTest < Minitest::Test
+
+  test "quotes" do
+    template = "<%= thing %> is gettin' on my noives!"
+    assert_equal "This is gettin' on my noives!", EJS.evaluate(template, thing: "This")
+  end
+
+  test "backslashes" do
+    template = "<%= thing %> is \\ridanculous"
+    assert_equal "This is \\ridanculous", EJS.evaluate(template, thing: "This")
+  end
+
+  test "backslashes into interpolation" do
+    template = %q{<%- "Hello \"World\"" %>}
+    assert_equal 'Hello "World"', EJS.evaluate(template)
+  end
+
+  test "implicit semicolon" do
+    template = "<% var foo = 'bar' %>"
+    assert_equal '', EJS.evaluate(template)
+  end
+
+  test "iteration" do
+    template = "<ul><%
+      for (var i = 0; i < people.length; i++) {
+    %><li><%= people[i] %></li><% } %></ul>"
+    result = EJS.evaluate(template, people: %w[Moe Larry Curly])
+    assert_equal "<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>", result
+  end
+
+  test "without interpolation" do
+    template = "<div><p>Just some text. Hey, I know this is silly but it aids consistency.</p></div>"
+    assert_equal template, EJS.evaluate(template)
+  end
+
+  test "two quotes" do
+    template = "It's its, not it's"
+    assert_equal template, EJS.evaluate(template)
+  end
+
+  test "quote in statement and body" do
+    template = "<%
+      if(foo == 'bar'){
+    %>Statement quotes and 'quotes'.<% } %>"
+    assert_equal "Statement quotes and 'quotes'.", EJS.evaluate(template, :foo => "bar")
+  end
+
+  test "newlines and tabs" do
+    template = "This\n\t\tis: <%= x %>.\n\tok.\nend."
+    assert_equal "This\n\t\tis: that.\n\tok.\nend.", EJS.evaluate(template, :x => "that")
+  end
+
+  test "escaping" do
+    template = "<%= foobar %>"
+    assert_equal "&#60;b&#62;Foo Bar&#60;&#47;b&#62;", EJS.evaluate(template, foobar: "<b>Foo Bar</b>")
+
+    template = "<%= foobar %>"
+    assert_equal "Foo &#38; Bar", EJS.evaluate(template, { :foobar => "Foo & Bar" })
+
+    template = "<%= foobar %>"
+    assert_equal "&#34;Foo Bar&#34;", EJS.evaluate(template, { :foobar => '"Foo Bar"' })
+
+    template = "<%= foobar %>"
+    assert_equal "&#39;Foo Bar&#39;", EJS.evaluate(template, { :foobar => "'Foo Bar'" })
+  end
+
+end
\ No newline at end of file
diff --git a/test/import_test.rb b/test/import_test.rb
new file mode 100644
index 0000000..bbb675d
--- /dev/null
+++ b/test/import_test.rb
@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class ImportTest < Minitest::Test
+
+  test "quotes" do
+    template = <<-DATA
+      <% import x from y %>
+      <% import a from z %>
+      
+      <% formTag = function(template) { return '<form>\\n'+template()+'\\n</form>'; } %>
+
+      <%- formTag(function () { %>
+        <input type="submit" />
+      <% }) %>
+    DATA
+
+    assert_equal <<~DATA.strip, EJS.transform(template)
+    import {escape} from 'ejs';
+    import x from y;
+    import a from z;
+
+    export default function (locals) {
+        var __output = [], __append = __output.push.bind(__output);
+        with (locals || {}) {
+            __append("      ");
+            __append("\\n      ");
+            __append("\\n      \\n      ");
+             formTag = function(template) { return '<form>\\n'+template()+'\\n</form>'; } 
+            __append("\\n\\n      ");
+            __append( formTag(function () { 
+                var __output = [], __append = __output.push.bind(__output);
+            __append("\\n        <input type=\\"submit\\" />\\n      ");
+
+                return __output.join("");
+     })         );
+            __append("\\n");
+        }
+        return __output.join("");
+    }
+    DATA
+  end
+  
+end
\ No newline at end of file
diff --git a/test/subtemplate_test.rb b/test/subtemplate_test.rb
new file mode 100644
index 0000000..ceae0b6
--- /dev/null
+++ b/test/subtemplate_test.rb
@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class SubtemplateTest < Minitest::Test
+
+  test "quotes" do
+    template = <<-DATA
+      <% formTag = function(template) { return '<form>\\n'+template()+'\\n</form>'; } %>
+
+      <%- formTag(function () { %>
+        <input type="submit" />
+      <% }) %>
+    DATA
+
+    assert_equal <<-DATA, EJS.evaluate(template)
+      
+
+      <form>
+
+        <input type=\"submit\" />
+      
+</form>
+    DATA
+  end
+  
+  test "with an else" do
+    template = <<-DATA
+      <% formTag = function(template) { return '<form>\\n'+template()+'\\n</form>'; } %>
+      
+      <%- formTag(function (f) { %>
+          <% if (true) { %>
+              yes
+          <% } else { %>
+              no
+          <% } %>
+      <% }) %>
+    DATA
+
+    assert_equal <<-DATA, EJS.evaluate(template)
+      
+      
+      <form>
+
+          
+              yes
+          
+      
+</form>
+    DATA
+  end
+
+  
+end
\ No newline at end of file
diff --git a/test/test_ejs.rb b/test/test_ejs.rb
deleted file mode 100644
index ed760da..0000000
--- a/test/test_ejs.rb
+++ /dev/null
@@ -1,200 +0,0 @@
-require "ejs"
-require "test/unit"
-
-FUNCTION_PATTERN = /^function\s*\(.*?\)\s*\{(.*?)\}$/
-
-BRACE_SYNTAX = {
-  :evaluation_pattern    => /\{\{([\s\S]+?)\}\}/,
-  :interpolation_pattern => /\{\{=([\s\S]+?)\}\}/,
-  :escape_pattern        => /\{\{-([\s\S]+?)\}\}/
-}
-
-QUESTION_MARK_SYNTAX = {
-  :evaluation_pattern    => /<\?([\s\S]+?)\?>/,
-  :interpolation_pattern => /<\?=([\s\S]+?)\?>/,
-  :escape_pattern        => /<\?-([\s\S]+?)\?>/
-}
-
-module TestHelper
-  def test(name, &block)
-    define_method("test #{name.inspect}", &block)
-  end
-end
-
-class EJSCompilationTest < Test::Unit::TestCase
-  extend TestHelper
-
-  test "compile" do
-    result = EJS.compile("Hello <%= name %>")
-    assert_match FUNCTION_PATTERN, result
-    assert_no_match(/Hello \<%= name %\>/, result)
-  end
-
-  test "compile with custom syntax" do
-    standard_result = EJS.compile("Hello <%= name %>")
-    braced_result   = EJS.compile("Hello {{= name }}", BRACE_SYNTAX)
-
-    assert_match FUNCTION_PATTERN, braced_result
-    assert_equal standard_result, braced_result
-  end
-end
-
-class EJSCustomPatternTest < Test::Unit::TestCase
-  extend TestHelper
-
-  def setup
-    @original_evaluation_pattern = EJS.evaluation_pattern
-    @original_interpolation_pattern = EJS.interpolation_pattern
-    EJS.evaluation_pattern = BRACE_SYNTAX[:evaluation_pattern]
-    EJS.interpolation_pattern = BRACE_SYNTAX[:interpolation_pattern]
-  end
-
-  def teardown
-    EJS.interpolation_pattern = @original_interpolation_pattern
-    EJS.evaluation_pattern = @original_evaluation_pattern
-  end
-
-  test "compile" do
-    result = EJS.compile("Hello {{= name }}")
-    assert_match FUNCTION_PATTERN, result
-    assert_no_match(/Hello \{\{= name \}\}/, result)
-  end
-
-  test "compile with custom syntax" do
-    standard_result = EJS.compile("Hello {{= name }}")
-    question_result = EJS.compile("Hello <?= name ?>", QUESTION_MARK_SYNTAX)
-
-    assert_match FUNCTION_PATTERN, question_result
-    assert_equal standard_result, question_result
-  end
-end
-
-class EJSEvaluationTest < Test::Unit::TestCase
-  extend TestHelper
-
-  test "quotes" do
-    template = "<%= thing %> is gettin' on my noives!"
-    assert_equal "This is gettin' on my noives!", EJS.evaluate(template, :thing => "This")
-  end
-
-  test "backslashes" do
-    template = "<%= thing %> is \\ridanculous"
-    assert_equal "This is \\ridanculous", EJS.evaluate(template, :thing => "This")
-  end
-
-  test "backslashes into interpolation" do
-    template = %q{<%= "Hello \"World\"" %>}
-    assert_equal 'Hello "World"', EJS.evaluate(template)
-  end
-
-  test "implicit semicolon" do
-    template = "<% var foo = 'bar' %>"
-    assert_equal '', EJS.evaluate(template)
-  end
-
-  test "iteration" do
-    template = "<ul><%
-      for (var i = 0; i < people.length; i++) {
-    %><li><%= people[i] %></li><% } %></ul>"
-    result = EJS.evaluate(template, :people => ["Moe", "Larry", "Curly"])
-    assert_equal "<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>", result
-  end
-
-  test "without interpolation" do
-    template = "<div><p>Just some text. Hey, I know this is silly but it aids consistency.</p></div>"
-    assert_equal template, EJS.evaluate(template)
-  end
-
-  test "two quotes" do
-    template = "It's its, not it's"
-    assert_equal template, EJS.evaluate(template)
-  end
-
-  test "quote in statement and body" do
-    template = "<%
-      if(foo == 'bar'){
-    %>Statement quotes and 'quotes'.<% } %>"
-    assert_equal "Statement quotes and 'quotes'.", EJS.evaluate(template, :foo => "bar")
-  end
-
-  test "newlines and tabs" do
-    template = "This\n\t\tis: <%= x %>.\n\tok.\nend."
-    assert_equal "This\n\t\tis: that.\n\tok.\nend.", EJS.evaluate(template, :x => "that")
-  end
-
-
-  test "braced iteration" do
-    template = "<ul>{{ for (var i = 0; i < people.length; i++) { }}<li>{{= people[i] }}</li>{{ } }}</ul>"
-    result = EJS.evaluate(template, { :people => ["Moe", "Larry", "Curly"] }, BRACE_SYNTAX)
-    assert_equal "<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>", result
-  end
-
-  test "braced quotes" do
-    template = "It's its, not it's"
-    assert_equal template, EJS.evaluate(template, {}, BRACE_SYNTAX)
-  end
-
-  test "braced quotes in statement and body" do
-    template = "{{ if(foo == 'bar'){ }}Statement quotes and 'quotes'.{{ } }}"
-    assert_equal "Statement quotes and 'quotes'.", EJS.evaluate(template, { :foo => "bar" }, BRACE_SYNTAX)
-  end
-
-
-  test "question-marked iteration" do
-    template = "<ul><? for (var i = 0; i < people.length; i++) { ?><li><?= people[i] ?></li><? } ?></ul>"
-    result = EJS.evaluate(template, { :people => ["Moe", "Larry", "Curly"] }, QUESTION_MARK_SYNTAX)
-    assert_equal "<ul><li>Moe</li><li>Larry</li><li>Curly</li></ul>", result
-  end
-
-  test "question-marked quotes" do
-    template = "It's its, not it's"
-    assert_equal template, EJS.evaluate(template, {}, QUESTION_MARK_SYNTAX)
-  end
-
-  test "question-marked quote in statement and body" do
-    template = "<? if(foo == 'bar'){ ?>Statement quotes and 'quotes'.<? } ?>"
-    assert_equal "Statement quotes and 'quotes'.", EJS.evaluate(template, { :foo => "bar" }, QUESTION_MARK_SYNTAX)
-  end
-
-  test "escaping" do
-    template = "<%- foobar %>"
-    assert_equal "&lt;b&gt;Foo Bar&lt;&#x2F;b&gt;", EJS.evaluate(template, { :foobar => "<b>Foo Bar</b>" })
-
-    template = "<%- foobar %>"
-    assert_equal "Foo &amp; Bar", EJS.evaluate(template, { :foobar => "Foo & Bar" })
-
-    template = "<%- foobar %>"
-    assert_equal "&quot;Foo Bar&quot;", EJS.evaluate(template, { :foobar => '"Foo Bar"' })
-
-    template = "<%- foobar %>"
-    assert_equal "&#x27;Foo Bar&#x27;", EJS.evaluate(template, { :foobar => "'Foo Bar'" })
-  end
-
-  test "braced escaping" do
-    template = "{{- foobar }}"
-    assert_equal "&lt;b&gt;Foo Bar&lt;&#x2F;b&gt;", EJS.evaluate(template, { :foobar => "<b>Foo Bar</b>" }, BRACE_SYNTAX)
-
-    template = "{{- foobar }}"
-    assert_equal "Foo &amp; Bar", EJS.evaluate(template, { :foobar => "Foo & Bar" }, BRACE_SYNTAX)
-
-    template = "{{- foobar }}"
-    assert_equal "&quot;Foo Bar&quot;", EJS.evaluate(template, { :foobar => '"Foo Bar"' }, BRACE_SYNTAX)
-
-    template = "{{- foobar }}"
-    assert_equal "&#x27;Foo Bar&#x27;", EJS.evaluate(template, { :foobar => "'Foo Bar'" }, BRACE_SYNTAX)
-  end
-
-  test "question-mark escaping" do
-    template = "<?- foobar ?>"
-    assert_equal "&lt;b&gt;Foo Bar&lt;&#x2F;b&gt;", EJS.evaluate(template, { :foobar => "<b>Foo Bar</b>" }, QUESTION_MARK_SYNTAX)
-
-    template = "<?- foobar ?>"
-    assert_equal "Foo &amp; Bar", EJS.evaluate(template, { :foobar => "Foo & Bar" }, QUESTION_MARK_SYNTAX)
-
-    template = "<?- foobar ?>"
-    assert_equal "&quot;Foo Bar&quot;", EJS.evaluate(template, { :foobar => '"Foo Bar"' }, QUESTION_MARK_SYNTAX)
-
-    template = "<?- foobar ?>"
-    assert_equal "&#x27;Foo Bar&#x27;", EJS.evaluate(template, { :foobar => "'Foo Bar'" }, QUESTION_MARK_SYNTAX)
-  end
-end
diff --git a/test/test_helper.rb b/test/test_helper.rb
new file mode 100644
index 0000000..cd02c7f
--- /dev/null
+++ b/test/test_helper.rb
@@ -0,0 +1,104 @@
+require "minitest/autorun"
+require 'minitest/reporters'
+require "ejs"
+
+FUNCTION_PATTERN = /\A\s*function\s*\(.*?\)\s*\{(.*?)\}\Z/m
+
+BRACE_SYNTAX = {
+  :evaluation_pattern    => /\{\{([\s\S]+?)\}\}/,
+  :interpolation_pattern => /\{\{=([\s\S]+?)\}\}/,
+  :escape_pattern        => /\{\{-([\s\S]+?)\}\}/,
+  :interpolation_with_subtemplate_pattern => %r{
+    \{\{=(?<start>(?:(?!\}\})[\s\S])+\{)\s*\}\}
+    (?<middle>
+    (
+      (?<re>
+        \{\{=?(?:(?!\}\})[\s\S])+\{\s*\}\}
+        (?:
+          \{\{\s*\}(?:(?!\{\s*\}\})[\s\S])+\{\s*\}\}
+          |
+          \g<re>
+          |
+          .{1}
+        )*?
+        \{\{\s*\}[^\{]+?\}\}
+      )
+      |
+      .{1}
+    )*?
+    )
+    \{\{\s*(?<end>\}[\s\S]+?)\}\}
+  }xm
+}
+
+QUESTION_MARK_SYNTAX = {
+  :evaluation_pattern    => /<\?([\s\S]+?)\?>/,
+  :interpolation_pattern => /<\?=([\s\S]+?)\?>/,
+  :escape_pattern        => /<\?-([\s\S]+?)\?>/,
+  :interpolation_with_subtemplate_pattern => %r{
+    <\?=(?<start>(?:(?!\?>)[\s\S])+\{)\s*\?>
+    (?<middle>
+    (
+      (?<re>
+        <\?=?(?:(?!\?>)[\s\S])+\{\s*\?>
+        (?:
+          <\?\s*\}(?:(?!\{\s*\?>)[\s\S])+\{\s*\?>
+          |
+          \g<re>
+          |
+          .{1}
+        )*?
+        <\?\s*\}[^\{]+?\?>
+      )
+      |
+      .{1}
+    )*?
+    )
+    <\?\s*(?<end>\}[\s\S]+?)\?>
+  }xm
+
+}
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+# File 'lib/active_support/testing/declarative.rb', somewhere in rails....
+class Minitest::Test
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+
+  # test/unit backwards compatibility methods
+  alias :assert_raise :assert_raises
+  alias :assert_not_empty :refute_empty
+  alias :assert_not_equal :refute_equal
+  alias :assert_not_in_delta :refute_in_delta
+  alias :assert_not_in_epsilon :refute_in_epsilon
+  alias :assert_not_includes :refute_includes
+  alias :assert_not_instance_of :refute_instance_of
+  alias :assert_not_kind_of :refute_kind_of
+  alias :assert_no_match :refute_match
+  alias :assert_not_nil :refute_nil
+  alias :assert_not_operator :refute_operator
+  alias :assert_not_predicate :refute_predicate
+  alias :assert_not_respond_to :refute_respond_to
+  alias :assert_not_same :refute_same
+
+  # Fails if the block raises an exception.
+  #
+  #   assert_nothing_raised do
+  #     ...
+  #   end
+  def assert_nothing_raised(*args)
+    yield
+  end
+    
+end
\ No newline at end of file