zena 0.15.2 → 0.16.0

data/lib/zafu/core/html.rb

@@ -0,0 +1,102 @@
+module Zafu
+  module Core
+    module HTML
+      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 && k == :_name
+            # :_name set by r_anchor
+            res[:name] ||= v
+          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
+
+      # 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' || !respond_to?("r_#{@method}".to_sym)
+            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
+    end # HTML
+  end # Core
+end # Zafu

data/lib/zafu/core/move_to_parser.rb

@@ -0,0 +1,167 @@
+# Elements here should be moved to the core zafu parser
+module Zafu
+  module Core
+    module MoveToParser
+      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
+        if @method != 'link'
+          @anchor_param = @params[:anchor]
+        end
+
+        true
+      end
+
+
+      def after_render(text)
+        if @anchor_param
+          @params[:anchor] = @anchor_param # set back in case of double rendering so it is computed again
+          r_anchor + super
+        else
+          super
+        end
+      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 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 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
+
+      # 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
+
+      # 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
+
+      def context
+        return @context if @context
+        # not rendered yet, find first parent with context
+        @context = parent ? parent.context : {}
+      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
+    end # MoveToParser
+  end # Core
+end # Zafu

data/lib/zafu/dates.rb

@@ -0,0 +1,58 @@
+module Zafu
+  module Dates
+    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
+
+    protected
+      def current_date
+        @context[:date] || 'main_date'
+      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 # Dates
+end # Zafu

data/lib/zafu/display.rb

@@ -0,0 +1,502 @@
+module Zafu
+  module Display
+
+    # This should be done with rubyless... (methods on the compiler...)
+    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 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_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
+        attribute_method = node_class.ancestors.include?(String) ? node : node_attribute('to_s')
+      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
+    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
+
+    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
+
+    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
+
+    # 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
+
+    # 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_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
+
+    # 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_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
+
+    # 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
+
+  end # Display
+end # Zafu