zena 0.15.2 → 0.16.0

data/app/controllers/sessions_controller.rb

@@ -1,41 +0,0 @@
-=begin rdoc
-Create, destroy sessions by letting users login and logout. When the user does not login, he/she is considered to be the anonymous user.
-=end
-class SessionsController < ApplicationController
-  skip_before_filter :authorize
-
-  def new
-    respond_to do |format|
-      format.html do
-        @node = visitor.site.root_node
-        render_and_cache :mode => '+login'
-      end
-    end
-  end
-
-  def create
-    if user = User.login(params[:login], params[:password], request.host)
-      successful_login(user)
-    else
-      failed_login _("Invalid login or password.")
-    end
-  end
-
-  # Clears session information and redirects to home page.
-  def destroy
-    reset_session
-    if request.referer =~ %r{(http://#{visitor.site.host}:\d*/)#{AUTHENTICATED_PREFIX}(.*)}
-      redirect_to $1 + visitor.lang + $2
-    else
-      redirect_to :controller => 'nodes', :action => 'index', :prefix => visitor.lang
-    end
-  end
-
-  protected
-
-    def failed_login(message)
-      session[:user] = nil
-      flash[:error] = message
-      redirect_to '/login'
-    end
-end

data/app/views/sites/zena_up.html.erb

@@ -1,11 +0,0 @@
-<% if @state == :wait -%>
-  <h2><%= _('Updating...') %></h2>
-  <p><%= _('Please wait while the code is updated and the site restarts (page reloads every 30s).') %></p>
-<% elsif @state == :done -%>
-  <h2><%= _('Up to date') %></h2>
-  <p><%= _('Your site is running the latest version of zena.') %> (<%= Zena::VERSION %> r<%= @target_rev %>)</p>
-<% else -%>
-  <h2><%= _('Update') %></h2>
-  <p><%= sprintf(_('Your site is running rev %i, newest revision is %i.'), @current_rev, @target_rev) %></p>
-  <p><%= link_to(_('Update'), :action => 'zena_up', :run => 'start', :rev => @target_rev) %></p>
-<% end -%>

data/config/database.yml

@@ -1,40 +0,0 @@
-# Enter database configuration information here (rename this file "database.yml").
-# You do not need to do any of this if you use capistraon (see config/deploy.rg).
-# MySQL
-login: &dev_login
-  adapter: mysql
-  socket: /tmp/mysql.sock
-  username: root
-  password:
-
-development:
-  database: zena_dev
-  encoding: utf8
-  <<: *dev_login
-
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-test:
- database: zena_test
- encoding: utf8
- <<: *dev_login
-
-# FIXME: use in memory sqlite3 for testing
-#test:
-#  adapter: sqlite3
-#  database: db/test.sqlite3
-#  pool: 5
-#  timeout: 5000
-#
-production:
-  database: zena_dev
-  encoding: utf8
-  <<: *dev_login
-
-#production:
-#  adapter: sqlite3
-#  database: db/production.sqlite3
-#  pool: 5
-#  timeout: 5000
-#

data/lib/bricks/patcher.rb

@@ -1,68 +0,0 @@
-module Bricks
-  class Patcher
-    class << self
-      def bricks_folders
-        @bricks_folders ||= [File.join(Zena::ROOT, 'bricks'), File.join(RAILS_ROOT, 'bricks')].uniq.reject {|f| !File.exist?(f)}
-      end
-
-      def models_paths
-        bricks_folders.map {|f| Dir["#{f}/**/models"] }.flatten
-      end
-
-      def libs_paths
-        bricks_folders.map {|f| Dir["#{f}/**/lib"] }.flatten
-      end
-
-      def foreach_brick(&block)
-        bricks_folders.each do |bricks_folder|
-          next unless File.exist?(bricks_folder)
-          Dir.entries(bricks_folder).sort.each do |brick|
-            next if brick =~ /\A\./
-            block.call(File.join(bricks_folder, brick))
-          end
-        end
-      end
-
-      def apply_patches(file_name = nil)
-        file_name ||= caller[0].split('/').last.split(':').first
-        foreach_brick do |brick_path|
-          patch_file = File.join(brick_path, 'patch', file_name)
-          if File.exist?(patch_file)
-            load patch_file
-          end
-        end
-      end
-
-      def load_bricks
-        # load all libraries in bricks
-        libs_paths.each do |lib_path|
-          Dir.foreach(lib_path) do |f|
-            next unless f =~ /\A.+\.rb\Z/
-            require File.join(lib_path, f)
-          end
-        end
-
-        # FIXME: do we really need to load these now, load_path isn't enough ?
-        models_paths.each do |models_path|
-          Dir.foreach(models_path) do |f|
-            next unless f =~ /\A.+\.rb\Z/
-            require File.join(models_path, f)
-          end
-        end
-      end
-
-      def load_zafu(mod)
-        foreach_brick do |brick_path|
-          brick_name = File.basename(brick_path)
-          zafu_path  = File.join(brick_path, 'zafu')
-          next unless File.exist?(zafu_path)
-          Dir.foreach(zafu_path) do |rules_name|
-            next if rules_name =~ /\A\./
-            load File.join(zafu_path, rules_name)
-          end
-          mod.send(:include, eval("Bricks::#{brick_name.capitalize}::Zafu"))
-        end
-      end
-    end
-  end
-end

data/lib/zena/parser/zena_tags.rb

@@ -1,3562 +0,0 @@
-=begin
-Thoughts for ajax related stuff cleanup (dom_id, erb_dom_id, ...)
-
-When we open a list context:
-- we change the context_dom_id => unique name => "page"
-
-When we open a single context (do_var, each, block):
-- we change the context_dom_id => unique name with id => "page_{parent_id}"
-
-Any 'id' is set with:
-- "{context_dom_id}_{id}"  => 'page_34' (if not in list) or 'page_12_34' if in list.
-
-
-List in list (initial node zip = 12):
-                             context_dom_id    dom_id          (context_erb_dom_id, erb_dom_id)
-<ul>                         page_12           page_12         [pages in='site']  new unique name
-  <li id='page_12_13'>       page_12           page_12_13      [each]   expand_with(:context_dom_id => 'page_13')
-    <ul>                     page_13
-      <li id='page_13_23'/>  page_13           page_13_23      [each]
-      <li id='page_13_24'/>  page_13           page_13_24      [each]
-      <li id='page_13_25'/>  page_13           page_13_25      [each]
-    </ul>
-  </li>
-  <li id='page_12_14'>       page_12           page_12_14      [each]   expand_with(:context_dom_id => 'page_14')
-    <ul>
-      <li id='page_14_23'/>  page_14           page_14_23      [each]   expand_with(:context_dom_id => 'page_23')
-      <li id='page_14_27'/>  page_14           page_14_27      [each]   ...
-    </ul>
-  </li>
-</ul>
-
-<div id='page1_12'>          page1_12          page1_12        [block]    new unique name
-  <ul>
-    <li id='page1_12_24'/>   page1_12          page1_12_24     [each]
-    <li id='page1_12_32'/>   page1_12          page1_12_32     [each]
-  </ul>
-</div>
-=end
-
-require 'yaml'
-
-module Zena
-  module Parser
-    include RubyLess::SafeClass
-    # Zafu tags used to display / edit nodes and versions
-    module ZenaTags
-      PSEUDO_ATTRIBUTES = {
-        'now'      => 'Time.now',
-        'start.id' => '(params[:s] || @node[:zip])',
-        'nil'      => 'nil',
-      }
-
-      class << self
-        def inline_methods(*args)
-          args.each do |name|
-            class_eval <<-END
-              def r_#{name}
-                "<%= #{name}(:node=>\#{node}\#{params_to_erb(@params)}) %>"
-              end
-            END
-          end
-        end
-
-        def direct_methods(*args)
-          args.each do |name|
-            class_eval <<-END
-              def r_#{name}
-                helper.#{name}
-              end
-            END
-          end
-        end
-      end
-      inline_methods :login_link, :visitor_link, :search_box, :show_menu, :show_path, :lang_links
-      direct_methods :uses_datebox
-
-      def before_render
-        return unless super
-
-        @var = nil # reset var counter
-
-        if key = @params[:store]
-          set_stored(Node, key, node)
-        end
-
-        if key = @params[:store_date]
-          set_stored(Date, key, current_date)
-        end
-        @anchor_param = @params[:anchor]
-
-        true
-      end
-
-      def do_method(sym)
-        method = sym
-        pre, post = '', ''
-
-        # do we need recursion ?
-        inc = descendant('include')
-        if inc && inc.params[:part] == @name
-          @context["#{@name}_method".to_sym] = method_name = template_url[1..-1].gsub(/[\/-]/,'_')
-          pre << "<% def #{method_name}(depth, node, list); return '' if depth > #{inc.params[:depth] ? [inc.params[:depth].to_i,30].min : 5}; _erbout = '' -%>"
-          post << "<% _erbout; end -%><%= #{method_name}(0,#{node},#{list || "[#{node}]"}) %>"
-          @context[:node] = 'node'
-          @context[:list] = 'list'
-        end
-
-        if @context[:make_form]
-          res = case method
-          when :r_title
-            make_input(:name => 'v_title')
-          when :r_link
-            make_input(:name => (@params[:attr] || 'v_title'))
-          when :r_show
-            make_input(:name => (@params[:attr] || @params[:tattr]), :date => @params[:date])
-          when :r_text
-            make_textarea(:name => 'v_text')
-          when :r_summary
-            make_textarea(:name => 'v_summary')
-          when :r_zazen
-            make_textarea(:name => @params[:attr])
-          else
-            if node_kind_of?(DataEntry) && @method.to_s =~ /node_/
-              # select node_id
-              "<%= select_id('#{base_class.to_s.underscore}', '#{@method}_id') %>"
-            end
-          end
-          res =  "<#{@html_tag || 'div'} class='zazen'>#{res}</#{@html_tag || 'div'}>" if [:r_summary, :r_text].include?(sym)
-        end
-
-
-        res ||= super(method)
-        "#{pre}#{res}#{post}"
-      end
-
-
-      def after_render(text)
-        if @anchor_param
-          @params[:anchor] = @anchor_param # set back in case of double rendering so it is computed again
-          res = r_anchor + super
-        else
-          res = super
-        end
-        res
-      end
-
-      # Our special version of r_expand_with tag with "set_" parsing.
-      def r_expand_with
-        hash = {}
-        @params.each do |k,v|
-          if k.to_s =~ /^set_(.+)$/
-            # TODO: DRY with render_html_tag
-            k   = $1
-            value, static = parse_attributes_in_value(v, :erb => false)
-            hash["exp_#{k}"] = static ? value.inspect : "\"#{value}\""
-          else
-            hash["exp_#{k}"] = v.inspect
-          end
-        end
-        @params = {}
-        expand_with(hash)
-      end
-
-      def r_show
-        if attr_or_date = @params[:attr_or_date]
-          # using [var] shortcut. Can be either a date or an attribute/var
-          if attr_or_date == 'current_date' || attr_or_date =~ /_at$/
-            @params[:date] = attr_or_date
-          else
-            @params[:attr] = attr_or_date
-          end
-        end
-
-        if var_name = @params[:var]
-          return parser_error("var #{@params[:var].inspect} not set") unless @context[:vars] && @context[:vars].include?(var_name)
-          attribute_method = "set_#{var_name}"
-        elsif @params[:eval]
-          return unless attribute_method = parse_eval_parameter(@params[:eval])
-        elsif @params[:tattr]
-          attribute_method = "_(#{node_attribute(@params[:tattr], :else=>@params[:else], :default=>@params[:default])})"
-        elsif @params[:attr]
-          attribute_method = node_attribute(@params[:attr], :else=>@params[:else], :default=>@params[:default])
-        elsif p = @params[:param]
-          return "<%= params[#{p.to_sym.inspect}] %>"
-        elsif @params[:date]
-          # date can be any attribute v_created_at or updated_at etc.
-          # TODO format with @params[:format] and @params[:tformat] << translated format
-          # TODO: test
-          if @params[:tformat]
-            format = _(@params[:tformat])
-          elsif @params[:format]
-            format = @params[:format]
-          else
-            format = "%Y-%m-%d"
-          end
-
-          tz   = ''
-          lang = ''
-          if tz_name = @params[:time_zone]
-            tz_list = @params.reject {|k,v| !(k.to_s =~ /^time_zone\d*$/)}.to_a.sort {|a,b| a[0].to_s <=> b[0].to_s }.map do |k,tz_name|
-              if tz_name =~ /^\[(\w+)\]$/
-                node_attribute($1)
-              else
-                begin
-                  TZInfo::Timezone.get(tz_name)
-                rescue TZInfo::InvalidTimezoneIdentifier
-                  return parser_error("invalid timezone #{tz_name.inspect}")
-                end
-                tz_name.inspect
-              end
-            end
-            tz = ", #{tz_list.join(' || ')}"
-          end
-          if lang = @params[:lang]
-            tz = ', nil' if tz == ''
-            lang = ", #{lang.inspect}"
-          end
-          attribute_method = "format_date(#{node_attribute(@params[:date])}, #{format.inspect}#{tz}#{lang})"
-        elsif @context[:trans]
-          # error
-          return "no attribute for 'show'".inspect
-        else
-          return parser_error("missing attribute")
-        end
-
-        if !@params[:date] && fmt = @params[:format]
-          begin
-            # test argument
-            sprintf(fmt, 123.45)
-          rescue ArgumentError
-            return parser_error("incorect format #{fmt.inspect}")
-          end
-          if fmt =~ /%[\d\.]*f/
-            modifier = ".to_f"
-          elsif fmt =~ /%[\d\.]*i/
-            modifier = ".to_i"
-          else
-            modifier = ''
-          end
-
-          if @params[:zero] == 'hide'
-            attribute_method = "sprintf_unless_zero(#{fmt.inspect}, #{attribute_method}#{modifier})"
-          else
-            attribute_method = "sprintf(#{fmt.inspect}, #{attribute_method}#{modifier})"
-          end
-        end
-
-
-        if @context[:trans]
-          # TODO: what do we do here with gsubs, url ?
-          return attribute_method
-        end
-
-        if gsub = @params[:gsub]
-          if gsub =~ /\A\/(.+)\/(.+)\/\Z/
-            value = $2
-            key   = $1.gsub(/\#([\{\$\@])/,'# \1') # FIXME: SECURITY.
-                                                   # Please note that .gsub(/#([\{\$\@])/,'\#\1') won't work, since '\#{blah}' will become '\\#{blah}' and 'blah' will be evaluated.
-            regexp_ok = begin
-              output = StringIO.open('','w')
-              $stderr = output
-              re = /#{key}/
-              output.string !~ /warning:/
-            rescue
-              false
-            ensure
-              $stderr = STDERR
-              false
-            end
-
-            if regexp_ok
-              attribute_method = "#{attribute_method}.to_s.gsub(/#{key}/,#{value.inspect})"
-            else
-              # invalid regexp
-              return parser_error("invalid gsub #{gsub.inspect}")
-            end
-          else
-            # error
-            return parser_error("invalid gsub #{gsub.inspect}")
-          end
-        end
-
-        if @params[:actions]
-          actions = "<%= node_actions(:node=>#{node}#{params_to_erb(:actions=>@params[:actions], :publish_after_save=>auto_publish_param)}) %>"
-        else
-          actions = ''
-        end
-
-        attribute = @params[:attr] || @params[:tattr] || @params[:date]
-
-        if (@params[:edit_preview] || @params[:ep]) == 'true'
-          @html_tag_params[:id] = "#{attribute}#{erb_node_id}"
-          @html_tag ||= 'span'
-        end
-
-        if @params[:edit] == 'true' && !['url','path'].include?(attribute)
-          "<% if #{node}.can_write? -%><span class='show_edit' id='#{erb_dom_id("_#{attribute}")}'>#{actions}<%= link_to_remote(#{attribute_method}, :url => edit_node_path(#{node_id}) + \"?attribute=#{attribute}&dom_id=#{dom_id("_#{attribute}")}#{auto_publish_param(true)}\", :method => :get) %></span><% else -%>#{actions}<%= #{attribute_method} %><% end -%>"
-        else
-          "#{actions}<%= #{attribute_method} %>"
-        end
-      end
-
-      def r_zazen
-        attribute = @params[:attr] || @params[:tattr]
-        limit  = @params[:limit] ? ", :limit=>#{@params[:limit].to_i}" : ""
-        if @context[:trans]
-          # TODO: what do we do here with dates ?
-          return "#{node_attribute(attribute)}"
-        elsif @params[:tattr]
-          return "<%= zazen(_(#{node_attribute(attribute)})#{limit}, :node=>#{node(Node)}) %>"
-        elsif @params[:attr]
-          if output_format == 'html'
-            res = "<%= zazen(#{node_attribute(attribute)}#{limit}, :node=>#{node(Node)}) %>"
-          else
-            return "<%= zazen(#{node_attribute(attribute)}#{limit}, :node=>#{node(Node)}, :output=>#{output_format.inspect}) %>"
-          end
-        elsif @params[:date]
-          # date can be any attribute v_created_at or updated_at etc.
-          # TODO format with @params[:format] and @params[:tformat] << translated format
-        else
-          # error
-        end
-
-        @html_tag ||= 'div'
-
-        add_html_class('zazen')
-
-        if (@params[:edit_preview] || @params[:ep]) == 'true'
-          @html_tag_params[:id] = "#{attribute}#{erb_node_id}"
-        end
-
-        if @params[:edit] == 'true' && !['url','path'].include?(attribute)
-          edit_text = _('edit')
-          @html_tag_params[:id] = erb_dom_id("_#{attribute}")
-          res = "<% if #{node}.can_write? -%><span class='zazen_edit'><%= link_to_remote(#{edit_text.inspect}, :url => edit_node_path(#{node_id}) + \"?attribute=#{attribute}&dom_id=#{dom_id("_#{attribute}")}#{auto_publish_param(true)}&zazen=true\", :method => :get) %></span><% end -%>#{res}"
-        else
-          res
-        end
-      end
-
-      # TODO: test, rename ?
-      def r_search_results
-        do_list("@nodes")
-      end
-
-
-      def r_set
-        return parser_error("'var' missing") unless var_name = @params[:var]
-        return parser_error("bad value for 'var' (#{var_name.inspect})") unless var_name =~ /^[a-zA-Z_]+$/
-        return '' unless @context[:set]
-        if @params[:value]
-          out "<% set_#{var_name} = #{@params[:value].inspect} -%>"
-          # TODO: isn't @context[:vars] = @params[:value].inspect missing here ?
-        elsif @params[:eval]
-          return unless eval_string = parse_eval_parameter(@params[:eval])
-          out "<% set_#{var_name} = #{eval_string} -%>"
-        else
-          out "<% set_#{var_name} = capture do %>"
-          out expand_with(:set => false) # do not propagate
-          out "<% end -%>"
-        end
-      end
-
-
-      # TODO: write a test (please)
-      # FIXME: we should use a single way to change a whole context into a template (applies to 'each', 'form', 'block'). Then 'swap' could use the 'each' block.
-      # Define a block of elements to be used by ajax calls (edit/filter)
-      def r_block
-        if @context[:block] == self
-          # called from self (storing template)
-          @context.reject! do |k,v|
-            # FIXME: reject all stored elements in a  better way then this
-            k.kind_of?(String) && k =~ /\ANode_\w/
-          end
-          @html_tag_done = false
-          @html_tag_params.merge!(:id=>erb_dom_id)
-          @context[:scope_node] = node if @context[:scope_node]
-          out expand_with(:node => node)
-          if @method == 'drop' && !@context[:make_form]
-            out drop_javascript
-          end
-        else
-          if parent.method == 'each' && @method == parent.single_child_method
-            # use parent as block
-            # FIXME: will not work with block as distant target...
-            # do nothing
-          else
-            @html_tag ||= 'div'
-            new_dom_scope
-
-            unless @context[:make_form]
-              # STORE TEMPLATE ========
-
-              context_bak = @context.dup # avoid side effects when rendering the same block
-              ignore_list = @method == 'block' ? ['form'] : [] # do not show the form in the normal template of a block
-              template    = expand_block(self, :block=>self, :list=>false, :saved_template=>true, :ignore => ignore_list)
-              @context    = context_bak
-              @result     = ''
-              out helper.save_erb_to_url(template, template_url)
-
-              # STORE FORM ============
-              if edit = descendant('edit')
-                publish_after_save = (edit.params[:publish] == 'true')
-                if form = descendant('form')
-                  # USE BLOCK FORM ========
-                  form_text = expand_block(form, :saved_template=>true, :publish_after_save => publish_after_save)
-                else
-                  # MAKE A FORM FROM BLOCK ========
-                  form = self.dup
-                  form.method = 'form'
-                  form_text = expand_block(form, :make_form => true, :list => false, :saved_template => true, :publish_after_save => publish_after_save)
-                end
-                out helper.save_erb_to_url(form_text, form_url)
-              end
-            end
-
-            # RENDER
-            @html_tag_done = false
-            @html_tag_params.merge!(:id=>erb_dom_id)
-          end
-
-          out expand_with
-          if @method == 'drop' && !@context[:make_form]
-            out drop_javascript
-          end
-        end
-      end
-
-      # TODO: test
-      def r_filter
-        if upd = @params[:update]
-          return unless block = find_target(upd)
-        else
-          return parser_error("missing 'block' in same parent") unless parent && block = parent.descendant('block')
-        end
-        return parser_error("cannot use 's' as key (used by start_node)") if @params[:key] == 's'
-        out "<%= form_remote_tag(:url => zafu_node_path(#{node_id}), :method => :get, :html => {:id => \"#{dom_id}_f\"}) %><div class='hidden'><input type='hidden' name='t_url' value='#{block.template_url}'/><input type='hidden' name='dom_id' value='#{block.erb_dom_id}'/>#{start_node_s_param(:input)}</div><div class='wrapper'>"
-        if @blocks == []
-          out "<input type='text' name='#{@params[:key] || 'f'}' value='<%= params[#{(@params[:key] || 'f').to_sym.inspect}] %>'/>"
-        else
-          out expand_with(:in_filter => true)
-        end
-        out "</div></form>"
-        if @params[:live] || @params[:update]
-          out "<%= observe_form( \"#{dom_id}_f\" , :method => :get, :frequency  =>  1, :submit =>\"#{dom_id}_f\", :url => zafu_node_path(#{node_id})) %>"
-        end
-      end
-
-      # swap an attribute
-      # TODO: test
-      def r_swap
-        if upd = @params[:update]
-          if upd == '_page'
-            block = nil
-          elsif block = find_target(upd)
-            # ok
-            if ancestor('block') || ancestor('each')
-              upd_both = '&upd_both=true'
-            else
-              upd_both = ''
-            end
-          else
-            return
-          end
-        elsif ancestor('block') || ancestor('each')
-          # ancestor: ok
-          block = self
-        elsif parent && block = parent.descendant('block')
-          # sibling: ok
-          upd_both = ''
-        else
-          return parser_error("missing 'block' in same parent")
-        end
-
-        states = ((@params[:states] || 'todo, done') + ' ').split(',').map(&:strip)
-
-        query_params = "node[#{@params[:attr]}]=\#{#{states.inspect}[ ((#{states.inspect}.index(#{node_attribute(@params[:attr])}.to_s) || 0)+1) % #{states.size}]}#{upd_both}"
-        out link_to_update(block, :query_params => query_params, :method => :put, :html_params => get_html_params(@params, :link))
-      end
-
-      def r_load
-        if dict = @params[:dictionary]
-          dict_content, absolute_url, doc = self.class.get_template_text(dict, @options[:helper], @options[:current_folder])
-          return parser_error("dictionary #{dict.inspect} not found") unless doc
-          @context[:dict] ||= {}
-          begin
-            definitions = YAML::load(dict_content)
-            definitions['translations'].each do |elem|
-              @context[:dict][elem[0]] = elem[1]
-            end
-          rescue
-            return parser_error("invalid dictionary content #{dict.inspect}")
-          end
-        else
-          return parser_error("missing 'dictionary'")
-        end
-        expand_with
-      end
-
-      def r_trans
-        static = true
-        if @params[:text]
-          text = @params[:text]
-        elsif @params[:attr]
-          text = "#{node_attribute(@params[:attr])}"
-          static = false
-        else
-          res  = []
-          text = ""
-          @blocks.each do |b|
-            if b.kind_of?(String)
-              res  << b.inspect
-              text << b
-            elsif ['show', 'current_date'].include?(b.method)
-              res << expand_block(b, :trans=>true)
-              static = false
-            else
-              # ignore
-            end
-          end
-          unless static
-            text = res.join(' + ')
-          end
-        end
-        if static
-          _(text)
-        else
-          "<%= _(#{text}) %>"
-        end
-      end
-
-      alias r_t r_trans
-
-      def r_anchor(obj=node)
-        "<a name='#{anchor_name(@anchor_param, obj)}'></a>"
-      end
-
-      def anchor_name(p, obj=node)
-        if p =~ /\[(.+)\]/
-          "<%= #{node_attribute($1)} %>"
-        else
-          "#{base_class.to_s.underscore}#{erb_node_id(obj)}"
-        end
-      end
-
-      def r_content_for_layout
-        "<% if content_for_layout = yield -%><%= content_for_layout %><% else -%>" +
-        expand_with +
-        "<% end -%>"
-      end
-
-      def r_title_for_layout
-        "<% if @title_for_layout -%><%= @title_for_layout %><% elsif @node && !@node.new_record? -%><%= @node.rootpath %><% elsif @node.parent -%><%= @node.parent.rootpath %><% else -%>" +
-        expand_with +
-        "<% end -%>"
-      end
-
-      def r_check_lang
-        text = @params[:text]   || expand_with
-        klass = @params[:class] || @html_tag_params[:class]
-        text = nil if text.blank?
-        klas = nil if klass.blank?
-        @html_tag_done = true
-        "#{@space_before}<%= check_lang(#{node},:text=>#{text.inspect},:class=>#{klass.inspect},:wrap=>#{@html_tag.inspect}) %>"
-      end
-
-      def r_title
-        if node_kind_of?(Version)
-          node = "#{self.node}.node"
-        elsif node_kind_of?(Node)
-          node = self.node
-        else
-          return parser_error('title','only works with nodes')
-        end
-        title_params = {}
-
-        title_params[:check_lang] = @params[:check_lang] if @params.include?(:check_lang)
-
-        if @params[:link]
-          value, static = parse_attributes_in_value(@params[:link], :erb => false)
-          link_param = ", :link=>\"#{value}\""
-        else
-          link_param = ''
-        end
-
-        res = "<%= show_title(:node=>#{node}#{link_param}#{params_to_erb(title_params)}"
-        if @params[:text]
-          res << ", :text=>#{@params[:text].inspect}"
-        elsif @params[:attr]
-          res << ", :text=>#{node_attribute(@params[:attr])}"
-        end
-
-        if @params.include?(:project)
-          res << ", :project=>#{@params[:project] == 'true'}"
-        end
-        res << ")"
-        if @params[:actions]
-          res << " + node_actions(:node=>#{node}#{params_to_erb(:actions=>@params[:actions], :publish_after_save=>auto_publish_param)})"
-        end
-        res << "%>"
-        if @params[:status] == 'true' || (@params[:status].nil? && @params[:actions])
-          @html_tag ||= 'span'
-          add_html_class("s<%= #{node}.version.status %>")
-        end
-        res
-      end
-
-      # TODO: test
-      def r_actions
-        out expand_with
-        out "<%= node_actions(:node=>#{node}#{params_to_erb(:actions=>@params[:select], :publish_after_save=>auto_publish_param)}) %>"
-      end
-
-      # TODO: test
-      def r_admin_links
-        "<%= show_link(:admin_links).join('</#{@html_tag}><#{@html_tag}>') %>"
-      end
-
-      def r_text
-        text = @params[:text] ? @params[:text].inspect : "#{node_attribute('v_text')}"
-        limit  = @params[:limit] ? ", :limit=>#{@params[:limit].to_i}" : ""
-
-        @html_tag ||= 'div'
-
-        if @html_tag_params[:id]
-          # add a sub-div
-          pre  = "<div id='v_text#{erb_node_id}'>"
-          post = "</div>"
-        else
-          pre = post = ''
-          @html_tag_params[:id] = "v_text#{erb_node_id}"
-        end
-
-        add_html_class('zazen')
-
-        unless @params[:empty] == 'true'
-          out "#{pre}<% if #{node}.kind_of?(TextDocument); l = #{node}.content_lang -%>"
-          out "<%= zazen(\"<code\#{l ? \" lang='\#{l}'\" : ''} class=\\'full\\'>\#{#{text}}</code>\") %>"
-          out "<% else -%>"
-          out "<%= zazen(#{text}#{limit}, :node=>#{node(Node)}) %>"
-          out "<% end -%>#{post}"
-        else
-          out "#{pre}#{post}"
-        end
-      end
-
-      def r_inspect
-        out ["params: #{@params.inspect}",
-        "name:   #{@context[:name]}",
-        "node:   #{node}",
-        "list:   #{list}"].join("<br/>")
-      end
-
-      # TODO: replace with a more general 'zazen' or 'show' with id ?
-      def r_summary
-        limit  = @params[:limit] ? ", :limit=>#{@params[:limit].to_i}" : ""
-        @html_tag ||= 'div'
-        if @html_tag_params[:id]
-          # add a sub-div
-          pre  = "<div id='v_summary#{erb_node_id}'>"
-          post = "</div>"
-        else
-          pre = post = ''
-          @html_tag_params[:id] = "v_summary#{erb_node_id}"
-        end
-
-        add_html_class('zazen')
-
-        unless @params[:or]
-          text = @params[:text] ? @params[:text].inspect : node_attribute('v_summary')
-          out "#{pre}<%= zazen(#{text}#{limit}, :node=>#{node(Node)}) %>#{post}"
-        else
-          limit ||= ', :limit => 2'
-          first_name = 'v_summary'
-          first  = node_attribute(first_name)
-
-          second_name = @params[:or].gsub(/[^a-z_]/,'') # FIXME: ist this still needed ? (ERB injection)
-          second = node_attribute(second_name)
-          out "#{pre}<% if #{first} != '' %>"
-          out "<%= zazen(#{first}, :node=>#{node(Node)}) %>"
-          out "<% else %>"
-          out "<%= zazen(#{second}#{limit}, :node=>#{node(Node)}) %>"
-          out "<% end %>#{post}"
-        end
-      end
-
-      def r_show_author
-        if @params[:size] == 'large'
-          out "#{_("posted by")} <b><%= #{node}.author.fullname %></b>"
-          out "<% if #{node}[:user_id] != #{node}.version[:user_id] -%>"
-          out "<% if #{node}[:ref_lang] != #{node}.version[:lang] -%>"
-          out "#{_("traduction by")} <b><%= #{node}.version.author.fullname %></b>"
-          out "<% else -%>"
-          out "#{_("modified by")} <b><%= #{node}.version.author.fullname %></b>"
-          out "<% end"
-          out "   end -%>"
-          out " #{_("on")} <%= format_date(#{node}.version.updated_at, #{_('short_date').inspect}) %>."
-          if @params[:traductions] == 'true'
-            out " #{_("Traductions")} : <span class='traductions'><%= helper.traductions(:node=>#{node}).join(', ') %></span>"
-          end
-        else
-          out "<b><%= #{node}.version.author.initials %></b> - <%= format_date(#{node}.version.updated_at, #{_('short_date').inspect}) %>"
-          if @params[:traductions] == 'true'
-            out " <span class='traductions'>(<%= helper.traductions(:node=>#{node}).join(', ') %>)</span>"
-          end
-        end
-      end
-
-      def r_comments_to_publish
-        open_context("visitor.comments_to_publish", :node_class => [Comment])
-      end
-
-      def r_to_publish
-        open_context("visitor.to_publish", :node_class => [Version])
-      end
-
-      def r_proposed
-        open_context("visitor.proposed", :node_class => [Version])
-      end
-
-      def r_redactions
-        open_context("visitor.redactions", :node_class => [Version])
-      end
-
-      def r_edit
-
-        if @context[:dom_prefix]
-          # ajax
-          if @context[:in_form]
-            # cancel button
-            @context[:form_cancel] || ''
-          else
-            # edit button
-
-            # TODO: show 'reply' instead of 'edit' in comments if visitor != author
-            out link_to_update(self, :default_text => _('edit'), :url => "\#{edit_#{base_class.to_s.underscore}_path(#{node_id})}", :html_params => get_html_params(@params, :link), :method => :get, :cond => "#{node}.can_write?", :else => :void)
-          end
-        else
-          # FIXME: we could link to some html page to edit the item.
-          ""
-        end
-      end
-
-      alias r_cancel r_edit
-
-      def r_textarea
-        out make_textarea(@html_tag_params.merge(@params))
-        @html_tag_done = true
-      end
-
-
-      # <r:select name='klass' root_class='...'/>
-      # <r:select name='parent_id' values='projects in site'/>
-      # TODO: optimization (avoid loading full AR to only use [id, name])
-      def r_select
-        html_attributes, attribute = get_input_params()
-        return parser_error("missing name") unless attribute
-        if value = @params[:selected]
-          # FIXME: DRY with html_attributes
-          value = value.gsub(/\[([^\]]+)\]/) do
-            node_attr = $1
-            res = node_attribute(node_attr)
-            "\#{#{res}}"
-          end
-          selected = value.inspect
-        elsif @context[:in_filter]
-          selected = "params[#{attribute.to_sym.inspect}].to_s"
-        else
-          selected = "#{node_attribute(attribute)}.to_s"
-        end
-        html_id = html_attributes[:id] ? " id='#{html_attributes[:id]}'" : ''
-        if @context[:in_filter]
-          select_tag = "<select#{html_id} name='#{attribute}'>"
-        else
-          select_tag = "<select#{html_id} name='#{base_class.to_s.underscore}[#{attribute}]'>"
-        end
-
-        if klass = @params[:root_class]
-          class_opts = {}
-          class_opts[:without]   = @params[:without]  if @params[:without]
-          # do not use 'selected' if the node is not new
-          "#{select_tag}<%= options_for_select(Node.classes_for_form(:class => #{klass.inspect}#{params_to_erb(class_opts)}), (#{node}.new_record? ? #{selected} : #{node}.klass)) %></select>"
-        elsif @params[:type] == 'time_zone'
-          # <r:select name='d_tz' type='time_zone'/>
-          "#{select_tag}<%= options_for_select(TZInfo::Timezone.all_identifiers, #{selected}) %></select>"
-        elsif options_list = get_options_for_select
-          "#{select_tag}<%= options_for_select(#{options_list}, #{selected}) %></select>"
-        else
-          parser_error("missing 'nodes', 'root_class' or 'values'")
-        end
-      end
-
-
-      def r_input
-        html_attributes, attribute = get_input_params()
-        case @params[:type]
-        when 'select' # FIXME: why is this only for classes ?
-          out parser_error("please use [select] here")
-          r_select
-        when 'date_box', 'date'
-          return parser_error("date_box without name") unless attribute
-          input_id = @context[:dom_prefix] ? ", :id=>\"#{dom_id}_#{attribute}\"" : ''
-          "<%= date_box '#{base_class.to_s.underscore}', #{attribute.inspect}, :size=>15#{@context[:in_add] ? ", :value=>''" : ''}#{input_id} %>"
-        when 'id'
-          return parser_error("select id without name") unless attribute
-          name = "#{attribute}_id" unless attribute[-3..-1] == '_id'
-          input_id = @context[:erb_dom_id] ? ", :input_id =>\"#{erb_dom_id}_#{attribute}\"" : ''
-          "<%= select_id('#{base_class.to_s.underscore}', #{attribute.inspect}#{input_id}) %>"
-        when 'time_zone'
-          out parser_error("please use [select] here")
-          r_select
-        when 'submit'
-          @html_tag = 'input'
-          @html_tag_params[:type] = @params[:type]
-          @html_tag_params[:text] = @params[:text] if @params[:text]
-          @html_tag_params.merge!(html_attributes)
-          render_html_tag(nil)
-        else
-          # 'text', 'hidden', ...
-          @html_tag = 'input'
-          @html_tag_params[:type] = @params[:type] || 'text'
-          if checked = html_attributes.delete(:checked)
-            @html_tag_params.merge!(html_attributes)
-            render_html_tag(nil, checked)
-          else
-            @html_tag_params.merge!(html_attributes)
-            render_html_tag(nil)
-          end
-        end
-      end
-
-      def r_form_tag
-        # replace <form> with constructed form
-        "#{@context[:form_tag]}#{expand_with(:form_tag => nil)}</form>"
-      end
-
-      # TODO: add parent_id into the form !
-      # TODO: add <div style="margin:0;padding:0"><input name="_method" type="hidden" value="put" /></div> if method == put
-      # FIXME: use <r:form href='self'> or <r:form action='...'>
-      def r_form
-        hidden_fields = {}
-        set_fields = []
-        id_hash    = {:class => @html_tag_params[:class] || @params[:class] || 'form'}
-        var_name   = base_class.to_s.underscore
-        (descendants('input') + descendants('select')).each do |tag|
-          set_fields << "#{var_name}[#{tag.params[:name]}]"
-        end
-
-        if @context[:dom_prefix] || @params[:update]
-          # ajax
-          if @context[:in_add]
-            # inline form used to create new elements: set values to '' and 'parent_id' from context
-            id_hash[:id] = "#{erb_dom_id}_form"
-            id_hash[:style] = "display:none;"
-
-            cancel =  "<p class='btn_x'><a href='#' onclick='[\"#{erb_dom_id}_add\", \"#{erb_dom_id}_form\"].each(Element.toggle);return false;'>#{_('btn_x')}</a></p>\n"
-            form  =  "<%= form_remote_tag(:url => #{base_class.to_s.underscore.pluralize}_path, :html => {:id => \"#{dom_id}_form_t\"}) %>\n"
-          else
-            # saved form
-
-            id_hash[:id] = erb_dom_id
-
-            cancel = !@context[:dom_prefix] ? "" : <<-END_TXT
-  <% if #{node}.new_record? -%>
-    <p class='btn_x'><a href='#' onclick='[\"<%= params[:dom_id] %>_add\", \"<%= params[:dom_id] %>_form\"].each(Element.toggle);return false;'>#{_('btn_x')}</a></p>
-  <% else -%>
-    <p class='btn_x'><%= link_to_remote(#{_('btn_x').inspect}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=\#{params[:dom_id]}#{@context[:need_link_id] ? "&link_id=\#{#{node}.link_id}" : ''}\", :method => :get) %></p>
-  <% end -%>
-  END_TXT
-            form =<<-END_TXT
-  <% if #{node}.new_record? -%>
-  <%= form_remote_tag(:url => #{base_class.to_s.underscore.pluralize}_path, :html => {:id => \"\#{params[:dom_id]}_form_t\"}) %>
-  <% else -%>
-  <%= form_remote_tag(:url => #{base_class.to_s.underscore}_path(#{node_id}), :method => :put, :html => {:id => \"#{dom_id}_form_t\"}) %>
-  <% end -%>
-  END_TXT
-          end
-
-          if (descendants('input') || []).select{|elem| elem.params[:type] == 'submit'} != []
-            # has submit
-          else
-            hidden_submit = "<input type='submit'/>" # hidden submit for Firefox compatibility
-          end
-
-          hidden_fields['link_id'] = "<%= #{node}.link_id %>" if @context[:need_link_id]
-
-          if @params[:update] || (@context[:add] && @context[:add].params[:update])
-            upd = @params[:update] || @context[:add].params[:update]
-            if target = find_target(upd)
-              hidden_fields['u_url']   = target.template_url
-              hidden_fields['udom_id'] = target.erb_dom_id
-              hidden_fields['u_id']    = "<%= #{@context[:parent_node]}.zip %>" if @context[:in_add]
-              hidden_fields['s']       = start_node_s_param(:value)
-            end
-          elsif (block = ancestor('block')) && node_kind_of?(DataEntry)
-            # updates template url
-            hidden_fields['u_url']   = block.template_url
-            hidden_fields['udom_id'] = block.erb_dom_id
-          end
-
-          hidden_fields['t_url'] = template_url
-          if t_id = @params[:t_id]
-            hidden_fields['t_id']  = parse_attributes_in_value(t_id)
-          end
-
-          erb_dom_id = @context[:saved_template] ? '<%= params[:dom_id] %>' : self.erb_dom_id
-
-          hidden_fields['dom_id'] = erb_dom_id
-
-          if node_kind_of?(Node)
-            hidden_fields['node[parent_id]'] = "<%= #{@context[:in_add] ? "#{@context[:parent_node]}.zip" : "#{node}.parent_zip"} %>"
-          elsif node_kind_of?(Comment)
-            # FIXME: the "... || '@node'" is a hack and I don't understand why it's needed...
-            hidden_fields['node_id'] = "<%= #{@context[:parent_node] || '@node'}.zip %>"
-          elsif node_kind_of?(DataEntry)
-            hidden_fields["data_entry[#{@context[:data_root]}_id]"] = "<%= #{@context[:in_add] ? @context[:parent_node] : "#{node}.#{@context[:data_root]}"}.zip %>"
-          end
-
-          if add_block = @context[:add]
-            params = add_block.params
-            [:after, :before, :top, :bottom].each do |sym|
-              if params[sym]
-                hidden_fields['position'] = sym.to_s
-                if params[sym] == 'self'
-                  if sym == :before
-                    hidden_fields['reference'] = "#{erb_dom_id}_add"
-                  else
-                    hidden_fields['reference'] = "#{erb_dom_id}_form"
-                  end
-                else
-                  hidden_fields['reference'] = params[sym]
-                end
-                break
-              end
-            end
-            if params[:done] == 'focus'
-              if params[:focus]
-                hidden_fields['done'] = "'$(\"#{erb_dom_id}_#{@params[:focus]}\").focus();'"
-              else
-                hidden_fields['done'] = "'$(\"#{erb_dom_id}_form_t\").focusFirstElement();'"
-              end
-            elsif params[:done]
-              hidden_fields['done'] = CGI.escape(params[:done]) # .gsub("NODE_ID", @node.zip).gsub("PARENT_ID", @node.parent_zip)
-            end
-          else
-            # ajax form, not in 'add'
-            hidden_fields['done'] = CGI.escape(@params[:done]) if @params[:done]
-          end
-        else
-          # no ajax
-          # FIXME
-          cancel = "" # link to normal node ?
-          form = "<form method='post' action='/nodes/#{erb_node_id}'><div style='margin:0;padding:0'><input name='_method' type='hidden' value='put' /></div>"
-        end
-
-        if node_kind_of?(Node) && (@params[:klass] || @context[:klass])
-          hidden_fields['node[klass]']    = @params[:klass] || @context[:klass]
-        end
-
-        if node_kind_of?(Node) && @params[:mode]
-          hidden_fields['mode'] = @params[:mode]
-        end
-
-        hidden_fields['node[v_status]'] = Zena::Status[:pub] if @context[:publish_after_save] || auto_publish_param
-
-        form << "<div class='hidden'>"
-        hidden_fields.each do |k,v|
-          next if set_fields.include?(k)
-          v = "'#{v}'" unless v.kind_of?(String) && ['"', "'"].include?(v[0..0])
-          form << "<input type='hidden' name='#{k}' value=#{v}/>\n"
-        end
-        form << hidden_submit << "\n" if hidden_submit
-        form << "</div>"
-
-        form << "<%= error_messages_for(#{node}) %>"
-
-        if !descendant('cancel') && !descendant('edit')
-          if !descendant('form_tag')
-            # add a descendant before blocks.
-            blocks_bak = @blocks
-            @blocks = @blocks.dup
-            @blocks = [make(:void, :method=>'void', :text=>cancel)] + blocks_bak
-          else
-            form   = cancel + form
-            cancel = ''
-          end
-        end
-
-        if descendant('form_tag')
-          res = expand_with(:form_tag => form, :in_form => true, :form_cancel => cancel, :erb_dom_id => erb_dom_id, :dom_id => dom_id)
-        else
-          res = form + expand_with(:in_form => true, :form_cancel => cancel, :erb_dom_id => erb_dom_id, :dom_id => dom_id) + '</form>'
-        end
-
-        @blocks = blocks_bak if blocks_bak
-
-        @html_tag_done = false
-        @html_tag_params.merge!(id_hash)
-        out render_html_tag(res)
-      end
-
-      # <r:checkbox role='collaborator_for' values='projects' in='site'/>"
-      # TODO: implement checkbox in the same spirit as 'r_select'
-      def r_checkbox
-        return parser_error("missing 'nodes'") unless values = @params[:values] || @params[:nodes]
-        return parser_error("missing 'role'")   unless   role = (@params[:role] || @params[:name])
-        attribute = @params[:attr] || 'name'
-        if role =~ /(.*)_ids?\Z/
-          role = $1
-        end
-        meth = role.singularize
-
-        if values =~ /^\d+\s*($|,)/
-          # ids
-          # TODO generate the full query instead of using secure.
-          values = values.split(',').map{|v| v.to_i}
-          list_finder = "(secure(Node) { Node.find(:all, :conditions => 'zip IN (#{values.join(',')})') })"
-        else
-          # relation
-          list_finder, klass = build_finder_for(:all, values)
-          return unless list_finder
-          return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-        end
-        out "<% if (#{list_var} = #{list_finder}) && (#{list_var}_relation = #{node}.relation_proxy(#{role.inspect})) -%>"
-        out "<% if #{list_var}_relation.unique? -%>"
-
-        out "<% #{list_var}_id = #{list_var}_relation.other_id -%>"
-        out "<div class='input_radio'><% #{list_var}.each do |#{var}| -%>"
-        out "<span><input type='radio' name='node[#{meth}_id]' value='#{erb_node_id(var)}'<%= #{list_var}_id == #{var}[:id] ? \" checked='checked'\" : '' %>/> <%= #{node_attribute(attribute, :node=>var)} %></span> "
-        out "<% end -%></div>"
-        out "<input type='radio' name='node[#{meth}_id]' value=''/> #{_('none')}"
-
-        out "<% else -%>"
-
-        out "<% #{list_var}_ids = #{list_var}_relation.other_ids -%>"
-        out "<div class='input_checkbox'><% #{list_var}.each do |#{var}| -%>"
-        out "<span><input type='checkbox' name='node[#{meth}_ids][]' value='#{erb_node_id(var)}'<%= #{list_var}_ids.include?(#{var}[:id]) ? \" checked='checked'\" : '' %>/> <%= #{node_attribute(attribute, :node=>var)} %></span> "
-        out "<% end -%></div>"
-        out "<input type='hidden' name='node[#{meth}_ids][]' value=''/>"
-
-        out "<% end -%><% end -%>"
-      end
-
-      alias r_radio r_checkbox
-
-      # TODO: test
-      def r_add
-        return parser_error("should not be called from within 'each'") if parent.method == 'each'
-        return '' if @context[:make_form]
-
-        # why is node = @node (which we need) but we are supposed to have Comments ?
-        # FIXME: during rewrite, replace 'node' by 'node(klass = node_class)' so the ugly lines below would be
-        # if node_kind_of?(Comment)
-        #   out "<% if #{node(Node)}.can_comment? -%>"
-        # Refs #198.
-        if node_kind_of?(Comment)
-          out "<% if #{node}.can_comment? -%>"
-        else
-          out "<% if #{node}.can_write? -%>"
-        end
-
-        unless descendant('add_btn')
-          # add a descendant between self and blocks.
-          blocks = @blocks.dup
-          @blocks = []
-          add_btn = make(:void, :method=>'add_btn', :params=>@params.dup, :text=>'')
-          add_btn.blocks = blocks
-          remove_instance_variable(:@all_descendants)
-        end
-
-        if @context[:form] && @context[:dom_prefix]
-          # ajax add
-
-          @html_tag_params.merge!(:id => "#{erb_dom_id}_add")
-          @html_tag_params[:class] ||= 'btn_add'
-          if @params[:focus]
-            focus = "$(\"#{erb_dom_id}_#{@params[:focus]}\").focus();"
-          else
-            focus = "$(\"#{erb_dom_id}_form_t\").focusFirstElement();"
-          end
-
-          out render_html_tag("#{expand_with(:onclick=>"[\"#{erb_dom_id}_add\", \"#{erb_dom_id}_form\"].each(Element.toggle);#{focus}return false;")}")
-
-          if node_kind_of?(Node)
-            # FIXME: BUG if we set <r:form klass='Post'/> the user cannot select class with menu...
-            klass = @context[:klass] || 'Node'
-            # FIXME: inspect '@context[:form]' to see if it contains v_klass ?
-            out "<% if #{var}_new = secure(Node) { Node.new_from_class(#{klass.inspect}) } -%>"
-          else
-            out "<% if #{var}_new = #{node_class}.new -%>"
-          end
-
-          if @context[:form].method == 'form'
-            out expand_block(@context[:form], :in_add => true, :no_ignore => ['form'], :add=>self, :node => "#{var}_new", :parent_node => node, :klass => klass, :publish_after_save => auto_publish_param)
-          else
-            # build form from 'each'
-            out expand_block(@context[:form], :in_add => true, :no_ignore => ['form'], :add=>self, :make_form => true, :node => "#{var}_new", :parent_node => node, :klass => klass, :publish_after_save => auto_publish_param)
-          end
-          out "<% end -%>"
-        else
-          # no ajax
-          @html_tag_params[:class] ||= 'btn_add' if @html_tag
-          out render_html_tag(expand_with)
-        end
-        out "<% end -%>"
-        @html_tag_done = true
-      end
-
-      def r_add_btn
-        if @params[:text]
-          text = @params[:text]
-          text = "<div>#{text}</div>" unless @html_tag
-        elsif @params[:trans]
-          text = _(@params[:trans])
-          text = "<div>#{text}</div>" unless @html_tag
-        elsif @blocks != []
-          text = expand_with
-        else
-          text = node_class == Comment ? _("btn_add_comment") : _("btn_add")
-        end
-
-        out "<a href='#' onclick='#{@context[:onclick]}'>#{text}</a>"
-      end
-
-      # Show html to add open a popup window to add a document.
-      # TODO: inline ajax for upload ?
-      def r_add_document
-        return parser_error("only works with nodes (not with #{node_class})") unless node_kind_of?(Node)
-        @html_tag_params[:class] ||= 'btn_add'
-        res = "<a href='/documents/new?parent_id=#{erb_node_id}' onclick='uploader=window.open(\"/documents/new?parent_id=#{erb_node_id}\", \"upload\", \"width=400,height=300\");return false;'>#{_('btn_add_doc')}</a>"
-        "<% if #{node}.can_write? -%>#{render_html_tag(res)}<% end -%>"
-      end
-
-      #if RAILS_ENV == 'test'
-      #  def r_test
-      #    inspect
-      #  end
-      #end
-
-      def r_drop
-        if parent.method == 'each' && @method == parent.single_child_method
-          parent.add_html_class('drop')
-        else
-          @html_tag_params[:class] ||= 'drop'
-        end
-        r_block
-      end
-
-      def drop_javascript
-        hover  = @params[:hover]
-        change = @params[:change]
-
-        if role = @params[:set] || @params[:add]
-          query_params = ["node[#{role}_id]=[id]"]
-        else
-          query_params = []
-          # set='icon_for=[id], v_status='50', v_title='[v_title]'
-          @params.each do |k, v|
-            next if [:hover, :change, :done].include?(k)
-            value, static = parse_attributes_in_value(v, :erb => false, :skip_node_attributes => true)
-            key = change == 'params' ? "params[#{k}]" : "node[#{k}]"
-            query_params << "#{key}=#{CGI.escape(value)}"
-          end
-          return parser_error("missing parameters to set values") if query_params == []
-        end
-
-        query_params << "change=#{change}" if change == 'receiver'
-        query_params << "t_url=#{CGI.escape(template_url)}"
-        query_params << "dom_id=#{erb_dom_id}"
-        query_params << start_node_s_param(:erb)
-        query_params << "done=#{CGI.escape(@params[:done])}" if @params[:done]
-
-        "<script type='text/javascript'>
-        //<![CDATA[
-        Droppables.add('#{erb_dom_id}', {hoverclass:'#{hover || 'drop_hover'}', onDrop:function(element){new Ajax.Request('/nodes/#{erb_node_id}/drop?#{query_params.join('&')}', {asynchronous:true, evalScripts:true, method:'put', parameters:'drop=' + encodeURIComponent(element.id)})}})
-        //]]>
-        </script>"
-      end
-
-      def r_draggable
-        new_dom_scope
-        @html_tag ||= 'div'
-        case @params[:revert]
-        when 'move'
-          revert_effect = 'Element.move'
-        when 'remove'
-          revert_effect = 'Element.remove'
-        else
-          revert_effect = 'Element.move'
-        end
-
-        res, drag_handle = set_drag_handle_and_id(expand_with, @params, :id => erb_dom_id)
-
-        out render_html_tag(res)
-
-        if drag_handle
-          out "<script type='text/javascript'>\n//<![CDATA[\n
-            new Draggable('#{erb_dom_id}', {ghosting:true, revert:true, revertEffect:#{revert_effect}, handle:$('#{erb_dom_id}').select('.#{drag_handle}')[0]});\n//]]>\n</script>"
-        else
-          out "<script type='text/javascript'>\n//<![CDATA[\nZena.draggable('#{erb_dom_id}',0,true,true,#{revert_effect})\n//]]>\n</script>"
-        end
-      end
-
-      def r_unlink
-        return "" if @context[:make_form]
-        opts = {}
-
-        if upd = @params[:update]
-          if upd == '_page'
-            target = nil
-          elsif target = find_target(upd)
-            # ok
-          else
-            return
-          end
-        elsif target = ancestor('block')
-          # ok
-        else
-          target = self
-        end
-
-        if node_kind_of?(Node)
-          opts[:cond] = "#{node}.can_write? && #{node}.link_id"
-          opts[:url] = "/nodes/\#{#{node_id}}/links/\#{#{node}.link_id}"
-        elsif node_kind_of?(Link)
-          opts[:url] = "/nodes/\#{#{node}.this_zip}/links/\#{#{node}.zip}"
-        end
-
-        opts[:method]       = :delete
-        opts[:default_text] = _('btn_tiny_del')
-        opts[:html_params]  = get_html_params({:class => 'unlink'}.merge(@params), :link)
-
-        out link_to_update(target, opts)
-
-       #tag_to_remote
-       #"<%= tag_to_remote({:url => node_path(#{node_id}) + \"#{opts[:method] != :put ? '/zafu' : ''}?#{action.join('&')}\", :method => #{opts[:method].inspect}}) %>"
-       #  out "<a class='#{@params[:class] || 'unlink'}' href='/nodes/#{erb_node_id}/links/<%= #{node}.link_id %>?#{action}' onclick=\"new Ajax.Request('/nodes/#{erb_node_id}/links/<%= #{node}.link_id %>?#{action}', {asynchronous:true, evalScripts:true, method:'delete'}); return false;\">"
-       #  if !@blocks.empty?
-       #    inner = expand_with
-       #  else
-       #    inner = _('btn_tiny_del')
-       #  end
-       #  out "#{inner}</a><% else -%>#{inner}<% end -%>"
-       #elsif node_kind_of?(DataEntry)
-       #  text = get_text_for_erb
-       #  if text.blank?
-       #    text = _('btn_tiny_del')
-       #  end
-       #  out "<%= link_to_remote(#{text.inspect}, {:url => \"/data_entries/\#{#{node}[:id]}?dom_id=#{dom_id}#{upd_url}\", :method => :delete}, :class=>#{(@params[:class] || 'unlink').inspect}) %>"
-       #end
-      end
-
-      # Group elements in a list. Use :order to specify order.
-      def r_group
-        return parser_error("cannot be used outside of a list") unless list_var = @context[:list]
-        return parser_error("missing 'by' clause") unless key = @params[:by]
-
-        sort_key = @params[:sort] || 'name'
-        if node_kind_of?(DataEntry) && DataEntry::NodeLinkSymbols.include?(key.to_sym)
-          key = "#{key}_id"
-          sort_block = "{|e| (e.#{key} || {})[#{sort_key.to_sym.inspect}]}"
-          group_array = "group_array(#{list_var}) {|e| e.#{key}}"
-        elsif node_kind_of?(Node)
-          if ['project', 'parent', 'section'].include?(key)
-            sort_block  = "{|e| (e.#{key} || {})[#{sort_key.to_sym.inspect}]}"
-            group_array = "group_array(#{list_var}) {|e| e.#{key}_id}"
-          end
-        end
-
-        group_array ||= "group_array(#{list_var}) {|e| #{node_attribute(key, :node => 'e')}}"
-
-        if sort_block
-          out "<% grp_#{list_var} = sort_array(#{group_array}) #{sort_block} -%>"
-        else
-          out "<% grp_#{list_var} = #{group_array} -%>"
-        end
-
-        if descendant('each_group')
-          out expand_with(:group => "grp_#{list_var}")
-        else
-          @context[:group] = "grp_#{list_var}"
-          r_each_group
-        end
-      end
-
-
-      # Compute statistics on elements in the current list context.
-      def r_stat
-        return parser_error("must be used inside a list context") unless list
-        find = @params[:find] || @params[:date] || 'count'
-        key  = @params[:of]   || @params[:from] || 'value'
-        case find
-        when 'sum'
-          value = "#{list}.flatten.inject(0) {|#{var}_sum,#{var}| #{var}_sum + #{node_attribute(key, :node => var)}.to_f}"
-        when 'min'
-          value = "#{node_attribute(key, :node => "min_array(#{list}) {|e| #{node_attribute(key, :node => 'e')}}")}"
-        when 'max'
-          value = "#{node_attribute(key, :node => "max_array(#{list}) {|e| #{node_attribute(key, :node => 'e')}}")}"
-        when 'count'
-          return "<%= #{list}.size %>"
-        end
-        if @params[:date]
-          # FIXME: DRY (r_show)
-          if @params[:tformat]
-            format = _(@params[:tformat])
-          elsif @params[:format]
-            format = @params[:format]
-          else
-            format = "%Y-%m-%d"
-          end
-          "<%= #{list}==[] ? '' : format_date(#{value}, #{format.inspect}) %>"
-        elsif format = @params[:format]
-
-          if @params[:zero] == 'hide'
-            "<%= #{list}==[] ? '' : sprintf_unless_zero(#{@params[:format].inspect}, #{value}) %>"
-          else
-            "<%= #{list}==[] ? '' : sprintf(#{@params[:format].inspect}, #{value}) %>"
-          end
-        else
-          "<%= #{list}==[] ? '' : #{value} %>"
-        end
-      end
-
-      def r_each_group
-        return parser_error("must be used inside a group context") unless group = @context[:group]
-        if join = @params[:join]
-          join = join.gsub(/&lt;([^%])/, '<\1').gsub(/([^%])&gt;/, '\1>')
-          out "<% #{group}.each_index do |#{list_var}_index| -%>"
-          out "<%= #{list_var}=#{group}[#{list_var}_index]; #{var} = #{list_var}[0]; #{list_var}_index > 0 ? #{join.inspect} : '' %>"
-        else
-          out "<% #{group}.each do |#{list_var}|; #{var} = #{list_var}[0]; -%>"
-        end
-        out render_html_tag(expand_with(:group => nil, :list => list_var, :node => var, :scope_node => var))
-        out "<% end -%>"
-      end
-
-      def r_each
-        is_draggable = @params[:draggable] == 'true' || @params[:drag_handle]
-
-        if descendant('edit') || descendant('unlink') || descendant('swap') || ['block', 'drop'].include?(single_child_method) || is_draggable
-          id_hash = {:id => erb_dom_id}
-        else
-          id_hash = nil
-        end
-
-
-        if @context[:make_form]
-          # use the elements inside 'each' loop to produce the edit form
-          r_form
-        elsif @context[:list]
-          # normal rendering: not the start of a saved template
-          if is_draggable || descendant('unlink')
-            out "<% #{var}_dom_ids = [] -%>"
-          end
-
-          @params[:alt_class] ||= @html_tag_params.delete(:alt_class)
-          # FIXME: add alt_reverse='true' to start counting from bottom (if order last on top...)
-          if @params[:alt_class] || @params[:join]
-            join = @params[:join] || ''
-            join = join.gsub(/&lt;([^%])/, '<\1').gsub(/([^%])&gt;/, '\1>')
-            out "<% #{var}_max_index = #{list}.size - 1 -%>" if @params[:alt_reverse]
-            out "<% #{list}.each_with_index do |#{var},#{var}_index| -%>"
-
-            if join_clause = @params[:join_if]
-              set_stored(Node, 'prev', "#{var}_prev")
-              cond = get_test_condition(var, :test=>join_clause)
-              out "<%= #{var}_prev = #{list}[#{var}_index - 1]; (#{var}_index > 0 && #{cond}) ? #{join.inspect} : '' %>"
-            else
-              out "<%= #{var}_index > 0 ? #{join.inspect} : '' %>"
-            end
-
-            if alt_class = @params[:alt_class]
-              alt_test = @params[:alt_reverse] == 'true' ? "(#{var}_max_index - #{var}_index) % 2 != 0" : "#{var}_index % 2 != 0"
-              if html_class = @html_tag_params.delete(:class)
-                html_append = " class='#{html_class}<%= #{alt_test} ? #{(' ' + alt_class).inspect} : '' %>'"
-              else
-                html_append = "<%= #{alt_test} ? ' class=#{alt_class.inspect}' : '' %>"
-              end
-            else
-              html_append = nil
-            end
-          else
-            out "<% #{list}.each do |#{var}| -%>"
-            html_append = nil
-          end
-
-          if is_draggable
-            out "<% #{var}_dom_ids << \"#{dom_id}\" -%>"
-          end
-
-          out r_anchor(var) if @anchor_param # insert anchor inside the each loop
-          @params[:anchor] = @anchor_param   # set back in case we double render
-          @anchor_param = nil
-
-          res, drag_handle = set_drag_handle_and_id(expand_with(:node => var, :scope_node => var), @params, id_hash)
-
-          out render_html_tag(res, html_append)
-
-          out "<% end -%>"
-
-          if is_draggable
-            if drag_handle
-              out "<script type='text/javascript'>\n//<![CDATA[\n<%= #{var}_dom_ids.inspect %>.each(function(dom_id, index) {
-                  new Draggable(dom_id, {ghosting:true, revert:true, handle:$(dom_id).select('.#{drag_handle}')[0]});
-              });\n//]]>\n</script>"
-            else
-              out "<script type='text/javascript'>\n//<![CDATA[\n<%= #{var}_dom_ids.inspect %>.each(Zena.draggable)\n//]]>\n</script>"
-            end
-          end
-
-        elsif @context[:saved_template]
-          # render to start a saved template
-          res, drag_handle = set_drag_handle_and_id(expand_with(:scope_node => node), @params, id_hash)
-
-          out render_html_tag(res)
-
-          if is_draggable
-            if drag_handle
-              out "<script type='text/javascript'>\n//<![CDATA[\nnew Draggable('#{erb_dom_id}', {ghosting:true, revert:true, handle:$('#{erb_dom_id}').select('.#{drag_handle}')[0]});\n//]]>\n</script>"
-            else
-              out "<script type='text/javascript'>\n//<![CDATA[\nZena.draggable('#{erb_dom_id}')\n//]]>\n</script>"
-            end
-          end
-        else
-          # TODO: make a single list ?
-          @context[:list] = "[#{node}]"
-          r_each
-        end
-      end
-
-      def r_case
-        out "<% if false -%>"
-        out expand_with(:in_if=>true, :only=>['when', 'else'], :html_tag => @html_tag, :html_tag_params => @html_tag_params)
-        @html_tag_done = true
-        out "<% end -%>"
-      end
-
-      # TODO: test
-      def r_if
-        cond = get_test_condition
-        return parser_error("condition error") unless cond
-
-        if cond == 'true'
-          return expand_with(:in_if => false)
-        elsif cond == 'false'
-          if descendant('else') || descendant('elsif')
-            return expand_with(:in_if=>true, :only=>['elsif', 'else'])
-          else
-            @html_tag_done = true
-            return ''
-          end
-        end
-
-        out "<% if #{cond} -%>"
-        out render_html_tag(expand_with(:in_if=>false))
-        out expand_with(:in_if=>true, :only=>['elsif', 'else'], :html_tag => @html_tag, :html_tag_params => @html_tag_params)
-        out "<% end -%>"
-      end
-
-      def r_else
-        if @context[:in_if]
-          @html_tag = @context[:html_tag]
-          @html_tag_params = @context[:html_tag_params] || {}
-          out "<% elsif true -%>"
-          if @params[:text]
-            out render_html_tag(@params[:text])
-          else
-            out render_html_tag(expand_with(:in_if=>false, :only => nil)) # do not propagate :only from ancestor 'if' clause
-          end
-        else
-          ""
-        end
-      end
-
-      def r_elsif
-        return '' unless @context[:in_if]
-        @html_tag = @context[:html_tag]
-        @html_tag_params = @context[:html_tag_params] || {}
-        cond = get_test_condition
-        return parser_error("condition error") unless cond
-        out "<% elsif #{cond} -%>"
-        out render_html_tag(expand_with(:in_if=>false, :only => nil)) # do not propagate :only from ancestor 'if' clause
-      end
-
-      def r_when
-        r_elsif
-      end
-
-      # be carefull, this gives a list of 'versions', not 'nodes'
-      def r_traductions
-        if @params[:except]
-          case @params[:except]
-          when 'current'
-            opts = "(:conditions=>\"lang != '#{helper.lang}'\")"
-          else
-            # list of lang
-            # TODO: test
-            langs = @params[:except].split(',').map{|l| l.gsub(/[^a-z]/,'').strip }
-            opts = "(:conditions=>\"lang NOT IN ('#{langs.join("','")}')\")"
-          end
-        elsif @params[:only]
-          # TODO: test
-          case @params[:only]
-          when 'current'
-            opts = "(:conditions=>\"lang = '#{helper.lang}'\")"
-          else
-            # list of lang
-            # TODO: test
-            langs = @params[:only].split(',').map{|l| l.gsub(/[^a-z]/,'').strip }
-            opts = "(:conditions=>\"lang IN ('#{langs.join("','")}')\")"
-          end
-        else
-          opts = ""
-        end
-        out "<% if #{list_var} = #{node}.traductions#{opts} -%>"
-        out expand_with(:list=>list_var, :node_class => Version)
-        out "<% end -%>"
-      end
-
-      # TODO: test
-      def r_show_traductions
-        "<% if #{list_var} = #{node}.traductions -%>"
-        "#{_("Traductions:")} <span class='traductions'><%= #{list_var}.join(', ') %></span>"
-        "<%= traductions(:node=>#{node}).join(', ') %>"
-      end
-
-      def r_node
-        @method = @params[:select] || 'node' # 'node' is for version.node
-        r_unknown
-      end
-
-      # icon or first image (defined using build_finder_for instead of zafu_known_context for performance reasons).
-      def r_icon
-        if !@params[:in] && !@params[:where] && !@params[:from] && !@params[:find]
-          finder, klass = build_finder_for(:first, 'icon', @params.merge(:or => 'image', :order => 'l_id desc, position asc, name asc', :group => 'id,l_id'))
-          return unless finder
-          return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-          do_var(finder, :node_class => klass)
-        else
-          r_unknown
-        end
-      end
-
-      def r_date
-        select = @params[:select]
-        case select
-        when 'main'
-          expand_with(:date=>'main_date')
-        when 'now'
-          expand_with(:date=>'Time.now')
-        else
-          if select =~ /^\d{4}-\d{1,2}-\d{1,2}$/
-            begin
-              d = Date.parse(select)
-              expand_with(:date=>select.inspect)
-            rescue
-              parser_error("invalid date '#{select}' should be 'YYYY-MM-DD'")
-            end
-          elsif date = find_stored(Date, select)
-            if date[0..0] == '"'
-              begin
-                d = Date.parse(date[1..-2])
-                expand_with(:date=>date)
-              rescue
-                parser_error("invalid date #{select} (#{date}) should be 'YYYY-MM-DD'")
-              end
-            else
-              expand_with(:date=>select)
-            end
-          elsif select =~ /\[(.*)\]/
-            date, static = parse_attributes_in_value(select, :erb => false)
-            expand_with(:date => "\"#{date}\"")
-          else
-            parser_error("bad parameter '#{select}'")
-          end
-        end
-      end
-
-      def r_javascripts
-        if @params[:list].nil?
-          list = %w{ prototype effects tablekit zena }
-        elsif @params[:list] == 'all'
-          list = %w{ prototype effects dragdrop tablekit zena }
-        else
-          list = @params[:list].split(',').map{|e| e.strip}
-        end
-        helper.javascript_include_tag(*list)
-      end
-
-      def r_stylesheets
-        if @params[:list] == 'all' || @params[:list].nil?
-          list = %w{ zena code }
-        else
-          list = @params[:list].split(',').map{|e| e.strip}
-        end
-        list << {:media => @params[:media]} if @params[:media]
-        helper.stylesheet_link_tag(*list)
-      end
-
-      def r_flash_messages
-        type = @params[:show] || 'both'
-        "<div id='messages'>" +
-        if (type == 'notice' || type == 'both')
-          "<% if flash[:notice] -%><div id='notice' class='flash' onclick='new Effect.Fade(\"error\")'><%= flash[:notice] %></div><% end -%>"
-        else
-          ''
-        end +
-        if (type == 'error'  || type == 'both')
-          "<% if flash[:error] -%><div id='error' class='flash' onclick='new Effect.Fade(\"error\")'><%= flash[:error] %></div><% end -%>"
-        else
-          ''
-        end +
-        "</div>"
-      end
-
-      # Shows a 'made with zena' link or logo. ;-) Thanks for using this !
-      # TODO: test and add translation.
-      # <r:zena show='logo'/> or <r:zena show='text'/> == <r:zena/>
-      def r_zena
-        if logo = @params[:logo]
-          # FIXME
-          case logo
-          when 'tiny'
-          else
-          end
-        else
-          text = case @params[:type]
-          when 'riding'
-            _("riding zena")
-          when 'peace'
-            _("in peace with zena")
-          when 'garden'
-            _("a zen garden")
-          else
-            _("made with zena")
-          end
-          "<a class='zena' href='http://zenadmin.org' title='zena <%= Zena::VERSION %>'>#{text}</a>"
-        end
-      end
-
-      def r_design
-        if @params[:by]
-          by = "<a href='#{@params[:href]}'>#{@params[:by]}</a>"
-        else
-          by = expand_with(:trans => true)
-        end
-        unless skin = @params[:skin]
-          skin = helper.instance_variable_get(:@controller).instance_variable_get(:@skin_name)
-        end
-        skin = "<i>#{skin}</i>" unless skin.blank?
-        _("%{skin}, design by %{name}") % {:name => by, :skin => skin}
-      end
-
-      # creates a link. Options are:
-      # :href (node, parent, project, root)
-      # :tattr (translated attribute used as text link)
-      # :attr (attribute used as text link)
-      # <r:link href='node'><r:trans attr='lang'/></r:link>
-      # <r:link href='node' tattr='lang'/>
-      # <r:link update='dom_id'/>
-      # <r:link page='next'/> <r:link page='previous'/> <r:link page='list'/>
-      def r_link
-        if @params[:page]
-          pagination_links
-        else
-          make_link
-        end
-      end
-
-      def make_link(options = {})
-        query_params = options[:query_params] || {}
-        default_text = options[:default_text]
-        params = @params.dup
-
-        opts = {}
-        if upd = params.delete(:update)
-          return unless remote_target = find_target(upd)
-        end
-
-        if href = params.delete(:href)
-          if lnode = find_stored(Node, href)
-            # using stored node
-          else
-            lnode, klass = build_finder_for(:first, href, {})
-            return unless lnode
-            return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-          end
-        else
-          # obj
-          if node_class == Version
-            lnode = "#{node}.node"
-            opts[:lang] = "#{node}.lang"
-          elsif node_kind_of?(Node)
-            lnode = node
-          else
-            lnode = @context[:previous_node]
-          end
-        end
-
-        if fmt = params.delete(:format)
-          if fmt == 'data'
-            opts[:format] = "#{node}.c_ext"
-          else
-            opts[:format] = fmt.inspect
-          end
-        end
-
-        if mode = params.delete(:mode)
-          opts[:mode] = mode.inspect
-        end
-
-        if sharp = params.delete(:sharp)
-          opts[:sharp] = sharp.inspect
-        end
-
-        if sharp_in = params.delete(:in)
-          finder, klass = build_finder_for(:first, sharp_in, {})
-          return unless finder
-          return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-          opts[:sharp_in] = finder
-        end
-
-        if @html_tag && @html_tag != 'a'
-          # FIXME: can we remove this ?
-          # html attributes do not belong to anchor
-          pre_space = ''
-          html_params = {}
-        else
-          html_params = get_html_params(params.merge(@html_tag_params), :link)
-          pre_space = @space_before || ''
-          @html_tag_done = true
-        end
-
-        (params.keys - [:style, :class, :id, :rel, :name, :anchor, :attr, :tattr, :trans, :text, :page]).each do |k|
-          next if k.to_s =~ /if_|set_/
-          query_params[k] = params[k]
-        end
-
-        # TODO: merge these two query_params cleanup things into something cleaner.
-        if remote_target
-          # ajax
-          query_params_list = []
-          query_params.each do |k,v|
-            if k == :date
-              if v == 'current_date'
-                str = "\#{#{current_date}}"
-              elsif v =~ /\A\d/
-                str = CGI.escape(v.gsub('"',''))
-              elsif v =~ /\[/
-                attribute, static = parse_attributes_in_value(v.gsub('"',''), :erb => false)
-                str = static ? CGI.escape(attribute) : "\#{CGI.escape(\"#{attribute}\")}"
-              else
-                str = "\#{CGI.escape(#{node_attribute(v)})}"
-              end
-            else
-              attribute, static = parse_attributes_in_value(v.gsub('"',''), :erb => false)
-              str = static ? CGI.escape(attribute) : "\#{CGI.escape(\"#{attribute}\")}"
-            end
-            query_params_list << "#{k.to_s.gsub('"','')}=#{str}"
-          end
-          pre_space + link_to_update(remote_target, :node_id => "#{lnode}.zip", :query_params => query_params_list, :default_text => default_text, :html_params => html_params)
-        else
-          # direct link
-          query_params.each do |k,v|
-            if k == :date
-              if v == 'current_date'
-                query_params[k] = current_date
-              elsif v =~ /\A\d/
-                query_params[k] = v.inspect
-              elsif v =~ /\[/
-                attribute, static = parse_attributes_in_value(v.gsub('"',''), :erb => false)
-                query_params[k] = "\"#{attribute}\""
-              else
-                query_params[k] = node_attribute(v)
-              end
-            else
-              attribute, static = parse_attributes_in_value(v.gsub('"',''), :erb => false)
-              query_params[k] = "\"#{attribute}\""
-            end
-          end
-
-          query_params.merge!(opts)
-
-          opts_str = ''
-          query_params.keys.sort {|a,b| a.to_s <=> b.to_s }.each do |k|
-            opts_str << ",:#{k.to_s.gsub(/[^a-z_A-Z_]/,'')}=>#{query_params[k]}"
-          end
-
-          opts_str += ", :host => #{@context["exp_host"]}" if @context["exp_host"]
-
-          pre_space + "<a#{params_to_html(html_params)} href='<%= zen_path(#{lnode}#{opts_str}) %>'>#{text_for_link(default_text)}</a>"
-        end
-      end
-
-      # <r:link page='next'/> <r:link page='previous'/> <r:link page='list'/>
-      def pagination_links
-        return parser_error("not in pagination scope") unless pagination_key = @context[:paginate]
-        case @params[:page]
-        when 'previous'
-          out "<% if set_#{pagination_key}_previous = (set_#{pagination_key} > 1 ? set_#{pagination_key} - 1 : nil) -%>"
-          @context[:vars] ||= []
-          @context[:vars] << "#{pagination_key}_previous"
-          out make_link(:default_text => "<%= set_#{pagination_key}_previous %>", :query_params => {pagination_key => "[#{pagination_key}_previous]"})
-          if descendant('else')
-            out expand_with(:in_if => true, :only => ['else', 'elsif'])
-          end
-          out "<% end -%>"
-        when 'next'
-          out "<% if set_#{pagination_key}_next = (set_#{pagination_key}_count - set_#{pagination_key} > 0 ? set_#{pagination_key} + 1 : nil) -%>"
-          @context[:vars] ||= []
-          @context[:vars] << "#{pagination_key}_next"
-          out make_link(:default_text => "<%= set_#{pagination_key}_next %>", :query_params => {pagination_key => "[#{pagination_key}_next]"})
-          if descendant('else')
-            out expand_with(:in_if => true, :only => ['else', 'elsif'])
-          end
-          out "<% end -%>"
-        when 'list'
-          @context[:vars] ||= []
-          @context[:vars] << "#{pagination_key}_page"
-          if @blocks == [] || (@blocks.size == 1 && !@blocks.first.kind_of?(String) && @blocks.first.method == 'else')
-            # add a default block
-            if tag = @params[:tag]
-              open_tag = "<#{tag}>"
-              close_tag = "</#{tag}>"
-            else
-              open_tag = close_tag = ''
-            end
-            link_params = {}
-            @params.each do |k,v|
-              next if [:tag, :page, :join, :page_count].include?(k)
-              link_params[k] = v
-            end
-            text = "#{open_tag}<r:link #{params_to_html(link_params)} #{pagination_key}='[#{pagination_key}_page]' do='[#{pagination_key}_page]'/>#{close_tag}"
-            @blocks = [make(:void, :method=>'void', :text=>text)]
-            remove_instance_variable(:@all_descendants)
-          end
-
-          if !descendant('else')
-            @blocks += [make(:void, :method=>'void', :text=>"<r:else>#{open_tag}<r:show var='#{pagination_key}_page'/>#{close_tag}</r:else>")]
-            remove_instance_variable(:@all_descendants)
-          end
-
-          out "<% page_numbers(set_#{pagination_key}, set_#{pagination_key}_count, #{(@params[:join] || ' ').inspect}, #{@params[:page_count] ? @params[:page_count].to_i : 'nil'}) do |set_#{pagination_key}_page, #{pagination_key}_page_join| %>"
-          out "<%= #{pagination_key}_page_join %>"
-          out "<% if set_#{pagination_key}_page != set_#{pagination_key} -%>"
-          out expand_with(:in_if => true)
-          out "<% end; end -%>"
-        else
-          parser_error("unkown 'page' option #{@params[:page].inspect} should be ('previous', 'next' or 'list')")
-        end
-      end
-
-      def r_img
-        return unless node_kind_of?(Node)
-        if @params[:src]
-          finder, klass = build_finder_for(:first, @params[:src])
-          return unless finder
-          return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-          img = finder
-        else
-          img = node
-        end
-        mode = @params[:mode] || 'std'
-        # FIXME: replace this call by something that integrates better with html_tag_params and such.
-        res = "img_tag(#{img}, :mode=>#{mode.inspect}"
-        [:class, :alt_src, :id, :border, :style].each do |k|
-          res  += ", :#{k}=>#{@params[k].inspect}" if @params[k]
-        end
-        res += ", :host => #{@context["exp_host"]}" if @context["exp_host"]
-        res += ")"
-        if @params[:link]
-          finder, klass = build_finder_for(:first, @params[:link])
-          return unless finder
-          return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-
-          opts_str = @context["exp_host"] ? ", :host => #{@context["exp_host"]}" : ""
-
-          "<a href='<%= zen_path(#{finder}#{opts_str}) %>'><%= #{res} %></a>"
-        else
-          "<%= #{res} %>"
-        end
-      end
-
-      def r_calendar
-        if @context[:block] == self
-          # called from self (storing template / rendering)
-          if role = @params[:assign_as]
-            assign_calendar(role)
-          else
-            display_calendar
-          end
-        else
-          # This is called first to prepare calendar
-          if @params[:assign_as]
-            fld = 'date'
-            table_name = 'links'
-          else
-            fld = @params[:date] || 'event_at'
-            if ['log_at', 'created_at', 'updated_at', 'event_at'].include?(fld) # TODO: use rubyless to learn type
-              table_name = 'nodes'
-            elsif fld == 'l_date'
-              fld = 'date'
-              table_name = 'links'
-            else
-              return parser_error("Invalid 'date' value for calendar (#{fld.inspect}).")
-            end
-          end
-
-          @date_scope = "TABLE_NAME[#{table_name}].#{fld} >= '\#{start_date.strftime('%Y-%m-%d')}' AND TABLE_NAME[#{table_name}].#{fld} <= '\#{end_date.strftime('%Y-%m-%d')}'"
-
-          new_dom_scope
-
-          # SAVED TEMPLATE
-          template = expand_block(self, :block => self, :saved_template => true)
-          out helper.save_erb_to_url(template, template_url)
-
-          # INLINE
-          out expand_block(self, :block => self, :saved_template => false)
-        end
-      end
-
-      def display_calendar
-        size     = (params[:size]  || 'large').to_sym
-        finder   = params[:select] || 'notes in project'
-
-        if @blocks == []
-          # add a default <r:link/> block
-          if size == :tiny
-            @blocks = [make(:void, :method=>'void', :text=>"<em do='link' date='current_date' do='[current_date]' format='%d'/><r:else do='[current_date]' format='%d'/>")]
-          else
-            @blocks = [make(:void, :method=>'void', :text=>"<span do='show' date='current_date' format='%d'/><ul><li do='each' do='link' attr='name'/></ul><r:else do='[current_date]' format='%d'/>")]
-          end
-          remove_instance_variable(:@all_descendants)
-        elsif !descendant('else')
-          @blocks += [make(:void, :method=>'void', :text=>"<r:else do='[current_date]' format='%d'/>")]
-          remove_instance_variable(:@all_descendants)
-        end
-
-        @html_tag_done = false
-        @html_tag_params[:id] = erb_dom_id
-        @html_tag_params[:class] ||= "#{size}cal"
-        @html_tag ||= 'div'
-
-        finder, klass = build_finder_for(:all, finder, @params, [@date_scope])
-        return unless finder
-        return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-
-        cell_code = "<% if #{list_var} = nodes_#{list_var}[cal_#{list_var}.strftime('%Y-%m-%d %H')] -%>#{expand_with(:in_if => true, :list => list_var, :date => "cal_#{list_var}", :saved_template => nil, :dom_prefix => nil, :in_calendar => true)}<% end -%>"
-
-        render_html_tag(calendar_code(finder, "", cell_code, "", params))
-      end
-
-      # manage links from @node ---- reference ----> ...
-      # <div do='calendar' assign='reference' to='main' split_hours='12' />
-      def assign_calendar(as_role)
-        size = (params[:size]  || 'large').to_sym
-        @html_tag_done = false
-        @html_tag_params[:id] = erb_dom_id
-        @html_tag_params[:class] ||= "#{size}cal"
-        @html_tag ||= 'div'
-        if rel = RelationProxy.find_by_role(as_role.singularize)
-          role = rel.this_role
-        else
-          return parser_error("Invalid role #{as_role.inspect}.")
-        end
-        finder, klass = build_finder_for(:all, role, @params, [@date_scope])
-        return unless finder
-        return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-
-        # SAVED TEMPLATE ========
-        template_url  = self.template_url + 'cell'
-        template      = "<%= cal_assign_cell(@node, #{role.inspect}, #{@params[:used].inspect}) %>"
-        out helper.save_erb_to_url(template, template_url)
-
-        # we call update on node 'B'
-        # A (main)
-        # ... B (other node)
-        #     calendar (in B context) ---- role --->
-
-        cell_prefix_code = "<span><%= day_#{list_var}.strftime('%d').to_i -%></span><ul>"
-        cell_code = "<%= #{list_var} = nodes_#{list_var}[cal_#{list_var}.strftime('%Y-%m-%d %H')]; #{node}.linked_node = #{list_var} ? #{list_var}.first : nil; cal_assign_cell(#{node}, #{role.inspect}, #{@params[:used].inspect}, params[:s] || @node.zip, cal_#{list_var}, #{template_url.inspect}) %>"
-        cell_postfix_code = "</ul>"
-        render_html_tag(calendar_code(finder, cell_prefix_code, cell_code, cell_postfix_code, params))
-      end
-
-      def calendar_code(finder, cell_prefix_code, cell_code, cell_postfix_code, params)
-        type = params[:type] ? params[:type].to_sym : :month
-        size = (params[:size] || 'large').to_sym
-        ref_date = params[:assign_as] ? 'l_date' : (params[:date] || 'event_at')
-
-        case type
-        when :month
-          title = "\"\#{_(Date::MONTHNAMES[main_date.mon])} \#{main_date.year}\""
-          prev_date = "\#{main_date.advance(:months => -1).strftime(\"%Y-%m-%d\")}"
-          next_date = "\#{main_date.advance(:months =>  1).strftime(\"%Y-%m-%d\")}"
-        when :week
-          title = "\"\#{_(Date::MONTHNAMES[main_date.mon])} \#{main_date.year}\""
-          prev_date = "\#{main_date.advance(:days => -7).strftime(\"%Y-%m-%d\")}"
-          next_date = "\#{main_date.advance(:days => +7).strftime(\"%Y-%m-%d\")}"
-        else
-          return parser_error("invalid type (should be 'month' or 'week')")
-        end
-
-        if hours = @params[:split_hours]
-          hours = hours.split(',').map{|l| l.to_i}
-          hours << 0
-          hours = hours.uniq.sort
-          # I feel all this would be much better if we could use "each_group" but then how do we access hours ?
-          week_code = "<% week.step(week+6,1) do |day_#{list_var}| -%>
-              <td<%= cal_class(day_#{list_var},#{current_date}) %>>#{cell_prefix_code}<% #{hours.inspect}.each do |set_hour|; cal_#{list_var} = Time.utc(day_#{list_var}.year,day_#{list_var}.month,day_#{list_var}.day,set_hour) -%>#{cell_code}<% end -%>#{cell_postfix_code}</td>
-          <% end -%>"
-          (@context[:vars] ||= []) << "hour"
-        else
-          hours = nil
-          week_code = "<% week.step(week+6,1) do |day_#{list_var}| -%>
-              <td<%= cal_class(day_#{list_var},#{current_date}) %>><% cal_#{list_var} = Time.utc(day_#{list_var}.year,day_#{list_var}.month,day_#{list_var}.day) -%>#{cell_prefix_code}#{cell_code}#{cell_postfix_code}</td>
-          <% end -%>"
-        end
-
-        res = <<-END_TXT
-  <h3 class='title'>
-  <span><%= link_to_remote(#{_('img_prev_page').inspect}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=#{dom_id}&date=#{prev_date}&#{start_node_s_param(:string)}\", :method => :get) %></span>
-  <span class='date'><%= link_to_remote(#{title}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=#{dom_id}&#{start_node_s_param(:string)}\", :method => :get) %></span>
-  <span><%= link_to_remote(#{_('img_next_page').inspect}, :url => #{base_class.to_s.underscore}_path(#{node_id}) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=#{dom_id}&date=#{next_date}&#{start_node_s_param(:string)}\", :method => :get) %></span>
-  </h3>
-  <table cellspacing='0' class='#{size}cal#{@params[:assign_as] ? " assign" : ''}'>
-  <tr class='head'><%= cal_day_names(#{size.inspect}) %></tr>
-  <% start_date, end_date = cal_start_end(#{current_date}, #{type.inspect}) -%>
-  <% cal_weeks(#{ref_date.to_sym.inspect}, #{finder}, start_date, end_date, #{hours.inspect}) do |week, nodes_#{list_var}| -%>
-  <tr class='body'>
-  #{week_code}
-  </tr>
-  <% end -%>
-  </table>
-  END_TXT
-      end
-
-      # part caching
-      def r_cache
-        kpath   = @params[:kpath]   || Page.kpath
-        out "<% #{cache} = Cache.with(visitor.id, visitor.group_ids, #{kpath.inspect}, #{helper.send(:lang).inspect}, #{template_url.inspect}) do capture do %>"
-        out expand_with
-        out "<% end; end %><%= #{cache} %>"
-      end
-
-      # recursion
-      def r_include
-        return '' if @context[:saved_template]
-        return super if @params[:template] || !@params[:part]
-        part = @params[:part].gsub(/[^a-zA-Z_]/,'')
-        method_name = @context["#{part}_method".to_sym]
-        return parser_error("no parent named '#{part}'") unless method_name
-        "<%= #{method_name}(depth+1,#{node},#{list}) %>"
-      end
-
-      # use all other tags as relations
-      def r_unknown
-        @params[:select] = @method
-        r_context
-      end
-
-      # Enter a new context (<r:context find='all' method='pages'>). This is the same as '<r:pages>...</r:pages>'). It is
-      # considered better style to use '<r:pages>...</r:pages>' instead of the more general '<r:context>' because the tags
-      # give a clue on the context at start and end. Another way to open a context is the 'do' syntax: "<div do='pages'>...</div>".
-      # FIXME: 'else' clause has been removed, find a solution to put it back.
-      def r_context
-        # DRY ! (build_finder_for, block)
-        return parser_error("missing 'method' parameter") unless method = @params[:select]
-
-        context = node_class.zafu_known_contexts[method]
-        if context && @params.keys == [:select]
-          open_context("#{node}.#{method}", context)
-        elsif node_kind_of?(Node)
-          count   = ['first','all','count'].include?(@params[:find]) ? @params[:find].to_sym : nil
-          count ||= Node.plural_relation?(method) ? :all : :first
-          finder, klass, query = build_finder_for(count, method, @params)
-          return unless finder
-          if node_kind_of?(Node) && !klass.ancestors.include?(Node)
-            # moving out of node: store last Node
-            @context[:previous_node] = node
-          end
-          if count == :all
-            # plural
-            do_list( finder, query, :node_class => klass)
-          # elsif count == :count
-          #   "<%= #{build_finder_for(count, method, @params)} %>"
-          else
-            # singular
-            do_var(  finder, :node_class => klass)
-          end
-        else
-          "unknown relation (#{method}) for #{node_class} class"
-        end
-      end
-
-      def open_context(finder, context)
-        klass = context[:node_class]
-        # hack to store last 'Node' context until we fix node(Node) stuff:
-        previous_node = node_kind_of?(Node) ? node : @context[:previous_node]
-        if klass.kind_of?(Array)
-          # plural
-          do_list( finder, nil, context.merge(:node_class => klass[0], :previous_node => previous_node) )
-        else
-          # singular
-          do_var(  finder, context.merge(:previous_node => previous_node) )
-        end
-      end
-
-      # Prepare stylesheet and xml content for xsl-fo post-processor
-      def r_fop
-        return parser_error("missing 'stylesheet' argument") unless @params[:stylesheet]
-        # get stylesheet text
-        xsl_content, absolute_url, doc = self.class.get_template_text(@params[:stylesheet], @options[:helper], @options[:current_folder])
-        return parser_error("stylesheet #{@params[:stylesheet].inspect} not found") unless doc
-
-        template_url = (self.template_url.split('/')[0..-2] + ['_main.xsl']).join('/')
-        helper.save_erb_to_url(xsl_content, template_url)
-        out "<?xml version='1.0' encoding='utf-8'?>\n"
-        out "<!-- xsl_id:#{doc[:id] } -->\n" if doc
-        out expand_with
-      end
-
-      # Prepare content for LateX post-processor
-      def r_latex
-        out "% latex\n"
-        # all content inside this will be informed to render for Latex output
-        out expand_with(:output_format => 'latex')
-      end
-
-      def r_debug
-        return '' unless @context[:dev]
-        add_html_class('debug')
-        out "<p>#{@params[:title]}</p>" if @params[:title]
-        (@params[:show] || '').split(',').map(&:strip).each do |what|
-          case what
-          when 'params'
-            out "<pre><%= params.inspect %></pre>"
-          else
-            parser_error("invalid element to show. Options are ['params'].")
-          end
-        end
-        out expand_with
-      end
-
-      # ================== HELPER METHODS ================
-
-      # Create an sql query to open a new context (passes its arguments to HasRelations#build_find)
-      def build_finder_for(count, rel, params=@params, raw_filters = [])
-        if (context = node_class.zafu_known_contexts[rel]) && !params[:in] && !params[:where] && !params[:from] && !params[:order] && raw_filters == []
-          klass = context[:node_class]
-
-          if klass.kind_of?(Array) && count == :all
-            return ["#{node}.#{rel}", klass[0]]
-          else
-            return [(count == :all ? "[#{node}.#{rel}]" : "#{node}.#{rel}"), klass]
-          end
-        end
-
-        rel ||= 'self'
-        if (count == :first)
-          if rel == 'self'
-            return [node, node_class]
-          elsif rel == 'main'
-            return ["@node", Node]
-          elsif rel == 'root'
-            return ["(secure(Node) { Node.find(#{current_site[:root_id]})})", Node]
-          elsif rel == 'start'
-            return ["start_node", Node]
-          elsif rel == 'visitor'
-            return ["visitor.contact", Node]
-          elsif rel =~ /^\d+$/
-            return ["(secure(Node) { Node.find_by_zip(#{rel.inspect})})", Node]
-          elsif node_name = find_stored(Node, rel)
-            return [node_name, Node]
-          elsif rel[0..0] == '/'
-            rel = rel[1..-1]
-            return ["(secure(Node) { Node.find_by_path(#{rel.inspect})})", Node]
-          end
-        end
-
-        pseudo_sql, add_raw_filters = make_pseudo_sql(rel, params)
-        raw_filters += add_raw_filters if add_raw_filters
-
-        # FIXME: stored should be clarified and managed in a single way through links and contexts.
-        # <r:void store='foo'>...
-        # <r:link href='foo'/>
-        # <r:pages from='foo'/> <-- this is just a matter of changing node parameter
-        # <r:pages from='site' project='foo'/>
-        # <r:img link='foo'/>
-        # ...
-
-        if node_kind_of?(Node)
-          node_name = @context[:parent_node] || node
-        else
-          node_name = @context[:previous_node]
-        end
-
-        # make sure we do not use a new record in a find query:
-        query = Node.build_find(count, pseudo_sql, :node_name => node_name, :raw_filters => raw_filters, :ref_date => "\#{#{current_date}}")
-
-        unless query.valid?
-          out parser_error(query.errors.join(' '), pseudo_sql.join(', '))
-          return nil
-        end
-
-
-        if count == :count
-          out "<%= #{query.finder(:count)} %>"
-          return nil
-        end
-
-        klass = query.main_class
-
-        if params[:else]
-          # FIXME: else not working with zafu_known_contexts
-          finder, else_class, else_query = build_finder_for(count, params[:else], {})
-          if finder && (else_query.nil? || else_query.valid?) && (else_class == klass || klass.ancestors.include?(else_class) || else_class.ancestors.include?(klass))
-            ["(#{query.finder(count)} || #{finder})", klass, query]
-          else
-            [query.finder(count), query.main_class, query]
-          end
-        else
-          [query.finder(count), query.main_class, query]
-        end
-      end
-
-      # Build pseudo sql from the parameters
-      # comments where ... from ... in ... order ... limit
-      def make_pseudo_sql(rel, params=@params)
-        parts   = [rel.dup]
-        filters = []
-
-        if params[:from]
-          parts << params[:from]
-
-          key_counter = 1
-          while sub_part = params["from#{key_counter}".to_sym]
-            key_counter += 1
-            parts << sub_part
-          end
-        end
-
-        if params[:where]
-          parts[0] << " where #{params[:where]}"
-        end
-
-        if params[:in]
-          parts[-1] << " in #{params[:in]}"
-        end
-
-        if group = params[:group]
-          parts[-1] << " group by #{group}" unless parts[0] =~ /group by/
-        end
-
-        if order = params[:order]
-          parts[-1] << " order by #{order}" unless parts[0] =~ /order by/
-        end
-
-        if paginate = params[:paginate]
-          page_size = params[:limit].to_i
-          page_size = 20 if page_size < 1
-          parts[-1] << " limit #{page_size} paginate #{paginate.gsub(/[^a-z_A-Z]/,'')}"
-        else
-          [:limit, :offset].each do |k|
-            next unless params[k]
-            parts[-1] << " #{k} #{params[k]}" unless parts[0] =~ / #{k} /
-          end
-        end
-
-        finders = [parts.join(' from ')]
-        if params[:or]
-          finders << params[:or]
-
-          key_counter = 1
-          while sub_or = params["or#{key_counter}".to_sym]
-            key_counter += 1
-            finders << sub_or
-          end
-        else
-          or_clause = nil
-        end
-
-        return [finders, parse_raw_filters(params)]
-      end
-
-      # Parse special filters
-      def parse_raw_filters(params)
-        filters = []
-
-        if value = params[:author]
-          if stored = find_stored(User, value)
-            filters << "TABLE_NAME.user_id = '\#{#{stored}.id}'"
-          elsif value == 'current'
-            filters << "TABLE_NAME.user_id = '\#{#{node}[:user_id]}'"
-          elsif value == 'visitor'
-            filters << "TABLE_NAME.user_id = '\#{visitor[:id]}'"
-          elsif value =~ /\A\d+\Z/
-            filters << "TABLE_NAME.user_id = '#{value.to_i}'"
-          elsif value =~ /\A[\w\/]+\Z/
-            # TODO: path, not implemented yet
-          end
-        end
-
-        if value = params[:project]
-          if stored = find_stored(Node, value)
-            filters << "TABLE_NAME.project_id = '\#{#{stored}.get_project_id}'"
-          elsif value == 'current'
-            filters << "TABLE_NAME.project_id = '\#{#{node}.get_project_id}'"
-          elsif value =~ /\A\d+\Z/
-            filters << "TABLE_NAME.project_id = '#{value.to_i}'"
-          elsif value =~ /\A[\w\/]+\Z/
-            # TODO: path, not implemented yet
-          end
-        end
-
-        if value = params[:section]
-          if stored = find_stored(Node, value)
-            filters << "TABLE_NAME.section_id = '\#{#{stored}.get_section_id}'"
-          elsif value == 'current'
-            filters << "TABLE_NAME.section_id = '\#{#{node}.get_section_id}'"
-          elsif value =~ /\A\d+\Z/
-            filters << "TABLE_NAME.section_id = '#{value.to_i}'"
-          elsif value =~ /\A[\w\/]+\Z/
-            # not implemented yet
-          end
-        end
-
-        [:updated, :created, :event, :log].each do |k|
-          if value = params[k]
-            # current, same are synonym for 'today'
-            filters << date_condition(value,"TABLE_NAME.#{k}_at",current_date)
-          end
-        end
-
-        filters == [] ? nil : filters
-      end
-
-      # helpers
-      # get current output format
-      def output_format
-        @context[:output_format] || 'html'
-      end
-
-      # find the current node name in the context
-      def node(klass = self.node_class)
-        if klass == self.node_class
-          (@context[:saved_template] && @context[:main_node]) ? "@#{base_class.to_s.underscore}" : (@context[:node] || '@node')
-        elsif klass == Node
-          @context[:previous_node] || '@node'
-        else
-          # ?
-          out parser_error("could not find node_name for #{klass} (current class is #{node_class})")
-          '@node'
-        end
-      end
-
-      def erb_node_id(obj = node)
-        if node_kind_of?(Version)
-          "<%= #{obj}.node.zip %>.<%= #{obj}.number %>"
-        else
-          "<%= #{node_id(obj)} %>"
-        end
-      end
-
-      def node_id(obj = node)
-        "#{obj}.zip"
-      end
-
-      def current_date
-        @context[:date] || 'main_date'
-      end
-
-      def var
-        return @var if @var
-        if node =~ /^var(\d+)$/
-          @var = "var#{$1.to_i + 1}"
-        else
-          @var = "var1"
-        end
-      end
-
-      def cache
-        return @cache if @cache
-        if @context[:cache] =~ /^cache(\d+)$/
-          @cache = "cache#{$1.to_i + 1}"
-        else
-          @cache = "cache1"
-        end
-      end
-
-      def list_var
-        return @list_var if @list_var
-        if (list || "") =~ /^list(\d+)$/
-          @list_var = "list#{$1.to_i + 1}"
-        else
-          @list_var = "list1"
-        end
-      end
-
-      # Class of the current 'node' object (can be Version, Comment, Node, DataEntry, etc)
-      def node_class
-        @context[:node_class] || Node
-      end
-
-      def base_class
-        if node_kind_of?(Node)
-          Node
-        elsif node_kind_of?(Version)
-          Version
-        else
-          node_class
-        end
-      end
-
-      def node_kind_of?(ancestor)
-        node_class.ancestors.include?(ancestor)
-      end
-
-      def list
-        @context[:list]
-      end
-
-      def helper
-        @options[:helper]
-      end
-
-      def params_to_erb(params, initial_comma = true)
-        res = initial_comma ? [""] : []
-        params.each do |k,v|
-          if v =~ /<%=/ && !(v =~ /"/)
-            # replace by #{}
-            val = v.gsub('#{', '# {').gsub(/<%=(.*?)%>/,'#{\1}')
-            res << "#{k.inspect}=>\"#{val}\""
-          else
-            res << "#{k.inspect}=>#{v.inspect}"
-          end
-        end
-        res.join(', ')
-      end
-
-      def do_var(var_finder=nil, opts={})
-        clear_dom_scope
-        if var_finder == 'nil'
-          out "<% if nil -%>"
-        elsif var_finder
-          out "<% if #{var} = #{var_finder} -%>"
-        end
-
-        if descendant('unlink')
-          @html_tag ||= 'div'
-          new_dom_scope
-          @html_tag_params[:id] = erb_dom_id
-        end
-
-        res = expand_with(opts.merge(:node=>var, :in_if => false))
-
-        if var_finder
-          res += expand_with(opts.merge(:in_if => true, :only => ['else', 'elsif'], :html_tag_params => @html_tag_params, :html_tag => @html_tag))
-        end
-        out render_html_tag(res)
-        out "<% end -%>" if var_finder
-      end
-
-      def do_list(list_finder, query = nil, opts={})
-        clear_dom_scope
-
-        @context.merge!(opts)          # pass options from 'zafu_known_contexts' to @context
-
-        if (each_block = descendant('each')) && (each_block.descendant('edit') || descendant('add') || descendant('add_document') || (descendant('swap') && descendant('swap').parent.method != 'block') || ['block', 'drop'].include?(each_block.single_child_method))
-          new_dom_scope
-          # ajax, build template. We could merge the following code with 'r_block'.
-          add_block  = descendant('add')
-          form_block = descendant('form') || each_block
-
-          @context[:need_link_id] = form_block.need_link_id
-
-          out "<% if (#{list_var} = #{list_finder}) || (#{node}.#{node_kind_of?(Comment) ? "can_comment?" : "can_write?"} && #{list_var}=[]) -%>"
-          if query && (pagination_key = query.pagination_key)
-            out "<% set_#{pagination_key}_nodes = #{query.finder(:count)}; set_#{pagination_key}_count = (set_#{pagination_key}_nodes / #{query.page_size.to_f}).ceil; set_#{pagination_key} = [1,params[:#{pagination_key}].to_i].max -%>"
-            @context[:paginate] = pagination_key
-            @context[:vars] ||= []
-            @context[:vars] << "#{pagination_key}_nodes"
-            @context[:vars] << "#{pagination_key}_count"
-            @context[:vars] << "#{pagination_key}"
-          end
-
-          # should we publish ?
-          publish_after_save ||= form_block ? form_block.params[:publish] : nil
-          publish_after_save ||= descendant('edit') ? descendant('edit').params[:publish] : nil
-
-          # class name for create form
-          klass       = add_block  ? add_block.params[:klass]  : nil
-          klass     ||= form_block ? form_block.params[:klass] : nil
-
-          # INLINE ==========
-          # 'r_add' needs the form when rendering. Send with :form.
-          out render_html_tag(expand_with(:list=>list_var, :in_if => false, :form=>form_block, :publish_after_save => publish_after_save, :ignore => ['form'], :klass => klass))
-          out expand_with(:in_if=>true, :only=>['elsif', 'else'], :html_tag => @html_tag, :html_tag_params => @html_tag_params)
-          out "<% end -%>"
-
-          # SAVED TEMPLATE ========
-          template      = expand_block(each_block, :list=>false, :klass => klass, :saved_template => true)
-          out helper.save_erb_to_url(template, template_url)
-
-          # FORM ============
-          if each_block != form_block
-            form = expand_block(form_block, :klass => klass, :add=>add_block, :publish_after_save => publish_after_save, :saved_template => true)
-          else
-            form = expand_block(form_block, :klass => klass, :add=>add_block, :make_form=>true, :publish_after_save => publish_after_save, :saved_template => true)
-          end
-          out helper.save_erb_to_url(form, form_url)
-        else
-          # no form, render, edit and add are not ajax
-          if descendant('add') || descendant('add_document')
-            out "<% if (#{list_var} = #{list_finder}) || (#{node}.#{node_kind_of?(Comment) ? "can_comment?" : "can_write?"} && #{list_var}=[]) -%>"
-          elsif list_finder != 'nil'
-            out "<% if #{list_var} = #{list_finder} -%>"
-          else
-            out "<% if nil -%>"
-          end
-
-          if query && (pagination_key = query.pagination_key)
-            out "<% set_#{pagination_key}_nodes = #{query.finder(:count)}; set_#{pagination_key}_count = (set_#{pagination_key}_nodes / #{query.page_size.to_f}).ceil; set_#{pagination_key} = [1,params[:#{pagination_key}].to_i].max -%>"
-            @context[:paginate] = pagination_key
-            @context[:vars] ||= []
-            @context[:vars] << "#{pagination_key}_nodes"
-            @context[:vars] << "#{pagination_key}_count"
-            @context[:vars] << "#{pagination_key}"
-          end
-
-          out render_html_tag(expand_with(:list=>list_var, :in_if => false))
-          out expand_with(:in_if=>true, :only=>['elsif', 'else'], :html_tag => @html_tag, :html_tag_params => @html_tag_params)
-          out "<% end -%>"
-        end
-      end
-
-      def _(text)
-        if @context[:dict]
-          @context[:dict][text] || helper.send(:_,text)
-        else
-          helper.send(:_,text)
-        end
-      end
-
-      # Find a block to update on the page
-      def find_target(name)
-        # find dom_id / template_url
-        target = nil
-        root.descendants('block').each do |b|
-          if b.name == name
-            target = b
-            break
-          end
-        end
-        out parser_error("could not find a block named '#{name}'") if target.nil?
-        target
-      end
-
-      # DOM id for the current context
-      def dom_id(suffix='')
-        return "\#{dom_id(#{node})}" if @context && (@context[:saved_template] && @context[:main_node])
-        if @context && scope_node = @context[:scope_node]
-          res = "#{dom_prefix}_\#{#{scope_node}.zip}"
-        else
-          res = dom_prefix
-        end
-        if (method == 'each' || method == 'each_group') && !@context[:make_form]
-          "#{res}_\#{#{var}.zip}"
-        elsif @context && @context[:in_calendar]
-          "#{res}_\#{#{current_date}.to_i}"
-        elsif method == 'unlink' || method == 'edit'
-          target = nil
-          parent = self.parent
-          while parent
-            if ['block', 'each', 'context', 'icon'].include?(parent.method)
-              target = parent
-              break
-            end
-            parent = parent.parent
-          end
-          target ? target.dom_id(suffix) : (res + suffix)
-        else
-          res + suffix
-        end
-      end
-
-      def erb_dom_id(suffix='')
-        return "<%= dom_id(#{node}) %>" if @context && (@context[:saved_template] && @context[:main_node])
-        if @context && scope_node = @context[:scope_node]
-          res = "#{dom_prefix}_<%= #{scope_node}.zip %>"
-        else
-          res = dom_prefix
-        end
-        if (method == 'each' || method == 'each_group') && !@context[:make_form]
-          "#{res}_<%= #{var}.zip %>"
-        elsif method == 'draggable'
-          "#{res}_<%= #{node}.zip %>"
-        elsif @context && @context[:in_calendar]
-          "#{res}_<%= #{current_date}.to_i %>"
-        elsif method == 'unlink'
-          target = nil
-          parent = self.parent
-          while parent
-            if ['block', 'each', 'context', 'icon'].include?(parent.method)
-              target = parent
-              break
-            end
-            parent = parent.parent
-          end
-          target ? target.erb_dom_id(suffix) : (res + suffix)
-        else
-          res + suffix
-        end
-      end
-
-      # Unique template_url, ending with dom_id
-      def template_url
-        "#{@options[:root]}/#{dom_prefix}"
-      end
-
-      def form_url
-        template_url + '_form'
-      end
-
-      # Return parameter value accessor
-      def get_param(key)
-        "params[:#{key}]"
-      end
-
-      def context
-        return @context if @context
-        # not rendered yet, find first parent with context
-        @context = parent ? parent.context : {}
-      end
-
-      # prefix for DOM id
-      def dom_prefix
-        (@context ? @context[:dom_prefix] : nil) || (@dom_prefix ||= unique_name)
-      end
-
-      # use our own scope
-      def clear_dom_scope
-        @context.delete(:make_form)      # should not propagate
-        @context.delete(:main_node)      # should not propagate
-      end
-
-      # create our own ajax DOM scope
-      def new_dom_scope
-        clear_dom_scope
-        @context.delete(:saved_template) # should not propagate on fresh template
-        @context.delete(:dom_prefix)     # should not propagate on fresh template
-        @context[:main_node]  = true     # the current context will be rendered with a fresh '@node'
-        @context[:dom_prefix] = self.dom_prefix
-      end
-
-      # Return a different name on each call
-      def unique_name(base = context_name)
-        root.next_name_index(base, base == @name).gsub(/[^\d\w\/]/,'_')
-      end
-
-      def context_name
-        @name || if @context
-          @context[:name] || 'list'
-        elsif parent
-          parent.context_name
-        else
-          'root'
-        end
-      end
-
-      def next_name_index(key, own_id = false)
-        @next_name_index ||= {}
-        if @next_name_index[key]
-          @next_name_index[key] += 1
-          key + @next_name_index[key].to_s
-        elsif own_id
-          @next_name_index[key] = 0
-          key
-        else
-          @next_name_index[key] = 1
-          key + '1'
-        end
-      end
-
-      def add_params(text, opts={}, inner = '')
-        text.sub(/\A([^<]*)<(\w+)(( .*?)[^%]|)>/) do
-          # we must set the first tag id
-          before = $1
-          tag = $2
-          params = parse_params($3)
-          opts.each do |k,v|
-            next unless v
-            params[k] = v
-          end
-          "#{before}<#{tag}#{params_to_html(params)}>#{inner}"
-        end
-      end
-
-      # TODO: RUBYLESS
-      def get_test_condition(node = self.node, params = @params)
-        tests = []
-        params.each do |k,v|
-          if k.to_s =~ /^(or_|)([a-zA-Z_]+)(\d*)$/
-            k = $2.to_sym
-          end                                         #tagged undocumented
-          if [:kind_of, :klass, :status, :lang, :can, :tagged, :node, :in, :visitor, :has].include?(k)
-            tests << [k, v]
-          elsif k == :test
-            if v =~ /\s/
-              tests << [:test, v]
-            else
-              tests << [:attribute, v]
-            end
-          end
-        end
-
-
-        tests.map! do |type,value|
-          case type
-          when :kind_of
-          "#{node}.vkind_of?(#{value.inspect})"
-          when :klass
-            klass = begin Module::const_get(value) rescue "NilClass" end
-            "#{node}.klass == #{value.inspect}"
-          when :status
-            "#{node}.version.status == #{Zena::Status[value.to_sym]}"
-          when :tagged
-            # TODO: undocumented: remove and use rubyless !
-            "#{node}.tagged[#{value.inspect}]"
-          when :lang
-            "#{node}.version.lang == #{value.inspect}"
-          when :can
-            # TODO: test
-            case value
-            when 'write', 'edit'
-              "#{node}.can_write?"
-            when 'drive', 'publish'
-              "#{node}.can_drive?"
-            else
-              nil
-            end
-          when :has
-            case value
-            when 'discussion'
-              "#{node}.discussion"
-            else
-              nil
-            end
-          when :test
-            parse_condition(value, node)
-          when :attribute
-            '!' + node_attribute(value, :node => node) + '.blank?'
-          when :node
-            if node_kind_of?(Node)
-              value, node_name = get_attribute_and_node(value)
-              node_name ||= '@node'
-              if value
-                case value
-                when 'main'
-                  "#{node}[:id] == #{node_name}[:id]"
-                when 'start'
-                  "#{node}[:zip] == (params[:s] || @node[:zip]).to_i"
-                when 'parent'
-                  "#{node}[:id] == #{node_name}[:parent_id]"
-                when 'project'
-                  "#{node}[:id] == #{node_name}[:project_id]"
-                when 'section'
-                  "#{node}[:id] == #{node_name}[:section_id]"
-                when 'ancestor'
-                  "#{node_name}.fullpath =~ /\\A\#{#{node}.fullpath}/"
-                else
-                  if stored = find_stored(Node, value)
-                    "#{node}[:id] == #{stored}[:id]"
-                  else
-                    nil
-                  end
-                end
-              else
-                # bad node_name
-                nil
-              end
-            else
-              nil
-            end
-          when :in
-            if @context["in_#{value}".to_sym] # FIXME: || ancestors.include?(value) ==> ancestors is a list of zafu tags, not a list of names !
-              'true'
-            else
-              'false'
-            end
-          when :visitor
-            if value == 'anon'
-              "visitor.is_anon?"
-            else
-              nil
-            end
-          else
-            nil
-          end
-        end.compact!
-        tests == [] ? nil : tests.join(' || ')
-      end
-
-      def parse_condition_error(clause, rest, res)
-        out parser_error("invalid clause #{clause.inspect} near \"#{res[-2..-1]}#{rest[0..1]}\"")
-      end
-
-      def parse_condition(clause, node_name)
-        rest         = clause.strip
-        types        = [:par_open, :value, :bool_op, :op, :par_close]
-        allowed      = [:par_open, :value]
-        par_count    = 0
-        uses_bool_op = false
-        segment      = []  # value op value
-        after_value  = lambda { segment.size == 3 ? [:bool_op, :par_close] : [:op, :bool_op, :par_close]}
-        res          = ""
-        while rest != ''
-          # puts rest.inspect
-          if rest =~ /\A\s+/
-            rest = rest[$&.size..-1]
-          elsif rest[0..0] == '('
-            unless allowed.include?(:par_open)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            res << '('
-            rest = rest[1..-1]
-            par_count += 1
-          elsif rest[0..0] == ')'
-            unless allowed.include?(:par_close)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            res << ')'
-            rest = rest[1..-1]
-            par_count -= 1
-            if par_count < 0
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            allowed = [:bool_op]
-          elsif rest =~ /\A(lt|le|eq|ne|ge|gt)\s+/
-            unless allowed.include?(:op)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            op = $1.strip
-            rest = rest[op.size..-1]
-            op = {'lt' => '<', 'le' => '<=', 'eq' => '==', 'ne' => '!=', 'ge' => '>=', 'gt' => '>'}[op]
-            segment << [op, :op]
-            allowed = [:value]
-          elsif rest =~ /\A("|')([^\1]*?)\1/
-            # string
-            unless allowed.include?(:value)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            rest = rest[$&.size..-1]
-            segment << [$2.inspect, :string]
-            allowed = after_value.call
-          elsif rest =~ /\A(-?\d+)/
-            # number
-            unless allowed.include?(:value)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            rest = rest[$&.size..-1]
-            segment << [$1, :number]
-            allowed = after_value.call
-          elsif rest =~ /\A(and|or)/
-            unless allowed.include?(:bool_op)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            uses_bool_op = true
-            rest = rest[$&.size..-1]
-            res << " #{$1} "
-            allowed = [:par_open, :value]
-          elsif rest =~ /\A([\w:\.\-]+)/
-            # variable
-            unless allowed.include?(:value)
-              parse_condition_error(clause, rest, res)
-              return nil
-            end
-            rest = rest[$&.size..-1]
-            fld  = $1
-            unless node_attr = node_attribute(fld, :node => node_name)
-              parser_error("invalid field #{fld.inspect}")
-              return nil
-            end
-            segment << [node_attr, :var]
-            allowed = after_value.call
-          else
-            parse_condition_error(clause, rest, res)
-            return nil
-          end
-          if segment.size == 3
-            toi = (segment[1][0] =~ /(>|<)/ || (segment[0][1] == :number || segment[2][1] == :number))
-            segment.map! do |part, type|
-              if type == :var
-                toi ? "#{part}.to_i" : part
-              elsif type == :string
-                toi ? part[1..-2].to_i : part
-              else
-                part
-              end
-            end
-            res << segment.join(" ")
-            segment = []
-          end
-        end
-
-        if par_count > 0
-          parser_error("invalid clause #{clause.inspect}: missing closing ')'")
-          return nil
-        elsif allowed.include?(:value)
-          parser_error("invalid clause #{clause.inspect}")
-          return nil
-        else
-          return uses_bool_op ? "(#{res})" : res
-        end
-      end
-
-      # Block visibility of descendance with 'do_list'.
-      def public_descendants
-        all = super
-        if ['context', 'each', 'block'].include?(self.method)
-          # do not propagate 'form',etc up
-          all.reject do |k,v|
-            ['form','unlink'].include?(k)
-          end
-        elsif ['if', 'case'].include?(self.method)
-          all.reject do |k,v|
-            ['else', 'elsif', 'when'].include?(k)
-          end
-        else
-          all
-        end
-      end
-
-      def single_child_method
-        return @single_child_method if defined?(@single_child_method)
-        @single_child_method = if @blocks.size == 1
-          single_child = @blocks[0]
-          return nil if single_child.kind_of?(String)
-          single_child.html_tag ? nil : single_child.method
-        else
-          nil
-        end
-      end
-
-      def get_attribute_and_node(str)
-        if str =~ /([^\.]+)\.(.+)/
-          node_name = $1
-          node_attr = $2
-          if att_node = find_stored(Node, node_name)
-            return [node_attr, att_node, Node]
-          elsif node_name == 'main'
-            return [node_attr, '@node', Node]
-          elsif node_name == 'visitor'
-            return [node_attr, 'visitor.contact', Contact]
-          elsif node_name == 'site'
-            return [node_attr, 'current_site', Site]
-          else
-            out parser_error("invalid node name #{node_name.inspect} in attribute #{str.inspect}")
-            return [nil]
-          end
-        else
-          return [str]
-        end
-      end
-
-      def parse_attributes_in_value(v, opts = {})
-        opts = {:erb => true}.merge(opts)
-        static = true
-
-        use_node  = @var || node
-        res = v.gsub(/\[([^\]]+)\]/) do
-          static = false
-          res    = nil
-          attribute = $1
-
-          if opts[:skip_node_attributes]
-            if attribute =~ /^param:(\w+)$/
-              attribute = get_param($1)
-            elsif attribute == 'current_date'
-              attribute = current_date
-            else
-              res = "[#{attribute}]"
-            end
-          else
-            attribute = node_attribute(attribute, :node => use_node )
-          end
-
-          res ||= if opts[:erb]
-            "<%= #{attribute} %>"
-          else
-            "\#{#{attribute}}"
-          end
-          res
-        end
-        [res, static]
-      end
-
-      def node_attribute(str, opts={})
-
-        if @context[:vars] && @context[:vars].include?(str)
-          return "set_#{str}"
-        end
-
-        res = PSEUDO_ATTRIBUTES[str]
-        return res if res
-        return current_date  if str == 'current_date'
-        return get_param($1) if str =~ /^param:(\w+)$/
-
-        attribute, att_node, klass = get_attribute_and_node(str)
-
-        return 'nil' unless attribute
-
-
-        att_node  ||= opts[:node]       || node
-        klass     ||= opts[:node_class] || node_class
-
-        real_attribute = attribute =~ /\Ad_/ ? attribute : attribute.gsub(/\A(|[\w_]+)id(s?)\Z/, '\1zip\2')
-
-        res = if klass.ancestors.include?(Node)
-          if ['url','path'].include?(real_attribute)
-            # pseudo attribute 'url'
-            params = {}
-            params[:mode]   = @params[:mode]   if @params[:mode]
-            params[:format] = @params[:format] if @params[:format]
-            "zen_#{real_attribute}(#{node}#{params_to_erb(params)})"
-          elsif type = safe_method_type([real_attribute])
-            type[:method]
-          elsif type = klass.safe_method_type([real_attribute])
-            "#{att_node}.#{type[:method]}"
-          else
-            "#{att_node}.safe_read(#{real_attribute.inspect})"
-          end
-        elsif type = klass.safe_method_type([real_attribute])
-          "#{att_node}.#{type[:method]}"
-        else
-          # unknown class, resolve at runtime
-          "#{att_node}.safe_read(#{real_attribute.inspect})"
-        end
-
-        res = "(#{res} || #{node_attribute(opts[:else])})" if opts[:else]
-        res = "(#{res} || #{opts[:default].inspect})" if opts[:default]
-        res
-      end
-
-      # Add a class name to the html_tag
-      def add_html_class(class_name)
-        if klass = @html_tag_params[:class]
-          @html_tag_params[:class] = "#{class_name} #{klass}"
-        else
-          @html_tag_params[:class] = class_name
-        end
-      end
-
-      def render_html_tag(text,*append)
-        append ||= []
-        return text if @html_tag_done
-        set_params  = {}
-        if_params   = {}
-        @params.each do |k,v|
-          if k.to_s =~ /^t?set_/
-            set_params[k] = v
-          end
-        end
-        tag_class = @html_tag_params[:class] || @params[:class]
-        if node_kind_of?(Node)
-
-          if @context[:make_form]
-            node_name = node
-          elsif (@method == 'each' || @method == 'each_group') && @context[:list]
-            node_name = var
-          elsif @method == 'context'
-            node_name = @var || node
-          else
-            node_name = node
-          end
-
-          class_cond = nil
-          @params.each do |k,v|
-            if k.to_s =~ /^(.+)_if$/
-              klass = $1
-              cond  = get_test_condition(node_name, :test => v)
-            elsif k.to_s =~ /^(.+)_if_(test|node|kind_of|klass|status|lang|can|in)$/
-              klass = $1
-              cond  = get_test_condition(node_name, $2.to_sym => v)
-            end
-            if cond
-              class_cond = "#{cond} ? \" class='#{klass}'\" : #{class_cond}" # (x = 3) ? "class='foo'" :
-            end
-          end
-
-          if class_cond
-            append << "<%= #{class_cond}\"#{tag_class ? " class='#{tag_class}'" : ""}\" %>"
-            @html_tag_params.delete(:class)
-          end
-        end
-
-        @html_tag = 'div' if !@html_tag && (set_params != {} || @html_tag_params != {})
-
-        bak = @html_tag_params.dup
-        @html_tag_params = get_html_params(set_params.merge(@html_tag_params), @html_tag)
-        res = super(text,*append)
-        @html_tag_params = bak
-        res
-      end
-
-      def link_to_update(target, opts = {})
-        method = opts[:method] || :get
-
-        html_params = opts[:html_params] || {}
-        node_id = opts[:node_id] || self.node_id
-
-        url    = opts[:url]    || "/#{base_class.to_s.pluralize.underscore}/\#{#{node_id}}#{method == :get ? '/zafu' : ''}"
-        opts[:cond]   ||= "#{node}.can_write?" if method != :get
-
-        query_params = [opts[:query_params]].flatten.compact
-
-        if method == :get
-          if target
-            query_params << "t_url=#{CGI.escape(target.template_url)}"
-            query_params << "dom_id=#{target.dom_id}"
-          else
-            query_params << "dom_id=_page"
-          end
-        else
-          query_params << "t_url=#{CGI.escape(template_url)}" if method != :delete
-
-          query_params << "dom_id=#{dom_id}"
-          if target != self
-            if target
-              query_params << "u_url=#{CGI.escape(target.template_url)}"
-              query_params << "udom_id=#{target.dom_id}"
-            else
-              query_params << "udom_id=_page"
-            end
-          end
-        end
-
-        query_params << "link_id=\#{#{node}.link_id}" if @context[:need_link_id] && node_kind_of?(Node)
-        query_params << "node[v_status]=#{Zena::Status[:pub]}" if @params[:publish] # FIXME: this acts like publish = 'force'
-        query_params << start_node_s_param(:string)
-
-        res = ''
-        res += "<% if #{opts[:cond]} -%>" if opts[:cond]
-        res += "<%= tag_to_remote({:url => \"#{url}?#{query_params.join('&')}\", :method => #{method.inspect}}#{params_to_erb(html_params)}) %>"
-        res += text_for_link(opts[:default_text])
-        res += "</a>"
-        if opts[:cond]
-          if opts[:else] != :void
-            res += "<% else -%>"
-            res += text_for_link(opts[:default_text])
-          end
-          res += "<% end -%>"
-        end
-        res
-      end
-
-      def text_for_link(default = nil)
-        if @blocks.size > 1 || (@blocks.size == 1 && !(@blocks.first.kind_of?(String) || ['else','elsif'].include?(@blocks.first.method)))
-          expand_with
-        elsif default
-          default
-        elsif erb_text = get_text_for_erb(@params, false, :string)
-          erb_text
-        elsif node_kind_of?(Node)
-          "<%= #{node}.version.title %>"
-        elsif node_kind_of?(Version)
-          "<%= #{node}.title %>"
-        elsif node_kind_of?(Link)
-          "<%= #{node}.name %>"
-        else
-          _('edit')
-        end
-      end
-
-      def get_text_for_erb(params = @params, use_blocks = true, context = :erb)
-        string_context = context == :string
-        if params[:attr]
-          string_context ? "<%= #{node_attribute(params[:attr])} %>" : node_attribute(params[:attr])
-        elsif params[:tattr]
-          string_context ? "<%= _(#{node_attribute(params[:tattr])}) %>" : "_(#{node_attribute(params[:tattr])})"
-        elsif params[:trans]
-          string_context ? _(params[:trans]) : _(params[:trans]).inspect
-        elsif params[:text]
-          string_context ? params[:text] : params[:text].inspect
-        elsif use_blocks && @blocks != []
-          res  = []
-          text = ""
-          static = true
-          @blocks.each do |b|
-            # FIXME: this is a little too hacky
-            if b.kind_of?(String)
-              res  << b.inspect
-              text << b
-            elsif ['show', 'img'].include?(b.method)
-              res << expand_block(b, :trans=>true)
-              static = false
-            elsif ['rename_asset', 'trans'].include?(b.method)
-              # FIXME: if a trans contains non-static: static should become false
-              res  << expand_block(b).inspect
-              text << expand_block(b)
-            else
-              # ignore
-            end
-          end
-          if static
-            # "just plain text"
-            string_context ? text : text.inspect
-          else
-            # function(...) + "blah" + function()
-            string_context ? "<%= #{res.join(' + ')} %>" : res.join(' + ')
-          end
-        else
-          nil
-        end
-      end
-
-      def get_input_params(params = @params)
-        res = {}
-        if res[:name] = (params[:name] || params[:date])
-          if res[:name] =~ /\A([\w_]+)\[(.*?)\]/
-            attribute, sub_attr = $1, $2
-          else
-            attribute = res[:name]
-          end
-
-          unless @context[:in_filter] || attribute == 's'
-            if sub_attr
-              res[:name] = "#{base_class.to_s.underscore}[#{attribute}][#{sub_attr}]"
-            else
-              res[:name] = "#{base_class.to_s.underscore}[#{attribute}]"
-            end
-          end
-
-          if sub_attr
-            if (nattr = node_attribute(attribute)) != 'nil'
-              nattr = "#{nattr}[#{sub_attr.inspect}]"
-            end
-          else
-            nattr = node_attribute(attribute)
-          end
-
-          if sub_attr && params[:type] == 'checkbox' && !params[:value]
-            # Special case when we have a sub_attribute: default value for "tagged[foobar]" is "foobar"
-            params[:value] = sub_attr
-          end
-
-          if @context[:in_add]
-            res[:value] = (params[:value] || params[:set_value]) ? ["'#{ helper.fquote(params[:value])}'"] : ["''"]
-          elsif @context[:in_filter]
-            res[:value] = attribute ? ["'<%= fquote params[#{attribute.to_sym.inspect}] %>'"] : ["''"]
-          elsif params[:value]
-            res[:value] = ["'#{ helper.fquote(params[:value])}'"]
-          else
-            if nattr != 'nil'
-              res[:value] = ["'<%= fquote #{nattr} %>'"]
-            else
-              res[:value] = ["''"]
-            end
-          end
-        end
-
-        if @context[:dom_prefix]
-          res[:id]   = "#{erb_dom_id}_#{attribute}"
-        else
-          res[:id]   = params[:id] if params[:id]
-        end
-
-        if params[:type] == 'checkbox' && nattr
-          if value = params[:value]
-            res[:checked] = "<%= #{nattr} == #{value.inspect} ? \" checked='checked'\" : '' %>"
-          else
-            res[:checked] = "<%= #{nattr}.blank? ? '' : \" checked='checked'\" %>"
-          end
-        end
-
-        [:size, :style, :class].each do |k|
-          res[k] = params[k] if params[k]
-        end
-
-        return [res, attribute]
-      end
-
-      def get_html_params(params, tag_type)
-        res  = {}
-        params.each do |k,v|
-          next unless v
-          if k.to_s =~ /\A(t?)set_(.+)$/
-            key   = $2
-            trans = $1 == 't'
-            value, static = parse_attributes_in_value(v, :erb => !trans)
-
-            if trans
-              if static
-                value = ["'#{_(value)}'"]            # array so it is not escaped on render
-              else
-                value = ["'<%= _(\"#{value}\") %>'"] # FIXME: use dict ! array so it is not escaped on render
-              end
-            end
-            res[key.to_sym] = value
-          elsif tag_type == :link && ![:style, :class, :id, :title].include?(k)
-            # bad html parameter for links (some keys for link tags are used as query parameters)
-            # filter out
-          else
-            res[k] ||= v
-          end
-        end
-
-        if params[:anchor]
-          @anchor_param = nil
-          res[:name] = anchor_name(params[:anchor], node)
-        end
-
-        res
-      end
-
-      def get_options_for_select
-        if nodes = @params[:nodes]
-          # TODO: dry with r_checkbox
-          if nodes =~ /^\d+\s*($|,)/
-            # ids
-            # TODO: optimization generate the full query instead of using secure.
-            nodes = nodes.split(',').map{|v| v.to_i}
-            nodes = "(secure(Node) { Node.find(:all, :conditions => 'zip IN (#{nodes.join(',')})') })"
-          else
-            # relation
-            nodes, klass = build_finder_for(:all, nodes)
-            return unless nodes
-            return parser_error("invalid class (#{klass})") unless klass.ancestors.include?(Node)
-          end
-          set_attr  = @params[:attr] || 'id'
-          show_attr = @params[:show] || 'name'
-          options_list = "[['','']] + (#{nodes} || []).map{|r| [#{node_attribute(show_attr, :node => 'r', :node_class => Node)}, #{node_attribute(set_attr, :node => 'r', :node_class => Node)}.to_s]}"
-        elsif values = @params[:values]
-          options_list = values.split(',').map(&:strip)
-
-          if show = @params[:show]
-            show_values = show.split(',').map(&:strip)
-          elsif show = @params[:tshow]
-            show_values = show.split(',').map do |s|
-              _(s.strip)
-            end
-          end
-
-          if show_values
-            options_list.each_index do |i|
-              options_list[i] = [show_values[i], options_list[i]]
-            end
-          end
-          options_list.inspect
-        end
-      end
-
-      def parse_eval_parameter(str)
-        # evaluate an expression. Can only contain vars, '(', ')', '*', '+', '/', '-', '[attr]'
-        # FIXME: SECURITY (audit this)
-        vars = @context[:vars] || []
-        parts = str.split(/\s+/)
-        res  = []
-        test = []
-        parts.each do |p|
-          if p =~ /\[([\w_]+)\]/
-            test << 1
-            res << (node_attribute($1) + '.to_f')
-          elsif p =~ /^[a-zA-Z_]+$/
-            unless vars.include?(p)
-              out parser_error("var #{p.inspect} not set in eval")
-              return nil
-            end
-            test << 1
-            res  << "set_#{p}.to_f"
-          elsif ['(', ')', '*', '+', '/', '-'].include?(p)
-            res  << p
-            test << p
-          elsif p =~ /^[0-9\.]+$/
-            res  << p
-            test << p
-          else
-            out parser_error("bad argument #{p.inspect} in eval")
-            return nil
-          end
-        end
-        begin
-          begin
-            eval test.join(' ')
-          rescue
-            # rescue evaluation error
-            out parser_error("error in eval")
-            return nil
-          end
-          "(#{res.join(' ')})"
-        rescue SyntaxError => err
-          # rescue compilation error
-          out parser_error("compilation error in eval")
-          return nil
-        end
-      end
-
-      def find_stored(klass, key)
-        if "#{klass}_#{key}" == "Node_start_node"
-          # main node before ajax stuff (the one in browser url)
-          "start_node"
-        else
-          @context["#{klass}_#{key}"]
-        end
-      end
-
-      def set_stored(klass, key, obj)
-        @context["#{klass}_#{key}"] = obj
-      end
-
-      # transform a 'show' tag into an input field.
-      def make_input(params = @params)
-        input, attribute = get_input_params(params)
-        return parser_error("missing 'name'") unless attribute
-        return '' if attribute == 'parent_id' # set with 'r_form'
-        return '' if ['url','path'].include?(attribute) # cannot be set with a form
-        if params[:date]
-        input_id = @context[:dom_prefix] ? ", :id=>\"#{dom_id}_#{attribute}\"" : ''
-          return "<%= date_box('#{base_class.to_s.underscore}', #{params[:date].inspect}#{input_id}) %>"
-        end
-        input_id = @context[:dom_prefix] ? " id='#{erb_dom_id}_#{attribute}'" : ''
-        "<input type='#{params[:type] || 'text'}'#{input_id} name='#{input[:name]}' value=#{input[:value]}/>"
-      end
-
-      # transform a 'zazen' tag into a textarea input field.
-      def make_textarea(params)
-        return parser_error("missing 'name'") unless name = params[:name]
-        if name =~ /\A([\w_]+)\[(.*?)\]/
-          attribute = $2
-        else
-          attribute = name
-          name = "#{base_class.to_s.underscore}[#{attribute}]"
-        end
-        return '' if attribute == 'parent_id' # set with 'r_form'
-
-        if @blocks == [] || @blocks == ['']
-          if @context[:in_add]
-            value = ''
-          else
-            value = attribute ? "<%= #{node_attribute(attribute)} %>" : ""
-          end
-        else
-          value = expand_with
-        end
-        html_id = @context[:dom_prefix] ? " id='#{erb_dom_id}_#{attribute}'" : ''
-        "<textarea#{html_id} name='#{name}'>#{value}</textarea>"
-      end
-
-      def default_focus_field
-        if (input_fields = descendants('input')) != []
-          field = input_fields.first.params[:name]
-        elsif (show_fields = descendants('show')) != []
-          field = show_fields.first.params[:attr]
-        elsif node_kind_of?(Node)
-          field = 'v_title'
-        else
-          field = 'text'
-        end
-      end
-
-      # Returns true if a form/edit needs to keep track of link_id (l_status or l_comment used).
-      def need_link_id
-        if (input_fields = (descendants('input') + descendants('select'))) != []
-          input_fields.each do |f|
-            return true if f.params[:name] =~ /\Al_/
-          end
-        elsif (show_fields = descendants('show')) != []
-          show_fields.each do |f|
-            return true if f.params[:attr] =~ /\Al_/
-          end
-        end
-        return false
-      end
-
-      def start_node_s_param(type = :input)
-        if type == :input
-          "<input type='hidden' name='s' value='<%= params[:s] || @node[:zip] %>'/>"
-        elsif type == :erb
-          "s=<%= params[:s] || @node[:zip] %>"
-        elsif type == :value
-          "<%= params[:s] || @node[:zip] %>"
-        else
-          "s=\#{params[:s] || @node[:zip]}"
-        end
-      end
-
-      def parser_error(message, tag=@method)
-        "<span class='parser_error'>[#{tag}] #{message}</span>"
-      end
-
-      # Used by [each] and [draggable] to insert 'id' and drag handle span
-      def set_drag_handle_and_id(text, params, id_hash)
-        res, drag_handle = text, nil
-        if params[:drag_handle]
-          drag_handle = params[:drag_handle] == 'true' ? 'drag_handle' : params[:drag_handle]
-          if text =~ /class\s*=\s*['"]#{drag_handle}/
-            # nothing to do
-            insert = ''
-          else
-            insert = "<span class='#{drag_handle}'>&nbsp;</span>"
-          end
-        else
-          insert = ''
-        end
-
-        res = insert + text
-
-        if id_hash
-          @html_tag ||= 'div'
-          @html_tag_params.merge!(id_hash)
-        end
-
-        [res, drag_handle]
-      end
-
-      def expand_with(acontext={})
-        # set variables
-        context = nil
-        pre = ''
-        @blocks.each do |block|
-          next if block.kind_of?(String) || block.method != 'set'
-          @context[:vars] ||= []
-          context ||= @context.merge(acontext).merge(:set => true)
-          pre << expand_block(block, context)
-          @context[:vars] << block.params[:var]
-        end
-
-        pre + super
-      end
-
-      def auto_publish_param(in_string = false)
-        if in_string
-          ['true','force'].include?(@params[:publish]) ? "&publish=#{@params[:publish]}" : ''
-        else
-          @params[:publish]
-        end
-      end
-
-      # This is used by zafu and it's a mess.
-      # ref_date can be a string ('2005-05-03') or ruby ('Time.now'). It should not come uncleaned from evil web.
-      def date_condition(date_cond, field, ref_date='today')
-        if date_cond == 'today' || ref_date == 'today'
-          ref_date = Zena::Db::NOW
-        elsif ref_date =~ /(\d{4}-\d{1,2}-\d{1,2}( \d{1,2}:\d{1,2}(:\d{1,2})?)?)/
-          ref_date = "'#{$1}'"
-        elsif ref_date =~ /\A"/
-          ref_date = "'\#{format_date(#{ref_date})}'"
-        else
-          ref_date = "'\#{#{ref_date}.strftime('%Y-%m-%d %H:%M:%S')}'"
-        end
-        Zena::Db.date_condition(date_cond, field, ref_date)
-      end
-    end # ZenaTags
-  end # Parser
-end # Zena