zena 1.0.0.beta3 → 1.0.0.rc1

data/lib/zena/use/workflow.rb

@@ -55,8 +55,13 @@ module Zena
 
         # Return true if the version should be cloned if it was changed.
         def clone_on_change?
+          # not same user
           user_id != visitor.id ||
+          # changed lang
           lang_changed?         ||
+          # new version on top of publication
+          status_changed?       ||
+          # not in redit time
           Time.now > created_at + current_site[:redit_time].to_i
         end
 
@@ -353,7 +358,6 @@ module Zena
 
       # Returns false is the current visitor does not have enough rights to perform the action.
       def can_apply?(method)
-        return true  if visitor.is_su?
         case method
         when :edit
           can_edit?

data/lib/zena/use/zafu_attributes.rb

@@ -70,7 +70,9 @@ module Zena
                   code = params.delete(k)
                   begin
                     typed_string = ::RubyLess.translate(self, code)
-                    set_context_var('set_var', var, typed_string)
+                    name = get_var_name('set_var', var)
+                    out "<% #{name} = #{typed_string} %>"
+                    set_context_var('set_var', var, RubyLess::TypedString.new(name, typed_string.opts))
                   rescue RubyLess::NoMethodError => err
                     parser_error(err.message, code)
                   end
@@ -149,7 +151,7 @@ module Zena
           # Rewrite things like <tt><h1 do='age' live='true'/></tt> to
           # <tt><h1 do='show' attr='age' live='true'/></tt>
           def filter_property
-            return if node.list_context?
+            return if node.list_context? || !(node.klass <= Node)
             keys = @params.keys
             return if keys & [:live, :edit] == []
             if type = node.klass.safe_method_type([@method])
@@ -176,29 +178,24 @@ module Zena
           end # filter_prefix
 
           def filter_status
+            # Do not filter or we cannot set any 'status' attribute in <r:new>.
+            return if %w{new link}.include?(@method)
             status = @params.delete(:status)
             if status == 'true' || (@params[:actions] && status != 'false')
-              node = @method == 'each' ? self.node.move_to(var, self.node.klass.first) : self.node
+              node = (@method == 'each' && self.node.list_context?) ? self.node.move_to(var, self.node.single_class) : self.node
 
-              if node.will_be? Node
-                accessor = "#{node}.version"
-              elsif node.will_be? Version
+              if node.will_be? Version
                 accessor = node
+              elsif node_name = node(Node)
+                accessor = "#{node_name}.version"
               else
-                accessor = "#{node(Node)}.version"
+                raise 'No Node context !'
               end
 
               @markup.tag ||= 'span'
               @markup.append_dyn_param(:class, "s<%= #{accessor}.status %>")
             end
           end
-
-          def steal_and_eval_html_params_for(markup, params)
-            markup.steal_keys.each do |key|
-              next unless value = params.delete(key)
-              append_markup_attr(markup, key, value)
-            end
-          end
       end # ZafuMethods
     end # ZafuAttributes
   end # Use

data/lib/zena/use/zafu_eval.rb

@@ -9,7 +9,7 @@ module Zena
           else
             res = RubyLess.translate(self, text)
             if res.literal.kind_of?(String)
-              res.literal
+              erb_escape res.literal
             else
               "<%= #{res} %>"
             end

data/lib/zena/use/zafu_safe_definitions.rb

@@ -8,25 +8,107 @@ module Zena
 
       module ViewMethods
         include RubyLess
