zena 0.15.0

data/lib/zena/use/error_rendering.rb

@@ -0,0 +1,52 @@
+module Zena
+  module Use
+    module ErrorRendering
+      module Common
+
+        #TODO: test
+        def error_messages_for(obj, opts={})
+          return '' if obj.errors.empty?
+          res = ["<table class='#{opts[:class] || 'errors'}'>"]
+          obj.errors.each_error do |er,msg|
+            res << "<tr><td><b>#{er}</b></td><td>#{_(msg)}</td></tr>"
+          end
+          res << '</table>'
+          res.join("\n")
+        end
+
+        # TODO: test (where is this used ? discussions, ?)
+        def processing_error(msg)
+          # (this method used to be called add_error, but it messed up with 'test/unit/testcase.rb' when testing helpers)
+          @errors ||= []
+          @errors << _(msg)
+        end
+
+        # TODO: test
+        def render_errors(errs=@errors)
+          if !errs || errs.empty?
+            ""
+          elsif errs.kind_of?(ActiveRecord::Errors)
+            res = "<table class='errors'>"
+            errs.each do |k,v|
+              res << "<tr><td><b>#{k}</b></td><td>#{v}</td></tr>\n"
+            end
+            res << "</table>"
+            res
+          else
+            "<table class='errors'><tr><td>#{errs.join("</td></tr>\n<tr><td>")}</td></tr></table>"
+          end
+        end
+
+      end # Common
+
+      module ControllerMethods
+        include Common
+      end
+
+      module ViewMethods
+        include Common
+      end
+
+    end # ErrorRendering
+  end # Use
+end # Zena

data/lib/zena/use/fixtures.rb

@@ -0,0 +1,133 @@
+module Zena
+  module Use
+    module Fixtures
+      # load all fixtures and setup fixture_accessors:
+      FIXTURE_PATH = File.join(RAILS_ROOT, 'test', 'fixtures')
+      FILE_FIXTURES_PATH = File.join(RAILS_ROOT, 'test', 'fixtures', 'files')
+      # We use transactional fixtures with a single load for ALL tests (this is not the default rails implementation). Tests are now 5x-10x faster.
+
+      def self.included(base)
+        self.load_fixtures unless defined?(@@loaded_fixtures)
+      end
+
+      # Could DRY with file_path defined in Base
+      def self.file_path(filename, content_id)
+        digest = Digest::SHA1.hexdigest(content_id.to_s)
+        fname = filename.split('.').first
+        "#{SITES_ROOT}/test.host/data/full/#{digest[0..0]}/#{digest[1..1]}/#{digest[2..2]}/#{fname}"
+      end
+
+      def self.load_fixtures
+        # make sure versions is of type InnoDB if testing with mysql (transaction support)
+        begin
+          Node.connection.remove_index "versions", ["title", "text", "summary"]
+        rescue ActiveRecord::StatementInvalid
+        ensure
+          Zena::Db.change_engine('versions', 'InnoDB')
+        end
+
+        # Our version of loaded fixtures to help define "users_id", "nodes_id" and such.
+        @@loaded_fixtures = {}
+        fixture_table_names = []
+
+        # no fixtures ? execute rake task
+        unless File.exist?(File.join(FIXTURE_PATH, 'nodes.yml'))
+          puts "No fixtures in 'test/fixtures'. Building from 'test/sites'."
+          `cd #{RAILS_ROOT} && rake zena:build_fixtures`
+        end
+
+        # make sure files and import directories are in sync
+        if RAILS_ROOT != Zena::ROOT
+          ['test/fixtures/files', 'test/fixtures/import'].each do |path|
+            from_dir = "#{Zena::ROOT}/#{path}"
+            FileUtils.mkpath(from_dir) unless File.exist?(from_dir)
+            Dir.foreach(from_dir) do |f|
+              FileUtils.cp_r("#{from_dir}/#{f}", "#{RAILS_ROOT}/#{path}/") unless File.exist?("#{RAILS_ROOT}/#{path}/#{f}")
+            end
+          end
+        end
+
+        Dir.foreach(FIXTURE_PATH) do |file|
+          next unless file =~ /^(.+)\.yml$/
+          table_name = $1
+          fixture_table_names << table_name
+
+          if ['users', 'sites'].include?(table_name)
+
+            define_method(table_name) do |fixture|
+              if @@loaded_fixtures[table_name][fixture.to_s]
+                # allways reload
+                @@loaded_fixtures[table_name][fixture.to_s].find
+              else
+                raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+              end
+            end
+
+            define_method(table_name + "_id") do |fixture|
+              Zena::FoxyParser::multi_site_id(fixture)
+            end
+          else
+
+            define_method(table_name) do |fixture|
+              raise Exception.new("$_test_site is blank!") if $_test_site.blank?
+              fixture_name = "#{$_test_site}_#{fixture}"
+              if fix = @@loaded_fixtures[table_name][fixture_name]
+                # allways reload
+                fix.find
+              else
+                raise StandardError, "No fixture with name '#{fixture_name}' found for table '#{table_name}' in site '#{$_test_site}'."
+              end
+            end
+
+            define_method(table_name + "_id") do |fixture|
+              raise Exception.new("$_test_site is blank!") if $_test_site.blank?
+              Zena::FoxyParser::id($_test_site, fixture)
+            end
+          end
+
+          if table_name == 'nodes' || table_name == 'zips'
+            define_method(table_name + "_zip") do |fixture|
+              # needed by additions_test
+              fixture_name = table_name == 'zips' ? fixture.to_s : "#{$_test_site}_#{fixture}"
+              if fix = @@loaded_fixtures[table_name][fixture_name]
+                fix.instance_eval { @fixture['zip'].to_i }
+              else
+                raise StandardError, "No fixture with name '#{fixture_name}' found for table '#{table_name}'"
+              end
+            end
+          end
+
+          if table_name == 'sites'
+            define_method("#{table_name}_host") do |fixture|
+              if fix = @@loaded_fixtures[table_name][fixture]
+                fix.instance_eval { @fixture['host'] }
+              else
+                raise StandardError, "No fixture with name '#{fixture}' found for '#{table_name}'"
+              end
+            end
+          end
+        end
+
+        fixtures = ::Fixtures.create_fixtures(FIXTURE_PATH, fixture_table_names)
+        unless fixtures.nil?
+          if fixtures.instance_of?(::Fixtures)
+            @@loaded_fixtures[fixtures.table_name] = fixtures
+          else
+            fixtures.each { |f| @@loaded_fixtures[f.table_name] = f }
+          end
+        end
+
+        unless File.exist?("#{SITES_ROOT}/test.host/data")
+          @@loaded_fixtures['document_contents'].each do |name,fixture|
+            fname, content_id = fixture.instance_eval { [@fixture['name']+"."+@fixture['ext'], @fixture['id'].to_s] }
+            path = file_path(fname, content_id)
+            FileUtils::mkpath(File.dirname(path))
+            if File.exist?(File.join(FILE_FIXTURES_PATH,fname))
+              FileUtils::cp(File.join(FILE_FIXTURES_PATH,fname),path)
+            end
+          end
+        end
+      end
+    end # Fixtures
+  end # use
+end # Zena

