rbbt-views 0.1.2 → 1.0.0

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

@@ -0,0 +1,38 @@
+
+module RbbtHTMLHelpers
+  def input(type, name, options = {})
+    id, hide, value, klass, default, description = Misc.process_options options, :id, :hide, :value, :class, :default, :description
+    str = "<div class='form_input' id='#{ id }'>"
+
+    if hide
+      str << "<input #{"id='#{ id }'" if id} type='hidden' name='#{ name }' #{"class='#{ klass }'" if klass} #{"value='#{ value }'" if value}/>" << '</div>' << "\n"
+      return str
+    end
+
+    case type
+    when :boolean
+      not_value = ! value
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}</label>" << "\n"
+      str << "<input type='radio' id='input_#{id}_true' name='#{ name }' value='true' #{"checked='true'" if value}>" << "\n"
+      str << "<label type='radio_option radio_true' for='input_#{id}_true' name='#{ name }'>true</label>" << "\n"
+      str << "<input type='radio' id='input_#{id}_false' name='#{ name }' value='false' #{"checked='false'" if not value}>" << "\n"
+      str << "<label type='radio_option radio_false' for='input_#{id}_false' name='#{ name }'>false</label>" << "\n"
+      str << "</div>"
+      str
+    when :string, :float, :integer
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}#{": <span class='input_default'>(Default: #{ default })</span>" if default}</label>" << "\n"
+      str << "<input #{"class='#{klass ? klass : "#{ name } #{ type }" }'"} #{"id='#{ id }'" if id} name='#{ name }' #{"value='#{ value }'" if value}/>" << "\n"
+      str << "</div>"
+      str
+    when :tsv, :array, :text
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}#{": <span class='input_default'>(Default: #{ default })</span>" if default}</label>" << "\n"
+      str << "<p>"
+      str << "<input type='file' #{"class='#{klass ? klass : "#{ name } #{ type }" }'"} #{"id='input_#{ id }_tsv_file'" if id} name='#{ name }_param_file' #{"value='#{ value }'" if value}/>" << "\n"
+      str << "<span class='tsv_textarea_note note'>(or use text area bellow)</span>"
+      str << "</p>"
+      str << "<textarea #{"class='#{klass ? klass : "#{ name } #{ type }" }'"} name='#{ name }' #{"id='input_#{ id }'" if id}></textarea>"
+      str << "</div>"
+      str
+    end
+  end
+end

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

@@ -1,209 +1,588 @@
-require 'rbbt/workflow/rest/entity'
+require 'rbbt/entity'
+
+module RbbtHTMLHelpers
+  PAGESIZE = 25
+
+  def self.locate_file(workflow, task, file)
+    file = case
+           when file =~  /\.[a-z]{2,4}$/
+             file
+           when file =~ /(.*)\/$/
+             $1
+           else
+             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
+
+    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
+
+    Log.debug "File #{[workflow, task, file].collect{|v| "'#{ v }'"} * ", "} located at #{ path }"
+    path
+  end
 
-module Sinatra
-  module SinatraRbbt
+  def locate_file(workflow, task, file)
+    RbbtHTMLHelpers.locate_file(workflow, task, file)
+  end
 
-    PAGESIZE = 25
 
-    def parse_page(page)
-      field, num, size = page.split("~").values_at 0, 1, 2
-      if num.nil?
-        num = field
-        field = "key"
-      end
-      size ||= PAGESIZE
-      [field, num, size]
+  def parse_page(page)
+    field, num, size = page.split("~").values_at 0, 1, 2
+    if num.nil?
+      num = field
+      field = "key"
     end
+    size ||= PAGESIZE
+    [field, num, size]
+  end
 
-    def paginate(object, page = nil, just_keys = false)
-      return object unless TSV === object and not page.nil?
+  def paginate(object, page = nil, just_keys = false)
+    return object unless TSV === object and not page.nil?
 
-      page = "key~1~#{PAGESIZE}" if page.nil? and object.size > 100
-      return object if page.nil? or page == "all"
-      field, num, size = parse_page(page)
+    return object if page == "all" or page.nil?
+    field, num, size = parse_page(page)
 
-      entity = Entity.formats[field]
+    entity = Entity.formats[field]
 
-      num = num.to_i
-      size = size.to_i
-      max = object.size / size + 1
+    num = num.to_i
+    size = size.to_i
+    max = object.size / size + 1
 
-      num = max if num > max
-      num = - max if num < - max
+    num = max if num > max
+    num = - max if num < - max
 
