taverna-player 0.2.1 → 0.3.0

data/CHANGES.rdoc

@@ -1,5 +1,15 @@
 = Changes log for Taverna Player
 
+== Version 0.3.0
+
+* Refactor callback code out into its own module.
+* Fix classname typo in port model templates.
+* Enable getting deep list outputs from the port models.
+* Add a method to get a route (path) to a port.
+* [TAV-465] Refactor renderers and add list rendering.
+* Factor out common list handling code for sharing.
+* Rename and re-document renderers.
+
 == Version 0.2.1
 
 * Fix classname typo in port model templates.

data/README.rdoc

@@ -172,9 +172,9 @@ They will be saved to <tt>lib/taverna_player_callbacks.rb</tt>. Don't forget to
 then require and register them in the Taverna Player initializer. There is more
 information on callbacks below.
 
-You can add to, or change, the workflow run outputs render methods to better
-suit your particular application. To copy the defaults that Taverna Player
-ships with into your application for customization run:
+You can add to, or change, the workflow port render methods to better suit
+your particular application. To copy the defaults that Taverna Player ships
+with into your application for customization run:
 
   rails generate taverna_player:renderers
 
@@ -182,12 +182,19 @@ They will be saved to <tt>lib/taverna_player_renderers.rb</tt>. Don't forget to
 then require and register them in the Taverna Player initializer. There is more
 information on renderers below.
 
-== Taverna Player initializer
+== Taverna Player initializers
 
