zine_brewer 1.3.2 → 1.5.0

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/context.rb

@@ -0,0 +1,173 @@
+require 'mustache/context_miss'
+
+class Mustache
+
+  # A Context represents the context which a Mustache template is
+  # executed within. All Mustache tags reference keys in the Context.
+  #
+  class Context
+
+    # Initializes a Mustache::Context.
+    #
+    # @param [Mustache] mustache A Mustache instance.
+    #
+    def initialize(mustache)
+      @stack = [mustache]
+      @partial_template_cache = {}
+    end
+
+    # A {{>partial}} tag translates into a call to the context's
+    # `partial` method, which would be this sucker right here.
+    #
+    # If the Mustache view handling the rendering (e.g. the view
+    # representing your profile page or some other template) responds
+    # to `partial`, we call it and render the result.
+    #
+    def partial(name, indentation = '')
+      # Look for the first Mustache in the stack.
+      mustache = mustache_in_stack
+
+      # Indent the partial template by the given indentation.
+      part = mustache.partial(name).to_s.gsub(/^/, indentation)
+
+      # Get a template object for the partial and render the result.
+      template_for_partial(part).render(self)
+    end
+
+    def template_for_partial(partial)
+      @partial_template_cache[partial] ||= Template.new(partial)
+    end
+
+    # Find the first Mustache in the stack.
+    #
+    # If we're being rendered inside a Mustache object as a context,
+    # we'll use that one.
+    #
+    # @return [Mustache] First Mustache in the stack.
+    #
+    def mustache_in_stack
+      @mustache_in_stack ||= @stack.find { |frame| frame.is_a?(Mustache) }
+    end
+
+    # Allows customization of how Mustache escapes things.
+    #
+    # @param [Object] value Value to escape.
+    #
+    # @return [String] Escaped string.
+    #
+    def escape(value)
+      mustache_in_stack.escape(value)
+    end
+
+    # Adds a new object to the context's internal stack.
+    #
+    # @param [Object] new_obj Object to be added to the internal stack.
+    #
+    # @return [Context] Returns the Context.
+    #
+    def push(new_obj)
+      @stack.unshift(new_obj)
+      @mustache_in_stack = nil
+      self
+    end
+
+    # Removes the most recently added object from the context's
+    # internal stack.
+    #
+    # @return [Context] Returns the Context.
+    #
+    def pop
+      @stack.shift
+      @mustache_in_stack = nil
+      self
+    end
+
+    # Can be used to add a value to the context in a hash-like way.
+    #
+    # context[:name] = "Chris"
+    def []=(name, value)
+      push(name => value)
+    end
+
+    # Alias for `fetch`.
+    def [](name)
+      fetch(name, nil)
+    end
+
+    # Do we know about a particular key? In other words, will calling
+    # `context[key]` give us a result that was set. Basically.
+    def has_key?(key)
+      fetch(key, false)
+    rescue ContextMiss
+      false
+    end
+
+    # Similar to Hash#fetch, finds a value by `name` in the context's
+    # stack. You may specify the default return value by passing a
+    # second parameter.
+    #
+    # If no second parameter is passed (or raise_on_context_miss is
+    # set to true), will raise a ContextMiss exception on miss.
+    def fetch(name, default = :__raise)
+      @stack.each do |frame|
+        # Prevent infinite recursion.
+        next if frame == self
+
+        value = find(frame, name, :__missing)
+        return value if :__missing != value
+      end
+
+      if default == :__raise || mustache_in_stack.raise_on_context_miss?
+        raise ContextMiss.new("Can't find #{name} in #{@stack.inspect}")
+      else
+        default
+      end
+    end
+
+    # Finds a key in an object, using whatever method is most
+    # appropriate. If the object is a hash, does a simple hash lookup.
+    # If it's an object that responds to the key as a method call,
+    # invokes that method. You get the idea.
+    #
+    # @param [Object] obj The object to perform the lookup on.
+    # @param [String,Symbol] key The key whose value you want
+    # @param [Object] default An optional default value, to return if the key is not found.
+    #
+    # @return [Object] The value of key in object if it is found, and default otherwise.
+    #
+    def find(obj, key, default = nil)
+      return find_in_hash(obj.to_hash, key, default) if obj.respond_to?(:to_hash)
+
+      unless obj.respond_to?(key)
+        # no match for the key, but it may include a hyphen, so try again replacing hyphens with underscores.
+        key = key.to_s.tr('-', '_')
+        return default unless obj.respond_to?(key)
+      end
+
+      meth = obj.method(key) rescue proc { obj.send(key) }
+      meth.arity == 1 ? meth.to_proc : meth.call
+    end
+
+    def current
+      @stack.first
+    end
+
+
+    private
+
+    # Fetches a hash key if it exists, or returns the given default.
+    def find_in_hash(obj, key, default)
+      return obj[key]      if obj.has_key?(key)
+      return obj[key.to_s] if obj.has_key?(key.to_s)
+      return obj[key]      if obj.respond_to?(:default_proc) && obj.default_proc && obj[key]
+
+      # If default is :__missing then we are from #fetch which is hunting through the stack
+      # If default is nil then we are reducing dot notation
+      if :__missing != default && mustache_in_stack.raise_on_context_miss?
+        raise ContextMiss.new("Can't find #{key} in #{obj}")
+      else
+        obj.fetch(key, default)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/context_miss.rb

