Class: Mustache::Context

Inherits:
Object
  • Object
show all
Defined in:
lib/mustache/context.rb

Overview

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(mustache) ⇒ Context

Expect to be passed an instance of ‘Mustache`.



18
19
20
 
# File 'lib/mustache/context.rb', line 18

def initialize(mustache)
  @stack = [mustache]
end

Instance Attribute Details

#frame ⇒ Object

Returns the value of attribute frame.



15
16
17
 
# File 'lib/mustache/context.rb', line 15

def frame
  @frame
end

#key ⇒ Object

Returns the value of attribute key.



15
16
17
 
# File 'lib/mustache/context.rb', line 15

def key
  @key
end

Instance Method Details

#[](name) ⇒ Object

Alias for ‘fetch`.



78
79
80
 
# File 'lib/mustache/context.rb', line 78

def [](name)
  fetch(name, nil)
end

#[]=(name, value) ⇒ Object

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

context = “Chris”



73
74
75
 
# File 'lib/mustache/context.rb', line 73

def []=(name, value)
  push(name => value)
end

#escapeHTML(str) ⇒ Object

Allows customization of how Mustache escapes things.

Returns a String.



48
49
50
 
# File 'lib/mustache/context.rb', line 48

def escapeHTML(str)
  mustache_in_stack.escapeHTML(str)
end

#fetch(name, default = :__raise) ⇒ Object

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.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/mustache/context.rb', line 96

def fetch(name, default = :__raise)
  @key = name

  @stack.each do |frame|
    # Prevent infinite recursion.
    next if frame == self
    @frame = frame

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

  @frame = @key = nil

  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) ⇒ Boolean

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

Returns:

  • (Boolean) 


84
85
86
87
88
 
# File 'lib/mustache/context.rb', line 84

def has_key?(key)
  !!fetch(key)
rescue ContextMiss
  false
end

#mustache_in_stack ⇒ Object

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



41
42
43
 
# File 'lib/mustache/context.rb', line 41

def mustache_in_stack
  @stack.detect { |frame| frame.is_a?(Mustache) }
end

#partial(name, indentation = '') ⇒ Object

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.



28
29
30
31
32
33
34
35
36
37
 
# File 'lib/mustache/context.rb', line 28

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)

  # Call the Mustache's `partial` method and render the result.
  result = mustache.render(part, self)
end

#pop ⇒ Object

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

Returns the Context.



65
66
67
68
 
# File 'lib/mustache/context.rb', line 65

def pop
  @stack.shift
  self
end

#push(new) ⇒ Object Also known as: update

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

Returns the Context.



55
56
57
58
 
# File 'lib/mustache/context.rb', line 55

def push(new)
  @stack.unshift(new)
  self
end