-      if entity and entity.respond_to? :tsv_sort
-        object.page(num, size, field, just_keys, entity.method(:tsv_sort))
-      else
-        object.page(num, size, field, just_keys)
-      end
+    if entity and entity.respond_to? :tsv_sort
+      object.page(num, size, field, just_keys, &entity.method(:tsv_sort))
+    else
+      object.page(num, size, field, just_keys)
     end
-    
-    def process_result(result, options)
-      rows = result
-
-      if options.include? :_filter and not options[:_filter].nil?
-        field, query = options[:_filter].split("~")
-
-        entity = Entity.formats[field]
-
-        if entity and entity.respond_to?(:filter)
-          filter_proc = entity.method :filter
-          if filter_proc.respond_to? :curry
-            curried_proc = filter_proc.curry(query, type, options.merge(:tsv => result, :field => field))
-          else
-            curried_proc = Proc.new{|entity|
-              filter_proc.call(query, type, options.merge(:tsv => result, :field => field), entity)
-            }
-          end
-          rows = rows.select field => curried_proc
+  end
+
+  def process_result(result, options)
+    rows = result
+
+    if options.include? :_filter and not options[:_filter].nil?
+      field, query = options[:_filter].split("~")
+
+      entity = Entity.formats[field]
+
+      if entity and entity.respond_to?(:filter)
+        filter_proc = entity.method :filter
+        if filter_proc.respond_to? :curry
+          curried_proc = filter_proc.curry(query, field, options.merge(:tsv => result, :field => field))
         else
-          rows = rows.select field => Regexp.new(query)
+          curried_proc = Proc.new{|entity|
+            filter_proc.call(query, field, options.merge(:tsv => result, :field => field), entity)
+          }
         end
+        rows = rows.select field => curried_proc
+      else
+        rows = rows.select field => Regexp.new(query)
       end
+    end
 
-      total = rows.size
+    total = rows.size
 
-      if options.include? :_page and not options[:_page].nil?
-        keys = paginate(rows, options[:_page], true)
-        
-        if keys
-          rows = keys.zip(rows.values_at *keys)
-        end
+    options[:_page] = "1" if rows.size > 100 and options[:_page].nil?
+    if options.include?(:_page) and not options[:_page].nil?
+      keys = paginate(rows, options[:_page], true)
 
+      if keys
+        rows = keys.zip(rows.values_at *keys)
       end
 
-      [rows, total]
     end
 
-    def workflow_render(workflow, task, file, locals = {}, &block)
-      size = locals["_size"] || :normal
+    [rows, total]
+  end
+
+  #def workflow_render(file, workflow = nil, task = nil, locals = {}, &block)
+  def workflow_render(file, *args, &block)
+    locals = Hash === args.last ? args.pop : {}
+
+    case args.length
+    when 0
+      workflow = locals[:workflow]
+      task = locals[:task]
+    when 1
+      workflow = args.shift
+      task = locals[:task]
+    when 2
+      workflow = args.shift
+      task     = args.shift
+    end
 
-      case size.to_sym
-      when :normal
+    size = locals.delete(:_size) || locals.delete("_size") || :normal
+
+    case size.to_sym
+    when :normal
+      path = locate_file(workflow, task, file)
+    when :small
+      begin
+        path = locate_file(workflow, task, file + '.small')
+      rescue
+        Log.debug $!.message
         path = locate_file(workflow, task, file)
-      when :small
-        begin
-          path = locate_file(workflow, task, file + '.small')
-        rescue
-          Log.debug $!.message
-          path = locate_file(workflow, task, file)
-        end
       end
+    end
 
-      layout = locals[:_layout]
-      layout = false if request.xhr? and layout.nil?
-
-      headers "AJAX-URL" => request.env["REQUEST_URI"]
+    layout = locals[:_layout]
+    layout = false if locals[:_xhr] and layout.nil?
+    layout = true if layout.nil?
 
-      locals = Misc.add_defaults locals, :workflow => workflow, :task => task
+    locals = Misc.add_defaults locals, :workflow => workflow, :task => task
 
-      renderer = Haml::Engine.new(path.read)
+    renderer = Haml::Engine.new(path.read)
 
-      case
-      when (not layout)
-        renderer.render(self, locals, &block)
-      when (not block_given?)
-        workflow_render(workflow, task, "layout", locals) do 
-          renderer.render(self, locals) 
-        end
-      else
-        renderer.render(self, locals, &block)
+    case
+    when (not layout)
+      renderer.render(self, locals, &block)
+    when (not block_given?)
+      workflow_render("layout", workflow, task, locals) do 
+        renderer.render(self, locals)
       end