data/lib/zena/use/grid.rb

@@ -0,0 +1,148 @@
+require 'json'
+
+module Zena
+  module Use
+    module Grid
+      module Common
+
+        # Build a tabular content from a node's attribute
+        def get_table_from_json(text)
+          if text.blank?
+            table = [{"type"=>"table"},[["title"],["value"]]]
+          else
+            table = JSON.parse(text)
+          end
+
+          raise JSON::ParserError unless table.kind_of?(Array) && table.size == 2 && table[0].kind_of?(Hash) && table[0]['type'] == 'table' && table[1].kind_of?(Array)
+          table
+        end
+
+      end # Common
+
+      module ControllerMethods
+        include Common
+
+        # Get cell text
+        def cell_edit
+          # get table
+          table = get_table_from_json(@node.safe_read(params[:attr]))
+          # get row/cell
+          table_data = table[1]
+
+          if row = table_data[params[:row].to_i]
+            if cell = row[params[:cell].to_i]
+              render :text => cell
+            else
+              ' '
+            end
+          else
+            ' '
+          end
+        end
+
+        # Ajax table editor
+        def cell_update
+          # get table
+          table = get_table_from_json(@node.safe_read(params[:attr]))
+          # get row/cell
+          table_data = table[1]
+
+          if row = table_data[params[:row].to_i]
+            if cell = row[params[:cell].to_i]
+              if cell != params[:value]
+                row[params[:cell].to_i] = params[:value]
+                @node.update_attributes(params[:attr] => table.to_json)
+              end
+            else
+              @node.errors.add(params[:attr], 'Cell outside of table range.')
+            end
+          else
+            @node.errors.add(params[:attr], 'Row outside of table range.')
+          end
+
+          respond_to do |format|
+            format.html { render :inline => @node.errors.empty? ? "<%= zazen(params[:value], :no_p => true) %>" : error_messages_for(@node) }
+          end
+        rescue JSON::ParserError
+          render :inline => _('could not save value (bad attribute)')
+        end
+
+        # Ajax table add row/column
+        def table_update
+          # get table
+          @table = get_table_from_json(@node.safe_read(params[:attr]))
+          # get row/cell
+          table_data = @table[1]
+
+          if params[:add] == 'row'
+            table_data << table_data[0].map { ' ' }
+          elsif params[:add] == 'column'
+            table_data.each do |row|
+              row << ' '
+            end
+          elsif params[:remove] == 'row' && table_data.size > 2
+            table_data.pop
+          elsif params[:remove] == 'column' && table_data[0].size > 1
+            table_data.each do |row|
+              row.pop
+            end
+          else
+            # reorder ...
+          end
+
+          @node.update_attributes(params[:attr] => @table.to_json)
+        rescue JSON::ParserError
+          render :inline => _('could not save value (bad attribute)')
+        end
+
+      end
+
+      Routes = {
+        :cell_update => :post, :table_update => :post, :cell_edit => :get
+      }
+
+      module ViewMethods
+        include Common
+
+        # Create a table from an attribute
+        def make_table(opts)
+          style, node, attribute, title, table = opts[:style], opts[:node], opts[:attribute], opts[:title], opts[:table]
+          attribute = "d_#{attribute}" unless ['v_', 'd_'].include?(attribute[0..1])
+          case (style || '').sub('.', '')
+          when ">"
+            prefix = "<div class='img_right'>"
+            suffix = "</div>"
+          when "<"
+            prefix = "<div class='img_left'>"
+            suffix = "</div>"
+          when "="
+            prefix = "<div class='img_center'>"
+            suffix = "</div>"
+          else
+            prefix = ''
+            suffix = ''
+          end
+
+          if node.can_write?
+            prefix << "<div class='table_add'>"
+            prefix << link_to_remote("<img src='/images/column_add.png' alt='#{_('add column')}'/>",
+                                      :url => "/nodes/#{node.zip}/table_update?add=column&attr=#{attribute}")
+            prefix << link_to_remote("<img src='/images/column_delete.png' alt='#{_('add column')}'/>",
+                                      :url => "/nodes/#{node.zip}/table_update?remove=column&attr=#{attribute}")
+            prefix << link_to_remote("<img src='/images/row_add.png' alt='#{_('add column')}'/>",
+                                      :url => "/nodes/#{node.zip}/table_update?add=row&attr=#{attribute}")
+            prefix << link_to_remote("<img src='/images/row_delete.png' alt='#{_('add column')}'/>",
+                                      :url => "/nodes/#{node.zip}/table_update?remove=row&attr=#{attribute}")
+            prefix << "</div>"
+          end
+
+          table ||= get_table_from_json(node.safe_read(attribute))
+
+          prefix + render_to_string( :partial=>'nodes/table', :locals=>{:table=>table, :node=>node, :attribute=>attribute}) + suffix
+        rescue JSON::ParserError
+          "<span class='unknownLink'>could not build table from text</span>"
+        end
+      end
+    end # Grid
+  end # Use
+end # Zena

