A Context represents the context which a Mustache template is executed within. All Mustache tags reference keys in the Context.

Methods
#
F
H
M
N
P
U
Class Public methods
new(mustache)

Expect to be passed an instance of `Mustache`.

# File lib/mustache/context.rb, line 16
    def initialize(mustache)
      @stack = [mustache]
    end
Instance Public methods
[](name)

Alias for `fetch`.

# File lib/mustache/context.rb, line 66
    def [](name)
      fetch(name, nil)
    end
[]=(name, value)

Can be used to add a value to the context in a hash-like way.

context[:name] = “Chris“

# File lib/mustache/context.rb, line 61
    def []=(name, value)
      push(name => value)
    end
fetch(name, default = :__raise)

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.

# File lib/mustache/context.rb, line 84
    def fetch(name, default = :__raise)
      @stack.each do |frame|
        # Prevent infinite recursion.
        next if frame == self

        # Is this frame a hash?
        hash = frame.respond_to?(:has_key?)

        if hash && frame.has_key?(name)
          return frame[name]
        elsif hash && frame.has_key?(name.to_s)
          return frame[name.to_s]
        elsif !hash && frame.respond_to?(name)
          return frame.__send__(name)
        end
      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
has_key?(key)

Do we know about a particular key? In other words, will calling `context[key]` give us a result that was set. Basically.

# File lib/mustache/context.rb, line 72
    def has_key?(key)
      !!fetch(key)
    rescue ContextMiss
      false
    end
mustache_in_stack()

Find the first Mustache in the stack. If we’re being rendered inside a Mustache object as a context, we’ll use that one.

# File lib/mustache/context.rb, line 36
    def mustache_in_stack
      @stack.detect { |frame| frame.is_a?(Mustache) }
    end
partial(name)

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.

# File lib/mustache/context.rb, line 26
    def partial(name)
      # Look for the first Mustache in the stack.
      mustache = mustache_in_stack

      # Call its `partial` method and render the result.
      mustache.render(mustache.partial(name), self)
    end
pop()

Removes the most recently added object from the context’s internal stack.

Returns the Context.

# File lib/mustache/context.rb, line 53
    def pop
      @stack.shift
      self
    end
push(new)

Adds a new object to the context’s internal stack.

Returns the Context.

This method is also aliased as update
# File lib/mustache/context.rb, line 43
    def push(new)
      @stack.unshift(new)
      self
    end
update(new)

Alias for push