+    else
+      renderer.render(self, locals, &block)
     end
+  end
+
+  def workflow_partial(file, *args)
+    locals = Hash === args.last ? args.pop : {}
+
+    case args.length
+    when 0
+      workflow = locals[:workflow]
+      task = locals[:task]
+    when 1
+      workflow = args.shift
+      task = locals[:task]
+    when 2
+      workflow = args.shift
+      task     = args.shift
+    end
+
+    workflow_render(file, workflow, task, locals.merge(:_layout => false))
+  end
 
-    def workflow_partial(workflow, task, file, locals = {})
-      workflow_render(workflow, task, file, locals.merge(:_layout => false))
+  def workflow_render_result(result, *args)
+    options = Hash === args.last ? args.pop : {}
+
+    case args.length
+    when 0
+      workflow = options[:workflow]
+      task = options[:task]
+    when 1
+      workflow = args.shift
+      task = options[:task]
+    when 2
+      workflow = args.shift
+      task     = args.shift
     end
 
-    def workflow_render_result(workflow, task_name, result, options = {})
-      format = options[:_format]
-      page = options[:_page]
 
-      case 
-      when format.to_sym == :raw
-        content_type "text/plain"
-        if Array === result
-          result * "\n"
+    format = options[:_format]
+    page = options[:_page]
+
+    case 
+    when format.to_sym == :raw
+      content_type "text/plain"
+      if Array === result
+        result * "\n"
+      else
+        result.to_s
+      end
+    when format.to_sym == :json
+      content_type "application/json"
+      if TSV === result
+        result = paginate(result, page)
+        result.to_json
+      else
+        result.to_json
+      end
+    when format.to_sym == :html
+      content_type "text/html"
+      options = Misc.add_defaults options, workflow.task_info(task)
+      options = Misc.add_defaults options, :result => result, :workflow => workflow, :task => task
+      workflow_render("result", workflow, task, options)
+    else
+      raise "Unkonwn format: #{format}"
+    end
+  end
+
+  def entity_render(type, locals, &block)
+    type, format = type.split ":"
+
+    size = locals.delete(:_size) || locals.delete("_size") || :normal
+
+    workflow = WorkflowREST.workflows.last
+
+    entity = locals[:entity]
+
+    entity_class = case
+                   when Entity.formats.include?(format)
+                     Entity.formats[format] 
+                   when Entity.formats.include?(type)
+                     Entity.formats[type] 
+                   else
+                     nil
+                   end
+
+    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| 
+        case v
+        when "false"
+          false
+        when "true"
+          true
         else
-          result.to_s
+          v
         end
-      when format.to_sym == :json
-        content_type "application/json"
-        if TSV === result
-          result = paginate(result, page)
-          result.to_json
+      })
+      entity.format = format if entity.respond_to? :format
+    end
+
+    layout = locals[:_layout]
+    layout = false if locals[:_xhr] and layout.nil?
+    layout = true if layout.nil?
+
+    renderer = Haml::Engine.new(path.read)
+
+    case
+    when (not layout)
+      renderer.render(self, locals, &block)
+    when (not block_given?)
+      workflow_render("layout", nil, nil, locals) do 
+        renderer.render(self, locals) 
+      end
+    else
+      renderer.render(self, locals, &block)
+    end
+  end
+
+  def entity_action_render(type, action, locals, &block)
+    type, format = type.split ":"
+
+    size = locals.delete(:_size) || locals.delete("_size") || :normal
+
+    workflow = WorkflowREST.workflows.last
+
+    entity = locals[:entity]
+
+    entity_class = case
+                   when Entity.formats.include?(format)
+                     Entity.formats[format] 
+                   when Entity.formats.include?(type)
+                     Entity.formats[type] 
+                   else
+                     nil
+                   end
+
+    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
+
+    if entity_class
+      entity_class.setup(entity, *locals.values_at(*entity_class.annotations).collect{|v| 
+        case v
+        when "false"
+          false
+        when "true"
+          true
         else
-          result.to_json
+          v
         end
-      when format.to_sym == :html
-        content_type "text/html"
-        options = Misc.add_defaults options, workflow.task_info(task_name)
-        options = Misc.add_defaults options, :result => result, :workflow => workflow, :task_name => task_name
-        workflow_render(workflow, task_name, "result", options)
-      else
-        raise "Unkonwn format: #{format}"
-      end
+      })
+      entity.format = format if entity.respond_to? :format
     end
 