data/lib/zena/use/html_tags.rb

@@ -0,0 +1,603 @@
+require 'will_paginate'
+require 'uuidtools'
+
+module Zena
+  module Use
+    module HtmlTags
+      module ImageTags
+
+        # This is used by _crop.rhtml
+        def crop_formats(obj)
+          buttons = ['jpg', 'png']
+          ext = TYPE_TO_EXT[obj.c_conten_type]
+          ext = ext ? ext[0] : obj.c_ext
+          buttons << ext unless buttons.include?(ext)
+          buttons.map do |e|
+            "<input type='radio' name='node[c_crop][format]' value='#{e}'#{e==ext ? " checked='checked'" : ''}/> #{e} "
+          end
+        end
+
+        # Display an image tag for the given node. If no mode is provided, 'full' is used. Options are ':mode', ':id', ':alt',
+        # ':alt_src' and ':class'. If no class option is passed, the format is used as the image class. Example :
+        # img_tag(@node, :mode=>'pv')  => <img src='/sites/test.host/data/jpg/20/bird_pv.jpg' height='80' width='80' alt='bird' class='pv'/>
+        def img_tag(obj, opts={})
+          return '' unless obj
+          # try:
+          # 1. tag on element data (Image, mp3 document)
+          res = asset_img_tag(obj, opts)
+
+          # 2. tag using alt_src data
+          if !res && alt_src = opts[:alt_src]
+            if alt_src == 'icon'
+              if icon = obj.icon
+                return img_tag(icon, opts.merge(:alt_src => nil))
+              end
+            elsif icon = obj.find(:first, alt_src.split(','))
+              # icon through alt_src relation
+              return img_tag(icon, opts.merge(:alt_src => nil))
+            end
+          end
+
+          # 3. generic icon
+          res ||= generic_img_tag(obj, opts)
+
+          if res.kind_of?(Hash)
+            out = "<img"
+            [:src, :width, :height, :alt, :id, :class, :style, :border].each do |k|
+              next unless v = res[k]
+              out << " #{k}='#{v}'"
+            end
+            out + "/>"
+          else
+            res
+          end
+        end
+
+        # <img> tag definition to show an Image / mp3 document
+        # FIXME: this should live inside zafu
+        def asset_img_tag(obj, opts)
+          if obj.kind_of?(Image)
+            res     = {}
+            content = obj.version.content
+            format  = Iformat[opts[:mode]] || Iformat['std']
+
+            [:id, :border].each do |k|
+              next unless opts[k]
+              res[k]    = opts[k]
+            end
+
+            res[:alt]   = opts[:alt] || fquote(obj.version.title)
+            res[:src]   = data_path(obj, :mode => (format[:size] == :keep ? nil : format[:name]), :host => opts[:host])
+            res[:class] = opts[:class] || format[:name]
+
+            # compute image size
+            res[:width]  = content.width(format)
+            res[:height] = content.height(format)
+            res
+          elsif obj.kind_of?(Document) && obj.version.content.ext == 'mp3' && (opts[:mode].nil? || opts[:mode] == 'std' || opts[:mode] == 'button')
+            # rough wrap to use the 'button'
+            # we differ '<object...>' by using a placeholder to avoid the RedCloth escaping.
+            add_place_holder( %{ <object type="application/x-shockwave-flash"
+              data="/images/swf/xspf/musicplayer.swf?&song_url=#{CGI.escape(data_path(obj))}"
+              width="17" height="17">
+              <param name="movie"
+              value="/images/swf/xspf/musicplayer.swf?&song_url=#{CGI.escape(data_path(obj))}" />
+              <img src="/images/sound_mute.png"
+              width="16" height="16" alt="" />
+            </object> } )
+          end
+        end
+
+        # <img> tag definition for the generic icon (image showing class of element).
+        def generic_img_tag(obj, opts)
+          res = {}
+          [:class, :id, :border, :style].each do |k|
+            next unless opts[k]
+            res[k] = opts[k]
+          end
+
+          if obj.vclass.kind_of?(VirtualClass) && !obj.vclass.icon.blank?
+            # FIXME: we could use a 'zip' to an image as 'icon' (but we would need some caching to avoid multiple loading during doc listing)
+            res[:src]     = obj.vclass.icon
+            res[:alt]     = opts[:alt] || (_('%{type} node') % {:type => obj.vclass.name})
+            res[:class] ||= obj.klass
+            # no width, height available
+            return res
+          end
+
+          # default generic icon from /images/ext folder
+          res[:width]  = 32
+          res[:height] = 32
+
+          if obj.kind_of?(Document)
+            name = obj.version.content.ext
+            res[:alt] = opts[:alt] || (_('%{ext} document') % {:ext => name})
+            res[:class] ||= 'doc'
+          else
+            name = obj.klass.underscore
+            res[:alt] = opts[:alt] || (_('%{ext} node') % {:ext => obj.klass})
+            res[:class] ||= 'node'
+          end
+
+          if !File.exist?("#{RAILS_ROOT}/public/images/ext/#{name}.png")
+            name = 'other'
+          end
+
+          res[:src] = "/images/ext/#{name}.png"
+
+          if opts[:mode] && (format = Iformat[opts[:mode]]) && format[:size] != :keep
+            # resize image
+            img = ImageBuilder.new(:path=>"#{RAILS_ROOT}/public#{res[:src]}", :width=>32, :height=>32)
+            img.transform!(format)
+            if (img.width == res[:width] && img.height == res[:height])
+              # ignore mode
+              res[:mode] = nil
+            else
+              res[:width]  = img.width
+              res[:height] = img.height
+
+              new_file = "#{name}_#{format[:name]}.png"
+              path     = "#{RAILS_ROOT}/public/images/ext/#{new_file}"
+              unless File.exist?(path)
+                # make new image with the mode
+                if img.dummy?
+                  File.cp("#{RAILS_ROOT}/public/images/ext/#{name}.png", path)
+                else
+                  File.open(path, "wb") { |f| f.syswrite(img.read) }
+                end
+              end
+
+              res[:src] = "/images/ext/#{new_file}"
+            end
+          end
+
+          res[:src] = "http://#{opts[:host]}#{res[:src]}" if opts[:host]
+
+          res
+        end
+      end # ImageTags
+
+      module FormTags
+
+        # date_box seizure setup
+        def uses_datebox(opt={})
+          if ZENA_CALENDAR_LANGS.include?(lang)
+            l = lang
+          else
+            l = visitor.site[:default_lang]
+          end
+          <<-EOL
+          <script src="/calendar/calendar.js" type="text/javascript"></script>
+          <script src="/calendar/calendar-setup.js" type="text/javascript"></script>
+          <script src="/calendar/lang/calendar-#{l}-utf8.js" type="text/javascript"></script>
+          <link href="/calendar/calendar-brown.css" media="screen" rel="Stylesheet" type="text/css" />
+          #{javascript_start}
+          Calendar._TT["DEF_DATE_FORMAT"] = "#{_('datetime')}";
+          Calendar._TT["FIRST_DAY"] = #{_('week_start_day')};
+          #{javascript_end}
+          EOL
+        end
+
+        #TODO: test
+      	# Return the list of groups from the visitor for forms
+      	def form_groups
+      	  @form_groups ||= Group.find(:all, :select=>'id, name', :conditions=>"id IN (#{visitor.group_ids.join(',')})", :order=>"name ASC").collect {|p| [p.name, p.id]}
+        end
+
+        #TODO: test
+        # Return the list of possible templates
+        def form_skins
+          @form_skins ||= secure!(Skin) { Skin.find(:all, :order=>'name ASC') }.map {|r| r[:name]}
+        end
+
+
+        def upload_form_tag(url_opts, html_opts = {})
+          @uuid = UUIDTools::UUID.random_create.to_s.gsub('-','')
+          html_opts.reverse_merge!(:multipart => true, :id => "UploadForm#{@uuid}")
+          if html_opts[:multipart]
+            html_opts[:onsubmit] = "submitUploadForm('#{html_opts[:id]}', '#{@uuid}');"
+            url_opts[UPLOAD_KEY] = @uuid
+          end
+          if block_given?
+            form_tag( url_opts, html_opts ) do |f|
+              yield(f)
+            end
+          else
+            form_tag( url_opts, html_opts )
+          end
+        end
+
+        # Date selection tool
+      	def date_box(obj, var, opts = {})
+      	  rnd_id = rand(100000000000)
+      	  defaults = {  :id=>"datef#{rnd_id}", :button=>"dateb#{rnd_id}", :display=>"dated#{rnd_id}" }
+      	  opts = defaults.merge(opts)
+      	  date = eval("@#{obj} ? @#{obj}.#{var} : nil")
+      	  value = tformat_date(date,'datetime')
+          if opts[:size]
+            fld = "<input id='#{opts[:id]}' name='#{obj}[#{var}]' type='text' size='#{opts[:size]}' value='#{value}' />"
+          else
+            fld = "<input id='#{opts[:id]}' name='#{obj}[#{var}]' type='text' value='#{value}' />"
+          end
+      		<<-EOL
+      <span class="date_box"><img src="/calendar/iconCalendar.gif" id="#{opts[:button]}" alt='#{_('date selection')}'/>
+      #{fld}
+      	<script type="text/javascript">
+          Calendar.setup({
+              inputField     :    "#{opts[:id]}",      // id of the input field
+              button         :    "#{opts[:button]}",  // trigger for the calendar (button ID)
+              singleClick    :    true,
+              showsTime      :    true
+          });
+      </script></span>
+      		EOL
+      	end
+
+        # Display an input field to select an id. The user can enter an id or a name in the field and the
+        # node's path is shown next to the input field. If the :class option is specified and the elements
+        # in this class are not too many, a select menu is shown instead (nodes in the menu are found using secure_write scope).
+        # 'Sym' is the field to select the id for (parent_id, ...).
+        def select_id(obj, sym, opt={})
+          unless kpath = opt[:kpath]
+            klass = opt[:class].kind_of?(Class) ? opt[:class] : Node.get_class(opt[:class] || 'Node')
+            kpath = klass.kpath
+          end
+
+          count = secure_write(Node) { Node.count(:all, :conditions => ['kpath LIKE ?', "#{kpath}%"]) }
+          if count < 30
+            sql = "SELECT zip, name FROM nodes WHERE kpath LIKE '#{kpath}%' AND #{secure_write_scope} ORDER BY name ASC"
+            values = Node.connection.select_all(sql, "Node Load").map do |record|
+              [record['name'], record['zip']]
+            end
+            return select(obj, sym, values, { :include_blank => opt[:include_blank] })
+          end
+
+          if obj == 'link'
+            if link = instance_variable_get("@#{obj}")
+              node        = link.this
+              current_obj = link.other
+            end
+          else
+            unless id = opt[:id]
+              node = instance_variable_get("@#{obj}")
+              if node
+                id = node.send(sym.to_sym)
+              else
+                id = nil
+              end
+            end
+
+            if !id.blank?
+              current_obj = secure!(Node) { Node.find(id) } rescue nil
+            end
+          end
+
+
+          name_ref = unique_id
+          attribute = opt[:show] || 'short_path'
+          if current_obj
+            zip = current_obj[:zip]
+            current = current_obj.send(attribute.to_sym)
+            if current.kind_of?(Array)
+              current = current.join('/ ')
+            end
+          else
+            zip = ''
+            current = ''
+          end
+          input_id = opt[:input_id] ? " id='#{params[:input_id]}'" : ''
+          # we use both 'onChange' and 'onKeyup' for old javascript compatibility
+          update = "new Ajax.Updater('#{name_ref}', '/nodes/#{(node || @node).zip}/attribute?node=' + this.value + '&attr=#{attribute}', {method:'get', asynchronous:true, evalScripts:true});"
+          "<div class='select_id'><input type='text' size='8'#{input_id} name='#{obj}[#{sym}]' value='#{zip}' onChange=\"#{update}\" onKeyup=\"#{update}\"/>"+
+          "<span class='select_id_name' id='#{name_ref}'>#{current}</span></div>"
+        end
+
+        def unique_id
+          @counter ||= 0
+          "#{Time.now.to_i}_#{@counter += 1}"
+        end
+
+        #TODO: test
+        def readers_for(obj=@node)
+          readers = if obj.public?
+            _('img_public')
+          else
+            names = []
+            names |= [truncate(obj.rgroup.name, :length => 7)] if obj.rgroup
+            names |= [truncate(obj.dgroup.name, :length => 7)] if obj.dgroup
+            names << obj.user.initials
+            names.join(', ')
+          end
+          custom = obj.inherit != 1 ? "<span class='custom'>#{_('img_custom_inherit')}</span>" : ''
+          "#{custom} #{readers}"
+        end
+
+      end # FormTags
+
+      module LinkTags
+        include WillPaginate::ViewHelpers
+
+        def protect_against_forgery?
+          false
+        end
+
+        # Add class='on' if the link points to the current page
+        def link_to_with_state(*args)
+          title, url, options = *args
+          options ||= {}
+          if request.path == url
+            options[:class] = 'on'
+          end
+          link_to(title, url, options)
+        end
+
+        #unobtrusive link_to_remote
+        def link_to_remote(name, options = {}, html_options = {})
+          html_options.merge!({:href => url_for(options[:url])}) unless options[:url].blank?
+          super(name, options, html_options)
+        end
+
+        # only display first <a> tag
+        def tag_to_remote(options = {}, html_options = {})
+          url = url_for(options[:url])
+          res = "<a href='#{url}' onclick=\"new Ajax.Request('#{url}', {asynchronous:true, evalScripts:true, method:'#{options[:method] || 'get'}'}); return false;\""
+          html_options.each do |k,v|
+            next unless [:class, :id, :style, :rel, :onclick].include?(k)
+            res << " #{k}='#{v}'"
+          end
+          res << ">"
+          res
+        end
+
+        # Shows 'login' or 'logout' button.
+        def login_link(opts={})
+          if visitor.is_anon?
+            if params[:prefix]
+              link_to _('login'), :overwrite_params => { :prefix => AUTHENTICATED_PREFIX }
+            else
+              "<a href='/login'>#{_('login')}</a>"
+            end
+          else
+            "<a href='/logout'>#{_('logout')}</a>"
+          end
+        end
+
+        # Show visitor name if logged in
+        def visitor_link(opts={})
+          unless visitor.is_anon?
+            link_to( visitor.fullname, user_path(visitor) )
+          else
+            ""
+          end
+        end
+
+        # TODO: rename 'admin_links' ?
+        # shows links for site features
+        def show_link(link, opt={})
+          case link
+          when :admin_links
+            [show_link(:home), show_link(:preferences), show_link(:comments), show_link(:users), show_link(:groups), show_link(:relations), show_link(:virtual_classes), show_link(:iformats), show_link(:sites), show_link(:zena_up), show_link(:dev)].reject {|l| l==''}
+          when :home
+            return '' if visitor.is_anon?
+            link_to_with_state(_('my home'), user_path(visitor))
+          when :preferences
+            return '' if visitor.is_anon?
+            link_to_with_state(_('preferences'), preferences_user_path(visitor[:id]))
+          when :comments
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('manage comments'), comments_path)
+          when :users
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('manage users'), users_path)
+          when :groups
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('manage groups'), groups_path)
+          when :relations
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('manage relations'), relations_path)
+          when :virtual_classes
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('manage classes'), virtual_classes_path)
+          when :iformats
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('image formats'), iformats_path)
+          when :sites
+            return '' unless visitor.is_admin?
+            link_to_with_state(_('manage sites'), sites_path)
+          when :zena_up
+            return '' unless ENABLE_ZENA_UP && visitor.is_admin?
+            link_to_with_state(_('update zena'), zena_up_sites_path)
+          when :dev
+            return '' unless visitor.is_admin?
+            if @controller.session[:dev]
+              link_to(_('turn dev off'), swap_dev_user_path(visitor))
+            else
+              link_to(_('turn dev on'), swap_dev_user_path(visitor))
+            end
+          else
+            ''
+          end
+        end
+
+        # show language selector
+        def lang_links(opts={})
+          if opts[:wrap]
+            tag_in  = "<#{opts[:wrap]}>"
+            tag_out = "</#{opts[:wrap]}>"
+          else
+            tag_in = tag_out = ''
+          end
+          res = []
+          visitor.site.lang_list.each do |l|
+            if l == lang
+              if opts[:wrap]
+                res << "<#{opts[:wrap]} class='on'>#{l}" + tag_out
+              else
+                res << "<em>#{l}</em>"
+              end
+            else
+              if visitor.is_anon? && params[:prefix]
+                res << tag_in + link_to(l, :overwrite_params => {:prefix => l}) + tag_out
+              else
+                res << tag_in + link_to(l, :overwrite_params => {:lang   => l}) + tag_out
+              end
+            end
+          end
+          res.join(opts[:join] || '')
+        end
+
+        # show current path with links to ancestors
+        def show_path(opts={})
+          node = opts.delete(:node) || @node
+          tag  = opts.delete(:wrap) || 'li'
+          join = opts.delete(:join) || ''
+          if tag != ''
+            open_tag  = "<#{tag}>"
+            close_tag = "</#{tag}>"
+          else
+            open_tag  = ""
+            close_tag = ""
+          end
+          nav = []
+          node.ancestors.each do |obj|
+            nav << link_to(obj.name, zen_path(obj, opts))
+          end
+
+          nav << "<a href='#{url_for(zen_path(node))}' class='current'>#{node.name}</a>"
+          res = "#{res}#{open_tag}#{nav.join("#{close_tag}#{open_tag}#{join}")}#{close_tag}"
+        end
+
+      end # LinkTags
+
+      module ActionTags
+
+        # Actions that appear on the web page
+        def node_actions(opts={})
+          actions = (opts[:actions] || 'all').to_s
+          actions = 'edit,propose,refuse,publish,drive' if actions == 'all'
+
+          node = opts[:node] || @node
+          return '' if node.new_record?
+          publish_after_save = opts[:publish_after_save]
+          res = actions.split(',').reject do |action|
+            !node.can_apply?(action.to_sym)
+          end.map do |action|
+            node_action_link(action, node, publish_after_save)
+          end.join(" ")
+
+          if res != ""
+            "<span class='actions'>#{res}</span>"
+          else
+            ""
+          end
+        end
+
+        # TODO: test
+        def node_action_link(action, node, publish_after_save)
+          case action
+          when 'edit'
+            url = edit_node_version_path(:node_id => node[:zip], :id => 0)
+            "<a href='#{url}#{publish_after_save ? "?pub=#{publish_after_save}" : ''}' target='_blank' title='#{_('btn_title_edit')}' onclick=\"editor=window.open('#{url}#{publish_after_save ? "?pub=#{publish_after_save}" : ''}', \'#{current_site.host}#{node[:zip]}\', 'location=0,width=300,height=400,resizable=1');return false;\">" +
+                   _('btn_edit') + "</a>"
+          when 'drive'
+            "<a href='#' title='#{_('btn_title_drive')}' onclick=\"editor=window.open('" +
+                   edit_node_url(:id => node[:zip] ) +
+                   "', '_blank', 'location=0,width=300,height=400,resizable=1');return false;\">" +
+                   _('btn_drive') + "</a>"
+          else
+            link_to( _("btn_#{action}"), {:controller=>'versions', :action => action, :node_id => node[:zip], :id => 0}, :title=>_("btn_title_#{action}"), :method => :put )
+          end
+        end
+
+        # Actions that appear in the drive popup versions list
+        def version_actions(version, opts={})
+          return "" unless version.kind_of?(Version)
+          # 'view' ?
+          actions = (opts[:actions] || 'all').to_s
+          actions = 'destroy_version,remove,redit,unpublish,propose,refuse,publish' if actions == 'all'
+
+          node = version.node
+
+          actions.split(',').reject do |action|
+            action.strip!
+            if action == 'view'
+              !node.can_apply?('publish', version)
+            else
+              !node.can_apply?(action.to_sym, version)
+            end
+          end.map do |action|
+            version_action_link(action, version)
+          end.join(' ')
+        end
+
+        # TODO: test
+        def version_action_link(action,version)
+          if action == 'view'
+            # FIXME
+            link_to_function(_('btn_view'), "opener.Zena.version_preview('/nodes/#{version.node.zip}/versions/#{version.number}');")
+          else
+            if action == 'destroy_version'
+              action = 'destroy'
+              method = :delete
+            else
+              method = :put
+            end
+            link_to_remote( _("btn_#{action}"), :url=>{:controller=>'versions', :action => action, :node_id => version.node[:zip], :id => version.number, :drive=>true}, :title=>_("btn_title_#{action}"), :method => method ) + "\n"
+          end
+        end
+
+
+        # TODO: test
+        def discussion_actions(discussion, opt={})
+          opt = {:action=>:all}.merge(opt)
+          return '' unless @node.can_drive?
+          if opt[:action] == :view
+            link_to_function(_('btn_view'), "opener.Zena.discussion_show(#{discussion[:id]}); return false;")
+          elsif opt[:action] == :all
+            if discussion.open?
+              link_to_remote( _("img_open"), :url=>{:controller=>'discussions', :action => 'close' , :id => discussion[:id]}, :title=>_("btn_title_close_discussion")) + "\n"
+            else
+              link_to_remote( _("img_closed"), :url=>{:controller=>'discussions', :action => 'open', :id => discussion[:id]}, :title=>_("btn_title_open_discussion")) + "\n"
+            end +
+            if discussion.can_destroy?
+              link_to_remote( _("btn_remove"), :url=>{:controller=>'discussions', :action => 'remove', :id => discussion[:id]}, :title=>_("btn_title_destroy_discussion")) + "\n"
+            else
+              ''
+            end
+          end
+        end
+      end # ActionTags
+
+      module ViewMethods
+        include ImageTags
+        include FormTags
+        include LinkTags
+        include ActionTags
+
+        # Display flash[:notice] or flash[:error] if any. <%= flash <i>[:notice, :error, :both]</i> %>"
+        def flash_messages(opts={})
+          type = opts[:show] || 'both'
+          "<div id='messages'>" +
+          if (type == 'notice' || type == 'both') && flash[:notice]
+            "<div id='notice' class='flash' onclick='new Effect.Fade(\"notice\")'>#{flash[:notice]}</div>"
+          else
+            ''
+          end +
+          if (type == 'error'  || type == 'both') && flash[:error ]
+            "<div id='error' class='flash' onclick='new Effect.Fade(\"error\")'>#{flash[:error]}</div>"
+          else
+            ''
+          end +
+          "</div>"
+        end
+
+        # TODO: test
+        def search_box(opts={})
+          render_to_string(:partial=>'search/form', :locals => {:ajax => opts[:ajax], :type => opts[:type]})
+        end
+
+
+      end # ViewMethods
+    end # HtmlTags
+  end # Use
+end # Zena