Class: Braintrust::Vendor::Mustache::Context

Inherits:
Object
  • Object
show all
Defined in:
lib/braintrust/vendor/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 Method Summary collapse

Constructor Details

#initialize(mustache) ⇒ Context

Initializes a Mustache::Context.

Parameters:

  • mustache (Mustache) —

    A Mustache instance.



20
21
22
23
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 20

def initialize(mustache)
  @stack = [mustache]
  @partial_template_cache = {}
end

Instance Method Details

#[](name) ⇒ Object

Alias for ‘fetch`.



99
100
101
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 99

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”



94
95
96
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 94

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

#current ⇒ Object 



157
158
159
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 157

def current
  @stack.first
end

#escape(value) ⇒ String

Allows customization of how Mustache escapes things.

Parameters:

  • value (Object) —

    Value to escape.

Returns:

  • (String) —

    Escaped string.



64
65
66
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 64

def escape(value)
  mustache_in_stack.escape(value)
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.



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 117

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

#find(obj, key, default = nil) ⇒ Object

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.

Parameters:

  • obj (Object) —

    The object to perform the lookup on.

  • key (String, Symbol) —

    The key whose value you want

  • default (Object) (defaults to: nil) —

    An optional default value, to return if the key is not found.

Returns:

  • (Object) —

    The value of key in object if it is found, and default otherwise.



144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 144

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

#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) 


105
106
107
108
109
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 105

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

#mustache_in_stack ⇒ Mustache

Find the first Mustache in the stack.

If we’re being rendered inside a Mustache object as a context, we’ll use that one.

Returns:

  • (Mustache) —

    First Mustache in the stack.



54
55
56
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 54

def mustache_in_stack
  @mustache_in_stack ||= @stack.find { |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.



32
33
34
35
36
37
38
39
40
41
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 32

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

#pop ⇒ Context

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

Returns:

  • (Context) —

    Returns the Context.



85
86
87
88
89
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 85

def pop
  @stack.shift
  @mustache_in_stack = nil
  self
end

#push(new_obj) ⇒ Context

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

Parameters:

  • new_obj (Object) —

    Object to be added to the internal stack.

Returns:

  • (Context) —

    Returns the Context.



74
75
76
77
78
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 74

def push(new_obj)
  @stack.unshift(new_obj)
  @mustache_in_stack = nil
  self
end

#template_for_partial(partial) ⇒ Object 



43
44
45
 
# File 'lib/braintrust/vendor/mustache/context.rb', line 43

def template_for_partial(partial)
  @partial_template_cache[partial] ||= Template.new(partial)
end