vagrant-unbundled 2.2.6.1 → 2.2.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3877d5536d61bcd8f8dfb66eb3154c25dce4dba2807a15b957335079e2e8d931
-  data.tar.gz: c39816ad0bda48892e90cf770fad896292c5d3a5e75566d14ee8059294dd1102
+  metadata.gz: 9bbf0332bbe6ca456380199ded15ef9328a2ebaa00f92ba7d112fb4c5b43bf15
+  data.tar.gz: 5a524b4d511179f37c729faa12a9af27b622783a0298815e5527575f51a0e0ed
 SHA512:
-  metadata.gz: 59b28f25f056aa10909d0226d4cc38a19fe6568f75602f1e3820a91b70c3d0048356df7038c0192e9ad3f0fa50dd754c6b896d599c22733576cd4130bd3635ea
-  data.tar.gz: af8e6cfffaa0e1bfe4fd8df9f315200ac376064471c1b45e3e31fcad0fb54133ed2d9e00e0226b812e4c167fe04e7f9d86156e4cb9095d8189ccd1b89dfffa27
+  metadata.gz: fc695c903cb52ca50c9d50530c0d461164210608d2ffae6961a00d252606dbcf2b5cc4b8cc9124bad784b7e655b980939c694dfce6e8dbf2ef2ac9475fac77fd
+  data.tar.gz: 9fabb62a9cdd8fb3070de6b6a0488e55216578725b802be4933f45dd65704a9564bc0885c4647abf7a3e6aac4a3f848d855702c735a3ba380c38c09b3dab658a

data/Gemfile.lock

@@ -11,7 +11,7 @@ GIT
 PATH
   remote: .
   specs:
-    vagrant-unbundled (2.2.6.1)
+    vagrant-unbundled (2.2.6.2)
       bcrypt_pbkdf (~> 1.0.0)
       childprocess (~> 0.6.0)
       ed25519 (~> 1.2.4)
@@ -26,7 +26,7 @@ PATH
       rb-kqueue (~> 0.2.0)
       rest-client (>= 1.6.0, < 3.0)
       ruby_dep (<= 1.3.1)
-      rubyzip (~> 1.2.2)
+      rubyzip
       vagrant_cloud (~> 2.0.3)
       wdm (~> 0.1.0)
       winrm (~> 2.1)
@@ -49,6 +49,7 @@ GEM
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
     ed25519 (1.2.4)
+    erubi (1.9.0)
     erubis (2.7.0)
     fake_ftp (0.1.1)
     ffi (1.11.1)
@@ -112,7 +113,7 @@ GEM
     rspec-support (3.5.0)
     ruby_dep (1.3.1)
     rubyntlm (0.6.2)
-    rubyzip (1.2.4)
+    rubyzip (2.0.0)
     safe_yaml (1.0.5)
     thor (0.18.1)
     unf (0.1.4)
@@ -125,22 +126,23 @@ GEM
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
       hashdiff
-    winrm (2.3.2)
+    winrm (2.3.3)
       builder (>= 2.1.2)
-      erubis (~> 2.7)
+      erubi (~> 1.8)
       gssapi (~> 1.2)
       gyoku (~> 1.0)
       httpclient (~> 2.2, >= 2.2.0.2)
       logging (>= 1.6.1, < 3.0)
       nori (~> 2.0)
       rubyntlm (~> 0.6.0, >= 0.6.1)
-    winrm-elevated (1.1.1)
+    winrm-elevated (1.1.2)
+      erubi (~> 1.8)
       winrm (~> 2.0)
       winrm-fs (~> 1.0)
-    winrm-fs (1.3.2)
-      erubis (~> 2.7)
+    winrm-fs (1.3.4)
+      erubi (~> 1.8)
       logging (>= 1.6.1, < 3.0)
-      rubyzip (~> 1.1)
+      rubyzip (~> 2.0)
       winrm (~> 2.0)
 
 PLATFORMS

data/vagrant.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.add_dependency "net-scp", "~> 1.2.0"
   s.add_dependency "rb-kqueue", "~> 0.2.0"
   s.add_dependency "rest-client", ">= 1.6.0", "< 3.0"
