zena 1.0.0.rc2 → 1.0.0.rc3

data/lib/zena/use/urls.rb

@@ -1,7 +1,23 @@
 module Zena
   module Use
     module Urls
-      ALLOWED_REGEXP = /\A(([a-zA-Z]+)([0-9]+)|([#{String::ALLOWED_CHARS_IN_FILENAME}]+))(_[a-zA-Z]+|)(\..+|)\Z/
+      NODE_ACTIONS = {
+        ''         => {:url => '/nodes/#{node_zip}'},
+        'drive'    => {:url => '/nodes/#{node_zip}/edit'},
+        'add_doc'  => {:url => '/documents/new', :query => {:parent_id => 'node_zip'}},
+        'destroy'  => {:url => '/nodes/#{node_zip}', :method => 'delete'},
+        'update'   => {:url => '/nodes/#{node_zip}', :method => 'put'},
+        'drop'     => {:url => '/nodes/#{node_zip}/drop'},
+        'unlink'   => {:url => '/nodes/#{node_zip}/link/#{node.link_id}', :method => 'delete'},
+        'zafu'     => {:url => '/nodes/#{node_zip}/zafu'},
+        'publish'  => {:url => '/nodes/#{node_zip}/versions/0/publish', :method => 'put'},
+        'propose'  => {:url => '/nodes/#{node_zip}/versions/0/propose', :method => 'put'},
+        'refuse'   => {:url => '/nodes/#{node_zip}/versions/0/refuse',  :method => 'put'},
+        'edit'     => {:url => '/nodes/#{node_zip}/versions/0/edit'},
+      }
+
+
+      ALLOWED_REGEXP = /\A(([a-zA-Z]+)([0-9]+)|([#{String::ALLOWED_CHARS_IN_FILENAME}%]+))(_[a-zA-Z]+|)(\..+|)\Z/
 
       module Common
         CACHESTAMP_FORMATS = ['jpg', 'png', 'gif', 'css', 'js']
@@ -15,22 +31,29 @@ module Zena
 
         # We overwrite some url writers that might use Node so that they use
         # zip instead of id.
-        ['', 'edit_', 'delete_', 'drop_', 'zafu_'].each do |method|
-          class_eval %Q{
-            def #{method}node_path(node, options={}) # def edit_node_path(node, options={})
-              if ep = options.delete(:encode_params)
-                ep.split(',').map(&:strip).each do |key|
-                  value = params[key]
-                  options[key] = value unless value.blank?
-                end
-              end
-              if node.kind_of?(Node)                  #   if node.kind_of?(Node)
-                super(node.zip, options)              #     super(node.zip, options)
-              else                                    #   else
-                super                                 #     super
-              end                                     #   end
-            end                                       # end
-          }
+        NODE_ACTIONS.each do |name, definition|
+          method = name.blank? ? 'node_path' : "#{name}_node_path"
+          hash_str = []
+          if query = definition[:query]
+            query.each do |k,v|
+              hash_str << ":#{k} => #{v}"
+            end
+          end
+
+          if hash_str.empty?
+            opts_merge = ''
+          else
+            opts_merge = "options = {#{hash_str.join(',')}}.merge(options)"  # {:parent_id => node_zip}.merge(options)
+          end
+
+          class_eval(%Q{
+            def #{method}(node, options={})                       # def zafu_node_path(node, options={})
+              return '#' unless node                              #   return '#' unless node
+              node_zip = node.kind_of?(Node) ? node.zip : node    #   node_zip = node.kind_of?(Node) ? node.zip : node
+              #{opts_merge}                                       #   options = {:parent_id => node.zip}.merge(options)
+              append_query_params("#{definition[:url]}", options) #   append_query_params("/nodes/\#{node.zip}/zafu", options)
+            end                                                   # end
+          }, __FILE__, __LINE__ - 5)
         end
 
         # Path to remove a node link.
@@ -159,6 +182,7 @@ module Zena
         # Url for a node. Options are 'mode' and 'format'
         # ex 'http://test.host/en/document34_print.html'
         def zen_url(node, opts={})
+          # FIXME: we *need* port number !
           zen_path(node,opts.merge(:host => visitor.site[:host]))
         end
 
@@ -224,27 +248,22 @@ module Zena
       module ViewMethods
         include Common
         include RubyLess
-        safe_method [:url,  Node]     => {:class => String, :method => 'zen_url'}
-        safe_method [:path, Node]     => {:class => String, :method => 'zen_path'}
+        safe_method [:url,  Node]       => {:class => String, :method => 'zen_url'}
+        safe_method [:url,  Node, Hash] => {:class => String, :method => 'zen_url'}
+        safe_method [:path, Node]       => {:class => String, :method => 'zen_path'}
+        safe_method [:path, Node, Hash] => {:class => String, :method => 'zen_path'}
 
         safe_method [:zen_path, Node, Hash]     => {:class => String, :accept_nil => true}
         safe_method [:zen_path, Node]           => {:class => String, :accept_nil => true}
         safe_method [:zen_path, String, Hash]   => {:class => String, :accept_nil => true, :method => 'dummy_zen_path'}
         safe_method [:zen_path, String]         => {:class => String, :accept_nil => true, :method => 'dummy_zen_path'}
 
-        safe_method [:zafu_node_path, Node, Hash]   => {:class => String, :accept_nil => true}
-        safe_method [:zafu_node_path, Node]         => {:class => String, :accept_nil => true}
-        safe_method [:update_node_path, Node, Hash]   => {:class => String, :accept_nil => true, :method => 'node_path'}
-        safe_method [:update_node_path, Node]         => {:class => String, :accept_nil => true, :method => 'node_path'}
 
-        safe_method [:edit_node_path, Node, Hash]   => {:class => String, :accept_nil => true}
-        safe_method [:edit_node_path, Node]         => {:class => String, :accept_nil => true}
-        safe_method [:delete_node_path, Node, Hash] => {:class => String, :accept_nil => true}
-        safe_method [:delete_node_path, Node]       => {:class => String, :accept_nil => true}
-        safe_method [:drop_node_path, Node, Hash]   => {:class => String, :accept_nil => true}
-        safe_method [:drop_node_path, Node]         => {:class => String, :accept_nil => true}
-        safe_method [:unlink_node_path, Node, Hash]   => {:class => String, :accept_nil => true}
-        safe_method [:unlink_node_path, Node]         => {:class => String, :accept_nil => true}
+        NODE_ACTIONS.keys.each do |action|
+          next if action.blank?
+          safe_method [:"#{action}_node_path", Node, Hash] => {:class => String, :accept_nil => true}
+          safe_method [:"#{action}_node_path", Node]       => {:class => String, :accept_nil => true}
+        end
 
         safe_method :start_id  => {:class => Number, :method => 'start_node_zip'}
 
@@ -304,6 +323,7 @@ module Zena
         def make_link(options = {})
           remote_target = (options[:update] || @params.delete(:update))
           options[:action] ||= @params.delete(:action)
+          confirm = @params.delete(:confirm)
 
           @markup.tag ||= 'a'
 
@@ -325,6 +345,22 @@ module Zena
             text = text_for_link(options[:default_text])
           end
 
+          http_method = http_method_from_action(options[:action])
+
+          if http_method == 'delete'
+            confirm ||= '#{t("Destroy ?")} "#{title}"'
+          end
+
+          if confirm
+            confirm = ::RubyLess.translate_string(self, confirm)
+
+            if confirm.literal
+              markup.set_param(:"data-confirm", confirm.literal)
+            else
+              markup.set_dyn_param(:"data-confirm", "<%= #{confirm} %>")
+            end
+          end
+
           if remote_target
             # ajax link (link_to_remote)
 
@@ -333,11 +369,17 @@ module Zena
 
 
             # Use onclick with Ajax.
-            markup.set_dyn_param(:onclick, "new Ajax.Request(\"<%= #{href} %>\", {asynchronous:true, evalScripts:true, method:\"#{http_method_from_action(options[:action])}\"}); return false;")
+            markup.set_dyn_param(:onclick, "new Ajax.Request(\"<%= #{href} %>\", {asynchronous:true, evalScripts:true, method:\"#{http_method}\"}); return false;")
           else
             markup.set_dyn_param(:href, "<%= #{href} %>")
+
+            if http_method != 'get' || confirm
+              markup.set_dyn_param(:onclick, "return Zena.m(this,#{http_method.inspect})")
+            end
           end
 
+          # We wrap without callbacks (before_wrap, after_wrap) so that the link
+          # is used as raw text in these callbacks.
           markup.wrap(text)
 =begin
           query_params = options[:query_params] || {}
@@ -471,15 +513,6 @@ module Zena
         private
 
           # Build the 'href' part of a link.
-          #
-          # ==== Parameters
-          #
-          # * +:remote_target+ - a processing node to update
-          # * +:action+ - action to use ('edit', 'show'). Default is 'show'.
-          #
-          # ==== Examples
-          #
-          #   Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"
           def make_href(remote_target = nil, opts = {})
             anchor = @params[:anchor]
             if anchor && !@params[:href]
@@ -487,13 +520,10 @@ module Zena
               return ::RubyLess.translate(self, "%Q{##{get_anchor_name(anchor)}}")
             end
 
-            # if opts[:action] == 'edit' && !remote_target
-            #   method = 'edit_node_path'
-            # els
-            if %w{edit drop unlink}.include?(opts[:action])
+            if opts[:action] == 'edit' && remote_target
+              method = 'zafu_node_path'
+            elsif NODE_ACTIONS[opts[:action]]
               method = "#{opts[:action]}_node_path"
-            elsif %w{update}.include?(opts[:action])
-              method = 'update_node_path'
             elsif remote_target
               method = 'zafu_node_path'
             else
@@ -503,21 +533,11 @@ module Zena
             method_args = []
             hash_params = []
 
-            # Select http verb.
-            unless remote_target
-              http_method = http_method_from_action(opts[:action])
-              if http_method != 'get'
-                hash_params << ":_method => '#{http_method}'"
-              end
-            end
-
             if href = @params[:href]
               method_args << href
             elsif node.will_be?(Version)
               method_args << "node"
               hash_params << ":lang => this.lang"
-            elsif node.list_context?
-              method_args << '@node'
             else
               method_args << 'this'
             end
@@ -525,12 +545,12 @@ module Zena
             insert_ajax_args(remote_target, hash_params, opts[:action]) if remote_target
 
             (opts[:query_params] || @params).each do |key, value|
-              next if [:href, :eval, :text, :attr].include?(key)
+              next if [:href, :eval, :text, :attr, :t].include?(key)
               if key == :anchor
                 value = get_anchor_name(value)
               end
 
-              # FIXME: Do not force string interpolation.
+              # FIXME: how to not force string interpolation ?
               hash_params << "#{key.inspect} => %Q{#{value}}"
             end
 
@@ -552,13 +572,22 @@ module Zena
               return
             elsif target.kind_of?(String)
               # named target
-              return nil unless target = find_target(target)
+              if target_block = find_target(target)
+                target = target_block
+              else
+                out parser_error("Could not find target name '#{target}'.")
+                return nil
+              end
             end
 
+
+            # FIXME: when we have proper markup.dyn_params[:id] support,
+            # we should not need this crap anymore.
             case action
             when 'edit'
-              # 'each' target in parent hierarchy
-              @insert_dom_id = %Q{"#{node.dom_id(:erb => false)}"}
+              # 'each' or 'block' target in parent hierarchy
+              is_list = ancestor(%w{each block}).method == 'each'
+              @insert_dom_id = %Q{"#{node.dom_id(:erb => false, :list => is_list)}"}
               hash_params << ":dom_id => insert_dom_id"
               hash_params << ":t_url  => %Q{#{form_url(node.dom_prefix)}}"
               # To enable link edit fix the following line:
@@ -566,17 +595,11 @@ module Zena
             when 'unlink', 'delete'
               @insert_dom_id = %Q{"#{node.dom_id(:erb => false)}"}
               hash_params << ":dom_id => insert_dom_id"
-              hash_params << ":t_url  => %Q{#{template_url(target.name)}}"
-            else # drop, swap
-              if target.context && target.node
-                # target loaded
-                dom_name = target.node.dom_prefix
-              else
-                # hack until we find a way to prebuild the target....
-                dom_name = target.name
-              end
-              hash_params << ":dom_id => %Q{#{dom_name}}"
-              hash_params << ":t_url  => %Q{#{template_url(dom_name)}}"
+              hash_params << ":t_url  => %Q{#{template_url(node.dom_prefix)}}"
+            else #drop, #swap
+              @insert_dom_id, dom_prefix = get_dom_id(target)
+              hash_params << ":dom_id => insert_dom_id"
+              hash_params << ":t_url  => %Q{#{template_url(dom_prefix)}}"
             end
 
             # method = opts[:method] || :get
@@ -632,7 +655,7 @@ module Zena
           def pagination_links
 
             return parser_error("not in pagination scope") unless pagination_key = get_context_var('paginate', 'key')
-            page_direction = @params[:page]
+            page_direction = @params.delete(:page)
             case page_direction
             when 'previous', 'next'
               current      = get_context_var('paginate', 'current')
@@ -640,21 +663,28 @@ module Zena
               prev_or_next = get_var_name('paginate', page_direction)
 
               if page_direction == 'previous'
-                out "<% if #{prev_or_next} = (#{current} > 1 ? #{current} - 1 : nil) %>"
+                cond = "#{prev_or_next} = (#{current} > 1 ? #{current} - 1 : nil)"
               else
-                out "<% if #{prev_or_next} = (#{count} - #{current} > 0 ? #{current} + 1 : nil) %>"
+                cond = "#{prev_or_next} = (#{count} - #{current} > 0 ? #{current} + 1 : nil)"
               end
 
               # previous_page // next_page
-              set_context_var('set_var', "#{page_direction}_page", RubyLess::TypedString.new(prev_or_next, :class => Number, :nil => true))
-
-              #, :params => @params.merge(:page => nil))
-              out make_link(:default_text => "<%= #{prev_or_next} %>", :query_params => {pagination_key => "\#{#{page_direction}_page}"})
-
-              if descendant('else')
-                out expand_with(:in_if => true, :only => ['else', 'elsif'])
+              set_context_var('set_var', "#{page_direction}_page",
+                RubyLess::TypedString.new(prev_or_next, :class => Number, :nil => true)
+              )
+
+              unless descendant('link')
+                # Do not wrap twice
+                link = {
+                  :href => '@node',
+                  :eval => "#{page_direction}_page",
+                  pagination_key => "\#{#{page_direction}_page}",
+                }.merge(@params)
+                # <r:link href='@node' p='next_page' eval='next_page'/>
+                wrap_in_block :method => 'link', :params => link
               end
-              out "<% end %>"
+
+              out expand_if(cond)
             when 'list'
 
               node_count  = get_context_var('paginate', 'nodes')
@@ -668,7 +698,7 @@ module Zena
               set_context_var('set_var', 'page_name', RubyLess::TypedString.new(page_name, String))
 
               if @blocks == [] || (@blocks.size == 1 && !@blocks.first.kind_of?(String) && @blocks.first.method == 'else')
-                # We need to insert the default 'link' tag: <r:link href='@node' #{pagination_key}='#{this}' ... do='this'/>
+                # We need to insert the default 'link' tag: <r:link href='@node' #{pagination_key}='#{this}' ... do='page_name'/>
                 link = {}
                 @params.each do |k,v|
                   next if [:tag, :page, :join, :page_count].include?(k)
@@ -682,19 +712,16 @@ module Zena
                 link[:eval] = 'page_name'
                 link[pagination_key.to_sym] = '#{this}'
 
-                # <r:link href='@node' href='@node' p='#{this}' ... eval='this'/>
-
-                @blocks = [make(:void, :method => 'link', :params => link)]
-                # Clear cached descendants
-                remove_instance_variable(:@all_descendants)
+                # <r:link href='@node' p='#{page_name}' ... eval='page_name'/>
+                add_block :method => 'link', :params => link
               end
 
               if !descendant('else')
                 else_tag = {:method => 'else', :text => '<r:this/>'}
                 else_tag[:tag] = tag if tag
-                @blocks += [make(:void, else_tag)]
+                add_block else_tag
                 # Clear cached descendants
-                remove_instance_variable(:@all_descendants)
+                @all_descendants = nil
               end
 
               out "<% page_numbers(#{curr_page}, #{page_count}, #{(@params[:join] || ' ').inspect}, #{@params[:page_count] ? @params[:page_count].to_i : 'nil'}) do |#{page_number}, #{page_join}, #{page_name}| %>"
@@ -713,7 +740,8 @@ module Zena
               expand_with
             else
               method = get_attribute_or_eval(false)
-              if !method && (@params.keys & [:attr, :eval, :text]) != []
+
+              if !method && (@params.keys & [:attr, :eval, :text, :t]) != []
                 out @errors.last
               end
 
@@ -722,11 +750,11 @@ module Zena
               elsif default
                 default
               elsif node.will_be?(Node)
-                "<%= #{node}.prop['title'] %>"
+                "<%= #{node(Node)}.prop['title'] %>"
               elsif node.will_be?(Version)
-                "<%= #{node}.node.prop['title'] %>"
+                "<%= #{node(Version)}.node.prop['title'] %>"
               elsif node.will_be?(Link)
-                "<%= #{node}.name %>"
+                "<%= #{node(Link)}.name %>"
               else
                 _('edit')
               end
@@ -735,14 +763,7 @@ module Zena
 
           # Return the HTTP verb to use for the given action.
           def http_method_from_action(action)
-            case action
-            when 'delete', 'unlink'
-              'delete'
-            when 'drop', 'update'
-              'put'
-            else
-              'get'
-            end
+            (NODE_ACTIONS[action] || {})[:method] || 'get'
           end
       end # ZafuMethods
     end # Urls

data/lib/zena/use/workflow.rb

@@ -17,7 +17,8 @@ module Zena
     # and it should be included *before* these two modules.
     module Workflow
       include RubyLess
-      safe_method :can_edit? => Boolean, :can_write? => Boolean, :can_drive? => Boolean
+      safe_method :can_edit? => Boolean, :can_write? => Boolean, :can_drive? => Boolean,
+                  :can_publish? => Boolean, :can_refuse? => Boolean, :can_unpublish? => Boolean
 
       WORKFLOW_ATTRIBUTES = %w{status publish_from}
       # The Workflow::VersionMethods module should be included in the model used as version.

data/lib/zena/use/zafu_attributes.rb

@@ -57,7 +57,7 @@ module Zena
 
           # Remove 'live' param so that it does not alter RubyLess method building.
           def filter_live
-            @live_param = @params.delete(:live)
+            @live_param = @params.delete(:live) unless %w{filter}.include?(@method)
           end
 
           # Evaluate 'set_xxx' param and store result in context with 'var' name. This name
@@ -89,7 +89,7 @@ module Zena
                 @if_class_params.each do |class_name, code|
                   begin
                     typed_string = ::RubyLess.translate(self, code)
-                    @markup.append_dyn_param(:class, "<%= (#{typed_string}) ? ' #{class_name}' : '' %>", true)
+                    @markup.append_dyn_param(:class, "<%= (#{typed_string}) ? ' #{class_name}' : '' %>", '')
                   rescue RubyLess::NoMethodError => err
                     text += parser_error(err.message, code)
                   end

data/lib/zena/use/zafu_safe_definitions.rb

@@ -84,10 +84,20 @@ module Zena
         safe_method_for Number, :to_s      => {:class => String, :pre_processor => true}
         safe_method_for Number, :to_f      => {:class => Number, :pre_processor => true}
         safe_method_for Number, :to_i      => {:class => Number, :pre_processor => true}
+        safe_method_for String, :to_f      => {:class => Number, :pre_processor => true}
         safe_method_for NilClass, :to_f      => {:class => Number, :pre_processor => true}
         safe_method_for NilClass, :to_i      => {:class => Number, :pre_processor => true}
         safe_method_for Object, :blank?    => Boolean
 
+        safe_method_for Time, [:advance, {
+          :years   => Number,
+          :months  => Number,
+          :weeks   => Number,
+          :days    => Number,
+          :hours   => Number,
+          :minutes => Number,
+          :seconds => Number}] => Time
+
         safe_method_for Node,  [:kind_of?, VirtualClass] =>
           {:method => 'nil', :nil => true, :pre_processor => kind_of_proc}
         safe_method_for Node,  [:kind_of?, Role]   =>
@@ -99,7 +109,17 @@ module Zena
           {:method => 'nil', :nil => true, :pre_processor => join_proc}
         safe_method_for Array, [:map, Symbol]     => # supports map(:name)
           {:method => 'nil', :nil => true, :pre_processor => map_proc}
+        safe_method [:min, Number, Number]        => {:method => 'zafu_min', :class => Number}
+        safe_method [:max, Number, Number]        => {:method => 'zafu_max', :class => Number}
+        # Returns the smallest of two values.
+        def zafu_min(a, b)
+          [a, b].min
+        end
 
+        # Returns the largest of two values.
+        def zafu_max(a, b)
+          [a, b].max
+        end
       end # ViewMethods
 
 

data/lib/zena/use/zafu_templates.rb

@@ -155,6 +155,7 @@ module Zena
         # Return the template path without '.erb' extension in case we need to append '_form'
         # from a template's url. The expected url is of the form '/skin/Klass-mode/partial'
         def template_path_from_template_url(template_url=params[:t_url])
+          raise "Missing template_url (t_url parameter)" unless template_url
           if template_url =~ /\A\.|[^ #{String::ALLOWED_CHARS_IN_FILEPATH}]/
             raise Zena::AccessViolation.new("'template_url' contains illegal characters : #{template_url.inspect}")
           end
@@ -184,7 +185,7 @@ module Zena
         def default_template_url(opts = {})
           if opts[:format] && opts[:format] != 'html'
             raise ActiveRecord::RecordNotFound
-          elsif %w{+login +index +adminLayout +popupLayout +notFound}.include?(opts[:mode])
+          elsif %w{+login +index +adminLayout +popupLayout +notFound admin}.include?(opts[:mode])
             zafu_url ="$default/Node-#{opts[:mode]}"
           elsif opts[:mode]
             raise ActiveRecord::RecordNotFound
@@ -237,7 +238,7 @@ module Zena
             document
           end
         end
-        
+
         def zafu_node(name, klass)
           zafu_context[:node] = Zena::Use::NodeContext.new(name, klass)
         end
@@ -390,7 +391,7 @@ module Zena
                   klass = [var.class]
                 end
               end
-              
+
               return Zena::Use::NodeContext.new(name, klass) if name
             end
 
@@ -433,7 +434,7 @@ module Zena
             if insert_dev
               # add template edit buttons
               if res =~ /<\/body>/
-                res.sub!('</body>', "#{dev_box}<%= render_js %></body>")
+                res.sub!('</body>', "#{dev_box(template)}<%= render_js %></body>")
               else
                 res << dev_box
               end
@@ -456,7 +457,7 @@ module Zena
             end
           end
 
-          def dev_box
+          def dev_box(template = nil)
             used_nodes = self.asset_cache.used_assets
 
             res = "<div id='dev'><ul>\n"
@@ -464,6 +465,19 @@ module Zena
               next if nodes.empty?
               res << "  <li><a class='group' onclick='$(\"dev_#{name}\").toggle();' href='#'>#{name}</a>\n"
               res << "  <table class='dev_pop' id='dev_#{name}'#{name == 'images' ? " style='display:none;'" : ''}>\n"
+              if template && name == 'zafu'
+                # Create specialized template on the fly for current page
+                res << %Q{<tr><td colspan='2'><% if @node.kpath != #{template.tkpath.inspect} -%>
+  <% _znode_dev = ::Template.new(:title => @node.klass, :parent_id => #{@skin.zip}) %>
+  <% form_for(:node, _znode_dev, :url => nodes_path, :html => {:method => 'post', :id => 'zmake_template'}) do |f| %>
+    <%= f.hidden_field(:parent_id) %>
+    <%= f.hidden_field(:title) %>
+    <%= f.hidden_field(:klass) %>
+    <input type='hidden' name='redir' value='<%= request.path %>?rebuild=true'/>
+    <b><a href='javascript:' onclick='$("zmake_template").submit();return false;'><img src='/images/add.png' title='create template for <%= @node.klass %>'/> create <%= @node.klass %>.zafu</a></b>
+  <% end %>
+<% end -%> #{node_action_link('add_doc', "#{@skin.zip}", :text => '')}</td></tr>}
+              end
               nodes.each do |path, node|
                 res << "    <tr><td class='actions'>#{zafu_helper.send(:node_actions, node)}</td><td>&nbsp;#{zafu_helper.send(:link_to, path.join('/'), zen_path(node))}</td></tr>\n"
               end
@@ -474,7 +488,7 @@ module Zena
             res << "  <li><a class='group' onclick='$(\"dev_tools\").toggle();' href='#'>tools</a>\n"
             res << "    <ul class='dev_pop' id='dev_tools'><li>\n"
             res << %Q{    <div style='float:right'><% form_for(:user, visitor, :url => user_path(visitor), :html => { :method => :put }) do |f| %>
-              <%= f.select(:dev_skin_id, dev_skin_options, {}, {:onchange => 'this.form.submit()'}) %> <input style='display:none;' type='submit' value='<%= _('validate') %>'/>
+              <p><%= f.select(:dev_skin_id, dev_skin_options, {}, {:onchange => 'this.form.submit()'}) %> <input style='display:none;' type='submit' value='<%= _('validate') %>'/></p>
             <% end %></div>}
             res << "      <a style='float:right; margin:0 8px;' href='?rebuild=true'>#{_('rebuild_btn')}</a>\n"
             res << "<% if @node.kind_of?(Skin) %><a href='<%= export_node_path(@node[:zip]) %>'>#{_('export')}</a>\n<% end %>"

data/lib/zena/use/zazen.rb

@@ -1,6 +1,8 @@
+require 'timeout'
 module Zena
   module Use
     module Zazen
+      ZAZEN_TIMEOUT = 5
       module ViewMethods
 
         include Zena::Use::Grid::ViewMethods
@@ -37,29 +39,38 @@ module Zena
         # * [!14!:37] you can use an image as the source for a link
         # * [!14!:www.example.com] use an image for an outgoing link
         def zazen(text, opt={})
-          return '' unless text
-          code_lang = opt[:code]
-          if !code_lang.blank?
-            return Zena::CodeSyntax.new(text, code_lang).to_html
-          end
+          Timeout.timeout(ZAZEN_TIMEOUT) do
+            return '' unless text
+            code_lang = opt[:code]
+            if code_lang == '' && opt[:node].kind_of?(TextDocument)
+              # do not parse. This is to make sure we do not accidently parse
+              # TextDocument content as Zazen.
+              return text
+            end
+            if !code_lang.blank?
+              return Zena::CodeSyntax.new(text, code_lang).to_html
+            end
 
-          opt = {:images=>true, :pretty_code=>true, :output=>'html'}.merge(opt)
-          no_p = opt.delete(:no_p)
-          img = opt[:images]
-          if opt[:limit]
-            opt[:limit] -= 1 unless opt[:limit] <= 0
-            paragraphs = text.split(/\n\n|\r\n\r\n/)
-            if paragraphs.size > (opt[:limit]+1) && opt[:limit] != -1
-              text = paragraphs[0..opt[:limit]].join("\r\n\r\n") + " &#8230;"
+            opt = {:images=>true, :pretty_code=>true, :output=>'html'}.merge(opt)
+            no_p = opt.delete(:no_p)
+            img = opt[:images]
+            if opt[:limit]
+              opt[:limit] -= 1 unless opt[:limit] <= 0
+              paragraphs = text.split(/\n\n|\r\n\r\n/)
+              if paragraphs.size > (opt[:limit]+1) && opt[:limit] != -1
+                text = paragraphs[0..opt[:limit]].join("\r\n\r\n") + " &#8230;"
+              end
+            end
+            opt[:node] ||= @node
+            res = ZazenParser.new(text,:helper=>self).render(opt)
+            if no_p && !text.include?("\n")
+              res.gsub(%r{\A<p>|</p>\Z},'')
+            else
+              res
             end
           end
-          opt[:node] ||= @node
-          res = ZazenParser.new(text,:helper=>self).render(opt)
-          if no_p && !text.include?("\n")
-            res.gsub(%r{\A<p>|</p>\Z},'')
-          else
-            res
-          end
+        rescue Timeout::Error
+          return %Q{<span class='parser_error'>#{_('Could not render text (Timeout error)')}</span>}
         end
 
         # TODO: test

data/lib/zena/view/test_case.rb

@@ -68,6 +68,11 @@ module Zena
         end
 
         @flash   = {}
+        class << @flash
+          def discard
+            clear
+          end
+        end
 
         @node
       end