-    def entity_render(type, locals, &block)
-      type, format = type.split ":"
+    layout = locals[:_layout]
+    layout = false if locals[:_xhr] and layout.nil?
+    layout = true if layout.nil?
 
-      size = locals["_size"] || :normal
+    renderer = Haml::Engine.new(path.read)
 
-      if Entity.formats.include?(format) and not Entity.formats[format].template.nil? or
-        Entity.formats.include?(type) and not Entity.formats[type].template.nil?
+    case
+    when (not layout)
+      renderer.render(self, locals, &block)
+    when (not block_given?)
+      workflow_render("layout", nil, nil, locals) do 
+        renderer.render(self, locals) 
+      end
+    else
+      renderer.render(self, locals, &block)
+    end
+  end
 
-        path = Entity.formats[format || type].template
-      else
-        path = nil
-
-        [format, type].each do |file|
-          begin
-            case size.to_sym
-            when :normal
-              file = File.join('entity', file + '.haml')
-              path = locate_file(nil, nil, file)
-            when :small
-              begin
-                file_small = File.join('entity', file + 'small.haml')
-                path = locate_file(nil, nil, file_small)
-              rescue
-                Log.debug $!.message
-                file = File.join('entity', file + '.haml')
-                path = locate_file(nil, nil, file)
-              end
-            end
-          rescue
-            next
-          end
+  def entity_list_render(type, locals, &block)
+    type, format = type.split ":"
+
+    size = locals.delete(:_size) || locals.delete("_size") || :normal
+
+    workflow = WorkflowREST.workflows.last
+
+    list = locals[:list] = Entity::REST.load_list(locals[:id])
+
+    entity_class = case
+                   when Entity.formats.include?(format)
+                     Entity.formats[format] 
+                   when Entity.formats.include?(type)
+                     Entity.formats[type] 
+                   else
+                     nil
+                   end
+
+    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].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
+
+    if entity_class
+      entity_class.setup(list, *locals.values_at(*entity_class.annotations).collect{|v| 
+        case v
+        when "false"
+          false
+        when "true"
+          true
+        else
+          v
         end
+      })
+      list.format = format if list.respond_to? :format
+    end
 
-        raise "Template not found for type, format: #{[type, format] * ", "}" if path.nil?
-      end
+    layout = locals[:_layout]
+    layout = false if locals[:_xhr] and layout.nil?
+    layout = true if layout.nil?
 
-      if (Entity.formats.include?(format) or Entity.formats.include?(type)) and locals[:entity]
-        entity = Entity.formats[format || type]
-        entity.setup(locals[:entity], *locals.values_at(*entity.annotations))
+    renderer = Haml::Engine.new(path.read)
+
+    case
+    when (not layout)
+      renderer.render(self, locals, &block)
+    when (not block_given?)
+      workflow_render("layout", nil, nil, locals) do 
+        renderer.render(self, locals) 
       end
+    else
+      renderer.render(self, locals, &block)
+    end
+  end
 
-      layout = locals[:_layout]
-      layout = false if request.xhr? and layout.nil?
+  
+
+  def entity_list_action_render(type, action, locals, &block)
+    type, format = type.split ":"
+
+    size = locals.delete(:_size) || locals.delete("_size") || :normal
+
+    workflow = WorkflowREST.workflows.last
+
+    list = locals[:list] = Entity::REST.load_list(locals[:id])
+
+    entity_class = case
+                   when Entity.formats.include?(format)
+                     Entity.formats[format] 
+                   when Entity.formats.include?(type)
+                     Entity.formats[type] 
+                   else
+                     nil
+                   end
+
+    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
+
+    if entity_class
+      entity_class.setup(list, *locals.values_at(*entity_class.annotations).collect{|v| 
+        case v
+        when "false"
+          false
+        when "true"
+          true
+        else
+          v
+        end
+      })
+      list.format = format if list.respond_to? :format
+    end
 
-      headers "AJAX-URL" => request.env["REQUEST_URI"]
+    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)
 
-      case
-      when (not layout)
-        renderer.render(self, locals, &block)
-      when (not block_given?)
-        entity_render(workflow, task, "layout", locals) do 
-          renderer.render(self, locals) 
-        end
-      else
-        renderer.render(self, locals, &block)
+    case
+    when (not layout)
+      renderer.render(self, locals, &block)
+    when (not block_given?)
+      workflow_render("layout", nil, nil, locals) do 
+        renderer.render(self, locals) 
       end
+    else
+      renderer.render(self, locals, &block)
     end
+ 
+  end
+end
 
+module Sinatra
+  module SinatraRbbt
+    include RbbtHTMLHelpers
   end
 end