@@ -0,0 +1,14 @@
+class Mustache
+
+  # A ContextMiss is raised whenever a tag's target can not be found
+  # in the current context if `Mustache#raise_on_context_miss?` is
+  # set to true.
+  #
+  # For example, if your View class does not respond to `music` but
+  # your template contains a `{{music}}` tag this exception will be raised.
+  #
+  # By default it is not raised. See Mustache.raise_on_context_miss.
+  #
+  class ContextMiss < RuntimeError;  end
+
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/enumerable.rb

@@ -0,0 +1,3 @@
+class Mustache
+  Enumerable = Module.new
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/generator.rb

@@ -0,0 +1,216 @@
+class Mustache
+  # The Generator is in charge of taking an array of Mustache tokens,
+  # usually assembled by the Parser, and generating an interpolatable
+  # Ruby string. This string is considered the "compiled" template
+  # because at that point we're relying on Ruby to do the parsing and
+  # run our code.
+  #
+  # For example, let's take this template:
+  #
+  #   Hi {{thing}}!
+  #
+  # If we run this through the Parser we'll get these tokens:
+  #
+  #   [:multi,
+  #     [:static, "Hi "],
+  #     [:mustache, :etag, "thing"],
+  #     [:static, "!\n"]]
+  #
+  # Now let's hand that to the Generator:
+  #
+  # >> puts Mustache::Generator.new.compile(tokens)
+  # "Hi #{CGI.escapeHTML(ctx[:thing].to_s)}!\n"
+  #
+  # You can see the generated Ruby string for any template with the
+  # mustache(1) command line tool:
+  #
+  #   $ mustache --compile test.mustache
+  #   "Hi #{CGI.escapeHTML(ctx[:thing].to_s)}!\n"
+  class Generator
+    # Options can be used to manipulate the resulting ruby code string behavior.
+    def initialize(options = {})
+      @options = options
+      @option_static_lambdas = options[:static_lambdas] == true
+    end
+
+    # Given an array of tokens, returns an interpolatable Ruby string.
+    def compile(exp)
+      "\"#{compile!(exp)}\""
+    end
+
+
+    private
+
+
+    # Given an array of tokens, converts them into Ruby code. In
+    # particular there are three types of expressions we are concerned
+    # with:
+    #
+    #   :multi
+    #     Mixed bag of :static, :mustache, and whatever.
+    #
+    #   :static
+    #     Normal HTML, the stuff outside of {{mustaches}}.
+    #
+    #   :mustache
+    #     Any Mustache tag, from sections to partials.
+    #
+    # To give you an idea of what you'll be dealing with take this
+    # template:
+    #
+    #   Hello {{name}}
+    #   You have just won ${{value}}!
+    #   {{#in_ca}}
+    #   Well, ${{taxed_value}}, after taxes.
+    #   {{/in_ca}}
+    #
+    # If we run this through the Parser, we'll get back this array of
+    # tokens:
+    #
+    #   [:multi,
+    #    [:static, "Hello "],
+    #    [:mustache, :etag,
+    #     [:mustache, :fetch, ["name"]]],
+    #    [:static, "\nYou have just won $"],
+    #   [:mustache, :etag,
+    #    [:mustache, :fetch, ["value"]]],
+    #   [:static, "!\n"],
+    #   [:mustache,
+    #    :section,
+    #    [:mustache, :fetch, ["in_ca"]],
+    #   [:multi,
+    #    [:static, "Well, $"],
+    #    [:mustache, :etag,
+    #     [:mustache, :fetch, ["taxed_value"]]],
+    #    [:static, ", after taxes.\n"]],
+    #    "Well, ${{taxed_value}}, after taxes.\n",
+    #    ["{{", "}}"]]]
+    def compile!(exp)
+      case exp.first
+      when :multi
+        exp[1..-1].reduce("") { |sum, e| sum << compile!(e) }
+      when :static
+        str(exp[1])
+      when :mustache
+        send("on_#{exp[1]}", *exp[2..-1])
+      else
+        raise "Unhandled exp: #{exp.first}"
+      end
+    end
+
+    # Callback fired when the compiler finds a section token. We're
+    # passed the section name and the array of tokens.
+    def on_section(name, offset, content, raw, delims)
+      # Convert the tokenized content of this section into a Ruby
+      # string we can use.
+      code = compile(content)
+
+      # Lambda handling - default handling is to dynamically interpret
+      # the returned lambda result as mustache source
+      proc_handling = if @option_static_lambdas
+        <<-compiled
+          v.call(lambda {|v| #{code}}.call(v)).to_s
+        compiled
+      else
+        <<-compiled
+          t = Mustache::Template.new(v.call(#{raw.inspect}).to_s)
+          def t.tokens(src=@source)
+            p = Mustache::Parser.new
+            p.otag, p.ctag = #{delims.inspect}
+            p.compile(src)
+          end
+          t.render(ctx.dup)
+        compiled
+      end
+
+      # Compile the Ruby for this section now that we know what's
+      # inside the section.
+      ev(<<-compiled)
+      case v = #{compile!(name)}
+      when NilClass, FalseClass
+      when TrueClass
+        #{code}
+      when Proc
+        #{proc_handling}
+      when Array, Enumerator, Mustache::Enumerable
+        v.map { |_| ctx.push(_); r = #{code}; ctx.pop; r }.join
+      else
+        ctx.push(v); r = #{code}; ctx.pop; r
+      end
+      compiled
+    end
+
+    # Fired when we find an inverted section. Just like `on_section`,
+    # we're passed the inverted section name and the array of tokens.
+    def on_inverted_section(name, offset, content, raw, delims)
+      # Convert the tokenized content of this section into a Ruby
+      # string we can use.
+      code = compile(content)
+
+      # Compile the Ruby for this inverted section now that we know
+      # what's inside.
+      ev(<<-compiled)
+      v = #{compile!(name)}
+      if v.nil? || v == false || v.respond_to?(:empty?) && v.empty?
+        #{code}
+      end
+      compiled
+    end
+
+    # Fired when the compiler finds a partial. We want to return code
+    # which calls a partial at runtime instead of expanding and
+    # including the partial's body to allow for recursive partials.
+    def on_partial(name, offset, indentation)
+      ev("ctx.partial(#{name.to_sym.inspect}, #{indentation.inspect})")
+    end
+
+    # An unescaped tag.
+    def on_utag(name, offset)
+      ev(<<-compiled)
+        v = #{compile!(name)}
+        if v.is_a?(Proc)
+          v = #{@option_static_lambdas ? 'v.call' : 'Mustache::Template.new(v.call.to_s).render(ctx.dup)'}
+        end
+        v.to_s
+      compiled
+    end
+
+    # An escaped tag.
+    def on_etag(name, offset)
+      ev(<<-compiled)
+        v = #{compile!(name)}
+        if v.is_a?(Proc)
+          v = #{@option_static_lambdas ? 'v.call' : 'Mustache::Template.new(v.call.to_s).render(ctx.dup)'}
+        end
+        ctx.escape(v)
+      compiled
+    end
+
+    def on_fetch(names)
+      return "ctx.current" if names.empty?
+
+      names = names.map { |n| n.to_sym }
+
+      initial, *rest = names
+      if rest.any?
+        <<-compiled
+          #{rest.inspect}.reduce(ctx[#{initial.inspect}]) { |value, key| value && ctx.find(value, key) }
+        compiled
+      else
+        <<-compiled
+          ctx[#{initial.inspect}]
+        compiled
+      end
+    end
+
+    # An interpolation-friendly version of a string, for use within a
+    # Ruby string.
+    def ev(s)
+      "#\{#{s}}"
+    end
+
+    def str(s)
+      s.inspect[1..-2]
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/lib/mustache/parser.rb

@@ -0,0 +1,371 @@
+require 'strscan'
+
+class Mustache
+  # The Parser is responsible for taking a string template and
+  # converting it into an array of tokens and, really, expressions. It
+  # raises SyntaxError if there is anything it doesn't understand and
+  # knows which sigil corresponds to which tag type.
+  #
+  # For example, given this template:
+  #
+  #   Hi {{thing}}!
+  #
+  # Run through the Parser we'll get these tokens:
+  #
+  #   [:multi,
+  #     [:static, "Hi "],
+  #     [:mustache, :etag, "thing"],
+  #     [:static, "!\n"]]
+  #
+  # You can see the array of tokens for any template with the
+  # mustache(1) command line tool:
+  #
+  #   $ mustache --tokens test.mustache
+  #   [:multi, [:static, "Hi "], [:mustache, :etag, "thing"], [:static, "!\n"]]
+  class Parser
+    # A SyntaxError is raised when the Parser comes across unclosed
+    # tags, sections, illegal content in tags, or anything of that
+    # sort.
+    class SyntaxError < StandardError
+      def initialize(message, position)
+        @message = message
+        @lineno, @column, @line, _ = position
+        @stripped_line = @line.strip
+        @stripped_column = @column - (@line.size - @line.lstrip.size)
+      end
+
+      def to_s
+        <<-EOF
+#{@message}
+  Line #{@lineno}
+    #{@stripped_line}
+    #{' ' * @stripped_column}^
+EOF
+      end
+    end
+
+    # The sigil types which are valid after an opening `{{`
+    VALID_TYPES = [ '#', '^', '/', '=', '!', '<', '>', '&', '{' ].map(&:freeze)
+
+    def self.valid_types
+      @valid_types ||= Regexp.new(VALID_TYPES.map { |t| Regexp.escape(t) }.join('|') )
+    end
+
+    # Add a supported sigil type (with optional aliases) to the Parser.
+    #
+    # Requires a block, which will be sent the following parameters:
+    #
+    # * content - The raw content of the tag
+    # * fetch- A mustache context fetch expression for the content
+    # * padding - Indentation whitespace from the currently-parsed line
+    # * pre_match_position - Location of the scanner before a match was made
+    #
+    # The provided block will be evaluated against the current instance of
+    # Parser, and may append to the Parser's @result as needed.
+    def self.add_type(*types, &block)
+      types = types.map(&:to_s)
+      type, *aliases = types
+      method_name = "scan_tag_#{type}".to_sym
+      define_method(method_name, &block)
+      aliases.each { |a| alias_method "scan_tag_#{a}", method_name }
+      types.each { |t| VALID_TYPES << t unless VALID_TYPES.include?(t) }
+      @valid_types = nil
+    end
+
+    # After these types of tags, all whitespace until the end of the line will
+    # be skipped if they are the first (and only) non-whitespace content on
+    # the line.
+    SKIP_WHITESPACE = [ '#', '^', '/', '<', '>', '=', '!' ].map(&:freeze)
+
+    # The content allowed in a tag name.
+    ALLOWED_CONTENT = /(\w|[?!\/.-])*/
+
+    # These types of tags allow any content,
+    # the rest only allow ALLOWED_CONTENT.
+    ANY_CONTENT = [ '!', '=' ].map(&:freeze)
+
+    attr_reader :otag, :ctag
+
+    # Accepts an options hash which does nothing but may be used in
+    # the future.
+    def initialize(options = {})
+      @options = options
+      @option_inline_partials_at_compile_time = options[:inline_partials_at_compile_time]
+      if @option_inline_partials_at_compile_time
+        @partial_resolver = options[:partial_resolver]
+        raise ArgumentError.new "Missing or invalid partial_resolver" unless @partial_resolver.respond_to? :call
+      end
+
+      # Initialize default tags
+      self.otag ||= '{{'
+      self.ctag ||= '}}'
+    end
+
+    # The opening tag delimiter. This may be changed at runtime.
+    def otag=(value)
+      regex = regexp value
+      @otag_regex     = /([ \t]*)?#{regex}/
+      @otag_not_regex = /(^[ \t]*)?#{regex}/
+      @otag = value
+    end
+
+    # The closing tag delimiter. This too may be changed at runtime.
+    def ctag=(value)
+      @ctag_regex = regexp value
+      @ctag = value
+    end
+
+    # Given a string template, returns an array of tokens.
+    def compile(template)
+      @encoding = nil
+
+      if template.respond_to?(:encoding)
+        @encoding = template.encoding
+        template = template.dup.force_encoding("BINARY")
+      end
+
+      # Keeps information about opened sections.
+      @sections = []
+      @result = [:multi]
+      @scanner = StringScanner.new(template)
+
+      # Scan until the end of the template.
+      until @scanner.eos?
+        scan_tags || scan_text
+      end
+
+      unless @sections.empty?
+        # We have parsed the whole file, but there's still opened sections.
+        type, pos, _ = @sections.pop
+        error "Unclosed section #{type.inspect}", pos
+      end
+
+      @result
+    end
+
+
+    private
+
+
+    def content_tags type, current_ctag_regex
+      if ANY_CONTENT.include?(type)
+        r = /\s*#{regexp(type)}?#{current_ctag_regex}/
+        scan_until_exclusive(r)
+      else
+        @scanner.scan(ALLOWED_CONTENT)
+      end
+    end
+
+    def dispatch_based_on_type type, content, fetch, padding, pre_match_position
+      send("scan_tag_#{type}", content, fetch, padding, pre_match_position)
+    end
+
+    def find_closing_tag scanner, current_ctag_regex
+      error "Unclosed tag" unless scanner.scan(current_ctag_regex)
+    end
+
+    # Find {{mustaches}} and add them to the @result array.
+    def scan_tags
+      # Scan until we hit an opening delimiter.
+      start_of_line = @scanner.beginning_of_line?
+      pre_match_position = @scanner.pos
+      last_index = @result.length
+
+      return unless @scanner.scan @otag_regex
+      padding = @scanner[1] || ''
+
+      # Don't touch the preceding whitespace unless we're matching the start
+      # of a new line.
+      unless start_of_line
+        @result << [:static, padding] unless padding.empty?
+        pre_match_position += padding.length
+        padding = ''
+      end
+
+      # Since {{= rewrites ctag, we store the ctag which should be used
+      # when parsing this specific tag.
+      current_ctag_regex = @ctag_regex
+      type = @scanner.scan(self.class.valid_types)
+      @scanner.skip(/\s*/)
+
+      # ANY_CONTENT tags allow any character inside of them, while
+      # other tags (such as variables) are more strict.
+      content = content_tags(type, current_ctag_regex)
+
+      # We found {{ but we can't figure out what's going on inside.
+      error "Illegal content in tag" if content.empty?
+
+      fetch = [:mustache, :fetch, content.split('.')]
+      prev = @result
+
+      dispatch_based_on_type(type, content, fetch, padding, pre_match_position)
+
+      # The closing } in unescaped tags is just a hack for
+      # aesthetics.
+      type = "}" if type == "{"
+
+      # Skip whitespace and any balancing sigils after the content
+      # inside this tag.
+      @scanner.skip(/\s+/)
+      @scanner.skip(regexp(type)) if type
+
+      find_closing_tag(@scanner, current_ctag_regex)
+
+      # If this tag was the only non-whitespace content on this line, strip
+      # the remaining whitespace.  If not, but we've been hanging on to padding
+      # from the beginning of the line, re-insert the padding as static text.
+      if start_of_line && !@scanner.eos?
+        if @scanner.peek(2) =~ /\r?\n/ && SKIP_WHITESPACE.include?(type)
+          @scanner.skip(/\r?\n/)
+        else
+          prev.insert(last_index, [:static, padding]) unless padding.empty?
+        end
+      end
+
+      # Store off the current scanner position now that we've closed the tag
+      # and consumed any irrelevant whitespace.
+      @sections.last[1] << @scanner.pos unless @sections.empty?
+
+      return unless @result == [:multi]
+    end
+
+    # Try to find static text, e.g. raw HTML with no {{mustaches}}.
+    def scan_text
+      text = scan_until_exclusive @otag_not_regex
+
+      if text.nil?
+        # Couldn't find any otag, which means the rest is just static text.
+        text = @scanner.rest
+        # Mark as done.
+        @scanner.terminate
+      end
+
+      text.force_encoding(@encoding) if @encoding
+
+      @result << [:static, text] unless text.empty?
+    end
+
+    # Scans the string until the pattern is matched. Returns the substring
+    # *excluding* the end of the match, advancing the scan pointer to that
+    # location. If there is no match, nil is returned.
+    def scan_until_exclusive(regexp)
+      pos = @scanner.pos
+      if @scanner.scan_until(regexp)
+        @scanner.pos -= @scanner.matched.size
+        @scanner.pre_match[pos..-1]
+      end
+    end
+
+    def offset
+      position[0, 2]
+    end
+
+    # Returns [lineno, column, line]
+    def position
+      # The rest of the current line
+      rest = @scanner.check_until(/\n|\Z/).to_s.chomp
+
+      # What we have parsed so far
+      parsed = @scanner.string[0...@scanner.pos]
+
+      lines = parsed.split("\n")
+
+      [ lines.size, lines.last.size - 1, lines.last + rest ]
+    end
+
+    # Used to quickly convert a string into a regular expression
+    # usable by the string scanner.
+    def regexp(thing)
+      Regexp.new Regexp.escape(thing) if thing
+    end
+
+    # Raises a SyntaxError. The message should be the name of the
+    # error - other details such as line number and position are
+    # handled for you.
+    def error(message, pos = position)
+      raise SyntaxError.new(message, pos)
+    end
+
+
+    #
+    # Scan tags
+    #
+    # These methods are called in `scan_tags`. Because they contain nonstandard
+    # characters in their method names, they are aliased to
+    # better named methods.
+    #
+
+
+    # This function handles the cases where the scanned tag does not have
+    # a type.
+    def scan_tag_ content, fetch, padding, pre_match_position
+      @result << [:mustache, :etag, fetch, offset]
+    end
+
+
+    def scan_tag_block content, fetch, padding, pre_match_position
+      block = [:multi]
+      @result << [:mustache, :section, fetch, offset, block]
+      @sections << [content, position, @result]
+      @result = block
+    end
+    alias_method :'scan_tag_#', :scan_tag_block
+
+
+    def scan_tag_inverted content, fetch, padding, pre_match_position
+      block = [:multi]
+      @result << [:mustache, :inverted_section, fetch, offset, block]
+      @sections << [content, position, @result]
+      @result = block
+    end
+    alias_method :'scan_tag_^', :scan_tag_inverted
+
+
+    def scan_tag_close content, fetch, padding, pre_match_position
+      section, pos, result = @sections.pop
+      if section.nil?
+        error "Closing unopened #{content.inspect}"
+      end
+
+      raw = @scanner.pre_match[pos[3]...pre_match_position] + padding
+      (@result = result).last << raw << [self.otag, self.ctag]
+
+      if section != content
+        error "Unclosed section #{section.inspect}", pos
+      end
+    end
+    alias_method :'scan_tag_/', :scan_tag_close
+
+
+    def scan_tag_comment content, fetch, padding, pre_match_position
+    end
+    alias_method :'scan_tag_!', :scan_tag_comment
+
+
+    def scan_tag_delimiter content, fetch, padding, pre_match_position
+      self.otag, self.ctag = content.split(' ', 2)
+    end
+    alias_method :'scan_tag_=', :scan_tag_delimiter
+
+
+    def scan_tag_open_partial content, fetch, padding, pre_match_position
+      @result << if @option_inline_partials_at_compile_time
+        partial = @partial_resolver.call content
+        partial.gsub!(/^/, padding) unless padding.empty?
+        self.class.new(@options).compile partial
+      else
+        [:mustache, :partial, content, offset, padding]
+      end
+    end
+    alias_method :'scan_tag_<', :scan_tag_open_partial
+    alias_method :'scan_tag_>', :scan_tag_open_partial
+
+
+    def scan_tag_unescaped content, fetch, padding, pre_match_position
+      @result << [:mustache, :utag, fetch, offset]
+    end
+    alias_method :'scan_tag_{', :'scan_tag_unescaped'
+    alias_method :'scan_tag_&', :'scan_tag_unescaped'
+
+  end
+end