-The {default initializer}[https://github.com/myGrid/taverna-player/blob/master/lib/generators/templates/initializer.rb]
-that is installed by the install generator requires minimal configuration for
-simple set ups. It is fully commented with everything that needs to be set but
-further explanations are given below.
+Two initializers are installed by the install generator:
+* {taverna_player.rb}[https://github.com/myGrid/taverna-player/blob/master/lib/generators/templates/player_initializer.rb]:
+  This contains configuration of Taverna Player.
+* {taverna_server.rb.example}[https://github.com/myGrid/taverna-player/blob/master/lib/generators/templates/server_initializer.rb]:
+  This is used to configure Taverna Player's connection to a Taverna Server.
+  It is initially set up as an example file as you will need to distribute
+  this with your application but you must not check in the contents of the
+  configured version to your repository.
+
+Both of these files require minimal configuration for simple set ups and are
+fully commented with everything that needs to be set - more details below.
 
 === Essential (required) configuration
 
@@ -332,6 +339,9 @@ your own needs.
 
 You can override the following core components:
 * Run (model)
+* RunPort (model)
+* RunPort::Input (model)
+* RunPort::Output (model)
 * RunsController
 * ServiceCredentialsController
 
@@ -405,28 +415,24 @@ A set of example callbacks can be installed with the generator detailed above.
 Don't forget to make sure any callback code is <tt>require</tt>d somewhere and
 the callbacks themselves registered in the initializer.
 
-== Rendering outputs
-
-Workflows can produce results in many different formats and Taverna Player
-tries to accomodate this as best it can. It provides basic facilities for
-rendering as many result types as it can and these are extendible wherever
-possible.
+== Rendering workflow ports
 
-=== Output helper
+Workflows can accept inputs and produce results in many different formats and
+Taverna Player tries to accomodate this as best it can. It provides basic
+facilities for rendering as many types as it can and these are extensible
+wherever possible.
 
-A very basic output helper is provided, <tt>show_output</tt>, which can be
-used in your views. This will format the output of each workflow output port in
-a generic way. If it is a singleton output then it is displayed normally. If it
-is a list output then the list is rendered as a HTML ordered list
-(<tt><ol></tt>).
+Calling the port renderer is as simple as just passing it the port to be
+rendered in your view.
 
-If you require anything more complex then you will have to override this helper
-or provide your own and call it from your views.
+  <% run.outputs.each do |output| %>
+    <%= TavernaPlayer.port_renderer.render(output) %>
+  <% end %>
 
 === Type renderers
 
 Taverna Player has a system of specific type renderers to handle different
-types of output. A number of defaults are supplied but these can be replaced
+types of value. A number of defaults are supplied but these can be replaced
 and added to if required.
 
 To install a set of example renderers you can use the generator detailed above.
@@ -434,22 +440,22 @@ To install a set of example renderers you can use the generator detailed above.
 To register a renderer for use add it into the renderers block in the
 initializer:
 
-  config.output_renderers do |renderers|
+  config.port_renderers do |renderers|
     ...
   end
 
 So to just register a single default renderer method (called
 "my_default_renderer") you would do this:
 
-  config.output_renderers do |renderers|
+  config.port_renderers do |renderers|
     renderers.default(:my_default_renderer)
   end
 
-And it would be used to render every type of output. A more sensible example
+And it would be used to render every type of value. A more sensible example
 would be to have a renderer for PNG-type images and a renderer for text
-outputs as well:
+values as well:
 
-  config.output_renderers do |renderers|
+  config.port_renderers do |renderers|
     renderers.default(:my_default_renderer)
     renderers.add("text/plain", :text_renderer, true)
     renderers.add("image/png", :show_image)
@@ -458,16 +464,16 @@ outputs as well:
 This does three things:
 * Registers a renderer for PNG images. This could be as simple as wrapping it
   in an <tt><img ../></tt> tag.
-* Registers a renderer for outputs of type "text/plain" and <em>sets this as
+* Registers a renderer for values of type "text/plain" and <em>sets this as
   the default renderer for all other types beginning with "text"</em>. That is
   what the final parameter set to +true+ does.
 * Registers a default renderer for all other types. This should probably give
-  an explanation as to why the output cannot be shown in the browser with a
-  link to download the output to the user's computer.
+  an explanation as to why the value cannot be shown in the browser with a
+  link to download the value to the user's computer.
 
 Note the use of MIME types for specifying all types.
 
-Obviously outputs such as images and text are so common that Taverna Player
+Obviously values such as images and text are so common that Taverna Player
 provides these renderers for you and has them set up and registered by default.
 You would only need to override them if you wanted extra information to be
 displayed as well, such as sizes next to images, etc.
@@ -485,22 +491,20 @@ show:
 
 Note that the same renderer callback is used for each one.
 
-=== Writing your own renderers
+=== Rendering lists
 
-To be a renderer callback a method must accept two parameters (in this order):
-1. The content to be rendered.
-1. The MIME type of the content.
+Taverna workflow inputs and output can be lists and rendering them requires a
 
-In the case of text outputs the content will likely (depending on the output
-helper you use, described above) be the entire text content of the output. In
-most other cases it will probably be a URI or path to the actual content for
-use in, for example, an <tt><img .../></tt> tag.
+=== Writing your own renderers
 
-The type is provided in case a renderer wishes to be general and differentiate
-between different subtypes.
+To be a renderer callback a method must accept two parameters (in this order):
+1. The port to be rendered.
+1. A list of indices into the port. For a singleton port this will be an empty
+   list. For a port of depth 2 this would be a list with two items, e.g.
+   <tt>[0, 0]</tt>
 
-Note that all renderer callbacks are called by Taverna Player in a context that
-includes the {ActionView::Helpers}[http://api.rubyonrails.org/classes/ActionView/Helpers.html]
+All renderer callbacks are called by Taverna Player in a context that includes
+the {ActionView::Helpers}[http://api.rubyonrails.org/classes/ActionView/Helpers.html]
 so your callbacks have access to them too, including helpers from third-party
 gems that register their helpers correctly.
 
@@ -515,9 +519,9 @@ Taverna Player provides a plain text renderer that formats text with a
 monospaced font, converts URI-like things to clickable links and respects
 carriage returns and newlines. It looks something like this:
 
-  def format_text(content, type)
+  def format_text(port, index = [])
     # Use CodeRay to format text so that newlines are respected.
-    content = CodeRay.scan(content, :text).div(:css => :class)
+    content = CodeRay.scan(port.value(index), :text).div(:css => :class)
 
     # Use auto_link to turn URI-like text into links.
     auto_link(content, :html => { :target => '_blank' }, :sanitize => false)
@@ -534,10 +538,10 @@ This renderer is registered as the default for all "text" media types.
 
 This renderer catches "text/XML" outputs:
 
-  def format_xml(content, type)
+  def format_xml(port, index = [])
     # Make sure XML is indented consistently.
     out = String.new
-    REXML::Document.new(content).write(out, 1)
+    REXML::Document.new(port.value(index)).write(out, 1)
     CodeRay.scan(out, :xml).div(:css => :class, :line_numbers => :table)
   end
 
@@ -554,24 +558,59 @@ the XML declaration, e.g.:
 
 As described above, images are just dropped into an <tt><img ../></tt> tag:
 
-  def show_image(content, type)
+  def show_image(port, index = [])
     # Can't use image_tag() here because the image doesn't really exist (it's
     # in a zip file, really) and this confuses the Rails asset pipeline.
-    tag("img", :src => content)
+    tag("img", :src => port.path(index))
   end
 
 Note the comment about the Rails asset pipeline in there if you are writing
 your own image renderer and are using the asset pipeline.
 
-The content parameter here gives the path to the image to be displayed.
+==== Lists
+
+Unless you can be absolutely sure that the workflows that will be run within
+your installation of Taverna Player will only have lists of a certain depth
+the lists renderer will need to be able to cope with anything that is thrown
+at it. The supplied renderer uses recursion to cope with what could, at least
+in theory, be infinitely deep lists:
+
+  def list_port(port, index = [], types = nil)
+    types = port.metadata[:type] if types.nil?
+
+    content = "<ol>"
+    i = 0
+    types.each do |type|
+      if type.is_a?(Array)
+        content += "<li><br />" +
+        list_port(port, index + [i], type) + "</li>"
+      else
+        content += "<li>(#{type})<p>" +
+          TavernaPlayer.port_renderer.render(port, index + [i]) +
+          "</p></li>"
+      end
+      i += 1
+    end
+
+    content += "</ol>"
+  end
+
+This method has an extra parameter that is used to drive the recursion. The
++types+ parameter contains the list structure of the whole port so can be used
+to loop over, or recurse into, each level as required.
+
+Lists are simply rendered as a numbered list along with their type
+information. Other registered renderers are called as necessary to render
+individual values.
 
 ==== Other types catch-all
 
 The default renderer for other, or unknown types, is:
 
-  def cannot_inline(content, type)
+  def cannot_inline(port, index = [])
     "Sorry but we cannot show this type of content in the browser. Please " +
-      link_to("download it", content) + " to view it on your local machine."
+      link_to("download it", port.path(index)) + " to view it on your " +
+      "local machine."
   end
 
 == Service Credentials

data/Rakefile

@@ -40,7 +40,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
     "app/models/taverna_player/run_port.rb",
     "app/models/taverna_player/service_credential.rb",
     "lib/taverna-player.rb",
-    "lib/taverna_player/output_renderer.rb"
+    "lib/taverna_player/port_renderer.rb"
     ]
 
   rdoc.rdoc_files.include(files)

data/app/helpers/taverna_player/runs_helper.rb

@@ -21,64 +21,5 @@ module TavernaPlayer
       end
     end
 
-    def show_output(run, output)
-      if output.depth == 0
-        if output.value.blank?
-          content = run_path(output.run_id) + "/output/#{output.name}"
-        else
-          if output.metadata[:size] < 255
-            content = output.value
-          else
-            Zip::ZipFile.open(run.results.path) do |zip|
-              content = zip.read(output.name)
-            end
-          end
-        end
-        raw(TavernaPlayer.output_renderer.render(content, output.metadata[:type]))
-      else
-        parse_port_list(run, output)
-      end
-    end
-
-    private
-
-    def parse_port_list(run, output)
-      types = output.metadata[:type]
-      content = String.new
-
-      Zip::ZipFile.open(run.results.path) do |zip|
-        content = deep_parse(types, output, zip)
-      end
-
-      content
-    end
-
-    def deep_parse(types, output, zip, index = [])
-      content = "<ol>"
-      i = 0
-      types.each do |type|
-        if type.is_a?(Array)
-          content += "<li><br />" +
-            deep_parse(type, output, zip, index + [i]) + "</li>"
-        else
-          # Text outputs are inlined here by us. Other types are linked and
-          # inlined by the browser.
-          content += "<li>(#{type})<p>"
-          if type.starts_with?("text")
-            path = (index + [i]).map { |j| j += 1 }.join("/")
-            data = zip.read("#{output.name}/#{path}")
-          else
-            path = (index + [i]).join("/")
-            data = run_path(output.run_id) + "/output/#{output.name}/#{path}"
-          end
-          content += TavernaPlayer.output_renderer.render(data, type)
-          content += "</p></li>"
-        end
-        i += 1
-      end
-
-      raw(content += "</ol>")
-    end
-
   end
 end

data/app/models/taverna_player/run_port.rb

@@ -40,8 +40,40 @@ module TavernaPlayer
     # :method: value
     # :call-seq:
     #   value -> string
+    #   value(indices) -> string
     #
-    # Return the value held in this port if there is one.
+    # Return the value held in this port if there is one. Pass in a list of
+    # indices if it is a list port.
+    #
+    # For a port of depth 0:
+    #
+    #  value = output.value
+    #
+    # For a port of depth 2:
+    #
+    #  value = output.value(0, 0)
+    #  value = output.value([1, 2])
+    #
+    # Trying to get a list value out of a port of depth 0 will simply return
+    # the port's value.
+
+    ##
+    # :method: path
+    # :call-seq:
+    #   path -> string
+    #   path(indices) -> string
+    #
+    # Return a url path segment that addresses this output value. Pass in a
+    # list of indices if it is a list port.
+    #
+    # For a port of depth 0 called "OUT":
+    #
+    #  path = output.path # => "/runs/1/output/OUT"
+    #
+    # For a port of depth 2 called "OUT_LIST":
+    #
+    #  path = output.path(0, 0) # => "runs/1/output/OUT_LIST/0/0"
+    #  path = output.path([1, 2]) # => "runs/1/output/OUT_LIST/1/2"
 
     ##
     # :method: metadata

data/app/views/taverna_player/runs/_outputs.html.erb

@@ -26,7 +26,7 @@
         <b>Value:</b>
         <%= "(#{output.metadata[:type]})" if output.depth == 0 %>
         <%= link_to "Download", run_path(run) + "/download/output/#{output.name}" %>
-        <%= show_output(run, output) %>
+        <%= TavernaPlayer.port_renderer.render(output) %>
       </p>
 
     <% end%>

data/app/views/taverna_player/runs/embedded/_outputs.html.erb

@@ -24,7 +24,7 @@
 
       <p>
         <b>Value:</b>
-        <%= show_output(run, output) %>
+        <%= TavernaPlayer.port_renderer.render(output) %>
       </p>
 
     <% end%>

data/lib/generators/taverna_player/install_generator.rb

@@ -22,7 +22,7 @@ module TavernaPlayer
           "config/initializers/taverna_player.rb"
 
         copy_file "server_initializer.rb",
-          "config/initializers/taverna_server.example.rb"
+          "config/initializers/taverna_server.rb.example"
       end
 
       def show_readme

data/lib/generators/templates/ReadMe.txt

@@ -111,9 +111,9 @@ There is also some manual setup to do, if you haven't already done it:
      They will be saved to "lib/taverna_player_callbacks.rb". Don't forget to
      then require and register them in the Taverna Player initializer.
 
- 11. You can add to, or change, the workflow run outputs render methods to
-     better suit your particular application. To copy the defaults that
-     Taverna Player ships with into your application for customization run:
+ 11. You can add to, or change, the workflow port render methods to better
+     suit your particular application. To copy the defaults that Taverna
+     Player ships with into your application for customization run:
 
        rails generate taverna_player:renderers
 

data/lib/generators/templates/callbacks/render_callbacks.rb

@@ -16,41 +16,69 @@
 # defaults automatically.
 #
 # Each method MUST accept two parameters:
-#  * The first (content) is what will be rendered. In the case of a text/*
-#    type output this will be the actual text. In the case of anything else
-#    this will be a path to the object to be linked to.
-#  * The second (type) is the MIME type of the output as a string. This allows
-#    a single method to handle multiple types or sub-types if needed.
+#  * The first (port) is the port to be rendered.
+#  * The second (index) is the index into the port. For singleton ports this
+#    will be the empty list.
 #
 # Note that you can use most of the ActiveView Helpers here as global methods
 # but the image_tag() method does not work as explained below.
 
-def format_text(content, type)
+def format_text(port, index = [])
   # Use CodeRay to format text so that newlines are respected.
-  content = CodeRay.scan(content, :text).div(:css => :class)
+  content = CodeRay.scan(port.value(index), :text).div(:css => :class)
 
   # Use auto_link to turn URI-like text into links.
   auto_link(content, :html => { :target => '_blank' }, :sanitize => false)
 end
 
-def format_xml(content, type)
+def format_xml(port, index = [])
   # Make sure XML is indented consistently.
   out = String.new
-  REXML::Document.new(content).write(out, 1)
+  REXML::Document.new(port.value(index)).write(out, 1)
   CodeRay.scan(out, :xml).div(:css => :class, :line_numbers => :table)
 end
 
-def show_image(content, type)
+def show_image(port, index = [])
   # Can't use image_tag() here because the image doesn't really exist (it's in
   # a zip file, really) and this confuses the Rails asset pipeline.
-  tag("img", :src => content)
+  tag("img", :src => port.path(index))
 end
 
-def workflow_error(content, type)
-  link_to("This output is a workflow error.", content)
+def workflow_error(port, index = [])
+  link_to("This output is a workflow error.", port.path(index))
 end
 
-def cannot_inline(content, type)
+def cannot_inline(port, index = [])
   "Sorry but we cannot show this type of content in the browser. Please " +
-   link_to("download it", content) + " to view it on your local machine."
+   link_to("download it", port.path(index)) + " to view it on " +
+   "your local machine."
+end
+
+# Rendering an empty port has no need of the index parameter.
+def empty_port(port, _)
+  "<div>&lt;empty port&gt;</div>"
+end
+
+# Rendering a list port requires recursion. In this implementation an extra
+# parameter (types) is added to drive the recursion; we can't just keep track
+# of depth because we need to know the length of each sub-list - and types can
+# be used to pass that through for us.
+def list_port(port, index = [], types = nil)
+  types = port.metadata[:type] if types.nil?
+
+  content = "<ol>"
+  i = 0
+  types.each do |type|
+    if type.is_a?(Array)
+      content += "<li><br />" +
+      list_port(port, index + [i], type) + "</li>"
+    else
+      content += "<li>(#{type})<p>" +
+        TavernaPlayer.port_renderer.render(port, index + [i]) +
+        "</p></li>"
+    end
+    i += 1
+  end
+
+  content += "</ol>"
 end

data/lib/generators/templates/player_initializer.rb

@@ -79,22 +79,22 @@ TavernaPlayer.setup do |config|
   #config.run_failed_callback = "player_run_failed_callback"
   #config.run_failed_callback = :player_run_failed_callback
 
-  # Callbacks to be run to render various types of workflow output. These can
-  # be defined as Proc objects or as methods and referenced by name.
+  # Callbacks to be run to render various types of workflow port. These can be
+  # defined as Proc objects or as methods and referenced by name.
   #
   # Be careful! If a callback fails then users will see an Internal Server
-  # Error (HTTP status code 500) instead of their run outputs!
+  # Error (HTTP status code 500) instead of their run inputs and/or outputs!
   #
   # Add callbacks in this initializer or define them elsewhere and require the
   # file as usual (if they are not pulled in by some other code). You can
-  # create example stub callbacks using:
+  # create example callbacks using:
   #   "rails generate taverna_player:renderers"
   # which will put them in "lib/taverna_player_renderers.rb".
   #require "taverna_player_renderers"
 
-  # Renderers for each type of output (referenced by MIME type) must then be
+  # Renderers for each type of value (referenced by MIME type) must then be
   # registered. All the renderers shown below are supplied as defaults.
-  #config.output_renderers do |renderers|
+  #config.port_renderers do |renderers|
     # Set a default renderer for if there is a workflow type that browsers
     # can't otherwise handle.
     #renderers.default(:cannot_inline)
@@ -104,7 +104,7 @@ TavernaPlayer.setup do |config|
     # aren't otherwise registered.
     #renderers.add("text/plain", :format_text, true)
 
-    # This renderer overrides the default text/* renderer for text/xml outputs.
+    # This renderer overrides the default text/* renderer for text/xml values.
     #renderers.add("text/xml", :format_xml)
 
     # Browsers can't show all image types so just register very common ones.
@@ -116,6 +116,10 @@ TavernaPlayer.setup do |config|
     # This is the workflow error type and you should have a special renderer
     # for it.
     #renderers.add("application/x-error", :workflow_error)
+
+    # If your workflows have list outputs (probable) then something to render
+    # lists is also needed.
+    #renderers.list(:list_port)
   #end
 end
 

data/lib/taverna-player.rb

@@ -69,29 +69,30 @@ module TavernaPlayer
   mattr_accessor :current_user_callback
   @@current_user_callback = nil
 
-  # Setup default output render callbacks.
-  mattr_reader :output_renderer
-  @@output_renderer = OutputRenderer.new
-  @@output_renderer.default(:cannot_inline_tp_default)
-  @@output_renderer.add("text/plain", :format_text_tp_default, true)
-  @@output_renderer.add("text/xml", :format_xml_tp_default)
-  @@output_renderer.add("image/jpeg", :show_image_tp_default)
-  @@output_renderer.add("image/png", :show_image_tp_default)
-  @@output_renderer.add("image/gif", :show_image_tp_default)
-  @@output_renderer.add("image/bmp", :show_image_tp_default)
-  @@output_renderer.add("application/x-error", :workflow_error_tp_default)
-  @@output_renderer.add("application/x-empty", :empty_tp_default)
-  @@output_renderer.add("inode/x-empty", :empty_tp_default)
+  # Setup default port render callbacks.
+  mattr_reader :port_renderer
+  @@port_renderer = PortRenderer.new
+  @@port_renderer.default(:cannot_inline_tp_default)
+  @@port_renderer.list(:list_tp_default)
+  @@port_renderer.add("text/plain", :format_text_tp_default, true)
+  @@port_renderer.add("text/xml", :format_xml_tp_default)
+  @@port_renderer.add("image/jpeg", :show_image_tp_default)
+  @@port_renderer.add("image/png", :show_image_tp_default)
+  @@port_renderer.add("image/gif", :show_image_tp_default)
+  @@port_renderer.add("image/bmp", :show_image_tp_default)
+  @@port_renderer.add("application/x-error", :workflow_error_tp_default)
+  @@port_renderer.add("application/x-empty", :empty_tp_default)
+  @@port_renderer.add("inode/x-empty", :empty_tp_default)
 
   # :call-seq:
-  #   output_renderers {|renderer| ...}
+  #   port_renderers {|renderer| ...}
   #
   # Set up the renderers for each MIME type that you want to be able to show
   # in the browser. In most cases the supplied defaults will be sufficient.
   #
   # See the taverna_player initializer for more information.
-  def self.output_renderers
-    yield @@output_renderer if block_given?
+  def self.port_renderers
+    yield @@port_renderer if block_given?
   end
 
   # Path to place where files should be stored.

data/lib/taverna_player/concerns/callback.rb

@@ -0,0 +1,29 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+  module Concerns
+    module Callback
+
+      extend ActiveSupport::Concern
+
+      def callback(cb, *params)
+        if cb.is_a? Proc
+          cb.call(*params)
+        else
+          method(cb).call(*params)
+        end
+      end
+
+    end
+  end
+end

data/lib/taverna_player/concerns/controllers/runs_controller.rb

@@ -17,6 +17,9 @@ module TavernaPlayer
 
         extend ActiveSupport::Concern
 
+        include TavernaPlayer::Concerns::Callback
+        include TavernaPlayer::Concerns::Utils
+
         included do
           respond_to :html, :json, :js
 
@@ -55,7 +58,7 @@ module TavernaPlayer
             return if params[:run][:embedded] == "true" || TavernaPlayer.user_proxy.nil?
 
             unless TavernaPlayer.current_user_callback.blank?
-              user = method(TavernaPlayer.current_user_callback).call
+              user = callback(TavernaPlayer.current_user_callback)
               params[:run][:user_id] = user.id unless user.nil?
             end
           end
@@ -76,13 +79,6 @@ module TavernaPlayer
             end
           end
 
-          # This is here because of Taverna's infinitely deep output ports :-(
-          def recurse_into_lists(list, indexes)
-            return list if indexes.empty? || !list.is_a?(Array)
-            i = indexes.shift
-            return recurse_into_lists(list[i], indexes)
-          end
-
           # Choose a layout for the page depending on action and embedded status.
           def choose_layout
             if (action_name == "new" || action_name == "show") && @run.embedded?

data/lib/taverna_player/concerns/models/run_port.rb

@@ -77,6 +77,17 @@ module TavernaPlayer
             end
           end
 
+          def deep_value(index)
+            path = index.map { |j| j += 1 }.join("/")
+
+            data = String.new
+            Zip::ZipFile.open(file.path) do |zip|
+              data = zip.read("#{path}")
+            end
+
+            data
+          end
+
         end # included
 
         def display_name
@@ -87,10 +98,20 @@ module TavernaPlayer
           self[:value]
         end
 
-        def value
-          v = self[:value]
+        def value(*indices)
+          if depth == 0
+            v = self[:value]
+
+            (!v.blank? && !file.path.blank?) ? File.read(file.path) : v
+          else
+            deep_value([*indices].flatten)
+          end
+        end
 
-          (!v.blank? && !file.path.blank?) ? File.read(file.path) : v
+        def path(*indices)
+          index = [*indices].flatten
+          path = index.empty? ? "" : "/" + index.join("/")
+          file_url_via_run + path
         end
 
       end

data/lib/taverna_player/concerns/utils.rb

@@ -0,0 +1,30 @@
+#------------------------------------------------------------------------------
+# Copyright (c) 2013 The University of Manchester, UK.
+#
+# BSD Licenced. See LICENCE.rdoc for details.
+#
+# Taverna Player was developed in the BioVeL project, funded by the European
+# Commission 7th Framework Programme (FP7), through grant agreement
+# number 283359.
+#
+# Author: Robert Haines
+#------------------------------------------------------------------------------
+
+module TavernaPlayer
+  module Concerns
+    module Utils
+
+      extend ActiveSupport::Concern
+
+      # Taverna can have arbitrary (therefore effectively "infinite") port
+      # depths so we need to recurse into them. This code is common across a
+      # number of other modules.
+      def recurse_into_lists(list, indexes)
+        return list if indexes.empty? || !list.is_a?(Array)
+        i = indexes.shift
+        recurse_into_lists(list[i], indexes)
+      end
+
+    end
+  end
+end

data/lib/taverna_player/{output_renderer.rb → port_renderer.rb}

@@ -12,14 +12,17 @@
 
 module TavernaPlayer
 
-  # This class manages the rendering of many different output types that could
-  # be produced by a workflow. It can be configured with new types and the
+  # This class manages the rendering of many different port types that could
+  # be associated with a workflow. It can be configured with new types and the
   # example renderers for each type can also be changed. An example of how to
   # set it up can be found in the taverna_player initializer.
   #
   # Each renderer has all of the ActionView::Helpers (such as link_to, tag,
   # etc) available to them.
-  class OutputRenderer
+  class PortRenderer
+    include TavernaPlayer::Concerns::Callback
+    include TavernaPlayer::Concerns::Utils
+
     # The renderers are all called in the scope of this class so we include
     # ActionView::Helpers here so that they are all available to them.
     include ActionView::Helpers
@@ -75,21 +78,30 @@ module TavernaPlayer
     end
 
     # :call-seq:
-    #   render(content, mimetype) -> markup
+    #   list(method)
     #
-    # This is the method that calls the correct renderer for the given content
-    # with the given MIME type and returns the resultant rendering.
-    def render(content, mimetype)
-      type = MIME::Types[mimetype].first
-
-      renderer = @hash[type.media_type][type.sub_type] ||
-        @hash[type.media_type][:default] || @hash[:default]
+    # Set a renderer to handle list ports. This will typically format the
+    # list somehow and render the list items with further calls to
+    # TavernaPlayer.port_renderer.render.
+    def list(method)
+      @hash[:list] = method
+    end
 
-      if renderer.is_a? Proc
-        renderer.call(content, type)
+    # :call-seq:
+    #   render(port) -> markup
+    #
+    # This is the method that calls the correct renderer for the given port
+    # and returns the resultant rendering.
+    def render(port, index = [])
+      if port.depth > 0 && index.empty?
+        renderer = @hash[:list]
       else
-        method(renderer).call(content, type)
+        type = MIME::Types[recurse_into_lists(port.metadata[:type], index.dup)].first
+        renderer = @hash[type.media_type][type.sub_type] ||
+          @hash[type.media_type][:default] || @hash[:default]
       end
+
+      raw(callback(renderer, port, index))
     end
 
   end

data/lib/taverna_player/render_callbacks.rb

@@ -10,32 +10,53 @@
 # Author: Robert Haines
 #------------------------------------------------------------------------------
 
-def format_text_tp_default(content, type)
-  content = CodeRay.scan(content, :text).div(:css => :class)
+def format_text_tp_default(port, index = [])
+  content = CodeRay.scan(port.value(index), :text).div(:css => :class)
   auto_link(content, :html => { :target => '_blank' }, :sanitize => false)
 end
 
-def format_xml_tp_default(content, type)
+def format_xml_tp_default(port, index = [])
   out = String.new
-  REXML::Document.new(content).write(out, 1)
+  REXML::Document.new(port.value(index)).write(out, 1)
   CodeRay.scan(out, :xml).div(:css => :class, :line_numbers => :table)
 end
 
-def show_image_tp_default(content, type)
+def show_image_tp_default(port, index = [])
   # Can't use image_tag() here because the image doesn't really exist (it's in
   # a zip file, really) and this confuses the Rails asset pipeline.
-  tag("img", :src => content)
+  tag("img", :src => port.path(index))
 end
 
-def workflow_error_tp_default(content, type)
-  link_to("This output is a workflow error.", content)
+def workflow_error_tp_default(port, index = [])
+  link_to("This output is a workflow error.", port.path(index))
 end
 
-def cannot_inline_tp_default(content, type)
+def cannot_inline_tp_default(port, index = [])
   "Sorry but we cannot show this type of content in the browser. Please " +
-   link_to("download it", content) + " to view it on your local machine."
+   link_to("download it", port.path(index)) + " to view it on " +
+   "your local machine."
 end
 
-def empty_tp_default(content, type)
-  "<div>&lt;empty output&gt;</div>"
+def empty_tp_default(port, _)
+  "<div>&lt;empty port&gt;</div>"
+end
+
+def list_tp_default(port, index = [], types = nil)
+  types = port.metadata[:type] if types.nil?
+
+  content = "<ol>"
+  i = 0
+  types.each do |type|
+    if type.is_a?(Array)
+      content += "<li><br />" +
+      list_tp_default(port, index + [i], type) + "</li>"
+    else
+      content += "<li>(#{type})<p>" +
+        TavernaPlayer.port_renderer.render(port, index + [i]) +
+        "</p></li>"
+    end
+    i += 1
+  end
+
+  content += "</ol>"
 end

data/lib/taverna_player/version.rb

@@ -11,5 +11,5 @@
 #------------------------------------------------------------------------------
 
 module TavernaPlayer
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/taverna_player/worker.rb

@@ -12,6 +12,7 @@
 
 module TavernaPlayer
   class Worker
+    include TavernaPlayer::Concerns::Callback
 
     # How to get the interaction presentation frame out of the interaction page.
     INTERACTION_REGEX = /document\.getElementById\(\'presentationFrame\'\)\.src = \"(.+)\";/
@@ -29,7 +30,7 @@ module TavernaPlayer
     def perform
       unless TavernaPlayer.pre_run_callback.nil?
         status_message "Running pre-run tasks"
-        run_callback(TavernaPlayer.pre_run_callback, @run)
+        callback(TavernaPlayer.pre_run_callback, @run)
       end
 
       status_message "Connecting to Taverna Server"
@@ -192,7 +193,7 @@ module TavernaPlayer
 
         unless TavernaPlayer.run_failed_callback.nil?
           status_message "Running post-failure tasks"
-          run_callback(TavernaPlayer.run_failed_callback, @run)
+          callback(TavernaPlayer.run_failed_callback, @run)
         end
 
         backtrace = exception.backtrace.join("\n")
@@ -206,7 +207,7 @@ module TavernaPlayer
 
       unless TavernaPlayer.post_run_callback.nil?
         status_message "Running post-run tasks"
-        run_callback(TavernaPlayer.post_run_callback, @run)
+        callback(TavernaPlayer.post_run_callback, @run)
       end
 
       @run.state = :finished
@@ -215,14 +216,6 @@ module TavernaPlayer
 
     private
 
-    def run_callback(callback, *params)
-      if callback.is_a? Proc
-        callback.call(*params)
-      else
-        method(callback).call(*params)
-      end
-    end
-
     def download_log(run)
       Dir.mktmpdir(run.id, Rails.root.join("tmp")) do |tmp_dir|
         tmp_file_name = File.join(tmp_dir, "log.txt")
@@ -313,7 +306,7 @@ module TavernaPlayer
 
       unless TavernaPlayer.run_cancelled_callback.nil?
         status_message "Running post-cancel tasks"
-        run_callback(TavernaPlayer.run_cancelled_callback, @run)
+        callback(TavernaPlayer.run_cancelled_callback, @run)
       end
 
       @run.state = :cancelled

data/test/functional/taverna_player/runs_controller_test.rb

@@ -38,22 +38,27 @@ module TavernaPlayer
     end
 
     test "should route to a run output" do
-      assert_routing "/runs/1/output/OUT",
+      assert_routing @run2.outputs[0].path,
         { :controller => "taverna_player/runs", :action => "output",
-          :id => "1", :port => "OUT" }, {}, {}, "Did not route correctly"
+          :id => "2", :port => "OUT" }, {}, {}, "Did not route correctly"
     end
 
     test "should route to a deep run output" do
-      assert_routing "/runs/1/output/OUT/0/0",
+      assert_routing @run2.outputs[0].path(0, 0),
         { :controller => "taverna_player/runs", :action => "output",
-          :id => "1", :port => "OUT", :path => "0/0" }, {}, {},
+          :id => "2", :port => "OUT", :path => "0/0" }, {}, {},
+        "Did not route correctly"
+
+      assert_routing @run2.outputs[0].path([1, 2]),
+        { :controller => "taverna_player/runs", :action => "output",
+          :id => "2", :port => "OUT", :path => "1/2" }, {}, {},
         "Did not route correctly"
     end
 
     test "should route to a run input" do
-      assert_routing "/runs/1/input/IN",
+      assert_routing @run3.inputs[0].path,
         { :controller => "taverna_player/runs", :action => "input",
-          :id => "1", :port => "IN" }, {}, {}, "Did not route correctly"
+          :id => "3", :port => "IN_Value" }, {}, {}, "Did not route correctly"
     end
 
     test "should route to cancel on a run" do

data/test/unit/helpers/taverna_player/runs_helper_test.rb

@@ -14,32 +14,6 @@ require 'test_helper'
 
 module TavernaPlayer
   class RunsHelperTest < ActionView::TestCase
-    setup do
-      @run1 = taverna_player_runs(:one)
-      @port1 = taverna_player_run_ports(:one)
 
-      @run2 = taverna_player_runs(:three)
-      @port2 = taverna_player_run_ports(:four)
-
-      @run3 = taverna_player_runs(:four)
-      @port3 = taverna_player_run_ports(:five)
-    end
-
-    test "should show text outputs" do
-      assert_equal "Hello, World!", @port1.value, "Unexpected workflow output"
-      assert show_output(@run1, @port1).include?("<pre>Hello, World!</pre>"),
-        "Workflow output not formatted correctly"
-
-      assert_equal "Rob", @port2.value, "Unexpected workflow output"
-      assert show_output(@run2, @port2).include?("<pre>Rob</pre>"),
-        "Workflow output not formatted correctly"
-    end
-
-    test "should autolink text output" do
-      assert_equal "(http://example.com/path?query=1)", @port3.value,
-        "Unexpected workflow output"
-      assert show_output(@run3, @port3).include?("(<a href=\"http://example.com/path?query=1\" target=\"_blank\">http://example.com/path?query=1</a>)"),
-        "Workflow output not formatted correctly"
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taverna-player
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-30 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -331,15 +331,17 @@ files:
 - lib/tasks/delete-cancelled-runs.rake
 - lib/tasks/delete-old-embedded-runs.rake
 - lib/taverna-player.rb
+- lib/taverna_player/concerns/callback.rb
 - lib/taverna_player/concerns/controllers/runs_controller.rb
 - lib/taverna_player/concerns/controllers/service_credentials_controller.rb
 - lib/taverna_player/concerns/models/input_port.rb
 - lib/taverna_player/concerns/models/output_port.rb
 - lib/taverna_player/concerns/models/run.rb
 - lib/taverna_player/concerns/models/run_port.rb
+- lib/taverna_player/concerns/utils.rb
 - lib/taverna_player/engine.rb
 - lib/taverna_player/model_proxy.rb
-- lib/taverna_player/output_renderer.rb
+- lib/taverna_player/port_renderer.rb
 - lib/taverna_player/render_callbacks.rb
 - lib/taverna_player/version.rb
 - lib/taverna_player/worker.rb
@@ -373,7 +375,7 @@ files:
 - test/dummy/config/initializers/secret_token.rb
 - test/dummy/config/initializers/session_store.rb
 - test/dummy/config/initializers/taverna_player.rb
-- test/dummy/config/initializers/taverna_server.example.rb
+- test/dummy/config/initializers/taverna_server.rb.example
 - test/dummy/config/initializers/wrap_parameters.rb
 - test/dummy/config/locales/en.yml
 - test/dummy/config/routes.rb
@@ -454,7 +456,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3999716263175930370
+      hash: 1554949292676939893
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -463,7 +465,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3999716263175930370
+      hash: 1554949292676939893
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.21
@@ -498,7 +500,7 @@ test_files:
 - test/dummy/config/initializers/secret_token.rb
 - test/dummy/config/initializers/session_store.rb
 - test/dummy/config/initializers/taverna_player.rb
-- test/dummy/config/initializers/taverna_server.example.rb
+- test/dummy/config/initializers/taverna_server.rb.example
 - test/dummy/config/initializers/wrap_parameters.rb
 - test/dummy/config/locales/en.yml
 - test/dummy/config/routes.rb