+
+        # Dynamic resolution of kind_of
+        def self.kind_of_proc
+          @@kind_of_proc ||= Proc.new do |receiver, role_or_vclass|
+            if role_or_vclass.kind_of?(VirtualClass)
+              res = "#{receiver}.kpath_match?('#{role_or_vclass.kpath}')"
+            else
+              # Role
+              res = "#{receiver}.has_role?(#{role_or_vclass.id})"
+            end
+
+            RubyLess::TypedString.new(res, :class => Boolean)
+          end
+        end
+
+        # Dynamic resolution of map
+        def self.map_proc
+          @@map_proc ||= Proc.new do |receiver, method|
+            if elem = receiver.opts[:elem] || receiver.klass.first
+              if type = RubyLess::safe_method_type_for(elem, [method.to_s])
+                if type[:method] =~ /\A\w+\Z/
+                  res = "#{receiver.raw}.map(&#{type[:method].to_sym.inspect}).compact"
+                else
+                  res = "#{receiver.raw}.map{|_map_obj| _map_obj.#{type[:method]}}.compact"
+                end
+                res = RubyLess::TypedString.new(res, :class => [type[:class]])
+              else
+                raise RubyLess::NoMethodError.new(receiver.raw, receiver.klass, ['map', method])
+              end
+            else
+              # should never happen
+              raise RubyLess::NoMethodError.new(receiver.raw, receiver.klass, ['map', method])
+            end
+          end
+        end
+
+        # Dynamic resolution of join
+        def self.join_proc
+          Proc.new do |receiver, join_arg|
+            # opts[:elem] = Resolution on Array or static %w{x y z}
+            # TODO remove with code in RubyLessProcessing
+            if elem = receiver.opts[:elem] || receiver.klass.first
+              if type = RubyLess::safe_method_type_for(elem, ['to_s'])
+                if type[:method] == 'to_s'
+                  # ok
+                  res = receiver.raw
+                elsif type[:method] =~ /\A\w+\Z/
+                  res = "#{receiver.raw}.map(&#{type[:method].inspect}).compact"
+                else
+                  res = "#{receiver.raw}.map{|_map_obj| _map_obj.#{type[:method]}}.compact"
+                end
+                RubyLess::TypedString.new("#{res}.join(#{join_arg.inspect})", :class => String)
+              else
+                raise RubyLess::NoMethodError.new(receiver.raw, receiver.klass, ['to_s'])
+              end
+            else
+              # internal bug: we should have :elem set whenever we use Array
+              raise RubyLess::NoMethodError.new(receiver.raw, receiver.klass, ['join', join_arg])
+            end
+          end
+        end
+
         safe_method :params => ParamsDictionary
         safe_method :now    => {:method => 'Time.now', :class => Time}
+        safe_method [:h, String] => {:class => String, :nil => true}
         safe_method_for String, [:gsub, Regexp, String] => {:class => String, :pre_processor => true}
