Module: Zafu::Process::Context

Defined in:
lib/zafu/process/context.rb

Overview

This module manages the change of contexts by opening (each) or moving into the NodeContext. The ‘@context’ holds many information on the current compilation environment. Inside this context, the “node” context holds information on the type of “this” (first responder).

Instance Method Summary collapse

Instance Method Details

#context_without_vars ⇒ Object

Return a new context without contextual variables.



92
93
94
95
96
97
98
 
# File 'lib/zafu/process/context.rb', line 92

def context_without_vars
  context = @context.dup
  context.keys.each do |k|
    context.delete(k) if k.kind_of?(String)
  end
  context
end

#expand_with_finder(finder) ⇒ Object

Expand blocks in a new context. This method is partly overwriten in Ajax



102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/zafu/process/context.rb', line 102

def expand_with_finder(finder)
  if finder[:nil]
    open_node_context(finder, :form => nil) do # do not propagate :form
      expand_if("#{var} = #{finder[:method]}", node.move_to(var, finder[:class], finder.merge(:nil => false)))
    end
  else
    res = ''
    res << "<% #{var} = #{finder[:method]} -%>"
    open_node_context(finder, :node => node.move_to(var, finder[:class], finder), :form => nil) do
      res << wrap(expand_with)
    end
    res
  end
end

#get_context_var(group, key, context = @context) ⇒ Object

Retrieve a value from a given contextual group. The value must have been previously set with ‘set_context_var’ somewhere in the hierarchy.



87
88
89
 
# File 'lib/zafu/process/context.rb', line 87

def get_context_var(group, key, context = @context)
  context["#{group}::#{key}"]
end

#get_var_name(group_name, wanted_name, context = @context) ⇒ Object

Get a variable name and store the name in context variables for the given group.

Parameters

  • group_name - name of the variable context group

  • wanted_name - wanted variable name (used as key to get real var back later with #get_context_var)

  • context - (optional) can be used if we do not want to store the variable definition in the current context



145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/zafu/process/context.rb', line 145

def get_var_name(group_name, wanted_name, context = @context)
  secure_name = wanted_name.gsub(/[^a-zA-Z0-9]/,'')
  name = "_z#{secure_name}"
  i    = 0
  while get_context_var('var', name, context)
    i += 1
    name = "_z#{secure_name}#{i}"
  end
  set_context_var('var', name, true)
  set_context_var(group_name, wanted_name, name)
  name
end

#helper ⇒ Object 



63
64
65
 
# File 'lib/zafu/process/context.rb', line 63

def helper
  @context[:helper]
end

#need_dom_id? ⇒ Boolean

Return true if we need to insert the dom id for this element. This method is overwritten in Ajax.

Returns:

  • (Boolean) 


68
69
70
 
# File 'lib/zafu/process/context.rb', line 68

def need_dom_id?
  false
end

#node(klass = nil) ⇒ Object

Return the node context for a given class (looks up into the hierarchy) or the current node context if klass is nil.



74
75
76
77
 
# File 'lib/zafu/process/context.rb', line 74

def node(klass = nil)
  return @context[:node] if !klass
  @context[:node].get(klass)
end

#node_context_vars(finder) ⇒ Object

This method is called when we enter a new node context



132
133
134
135
 
# File 'lib/zafu/process/context.rb', line 132

def node_context_vars(finder)
  # do nothing (this is a hook for other modules like QueryBuilder and RubyLess)
  {}
end

#open_node_context(finder, cont = {}) ⇒ Object

This should be called when we enter a new node context so that the proper hooks are triggered (insertion of contextual variables).



174
175
176
177
178
179
180
 
# File 'lib/zafu/process/context.rb', line 174

def open_node_context(finder, cont = {})
  sub_context = node_context_vars(finder).merge(cont)

  with_context(sub_context) do
    yield
  end
end

#r_each ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/zafu/process/context.rb', line 7

def r_each
  if node.list_context?
    if @params[:alt_class] || @params[:join]
      out "<% #{var}_max_index = #{node}.size - 1 -%>" if @params[:alt_reverse]
      out "<% #{node}.each_with_index do |#{var},#{var}_index| -%>"

      if join = @params[:join]
        join = RubyLess.translate_string(self, join)
        #if join_clause = @params[:join_if]
        #  set_stored(Node, 'prev', "#{var}_prev")
        #  cond = get_test_condition(var, :test=>join_clause)
        #  out "<%= #{var}_prev = #{node}[#{var}_index - 1]; (#{var}_index > 0 && #{cond}) ? #{join.inspect} : '' %>"
        #else
          out "<%= #{var}_index > 0 ? #{join} : '' %>"
        #end
      end

      if alt_class = @params[:alt_class]
        alt_class = RubyLess.translate_string(self, alt_class)
        alt_test = @params[:alt_reverse] == 'true' ? "(#{var}_max_index - #{var}_index) % 2 != 0" : "#{var}_index % 2 != 0"
        @markup.append_dyn_param(:class, "<%= #{alt_test} ? #{alt_class} : '' %>")
        @markup.tag ||= 'div'
      end
    else
      out "<% #{node}.each do |#{var}| -%>"
    end


    with_context(:node => node.move_to(var, node.klass.first, :query => node.opts[:query])) do
      # We pass the :query option for RubyLess resolution by using the QueryBuilder finder

      # The id set here should be used as prefix for sub-nodes to ensure uniqueness of generated DOM ids
      if node.list_context?
        # we are still in a list (example: previous context was [[Node]], current is [Node])
      else
        node.propagate_dom_scope!
      end

      steal_and_eval_html_params_for(@markup, @params)

      if need_dom_id?
        set_dom_prefix
        @markup.set_id(node.dom_id)
      end

      out wrap(expand_with)
    end
    out "<% end -%>"
  else
    out expand_with
  end

  # We need to return true for Ajax 'make_form'
  true
end

#set_context_var(group, key, obj, context = @context) ⇒ Object

Store some contextual value / variable inside a named group. This should be used to avoid key clashes between different types of elements to store.



81
82
83
 
# File 'lib/zafu/process/context.rb', line 81

def set_context_var(group, key, obj, context = @context)
  context["#{group}::#{key}"] = obj
end

#var ⇒ Object

def context_with_node(name, klass)

context = @context.dup
context[:node] = context[:node].move_to(name, klass)

end



122
123
124
125
126
127
128
129
 
# File 'lib/zafu/process/context.rb', line 122

def var
  return @var if @var
  if node.name =~ /^var(\d+)$/
    @var = "var#{$1.to_i + 1}"
  else
    @var = "var1"
  end
end

#with_context(cont, merge = true) ⇒ Object

Change context for a given scope.



159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/zafu/process/context.rb', line 159

def with_context(cont, merge = true)
  raise "Block missing" unless block_given?
  cont_bak = @context.dup
    if merge
      @context.merge!(cont)
    else
      @context = cont
    end
    res = yield
  @context = cont_bak
  res
end