rbbt-views 1.0.1 → 2.0.0

data/lib/rbbt/workflow/rest/notes.rb

@@ -0,0 +1,125 @@
+require 'redcarpet/compat'
+module Sinatra
+  module SinatraRbbt
+
+    #{{{ Locating markup
+    
+    def user_notes(user = nil)
+      notes = {}
+      Dir.glob(File.join(*[settings.note_dir, user, '/**/*'].compact)).each do |path|
+        next if File.directory? path
+        path.sub!(/.*?notes\//,'')
+        path.sub!(/^#{user}\//,'') if user
+        notes[path] = '/notes/' + path
+      end
+      notes
+    end
+
+    def shared_notes(user)
+      notes = {}
+      Dir.glob(File.join(*[settings.note_dir, user, '.shared', '/**/*'].compact)).each do |path|
+        next if File.directory? path
+        path.sub!(/.*?notes\//,'')
+        path.sub!(/^#{user}\/.shared\//,'')
+        notes[path] = "/notes/shared/#{ user }/" + path
+      end
+      notes
+    end
+
+    def notes_filepath(path, params, user = nil, shared = false)
+      path = 'news' if path.empty?
+      if user and shared
+        filepath = File.join(*[settings.note_dir, user, '.shared', path].compact)
+      else
+        filepath = File.join(*[settings.note_dir, user, path].compact)
+      end
+
+      filepath = File.expand_path(filepath)
+      raise "Ilegal: #{ path }" unless Misc.path_relative_to(settings.note_dir, filepath)
+
+
+      params.delete('_update')
+      params.delete('_')
+
+      layout = params.delete('_layout')
+      layout = false if params.delete(:_xhr) and layout.nil? 
+      layout = true if layout.nil?
+
+      filepath << "?" << Misc.hash2GET_params(params) if params.any?
+
+      [filepath, layout]
+    end
+
+    def get_notes_markup(path, params, user = nil, shared = false)
+      filepath, layout = notes_filepath(path, params, user, shared)
+      Open.read(filepath) rescue ""
+    end
+
+    def delete_notes_markup(path, params, user = nil, shared = false)
+      filepath, layout = notes_filepath(path, params, user, shared)
+      FileUtils.rm(filepath) rescue ""
+    end
+
+    def save_notes(path, params, markup, user = nil)
+      filepath, layout = notes_filepath(path, params, user)
+      Open.write(filepath, markup)
+    end
+
+    def share_notes(path, params, markup, user = nil)
+      filepath, layout = notes_filepath(path, params, user, false)
+      shared_filepath, layout = notes_filepath(path, params, user, true)
+      FileUtils.mkdir_p(File.dirname(shared_filepath)) unless File.exists? File.dirname(shared_filepath)
+      FileUtils.ln_s(filepath, shared_filepath)
+    end
+
+    def unshare_notes(path, params, markup, user = nil)
+      shared_filepath, layout = notes_filepath(path, params, user, true)
+      FileUtils.rm(shared_filepath)
+    end
+
+
+    #{{{ Processing markup
+    
+    def gene_links(markup)
+      markup.gsub(/Gene ([^\s]+)/) do |gene|
+        Gene.setup($1, "Associated Gene Name", "Hsa/jun2011").ensembl.link
+      end
+    end
+
+    def kegg_links(markup)
+      markup.gsub(/KEGG:"([^"]+)"/) do |match|
+        pathway = KEGG.name2id($1).select{|id| id =~ /^hsa/}.first
+        if pathway
+          KeggPathway.setup(pathway, "Hsa/jun2011").link
+        else
+          match
+        end
+      end
+    end
+
+    def render_notes(path, params, user = nil, shared = false)
+      html_header = ""
+      html_header += "<a class='back_note' href='#{ request.env['REQUEST_URI'].sub(/\/notes/, '').sub(/^\/shared\/\w+\//, '/')}'>Page</a>\n\n" unless path == 'news'
+      if request.env['REQUEST_URI'].sub(/\/notes/, '') !~ /^\/shared\//
+        html_header +=  "<a class='edit_note' href='#{ request.env['REQUEST_URI'].sub(/\/notes/, '/notes/edit')}' >Edit</a>\n"
+        html_header += "<a class='delete_note DELETE' href='#{ request.env['REQUEST_URI'].sub(/\/notes/, '/notes')}'>Delete</a>\n\n"
+      end
+
+      markup = get_notes_markup(path, params, user, shared)
+
+      markup = gene_links(markup)
+      markup = kegg_links(markup)
+      engine = Markdown
+      if layout
+        workflow_render("layout", nil, nil, params) do 
+          html_header + "<div class='note'>" + engine.new(markup).to_html + "</div>"
+        end
+      else
+        html_header + "<div class='note'>" + engine.new(markup).to_html + "</div>"
+      end
+    end
+
+  end
+end
+
+

data/lib/rbbt/workflow/rest/render.rb

@@ -3,8 +3,14 @@ require 'rbbt/entity'
 module RbbtHTMLHelpers
   PAGESIZE = 25
 
-  def self.locate_file(workflow, task, file)
-    file = case
+  class << self
+    attr_accessor :default_workflow_views
+  end
+
+  class TemplateNotFoundError < StandardError; end
+
+  def self.locate_file(workflow, task, file, entity = nil)
+    fixed_file = case
            when file =~  /\.[a-z]{2,4}$/
              file
            when file =~ /(.*)\/$/
@@ -13,68 +19,65 @@ module RbbtHTMLHelpers
              file + '.haml'
            end
 
-    webapp_dir_views = Rbbt.www.views.find(:lib, Sinatra::Application.root)
-    workflow_dir_views = (workflow.nil? or workflow.libdir.nil?) ? nil : workflow.libdir.www.views
-    global_views = Rbbt.share.views
-
-    # workflow = workflow.to_s unless workflow.nil? or String === workflow
+    if File.exists? file
+      path = Path.setup(File.join('.', file))
+      Log.debug "File #{[workflow, task, file, entity].collect{|v| "'#{ v }'"} * ", "} located at #{ path }"
+      return path
+    end
 
     path = nil
-    [webapp_dir_views, workflow_dir_views, global_views].compact.each do |resource|
-      path = case
-             when resource[workflow][task][file].exists?
-               resource[workflow][task][file]
-             when resource[task][file].exists?
-               resource[task][file]
-             when resource[workflow][file].exists?
-               resource[workflow][file]
-             when resource[file].exists?
-               resource[file]
-             end
+    [file, fixed_file].uniq.each do |f|
+
+      webapp_views = Rbbt.www.views.find(:lib, Sinatra::Application.root)
+      global_views = Rbbt.share.views
+
+      workflow_views = case
+                       when (not workflow.nil? and workflow.respond_to? :libdir and not Path === workflow.libdir)
+                         workflow.libdir.www.views
+                       when Path === default_workflow_views
+                         default_workflow_views
+                       else
+                         nil
+                       end
+
+      entity_views = case
+                     when Path === entity
+                       entity
+                     when Resource === entity
+                       entity.www.views
+                     when (Workflow === entity and not entity.libdir.nil?)
+                       entity.libdir.www.views
+                     else
+                       nil
+                     end
+        
+      [webapp_views, entity_views, workflow_views, global_views].compact.each do |resource_path|
+
+        path = case
+               when resource_path[workflow][task][f].exists?
+                 resource_path[workflow][task][f]
+               when resource_path[task][f].exists?
+                 resource_path[task][f]
+               when resource_path[workflow][f].exists?
+                 resource_path[workflow][f]
+               when resource_path[f].exists?
+                 resource_path[f]
+               end
+
+        break unless path.nil?
+      end
       break unless path.nil?
     end
 
-#    path = case
-#           when webapp_dir_views[workflow][task][file].exists?
-#             webapp_dir_views[workflow][task][file]
-#           when webapp_dir_views[task][file].exists?
-#             webapp_dir_views[task][file]
-#           when webapp_dir_views[workflow][file].exists?
-#             webapp_dir_views[workflow][file]
-#           when webapp_dir_views[file].exists?
-#             webapp_dir_views[file]
-#
-#           when (not workflow_dir_views.nil? and workflow_dir_views[workflow][task][file].exists?)
-#             workflow_dir_views[workflow][task][file]
-#           when (not workflow_dir_views.nil? and workflow_dir_views[task][file].exists?)
-#             workflow_dir_views[task][file]
-#           when (not workflow_dir_views.nil? and workflow_dir_views[workflow][file].exists?)
-#             workflow_dir_views[workflow][file]
-#           when (not workflow_dir_views.nil? and workflow_dir_views[file].exists?)
-#             workflow_dir_views[file]
-#
-#           when global_views[workflow][task][file].exists?
-#             global_views[workflow][task][file]
-#           when global_views[task][file].exists?
-#             global_views[task][file]
-#           when global_views[workflow][file].exists?
-#             global_views[workflow][file]
-#           when global_views[file].exists?
-#             global_views[file]
-#           else
-#             raise "File not found: #{[workflow, task, file].compact * ", "}"
-#           end
-
-    raise "File not found: #{[workflow, task, file].compact * ", "}" if path.nil?
-    Log.debug "File #{[workflow, task, file].collect{|v| "'#{ v }'"} * ", "} located at #{ path }"
+    raise TemplateNotFoundError, "File not found: #{[workflow, task, file, entity].compact * ", "}" if path.nil?
+    Log.debug "File #{[workflow, task, file, entity].collect{|v| "'#{ v }'"} * ", "} located at #{ path }"
     path
   end
 
-  def locate_file(workflow, task, file)
-    RbbtHTMLHelpers.locate_file(workflow, task, file)
+  def locate_file(*args)
+    RbbtHTMLHelpers.locate_file(*args)
   end
 
-
   def parse_page(page)
     field, num, size = page.split("~").values_at 0, 1, 2
     if num.nil?
@@ -180,7 +183,7 @@ module RbbtHTMLHelpers
 
     locals = Misc.add_defaults locals, :workflow => workflow, :task => task
 
-    renderer = Haml::Engine.new(path.read)
+    renderer = Haml::Engine.new(path.read, :filename => path.find)
 
     case
     when (not layout)
@@ -215,6 +218,7 @@ module RbbtHTMLHelpers
   def workflow_render_result(result, *args)
     options = Hash === args.last ? args.pop : {}
 
+
     case args.length
     when 0
       workflow = options[:workflow]
@@ -231,22 +235,32 @@ module RbbtHTMLHelpers
     format = options[:_format]
     page = options[:_page]
 
+    # This part might be redundant!!!!
     case 
     when format.to_sym == :raw
       content_type "text/plain"
-      if Array === result
+      case
+      when options[:result_type] == :annotations
+        Annotated.tsv(result, :all).to_s
+      when Array === result
         result * "\n"
       else
         result.to_s
       end
     when format.to_sym == :json
       content_type "application/json"
-      if TSV === result
+
+      case
+      when TSV === result
         result = paginate(result, page)
-        result.to_json
+        result.dup.to_json
+      when options[:result_type] == :annotations
+        Annotated.json(result, true)
       else
         result.to_json
       end
+
+      # This might be the only actual option
     when format.to_sym == :html
       content_type "text/html"
       options = Misc.add_defaults options, workflow.task_info(task)
@@ -257,61 +271,18 @@ module RbbtHTMLHelpers
     end
   end
 
-  def entity_render(type, locals, &block)
-    type, format = type.split ":"
-
-    size = locals.delete(:_size) || locals.delete("_size") || :normal
-
-    entity = locals[:entity]
-
-
+  def setup_entity(entity_type, format, entity, locals = {})
     entity_class = case
                    when Entity.formats.include?(format)
                      Entity.formats[format] 
-                   when Entity.formats.include?(type)
-                     Entity.formats[type] 
+                   when Entity.formats.include?(entity_type)
+                     Entity.formats[entity_type] 
                    else
                      nil
                    end
 
-    workflow = Workflow === entity_class ? entity_class : WorkflowREST.workflows.last
-
-    path = case
-           when (entity.respond_to? :template and not entity.template.nil?)
-             entity.template
-           when (entity_class.respond_to? :template and not entity_class.template.nil?)
-             entity_class.template
-           else
-             path = nil
-
-             [format, type].compact.each do |file|
-               break unless path.nil?
-               begin
-                 case size.to_sym
-                 when :normal
-                   file = File.join('entity', file + '.haml')
-                   path = locate_file(workflow, nil, file)
-                 when :small
-                   begin
-                     file_small = File.join('entity', file + '.small.haml')
-                     path = locate_file(workflow, nil, file_small)
-                   rescue
-                     Log.debug $!.message
-                     file = File.join('entity', file + '.haml')
-                     path = locate_file(workflow, nil, file)
-                   end
-                 end
-               rescue
-                 next
-               end
-             end
-             raise "Template not found for type, format: #{[type, format] * ", "}" if path.nil?
-
-             path
-           end
-
     if entity_class
-      entity_class.setup(entity, *locals.values_at(*entity_class.annotations).collect{|v| 
+      entity_class.setup(entity, *locals.values_at(*entity_class.all_annotations).collect{|v| 
         case v
         when "false"
           false
@@ -324,11 +295,71 @@ module RbbtHTMLHelpers
       entity.format = format if entity.respond_to? :format
     end
 
+    entity
+  end
+
+  def entity_render(entity_type, locals, &block)
+    entity_type, format = entity_type.split ":"
+
+    size = locals.delete(:_size) || locals.delete("_size") || :normal
+
+    entity = setup_entity(entity_type, format, locals[:entity], locals)
+
+    entity_class = case
+                   when Entity.formats.include?(format)
+                     Entity.formats[format] 
+                   when Entity.formats.include?(entity_type)
+                     Entity.formats[entity_type] 
+                   else
+                     nil
+                   end
+
+    workflow = WorkflowREST.workflows.last
+
+    path = nil
+    begin
+      entity_resources = [] 
+      entity_resources << entity.template if entity.respond_to? :template
+      entity_resources << entity if Resource === entity or Workflow === entity
+      entity_resources << entity_class.template if entity_class.respond_to? :template
+      entity_resources << entity_class if Resource === entity_class or Workflow === entity_class
+      entity_resources << [nil]
+
+      entity_resources.each do |entity_resource|
+        [format, entity_type].compact.each do |name|
+
+          begin
+            case size.to_sym
+            when :normal
+              file = File.join('entity', name + '.haml')
+              path = locate_file(workflow, nil, file, entity_resource)
+            when :small
+              file_small = File.join('entity', name + '.small.haml')
+              path = locate_file(workflow, nil, file_small, entity_resource)
+            end
+          rescue TemplateNotFoundError
+            next
+          end
+
+          break unless path.nil?
+        end
+        break unless path.nil?
+      end
+      raise TemplateNotFoundError if path.nil?
+    rescue TemplateNotFoundError
+      if size.to_sym == :small
+        size = :normal
+        retry
+      end
+    end
+
+    raise "Template not found for type, format: #{[entity_type, format] * ", "}" if path.nil?
+    
     layout = locals[:_layout]
     layout = false if locals[:_xhr] and layout.nil?
     layout = true if layout.nil?
 
-    renderer = Haml::Engine.new(path.read)
+    renderer = Haml::Engine.new(path.read, :filename => path.find)
 
     case
     when (not layout)
@@ -342,76 +373,71 @@ module RbbtHTMLHelpers
     end
   end
 
-  def entity_action_render(type, action, locals, &block)
-    type, format = type.split ":"
+  def entity_action_render(entity_type, action, locals, &block)
+    entity_type, format = entity_type.split ":"
+
+    locals[:entity_type] = entity_type
+    locals[:action] = action
+
 
     size = locals.delete(:_size) || locals.delete("_size") || :normal
-    entity = locals[:entity]
+    entity = setup_entity(entity_type, format, locals[:entity], locals)
 
     entity_class = case
                    when Entity.formats.include?(format)
                      Entity.formats[format] 
-                   when Entity.formats.include?(type)
-                     Entity.formats[type] 
+                   when Entity.formats.include?(entity_type)
+                     Entity.formats[entity_type] 
                    else
                      nil
                    end
 
-    workflow = Workflow === entity_class ? entity_class : WorkflowREST.workflows.last
-
-    path = case
-           when (entity.respond_to? :action_template and Hash === entity.action_template and not entity.action_template[action].nil?)
-             entity.action_template[action]
-           when (entity_class.respond_to? :action_template and Hash === entity_class.action_template and not entity_class.action_template[action].nil?)
-             entity_class.action_template[action]
-           else
-             path = nil
-
-             [format, type].compact.each do |file|
-               break unless path.nil?
-               file = File.join(file, action)
-               begin
-                 case size.to_sym
-                 when :normal
-                   file = File.join('entity', file + '.haml')
-                   path = locate_file(workflow, nil, file)
-                 when :small
-                   begin
-                     file_small = File.join('entity', file + '.small.haml')
-                     path = locate_file(workflow, nil, file_small)
-                   rescue
-                     Log.debug $!.message
-                     file = File.join('entity', file + '.haml')
-                     path = locate_file(workflow, nil, file)
-                   end
-                 end
-               rescue
-                 next
-               end
-             end
-             raise "Action Template not found for type, format, action: #{[type, format, action] * ", "}" if path.nil?
-             path
-           end
+    workflow = WorkflowREST.workflows.last
 
-    if entity_class
-      entity_class.setup(entity, *locals.values_at(*entity_class.annotations).collect{|v| 
-        case v
-        when "false"
-          false
-        when "true"
-          true
-        else
-          v
+    path = nil
+    begin
+      entity_resources = [] 
+      entity_resources << entity.action_template if entity.respond_to? :action_template
+      entity_resources << entity if Resource === entity or Workflow === entity
+      entity_resources << entity_class.action_template if entity_class.respond_to? :action_template
+      entity_resources << entity_class if Resource === entity_class or Workflow === entity_class
+      entity_resources << [nil]
+
+      entity_resources.each do |entity_resource|
+        [format, entity_type].compact.each do |name|
+
+          begin
+            case size.to_sym
+            when :normal
+              file = File.join('entity', name, action + '.haml')
+              path = locate_file(workflow, nil, file, entity_resource)
+            when :small
+              file_small = File.join('entity', name, action + '.small.haml')
+              path = locate_file(workflow, nil, file_small, entity_resource)
+            end
+          rescue TemplateNotFoundError
+            next
+          end
+
+          break unless path.nil?
         end
-      })
-      entity.format = format if entity.respond_to? :format
+        break unless path.nil?
+      end
+      raise TemplateNotFoundError if path.nil?
+    rescue TemplateNotFoundError
+      if size.to_sym == :small
+        size = :normal
+        retry
+      end
     end
 
+    raise "Action template not found for type, format: #{[entity_type, format] * ", "}: #{ action }" if path.nil?
+
     layout = locals[:_layout]
     layout = false if locals[:_xhr] and layout.nil?
     layout = true if layout.nil?
 
-    renderer = Haml::Engine.new(path.read)
+    renderer = Haml::Engine.new(path.read, :filename => path.find)
 
     case
     when (not layout)
@@ -425,65 +451,71 @@ module RbbtHTMLHelpers
     end
   end
 
-  def entity_list_render(type, locals, &block)
-    type, format = type.split ":"
+  def entity_list_render(entity_type, locals, &block)
+    entity_type, format = entity_type.split ":"
 
     size = locals.delete(:_size) || locals.delete("_size") || :normal
 
-    locals[:type] = type
+    locals[:entity_type] = entity_type
     locals[:format] = format
 
-    list = locals[:list] = Entity::REST.load_list(locals[:type], locals[:id], user)
+    list = locals[:list] = Entity::REST.load_list(locals[:entity_type], locals[:id], user)
 
     entity_class = case
                    when Entity.formats.include?(format)
                      Entity.formats[format] 
-                   when Entity.formats.include?(type)
-                     Entity.formats[type] 
+                   when Entity.formats.include?(entity_type)
+                     Entity.formats[entity_type] 
                    else
                      nil
                    end
 
-    workflow = Workflow === entity_class ? entity_class : WorkflowREST.workflows.last
-    
-    path = case
-           when (list.respond_to? :list_template and not list.list_template.nil?)
-             list.list_template
-           when (entity_class.respond_to? :list_template and not entity_class.list_template.nil?)
-             entity_class.list_template
-           else
-             path = nil
-
-             [format, type, "Default"].compact.each do |file|
-               break unless path.nil?
-               begin
-                 case size.to_sym
-                 when :normal
-                   file = File.join('entity_list', file + '.haml')
-                   path = locate_file(workflow, nil, file)
-                 when :small
-                   begin
-                     file_small = File.join('entity_list', file + '.small.haml')
-                     path = locate_file(workflow, nil, file_small)
-                   rescue
-                     Log.debug $!.message
-                     file = File.join('entity_list', file + '.haml')
-                     path = locate_file(workflow, nil, file)
-                   end
-                 end
-               rescue
-                 next
-               end
-             end
-             raise "List template not found for type, format: #{[type, format] * ", "}" if path.nil?
-             path
-           end
+    workflow = WorkflowREST.workflows.last
+
+    path = nil
+    begin
+      entity_resources = [] 
+      entity_resources << list.list_template if list.respond_to? :list_template
+      entity_resources << list if Resource === list or Workflow === list
+      entity_resources << entity_class.list_template if entity_class.respond_to? :list_template
+      entity_resources << entity_class if Resource === entity_class or Workflow === entity_class
+      entity_resources << [nil]
+
+      entity_resources.each do |entity_resource|
+        [format, entity_type, "Default"].compact.each do |name|
+
+          begin
+            case size.to_sym
+            when :normal
+              file = File.join('entity_list', name + '.haml')
+              path = locate_file(workflow, nil, file, entity_resource)
+            when :small
+              file_small = File.join('entity_list', name + '.small.haml')
+              path = locate_file(workflow, nil, file_small, entity_resource)
+            end
+          rescue TemplateNotFoundError
+            next
+          end
+
+          break unless path.nil?
+        end
+        break unless path.nil?
+      end
+      raise TemplateNotFoundError if path.nil?
+    rescue TemplateNotFoundError
+      if size.to_sym == :small
+        size = :normal
+        retry
+      end
+    end
+
+    raise "List template not found for type, format: #{[entity_type, format] * ", "}" if path.nil?
 
     layout = locals[:_layout]
     layout = false if locals[:_xhr] and layout.nil?
     layout = true if layout.nil?
 
-    renderer = Haml::Engine.new(path.read)
+    renderer = Haml::Engine.new(path.read, :filename => path.find)
 
     case
     when (not layout)
@@ -499,64 +531,72 @@ module RbbtHTMLHelpers
 
 
 
-  def entity_list_action_render(type, action, locals, &block)
-    type, format = type.split ":"
+  def entity_list_action_render(entity_type, action, locals, &block)
+    entity_type, format = entity_type.split ":"
+
+    locals[:entity_type] = entity_type
+    locals[:action] = action
 
     size = locals.delete(:_size) || locals.delete("_size") || :normal
 
-    list = locals[:list] = Entity::REST.load_list(type, locals[:id], user)
-    locals[:type] = type
+    list = locals[:list] = Entity::REST.load_list(entity_type, locals[:id], user)
 
     entity_class = case
                    when Entity.formats.include?(format)
                      Entity.formats[format] 
-                   when Entity.formats.include?(type)
-                     Entity.formats[type] 
+                   when Entity.formats.include?(entity_type)
+                     Entity.formats[entity_type] 
                    else
                      nil
                    end
 
-    workflow = Workflow === entity_class ? entity_class : WorkflowREST.workflows.last
+    workflow = WorkflowREST.workflows.last
+
+    path = nil
+    begin
+      entity_resources = [] 
+      entity_resources << list.list_action_template if list.respond_to? :list_action_template
+      entity_resources << list if Resource === list or Workflow === list
+      entity_resources << entity_class.list_action_template if entity_class.respond_to? :list_action_template
+      entity_resources << entity_class if Resource === entity_class or Workflow === entity_class
+      entity_resources << [nil]
+
+      entity_resources.each do |entity_resource|
+        [format, entity_type, "Default"].compact.each do |name|
+
+          begin
+            case size.to_sym
+            when :normal
+              file = File.join('entity_list', name, action + '.haml')
+              path = locate_file(workflow, nil, file, entity_resource)
+            when :small
+              file_small = File.join('entity_list', name, action + '.small.haml')
+              path = locate_file(workflow, nil, file_small, entity_resource)
+            end
+          rescue TemplateNotFoundError
+            next
+          end
+
+          break unless path.nil?
+        end
+        break unless path.nil?
+      end
+      raise TemplateNotFoundError if path.nil?
+    rescue TemplateNotFoundError
+      if size.to_sym == :small
+        size = :normal
+        retry
+      end
+    end
+
+    raise "List action template not found for type, format: #{[entity_type, format] * ", "}: #{ action }" if path.nil?
 
-    path = case
-           when (list.respond_to? :list_action_template and Hash === list.list_action_template and not list.list_action_template[action].nil?)
-             list.list_action_template[action]
-           when (entity_class.respond_to? :list_action_template and Hash === entity_class.list_action_template and not entity_class.list_action_template[action].nil?)
-             entity_class.list_action_template[action]
-           else
-             path = nil
-
-             [format, type].compact.each do |file|
-               break unless path.nil?
-               file = File.join(file, action)
-               begin
-                 case size.to_sym
-                 when :normal
-                   file = File.join('entity_list', file + '.haml')
-                   path = locate_file(workflow, nil, file)
-                 when :small
-                   begin
-                     file_small = File.join('entity_list', file + '.small.haml')
-                     path = locate_file(workflow, nil, file_small)
-                   rescue
-                     Log.debug $!.message
-                     file = File.join('entity_list', file + '.haml')
-                     path = locate_file(workflow, nil, file)
-                   end
-                 end
-               rescue
-                 next
-               end
-             end
-             raise "List Template not found for type, format: #{[type, format] * ", "}" if path.nil?
-             path
-           end
 
     layout = locals[:_layout]
     layout = false if locals[:_xhr] and layout.nil?
     layout = true if layout.nil?
 
-    renderer = Haml::Engine.new(path.read)
+    renderer = Haml::Engine.new(path.read, :filename => path.find)
 
     case
     when (not layout)