zine_brewer 1.3.0 → 1.3.1

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

@@ -1,173 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

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

@@ -1,216 +0,0 @@
-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

@@ -1,371 +0,0 @@
-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