-        safe_method_for String, :upcase => {:class => String, :pre_processor => true}
-        safe_method_for Number, :to_s   => {:class => String, :pre_processor => true}
-        safe_method_for Object, :blank? => Boolean
+        safe_method_for String, :upcase    => {:class => String, :pre_processor => true}
+        safe_method_for String, :strip     => {:class => String, :pre_processor => true}
+        safe_method_for String, :urlencode => {:class => String, :pre_processor => true, :method => :url_name}
+        safe_method_for String, :to_i      => {:class => Number, :pre_processor => true}
+        safe_method_for String, :to_s      => {:class => String, :pre_processor => true}
+        safe_method_for String, [:limit, Number]  => {:class => String, :pre_processor => true}
+        safe_method_for String, [:limit, Number, String]  => {:class => String, :pre_processor => true}
+        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 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 Node,  [:kind_of?, VirtualClass] =>
+          {:method => 'nil', :nil => true, :pre_processor => kind_of_proc}
+        safe_method_for Node,  [:kind_of?, Role]   =>
+          {:method => 'nil', :nil => true, :pre_processor => kind_of_proc}
+        safe_method_for Node,  [:kind_of?, String] => {:method => 'kpath_match?', :class => Boolean}
+        safe_method_for Node,  [:kind_of?, Number] => {:method => 'has_role?',    :class => Boolean}
+        safe_method_for Array, [:index, String]   => {:class => Number, :nil => true}
+        safe_method_for Array, [:join, String]    => # supports map(:name)
+          {: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_for Node, [:kind_of?, String] => {:method => 'kpath_match?', :class => Boolean}
-        safe_method_for Node, [:kind_of?, Number] => {:method => 'has_role?',    :class => Boolean}
       end # ViewMethods
 
 
       module ZafuMethods
-
         def safe_const_type(class_name)
-          if klass = get_class(class_name)
-            {:method => "'#{klass.kpath}'", :class => String}
+          if klass = VirtualClass[class_name]
+            {:method => "VirtualClass[#{class_name.inspect}]", :nil => true, :class => VirtualClass, :literal => klass}
           elsif role = Node.get_role(class_name)
-            {:method => role.id.to_s, :class => Number}
+            {:method => "Role.find(#{role.id})", :nil => true, :class => Role, :literal => role}
           else
             nil
           end

data/lib/zena/use/zafu_templates.rb

@@ -3,6 +3,40 @@ require 'zafu/controller_methods'
 module Zena
   module Use
     module ZafuTemplates
+      class AssetCache
+        attr_accessor :used_assets
+
+        def initialize
+          @used_assets  = {'zafu' => [], 'images' => [], 'assets' => []}
+          @cached_nodes = {}
+          @used_assets['zafu'] = []
+        end
+
+        def cache_with_path(section_id, path)
+          if cached = @cached_nodes[[section_id, path]]
+            return cached
+          else
+            if document = yield
+              if document.kind_of?(Template)
+                @used_assets['zafu']   << [path, document]
+              elsif document.kind_of?(Image)
+                @used_assets['images'] << [path, document]
+              else
+                @used_assets['assets'] << [path, document]
+              end
+              @cached_nodes[[section_id, path]] = document
+            else
+              nil
+            end
+          end
+        end
+
+        def used_nodes
+          @cached_nodes.values
+        end
+      end # DevBox
+
+
       module Common
         DEFAULT_PATH = %r{^\/?\$([\+\-\w\/]+)}
         DEFAULT_TEMPLATES_PATH = "#{Zena::ROOT}/app/views/zafu"
@@ -10,25 +44,28 @@ module Zena
         # Return a template's content from an url. If the url does not start with a '/', we try by replacing the
         # first element with the current skin_name and if it does not work, we try with the full url. If the url
         # start with a '/' we use the full url directly.
-        def get_template_text(path, base_path)
+        def get_template_text(path, section_id = nil)
           if path =~ DEFAULT_PATH
             filepath = File.join(DEFAULT_TEMPLATES_PATH, "#{$1}.zafu")
             text = File.exist?(filepath) ? File.read(filepath) : nil
-            return text, path, base_path
+            return text, path, nil
           elsif @skin.nil? && path == 'Node'
             filepath = File.join(DEFAULT_TEMPLATES_PATH, "default/#{path}.zafu")
             text = File.exist?(filepath) ? File.read(filepath) : nil
-            return text, path, base_path
-          elsif res = find_document_for_template(path, base_path)
-            doc, base_path = res
-            # text, fullpath (for recursion testing), base_path
-            return doc.text, doc.fullpath, base_path, doc
+            return text, path, nil
           else
-            nil
+            path = path.split('/').map {|s| String.from_filename(s) }
+            if doc = find_document_for_template(path, section_id)
+              # text, fullpath (for recursion testing), base_path
+              return (doc.text || ''), doc.fullpath, doc.section_id, doc
+            else
+              nil
+            end
           end
         end
 
-        # Return the zen_path ('/en/image34.png') for an asset given its name ('img/footer.png').
+        # Return the zen_path ('/en/image34.png') for an asset given its (urlencoded)
+        # path ('img/footer.png').
         # The rule is not the same whether we are rendering a template and find <img/> <link rel='stylesheet'/> tags
         # or if we are parsing assets in a CSS file.
         def template_url_for_asset(opts)
@@ -38,8 +75,7 @@ module Zena
           end
 
           if opts[:parse_assets]
-            base_path = opts[:base_path] || ''
-            base_path = base_path[1..-1] if base_path[0..0] == '/'
+            parent_id = opts[:parent].id
 
             if source =~ /\A(.*)_(\w+)\Z/
               # if the element was not found, maybe it was not a name with underscore but it was an image mode
@@ -48,48 +84,54 @@ module Zena
 
             paths = []
             if source[0..0] == '/'
+              # ignore parent
+              parent_id = current_site.root_id
               paths << source[1..-1]
               paths << src2[1..-1] if src2
             else
-              paths << (base_path + '/' + source)
-              paths << (base_path + '/' + src2) if src2
+              paths << source
+              paths << src2 if src2
             end
 
-            # make sure path elements are url_names
+            # Retrieve titles from urlencoding
             paths.map! do |path|
-              res = []
+              res    = nil
+              par_id = parent_id
               path.split('/').each do |e|
                 if e == '..'
+                  # forces absolute path
+                  par_id = current_site.root_id
+                  res ||= opts[:parent].fullpath_as_title
                   res.pop
                 else
-                  res << e.url_name
+                  res ||= []
+                  res << String.from_filename(e)
                 end
               end
-              res.join('/')
+              [res, par_id]
             end
 
-            if asset = secure(Document) { Document.find_by_path(paths[0]) }
-            elsif src2 && (asset = secure(Document) { Document.find_by_path(paths[1]) })
+            if asset = secure(Document) { Document.find_by_path(*paths[0]) }
+            elsif src2 && (asset = secure(Document) { Document.find_by_path(*paths[1]) })
               mode = mode2
             else
               return nil
             end
           else
-            src2 = source.split('/').map {|s| s.url_name!}.join('/')
+            src2 = source.split('/').map {|s| String.from_filename(s) }
 
             if source =~ /\A(.*)_(\w+)\Z/
               source, mode = $1, $2
             end
 
+            source = source.split('/').map {|f| String.from_filename(f) }
 
-            unless res = find_document_for_template(source, opts[:base_path])
+            unless asset = find_document_for_template(source, opts[:base_path])
               # '_...' did not mean mode but was an old name.
               mode = nil
-              return nil unless res = find_document_for_template(src2, opts[:base_path])
+              return nil unless asset = find_document_for_template(src2, opts[:base_path])
             end
 
-            asset, base_path = res
-            self.renamed_assets[asset.fullpath] = asset
           end
 
           data_path(asset, :mode => mode)
@@ -113,14 +155,15 @@ 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])
-          if template_url =~ /\A\.|[^\w\+\._\-\/\$]/
+          if template_url =~ /\A\.|[^ #{String::ALLOWED_CHARS_IN_FILEPATH}]/
             raise Zena::AccessViolation.new("'template_url' contains illegal characters : #{template_url.inspect}")
           end
 
           template_url = template_url.split('/')
-          path = "/#{template_url[0]}/#{template_url[1]}/#{dev_mode? ? "dev_#{lang}" : lang}/#{template_url[2..-1].join('/')}"
+          template_url.insert(-2, dev_mode? ? "dev_#{lang}" : lang)
+          path = template_url.join('/')
 
-          "/#{current_site.host}/zafu#{path}"
+          "/#{current_site.host}/zafu/#{path}"
         end
 
         # Make sure some vital templates never get broken
@@ -141,7 +184,7 @@ module Zena
         def default_template_url(opts = {})
           if opts[:format] && opts[:format] != 'html'
             raise ActiveRecord::RecordNotFound
-          elsif %w{+login +index +adminLayout +popupLayout}.include?(opts[:mode])
+          elsif %w{+login +index +adminLayout +popupLayout +notFound}.include?(opts[:mode])
             zafu_url ="$default/Node-#{opts[:mode]}"
           elsif opts[:mode]
             raise ActiveRecord::RecordNotFound
@@ -170,53 +213,44 @@ module Zena
         # Without a leading slash "special/Node"
         # 1. Search for a Document with fullpath [current directory]/special/Node
         # 2. Search anywhere in the master skin for a document named 'Node'
-        def find_document_for_template(src, base_path = nil)
-          if src =~ /^\//
+        def find_document_for_template(src, section_id = nil)
+          src = src.split('/') unless src.kind_of?(Array)
+
+          if src[0] == ''
             # Starts with '/' : first part of the path is a Skin
-            url = src[1..-1].split('/')
-          else
+            section_id = nil
+            # remove blank
+            src.shift
+            # get skin
+            return nil unless skin = get_skin(src.shift)
+            section_id = skin.id
+          elsif section_id.nil? && @skin
+            section_id = @skin.id
             # does not start with '/' : look in current directory
-            folder = base_path.blank? ? [] : base_path.split('/')
-            url = folder + src.split('/')
           end
 
-          skin_name = url.shift
-
-          # TODO: can we move this initialization somewhere else ?
-          self.expire_with_nodes ||= {}
-          self.renamed_assets ||= {}
-
-          return nil unless skin = get_skin(skin_name)
-
-          fullpath = (skin.fullpath.split('/') + url).join('/')
-
-          unless document = self.expire_with_nodes[fullpath]
-            unless document = secure(Document) { Document.find_by_path(fullpath) }
-              document = secure(Document) { Document.first(:conditions => ['node_name = ? AND section_id = ?', url.last, skin.id]) }
-              self.expire_with_nodes[document.fullpath] = document if document
+          self.asset_cache.cache_with_path(section_id, src) do
+            unless document = secure(Document) { Document.find_by_path(src, section_id) }
+              # find anywhere in Skin
+              document = secure(Document) { Document.find_by_title(src.last, :conditions => ['section_id = ?', section_id]) }
             end
-            self.expire_with_nodes[fullpath] = document if document
-          end
-
-          if document
-            # Return document and base_path to document
-            base_path = "#{([skin.node_name] + url[0..-2]).join('/')}"
-            [document, base_path]
-          else
-            nil
+            document
           end
         end
-
+        
+        def zafu_node(name, klass)
+          zafu_context[:node] = Zena::Use::NodeContext.new(name, klass)
+        end
       end # Common
 
       module ControllerMethods
 
         def self.included(base)
-          base.send(:helper_attr, :expire_with_nodes, :renamed_assets)
+#          base.send(:helper_attr, :asset_cache)
           if base.respond_to?(:helper_method)
-            base.send(:helper_method, :dev_mode?, :lang_path, :rebuild_template, :get_template_text, :template_url_for_asset, :zafu_helper)
+            base.send(:helper_method, :dev_mode?, :lang_path, :rebuild_template, :get_template_text, :template_url, :template_url_for_asset, :zafu_helper)
           end
-          base.send(:attr_accessor, :expire_with_nodes, :renamed_assets)
+
           base.send(:include, ::Zafu::ControllerMethods)
           # Needs to be inserted after Zafu::ControllerMethods since we overwrite get_template_text and such
           base.send(:include, Common)
@@ -241,21 +275,26 @@ module Zena
               :order      => "length(tkpath) DESC"
             )}
 
