Class: Liquid::Context

### Home Classes Methods

### In Files

- lib/liquid/context.rb

### Parent

Object

### Methods

- ::new
- #[]
- #[]=
- #add_filters
- #clear_instance_assigns
- #handle_error
- #has_interrupt?
- #has_key?
- #invoke
- #merge
- #pop
- #pop_interrupt
- #push
- #push_interrupt
- #resource_limits_reached?
- #stack
- #strainer

### Class/Module Index

Quicksearch

- Liquid
- Liquid::ArgumentError
- Liquid::Assign
- Liquid::BlankFileSystem
- Liquid::Block
- Liquid::Break
- Liquid::BreakInterrupt
- Liquid::Capture
- Liquid::Case
- Liquid::Comment
- Liquid::Context
- Liquid::ContextError
- Liquid::Continue
- Liquid::ContinueInterrupt
- Liquid::Cycle
- Liquid::Decrement
- Liquid::Document
- Liquid::Drop
- Liquid::ElseCondition
- Liquid::Error
- Liquid::FileSystemError
- Liquid::FilterNotFound
- Liquid::For
- Liquid::If
- Liquid::Ifchanged
- Liquid::Include
- Liquid::Increment
- Liquid::Interrupt
- Liquid::LocalFileSystem
- Liquid::MemoryError
- Liquid::Raw
- Liquid::StackLevelError
- Liquid::StandardError
- Liquid::StandardFilters
- Liquid::SyntaxError
- Liquid::TableRow
- Liquid::Tag
- Liquid::Template
- Liquid::Unless
- Liquid::Utils
- Liquid::Variable
- FalseClass
- LiquidView
- Module
- NilClass
- TrueClass

No matching classes.

# Liquid::Context

Context keeps the variable stack and resolves variables, as well as keywords

    context['variable'] = 'testing'
    context['variable'] #=> 'testing'
    context['true']     #=> true
    context['10.2232']  #=> 10.2232

    context.stack do
       context['bob'] = 'bobsen'
    end

    context['bob']  #=> nil  class Context

### Constants

LITERALS

### Attributes

environments[R]
errors[R]
registers[R]
resource_limits[R]
scopes[R]

### Public Class Methods

new(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {}) click to toggle source

    # File lib/liquid/context.rb, line 18
    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
      @environments    = [environments].flatten
      @scopes          = [(outer_scope || {})]
      @registers       = registers
      @errors          = []
      @rethrow_errors  = rethrow_errors
      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
      squash_instance_assigns_with_environments

      @interrupts = []
    end

### Public Instance Methods

[](key) click to toggle source

    # File lib/liquid/context.rb, line 126
    def [](key)
      resolve(key)
    end

[]=(key, value) click to toggle source

Only allow String, Numeric, Hash, Array, Proc, Boolean or `Liquid::Drop`

    # File lib/liquid/context.rb, line 122
    def []=(key, value)
      @scopes[0][key] = value
    end

add_filters(filters) click to toggle source

Adds filters to this context.

Note that this does not register the filters with the main Template object. see `Template.register_filter` for that

    # File lib/liquid/context.rb, line 44
    def add_filters(filters)
      filters = [filters].flatten.compact

      filters.each do |f|
        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
        Strainer.add_known_filter(f)
        strainer.extend(f)
      end
    end

clear_instance_assigns() click to toggle source

    # File lib/liquid/context.rb, line 117
    def clear_instance_assigns
      @scopes[0] = {}
    end

handle_error(e) click to toggle source

    # File lib/liquid/context.rb, line 69
    def handle_error(e)
      errors.push(e)
      raise if @rethrow_errors

      case e
      when SyntaxError
        "Liquid syntax error: #{e.message}"
      else
        "Liquid error: #{e.message}"
      end
    end

has_interrupt?() click to toggle source

are there any not handled interrupts?

    # File lib/liquid/context.rb, line 55
    def has_interrupt?
      @interrupts.any?
    end

has_key?(key) click to toggle source

    # File lib/liquid/context.rb, line 130
    def has_key?(key)
      resolve(key) != nil
    end

invoke(method, *args) click to toggle source

    # File lib/liquid/context.rb, line 81
    def invoke(method, *args)
      strainer.invoke(method, *args)
    end

merge(new_scopes) click to toggle source

Merge a hash of variables in the current local scope

    # File lib/liquid/context.rb, line 92
    def merge(new_scopes)
      @scopes[0].merge!(new_scopes)
    end

pop() click to toggle source

Pop from the stack. use `Context#stack` instead

    # File lib/liquid/context.rb, line 97
    def pop
      raise ContextError if @scopes.size == 1
      @scopes.shift
    end

pop_interrupt() click to toggle source

pop an interrupt from the stack

    # File lib/liquid/context.rb, line 65
    def pop_interrupt
      @interrupts.pop
    end

push(new_scope={}) click to toggle source

Push new local scope on the stack. use `Context#stack` instead

    # File lib/liquid/context.rb, line 86
    def push(new_scope={})
      @scopes.unshift(new_scope)
      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
    end

push_interrupt(e) click to toggle source

push an interrupt to the stack. this interrupt is considered not handled.

    # File lib/liquid/context.rb, line 60
    def push_interrupt(e)
      @interrupts.push(e)
    end

resource_limits_reached?() click to toggle source

    # File lib/liquid/context.rb, line 30
    def resource_limits_reached?
      (@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
      (@resource_limits[:render_score_limit]  && @resource_limits[:render_score_current]  > @resource_limits[:render_score_limit] ) ||
      (@resource_limits[:assign_score_limit]  && @resource_limits[:assign_score_current]  > @resource_limits[:assign_score_limit] )
    end

stack(new_scope={}) click to toggle source

Pushes a new local scope on the stack, pops it at the end of the block

Example:

    context.stack do
       context['var'] = 'hi'
    end

    context['var]  #=> nil

    # File lib/liquid/context.rb, line 110
    def stack(new_scope={})
      push(new_scope)
      yield
    ensure
      pop
    end

strainer() click to toggle source

    # File lib/liquid/context.rb, line 36
    def strainer
      @strainer ||= Strainer.create(self)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.