-  s.add_dependency "rubyzip", "~> 1.2.2"
+  s.add_dependency "rubyzip"
   s.add_dependency "wdm", "~> 0.1.0"
   s.add_dependency "winrm", "~> 2.1"
   s.add_dependency "winrm-fs", "~> 1.0"

data/vendor/bundle/ruby/2.6.0/bundler/gems/vagrant-spec-abfc34474d12/vagrant-spec.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Mitchell Hashimoto".freeze]
-  s.date = "2019-10-19"
+  s.date = "2019-11-15"
   s.description = "Tool and library for testing Vagrant plugins".freeze
   s.email = ["mitchell.hashimoto@gmail.com".freeze]
   s.executables = ["vagrant-spec".freeze]

data/vendor/bundle/ruby/2.6.0/gems/erubi-1.9.0/CHANGELOG

@@ -0,0 +1,79 @@
+=== 1.9.0 (2019-09-25)
+
+* Change default :bufvar from 'String.new' to '::String.new' to work with BasicObject (jeremyevans)
+
+=== 1.8.0 (2018-12-18)
+
+* Support :yield_returns_buffer option in capture_end for always returning the (potentially modified) buffer in <%|= tags (evanleck) (#15)
+
+=== 1.7.1 (2018-03-05)
+
+* Make whitespace handling for <%# %> tags more compatible with Erubis (jeremyevans) (#14)
+
+=== 1.7.0 (2017-10-09)
+
+* Fix escaping in erubi/capture_end, the setting was previously inverted (jeremyevans) (#10)
+
+=== 1.6.1 (2017-06-27)
+
+* Fix usage on newer versions of JRuby 9.1 (jeremyevans)
+
+=== 1.6.0 (2017-02-27)
+
+* Use cgi/escape if available for 6x faster HTML escaping (k0kubun, jeremyevans) (#4)
+
+=== 1.5.0 (2017-01-26)
+
+* Drop tilt/erubi file, as tilt now ships with Erubi support (jeremyevans)
+
+* Drop erubi/capture file, Erubi::CaptureEngine support (jeremyevans)
+
+=== 1.4.0 (2017-01-20)
+
+* Allow postambles to depend on internal state of engine (jeremyevans)
+
+* Allow overriding of behavior for <%= and <%== tags to depend on which indicator was used (jeremyevans)
+
+* Make whitespace handling for <% %> tags more compatible with Erubis for subclasses overriding add_text (jeremyevans)
+
+=== 1.3.0 (2016-12-29)
+
+* Support :capture=>:explicit option in tilt support to use Erubi::CaptureEndEngine (jeremyevans)
+
+* Add erubi/capture_end containing Erubi::CaptureEndEngine, allowing <%|= and <%|== for opening capture tags, and <%| for closing capture tags (jeremyevans)
+
+=== 1.2.1 (2016-11-21)
+
+* Don't automatically freeze template text strings on ruby 1.9 or 2.0 (jeremyevans)
+
+=== 1.2.0 (2016-11-21)
+
+* Engine#src now returns a frozen string (jeremyevans)
+
+* Automatically freeze template text strings on ruby 2.1+, reducing garbage generated (jeremyevans)
+
+* Allow overriding of behavior for <%= and <%== tags (ujifgc) (#1)
+
+=== 1.1.0 (2016-11-14)
+
+* Add :ensure option to supporting restoring bufvar to original value (jeremyevans)
+
+* Don't have tilt support require erb (jeremyevans)
+
+* Support :engine_class option in tilt support to override engine class used (jeremyevans)
+
+* Support :capture option in tilt support to use Erubi::CaptureEngine (jeremyevans)
+
+* Add erubi/capture file containing Erubi::CaptureEngine, allowing <%|= and <%|== for capture (and escaping) blocks in templates (jeremyevans)
+
+* Raise ArgumentError if template source code contains indicators matched by regexp but not handled (jeremyevans)
+
+* Add :bufval option to support arbitrary buffer values (jeremyevans)
+
+* Add :regexp option to specify regexp used for scanning (jeremyevans)
+
+* Add :src option to specify initial template source (jeremyevans)
+
+=== 1.0.0 (2016-11-10)
+
+* Initial Public Release

data/vendor/bundle/ruby/2.6.0/gems/erubi-1.9.0/MIT-LICENSE

@@ -0,0 +1,21 @@
+copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
+copyright(c) 2016-2018 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/2.6.0/gems/erubi-1.9.0/README.rdoc

@@ -0,0 +1,109 @@
+= Erubi
+
+Erubi is a ERB template engine for ruby. It is a simplified fork of Erubis, using
+the same basic algorithm, with the following differences:
+
+* Handles postfix conditionals when using escaping (e.g. <tt><%= foo if bar %></tt>)
+* Supports frozen_string_literal: true in templates via :freeze option
+* Works with ruby's --enable-frozen-string-literal option
+* Automatically freezes strings for template text when ruby optimizes it (on ruby 2.1+)
+* Escapes ' (apostrophe) when escaping for better XSS protection 
+* Has 6x faster escaping on ruby 2.3+ by using cgi/escape
+* Has 86% smaller memory footprint
+* Does no monkey patching (Erubis adds a method to Kernel)
+* Uses an immutable design (all options passed to the constructor, which returns a frozen object)
+* Has simpler internals (1 file, <150 lines of code)
+* Is not dead (Erubis hasn't been updated since 2011)
+
+It is not designed with Erubis API compatibility in mind, though most Erubis
+ERB syntax works, with the following exceptions:
+
+* No support for <tt><%===</tt> for debug output
+
+= Installation
+
+  gem install erubi
+
+= Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/erubi
+
+= Usage
+
+Erubi only has built in support for retrieving the generated source for a
+file:
+
+  require 'erubi'
+  eval(Erubi::Engine.new(File.read('filename.erb')).src)
+
+Most users will probably use Erubi via Rails or Tilt.  Erubi is the default
+erb template handler in Tilt 2.0.6+ and Rails 5.1+.
+
+== Capturing
+
+Erubi does not support capturing block output into the template by default.
+However, it comes with an +erubi/capture_end+ file that supports capturing
+via <tt><%|=</tt> and <tt><%|==</tt> tags which are closed with a
+<tt><%|</tt> tag:
+
+  <%|= form do %>
+    <input>
+  <%| end %>
+
+This offers similar functionality to that offered by Rails' <tt><%=</tt>
+tags, but without the corner cases with that approach (which are due to
+attempting to parse ruby code via a regexp).  Similar to the <tt><%=</tt>
+and <tt><%==</tt> tags, <tt><%|=</tt> captures by default and
+<tt><%|==</tt> captures and escapes by default, but this can be reversed
+via the +:escape_capture+ or +:escape+ options.
+
+To use the capture_end support with tilt:
+
+  require 'tilt'
+  require 'erubi/capture_end'
+  Tilt.new("filename.erb", :engine_class=>Erubi::CaptureEndEngine).render
+
+When using the capture_end support, any methods (such as +form+ in the example
+above) should return the (potentially modified) buffer.  Since the buffer
+variable is a local variable and not an instance variable by default, you'll
+probably want to set the +:bufvar+ variable when using the capture_end
+support to an instance variable, and have any methods used access that
+instance variable.  Example:
+
+  def form
+    @_buf << "<form>"
+    yield
+    @_buf << "</form>"
+    @_buf
+  end
+
+  puts eval(Erubi::CaptureEndEngine.new(<<-END, :bufvar=>:@_buf).src)
+  before
+  <%|= form do %>
+  inside
+  <%| end %>
+  after
+  END
+
+  # Output:
+  # before
+  # <form>
+  # inside
+  # </form>
+  # after
+
+Alternatively, passing the option +:yield_returns_buffer => true+ will return the
+buffer captured by the block instead of the last expression in the block.
+
+= Reporting Bugs
+
+The bug tracker is located at https://github.com/jeremyevans/erubi/issues
+
+= License
+
+MIT
+
+= Authors
+
+Jeremy Evans <code@jeremyevans.net>
+kuwata-lab.com

data/vendor/bundle/ruby/2.6.0/gems/erubi-1.9.0/Rakefile

@@ -0,0 +1,78 @@
+require "rake"
+require "rake/clean"
+
+NAME = 'erubi'
+CLEAN.include ["#{NAME}-*.gem", "rdoc", "coverage"]
+
+# Gem Packaging and Release
+
+desc "Packages #{NAME}"
+task :package=>[:clean] do |p|
+  sh %{gem build #{NAME}.gemspec}
+end
+
+### RDoc
+
+RDOC_DEFAULT_OPTS = ["--line-numbers", "--inline-source", '--title', 'Erubi: Small ERB Implementation']
+
+begin
+  gem 'hanna-nouveau'
+  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
+rescue Gem::LoadError
+end
+
+rdoc_task_class = begin
+  require "rdoc/task"
+  RDoc::Task
+rescue LoadError
+  require "rake/rdoctask"
+  Rake::RDocTask
+end
+
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+RDOC_FILES = %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
+
+rdoc_task_class.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.rdoc_files.add RDOC_FILES
+end
+
+### Specs
+
+spec = proc do |env|
+  env.each{|k,v| ENV[k] = v}
+  sh "#{FileUtils::RUBY} test/test.rb"
+  env.each{|k,v| ENV.delete(k)}
+end
+
+desc "Run specs"
+task "spec" do
+  spec.call({})
+end
+
+task :default=>:spec
+
+desc "Run specs with coverage"
+task "spec_cov" do
+  spec.call('COVERAGE'=>'1')
+end
+  
+desc "Run specs with -w, some warnings filtered"
+task "spec_w" do
+  ENV['RUBYOPT'] ? (ENV['RUBYOPT'] += " -w") : (ENV['RUBYOPT'] = '-w')
+  rake = ENV['RAKE'] || "#{FileUtils::RUBY} -S rake"
+  sh %{#{rake} 2>&1 | egrep -v \": warning: instance variable @.* not initialized|: warning: method redefined; discarding old|: warning: previous definition of|: warning: statement not reached"}
+end
+
+### Other
+
+desc "Start an IRB shell using the extension"
+task :irb do
+  require 'rbconfig'
+  ruby = ENV['RUBY'] || File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  irb = ENV['IRB'] || File.join(RbConfig::CONFIG['bindir'], File.basename(ruby).sub('ruby', 'irb'))
+  sh %{#{irb} -I lib -r #{NAME}}
+end
+
+

data/vendor/bundle/ruby/2.6.0/gems/erubi-1.9.0/lib/erubi/capture_end.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'erubi'
+
+module Erubi
+  # An engine class that supports capturing blocks via the <%|= and <%|== tags,
+  # explicitly ending the captures using <%| end %> blocks.
+  class CaptureEndEngine < Engine
+    # Initializes the engine.  Accepts the same arguments as ::Erubi::Engine, and these
+    # additional options:
+    # :escape_capture :: Whether to make <%|= escape by default, and <%|== not escape by default,
+    #                    defaults to the same value as :escape.
+    # :yield_returns_buffer :: Whether to have <%| tags insert the buffer as an expression, so that
+    #                          <%| end %> tags will have the buffer be the last expression inside
+    #                          the block, and therefore have the buffer be returned by the yield
+    #                          expression.  Normally the buffer will be returned anyway, but there
+    #                          are cases where the last expression will not be the buffer,
+    #                          and therefore a different object will be returned.
+    def initialize(input, properties={})
+      properties = Hash[properties]
+      escape = properties.fetch(:escape){properties.fetch(:escape_html, false)}
+      @escape_capture = properties.fetch(:escape_capture, escape)
+      @yield_returns_buffer = properties.fetch(:yield_returns_buffer, false)
+      @bufval = properties[:bufval] ||= '::String.new'
+      @bufstack = '__erubi_stack'
+      properties[:regexp] ||= /<%(\|?={1,2}|-|\#|%|\|)?(.*?)([-=])?%>([ \t]*\r?\n)?/m
+      super
+    end
+
+    private
+
+    # Handle the <%|= and <%|== tags
+    def handle(indicator, code, tailch, rspace, lspace)
+      case indicator
+      when '|=', '|=='
+        rspace = nil if tailch && !tailch.empty?
+        add_text(lspace) if lspace
+        escape_capture = !((indicator == '|=') ^ @escape_capture)
+        src << "begin; (#{@bufstack} ||= []) << #{@bufvar}; #{@bufvar} = #{@bufval}; #{@bufstack}.last << #{@escapefunc if escape_capture}((" << code
+        add_text(rspace) if rspace
+      when '|'
+        rspace = nil if tailch && !tailch.empty?
+        add_text(lspace) if lspace
+        result = @yield_returns_buffer ? " #{@bufvar}; " : ""
+        src << result << code << ")).to_s; ensure; #{@bufvar} = #{@bufstack}.pop; end;"
+        add_text(rspace) if rspace
+      else
+        super
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/erubi-1.9.0/lib/erubi.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Erubi
+  VERSION = '1.9.0'
+  RANGE_ALL = 0..-1
+
+  if RUBY_VERSION >= '1.9'
+    RANGE_FIRST = 0
+    RANGE_LAST = -1
+    TEXT_END = RUBY_VERSION >= '2.1' ? "'.freeze;" : "';"
+  else
+    # :nocov:
+    RANGE_FIRST = 0..0
+    RANGE_LAST = -1..-1
+    TEXT_END = "';"
+  end
+
+  begin
+    require 'cgi/escape'
+    unless CGI.respond_to?(:escapeHTML) # work around for JRuby 9.1
+      CGI = Object.new
+      CGI.extend(defined?(::CGI::Escape) ? ::CGI::Escape : ::CGI::Util)
+    end
+    def self.h(value)
+      CGI.escapeHTML(value.to_s)
+    end
+  rescue LoadError
+    ESCAPE_TABLE = {'&' => '&amp;'.freeze, '<' => '&lt;'.freeze, '>' => '&gt;'.freeze, '"' => '&quot;'.freeze, "'" => '&#39;'.freeze}.freeze
+    if RUBY_VERSION >= '1.9'
+      # Escape the following characters with their HTML/XML
+      # equivalents.
+      def self.h(value)
+        value.to_s.gsub(/[&<>"']/, ESCAPE_TABLE)
+      end
+    else
+      def self.h(value)
+        value.to_s.gsub(/[&<>"']/){|s| ESCAPE_TABLE[s]}
+      end
+    end
+  end
+
+  class Engine
+    # The frozen ruby source code generated from the template, which can be evaled.
+    attr_reader :src
+
+    # The filename of the template, if one was given.
+    attr_reader :filename
+
+    # The variable name used for the buffer variable.
+    attr_reader :bufvar
+
+    # Initialize a new Erubi::Engine.  Options:
+    # :bufval :: The value to use for the buffer variable, as a string.
+    # :bufvar :: The variable name to use for the buffer variable, as a string (default '::String.new')
+    # :ensure :: Wrap the template in a begin/ensure block restoring the previous value of bufvar.
+    # :escapefunc :: The function to use for escaping, as a string (default: '::Erubi.h').
+    # :escape :: Whether to make <%= escape by default, and <%== not escape by default.
+    # :escape_html :: Same as :escape, with lower priority.
+    # :filename :: The filename for the template.
+    # :freeze :: Whether to enable frozen string literals in the resulting source code.
+    # :outvar :: Same as bufvar, with lower priority.
+    # :postamble :: The postamble for the template, by default returns the resulting source code.
+    # :preamble :: The preamble for the template, by default initializes up the buffer variable.
+    # :regexp :: The regexp to use for scanning.
+    # :src :: The initial value to use for the source code
+    # :trim :: Whether to trim leading and trailing whitespace, true by default.
+    def initialize(input, properties={})
+      @escape = escape = properties.fetch(:escape){properties.fetch(:escape_html, false)}
+      trim       = properties[:trim] != false
+      @filename  = properties[:filename]
+      @bufvar = bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
+      bufval = properties[:bufval] || '::String.new'
+      regexp = properties[:regexp] || /<%(={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m
+      preamble   = properties[:preamble] || "#{bufvar} = #{bufval};"
+      postamble  = properties[:postamble] || "#{bufvar}.to_s\n"
+
+      @src = src = properties[:src] || String.new
+      src << "# frozen_string_literal: true\n" if properties[:freeze]
+      src << "begin; __original_outvar = #{bufvar} if defined?(#{bufvar}); " if properties[:ensure]
+
+      unless @escapefunc = properties[:escapefunc]
+        if escape
+          @escapefunc = '__erubi.h'
+          src << "__erubi = ::Erubi;"
+        else
+          @escapefunc = '::Erubi.h'
+        end
+      end
+
+      src << preamble
+
+      pos = 0
+      is_bol = true
+      input.scan(regexp) do |indicator, code, tailch, rspace|
+        match = Regexp.last_match
+        len  = match.begin(0) - pos
+        text = input[pos, len]
+        pos  = match.end(0)
+        ch   = indicator ? indicator[RANGE_FIRST] : nil
+
+        lspace = nil
+
+        unless ch == '='
+          if text.empty?
+            lspace = "" if is_bol
+          elsif text[RANGE_LAST] == "\n"
+            lspace = ""
+          else
+            rindex = text.rindex("\n")
+            if rindex
+              range = rindex+1..-1
+              s = text[range]
+              if s =~ /\A[ \t]*\z/
+                lspace = s
+                text[range] = ''
+              end
+            else
+              if is_bol && text =~ /\A[ \t]*\z/
+                lspace = text.dup
+                text[RANGE_ALL] = ''
+              end
+            end
+          end
+        end
+
+        is_bol = rspace
+        add_text(text) if text && !text.empty?
+        case ch
+        when '='
+          rspace = nil if tailch && !tailch.empty?
+          add_text(lspace) if lspace
+          add_expression(indicator, code)
+          add_text(rspace) if rspace
+        when '#'
+          n = code.count("\n") + (rspace ? 1 : 0)
+          if trim && lspace && rspace
+            add_code("\n" * n)
+          else
+            add_text(lspace) if lspace
+            add_code("\n" * n)
+            add_text(rspace) if rspace
+          end
+        when '%'
+          add_text("#{lspace}#{prefix||='<%'}#{code}#{tailch}#{postfix||='%>'}#{rspace}")
+        when nil, '-'
+          if trim && lspace && rspace
+            add_code("#{lspace}#{code}#{rspace}")
+          else
+            add_text(lspace) if lspace
+            add_code(code)
+            add_text(rspace) if rspace
+          end
+        else
+          handle(indicator, code, tailch, rspace, lspace)
+        end
+      end
+      rest = pos == 0 ? input : input[pos..-1]
+      add_text(rest)
+
+      src << "\n" unless src[RANGE_LAST] == "\n"
+      add_postamble(postamble)
+      src << "; ensure\n  #{bufvar} = __original_outvar\nend\n" if properties[:ensure]
+      src.freeze
+      freeze
+    end
+
+    private
+
+    # Add raw text to the template
+    def add_text(text)
+      @src << " #{@bufvar} << '" << text.gsub(/['\\]/, '\\\\\&') << TEXT_END unless text.empty?
+    end
+
+    # Add ruby code to the template
+    def add_code(code)
+      @src << code
+      @src << ';' unless code[RANGE_LAST] == "\n"
+    end
+
+    # Add the given ruby expression result to the template,
+    # escaping it based on the indicator given and escape flag.
+    def add_expression(indicator, code)
+      if ((indicator == '=') ^ @escape)
+        add_expression_result(code)
+      else
+        add_expression_result_escaped(code)
+      end
+    end
+
+    # Add the result of Ruby expression to the template
+    def add_expression_result(code)
+      @src << " #{@bufvar} << (" << code << ').to_s;'
+    end
+
+    # Add the escaped result of Ruby expression to the template
+    def add_expression_result_escaped(code)
+      @src << " #{@bufvar} << #{@escapefunc}((" << code << '));'
+    end
+
+    # Add the given postamble to the src.  Can be overridden in subclasses
+    # to make additional changes to src that depend on the current state.
+    def add_postamble(postamble)
+      src << postamble
+    end
+
+    # Raise an exception, as the base engine class does not support handling other indicators.
+    def handle(indicator, code, tailch, rspace, lspace)
+      raise ArgumentError, "Invalid indicator: #{indicator}"
+    end
+  end
+end