-
             # Path as seen from zafu:
-            zafu_url  = template.fullpath.gsub(/^#{@skin.fullpath}/, @skin.node_name)
+            path_in_skin = template.fullpath.gsub(/^#{@skin.fullpath}\//, '')
 
-            rel_path  = current_site.zafu_path + "/#{zafu_url}/#{lang_path}/_main.erb"
+            if path_in_skin == template.zip.to_s
+              zafu_url = [@skin.title, template.title]
+            else
+              zafu_url = [@skin.title] + Node.fullpath_map(path_in_skin, :title)
+            end
+
+            rel_path  = current_site.zafu_path + "/#{zafu_url.map(&:to_filename).join('/')}/#{lang_path}/_main.erb"
             path      = SITES_ROOT + rel_path
 
             if !File.exists?(path) || params[:rebuild]
-              if @node && klass = Node.get_class_from_kpath(template.tkpath)
-                zafu_node('@node', Zena::Acts::Enrollable.make_class(klass))
+              if @node && klass = VirtualClass.find_by_kpath(template.tkpath)
+                zafu_node('@node', klass)
               else
                 nil
               end
 
-              unless rebuild_template(template, opts.merge(:zafu_url => zafu_url, :rel_path => rel_path, :dev_mode => (dev_box?(mode, format))))
+              unless rebuild_template(template, opts.merge(:zafu_url => zafu_url.join('/'), :rel_path => rel_path, :dev_mode => (dev_box?(mode, format))))
                 return default_template_url(opts)
               end
             end
@@ -286,7 +325,7 @@ module Zena
 
         # Return true if we should display the dev box
         def dev_box?(mode, format)
-          format == 'html' && mode != '+popupLayout' && dev_mode?
+          (format == 'html' && mode != '+popupLayout') && dev_mode?
         end
 
         def lang_path
@@ -314,16 +353,20 @@ module Zena
           elsif skin = @skins[skin_name]
             return skin
           else
-            skin =secure(Skin) { Skin.find_by_node_name(skin_name)}
+            skin =secure(Skin) { Skin.find_by_title(skin_name) }
           end
 
           if skin
-            @skins[skin.node_name] = skin
+            @skins[skin.title] = skin
           end
 
           skin
         end
 
+        def asset_cache
+          @asset_cache ||= AssetCache.new
+        end
+
         private
           # Return the node_context to use in zafu compilation from the current controller and action.
           # FIXME: Use information on template target_class to get class !
@@ -332,18 +375,27 @@ module Zena
 
             if self.class.to_s =~ /\A([A-Z]\w+?)s?[A-Z]/
               ivar = "@#{$1.downcase}"
-              if var = self.instance_variable_get(ivar.to_sym)
+              if var = instance_variable_get(ivar.to_sym)
                 name  = ivar
-                klass = Zena::Acts::Enrollable.make_class(var.class)
+                if var.kind_of?(Node)
+                  klass = VirtualClass['Node'] # we could use $1
+                else
+                  klass = var.class
+                end
               elsif var = self.instance_variable_get(ivar + 's')
                 name = ivar + 's'
-                klass = [Zena::Acts::Enrollable.make_class(var.first.class)]
+                if var.first.kind_of?(Node)
+                  klass = [VirtualClass['Node']] # we could use $1
+                else
+                  klass = [var.class]
+                end
               end
-              return Zafu::NodeContext.new(name, klass) if name
+              
+              return Zena::Use::NodeContext.new(name, klass) if name
             end
 
             if defined?(@node)
-              return Zafu::NodeContext.new('@node', Zena::Acts::Enrollable.make_class(Node))
+              return Zena::Use::NodeContext.new('@node', VirtualClass['Node'])
             else
               raise Exception.new("Could not guess node context from request parameters, please add something like \"zafu_node('@var_name', Page)\" in your action.")
             end
@@ -353,18 +405,24 @@ module Zena
           # a filesystem path inside SITES_ROOT where the built template should be compiled.
           def rebuild_template(template, opts = {})
             zafu_url, rel_path, insert_dev = opts[:zafu_url], opts[:rel_path], opts[:dev_mode]
+
             # clear :
             FileUtils::rmtree(File.dirname(SITES_ROOT + rel_path))
 
+            @asset_cache = AssetCache.new
+
             # Cache loaded templates and skins
             if template
-              self.expire_with_nodes = {
-                template.fullpath => template
-              }
+              # Store template in expiry list and dev_box
+              if fullpath = template.fullpath[/^#{@skin.fullpath}\/(.*)/,1]
+                # absolute path with skin
+                fullpath = [@skin.title] + template.fullpath_as_title(fullpath)
+                self.asset_cache.cache_with_path(@skin.id, fullpath) do
+                  template
+                end
+              end
             end
 
-            self.renamed_assets = {}
-
             res = ZafuCompiler.new_with_url(zafu_url, :helper => zafu_helper).to_erb(:dev => dev_mode?, :node => get_node_context)
 
             unless valid_template?(res, opts)
@@ -387,7 +445,7 @@ module Zena
               secure!(CachedPage) { CachedPage.create(
                 :path            => rel_path,
                 :expire_after    => nil,
-                :expire_with_ids => self.expire_with_nodes.values.map{|n| n[:id]}.uniq,
+                :expire_with_ids => self.asset_cache.used_nodes.map(&:id).uniq,
                 :node_id         => template[:id],
                 :content_data    => res) }
             else
@@ -399,29 +457,15 @@ module Zena
           end
 
           def dev_box
-            used_nodes  = []
-            zafu_nodes  = []
-            image_nodes = []
-            asset_nodes = []
-            self.expire_with_nodes.merge(self.renamed_assets).each do |k, n|
-              if n.kind_of?(Image)
-                image_nodes << [k,n]
-              elsif n.kind_of?(Template)
-                zafu_nodes  << [k,n]
-              else
-                asset_nodes << [k,n]
-              end
-            end
-            used_nodes << ['zafu',    zafu_nodes] unless zafu_nodes.empty?
-            used_nodes << ['images', image_nodes] unless image_nodes.empty?
-            used_nodes << ['assets', asset_nodes] unless asset_nodes.empty?
+            used_nodes = self.asset_cache.used_assets
 
             res = "<div id='dev'><ul>\n"
             used_nodes.each do |name, nodes|
+              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"
-              nodes.each do |k,n|
-                res << "    <tr><td class='actions'>#{zafu_helper.send(:node_actions, n)}</td><td>#{zafu_helper.send(:link_to,k,zen_path(n))}</td></tr>\n"
+              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
               res << "  </table>\n"
               res << "  </li>\n"
@@ -431,9 +475,9 @@ module Zena
             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') %>'/>
-            <% end -%></div>}
+            <% 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 -%>"
+            res << "<% if @node.kind_of?(Skin) %><a href='<%= export_node_path(@node[:zip]) %>'>#{_('export')}</a>\n<% end %>"
             res << "      <a style='float:right' href='/dev_skin'>#{_('turn_dev_off_btn')}</a>\n"
             res << "    </li></ul>\n  </li>\n</ul></div>"
             res
@@ -449,7 +493,7 @@ module Zena
           [
             ['off',    nil ],
             ['any',    0   ],
-          ] + skins.map {|s| [ s.node_name, s.zip ] } + [
+          ] + skins.map {|s| [ s.title, s.zip ] } + [
             ['rescue', -1  ],
           ]
         end