ruote 0.9.19 → 0.9.20

data/lib/openwfe/{storage/yamlfilestorage.rb → participants/yaml_filestorage.rb}

@@ -1,42 +1,27 @@
-#
 #--
-# Copyright (c) 2006-2008, Nicolas Modryzk and John Mettraux, OpenWFE.org
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
+# Copyright (c) 2006-2009, Nicolas Modryzk and John Mettraux, OpenWFE.org
 #
-# . Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
 #
-# . Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
 #
-# . Neither the name of the "OpenWFE" nor the names of its contributors may be
-#   used to endorse or promote products derived from this software without
-#   specific prior written permission.
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
 #
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
+# Made in Japan.
 #++
-#
 
-#
-# "made in Japan"
-#
-# Nicolas Modrzyk at openwfe.org
-# John Mettraux at openwfe.org
-#
 
 require 'find'
 require 'yaml'
@@ -46,13 +31,6 @@ require 'fileutils'
 require 'openwfe/utils'
 require 'openwfe/service'
 
-require 'openwfe/expressions/flowexpression'
-  #--
-  # making sure classes in those files are loaded
-  # before their yaml persistence is tuned
-  # (else the reopening of the class is interpreted as
-  # a definition of the class...)
-  #++
 
 module OpenWFE
 
@@ -60,9 +38,10 @@ module OpenWFE
   # Stores OpenWFEru related objects into yaml encoded files.
   # This storage is meant to look and feel like a Hash.
   #
+  # DEPRECATED
+  #
   class YamlFileStorage
     include ServiceMixin
-    #include MonitorMixin
 
     #
     # The root path for this file persistence mecha.
@@ -76,7 +55,7 @@ module OpenWFE
       service_init(service_name, application_context)
 
       @basepath = get_work_directory + path
-      @basepath += "/" unless @basepath[-1, 1] == "/"
+      @basepath += '/' if @basepath[-1, 1] != '/'
 
       FileUtils.makedirs @basepath
     end
@@ -85,31 +64,25 @@ module OpenWFE
     # Stores an object with its FlowExpressionId instance as its key.
     #
     def []= (fei, object)
-      #synchronize do
 
       #linfo { "[]= #{fei}" }
 
-      fei_path = compute_file_path fei
+      fei_path = compute_file_path(fei)
 
-      fei_parent_path = File.dirname fei_path
+      fei_parent_path = File.dirname(fei_path)
 
       FileUtils.makedirs(fei_parent_path) \
         unless File.exist?(fei_parent_path)
 
-      File.open(fei_path, "w") do |file|
-        YAML.dump object, file
-      end
-      #end
+      File.open(fei_path, 'w') { |file| YAML.dump(object, file) }
     end
 
     #
     # Deletes the whole storage directory... beware...
     #
     def purge
-      #synchronize do
 
-      FileUtils.remove_dir @basepath
-      #end
+      FileUtils.remove_dir(@basepath)
     end
 
     #
@@ -126,14 +99,12 @@ module OpenWFE
     # instance.
     #
     def delete (fei)
-      #synchronize do
 
-      fei_path = compute_file_path fei
+      fei_path = compute_file_path(fei)
 
-      ldebug { "delete()\n  for #{fei.to_debug_s}\n  at #{fei_path}" }
+      #ldebug { "delete() for #{fei.to_debug_s} at #{fei_path}" }
 
-      File.delete fei_path
-      #end
+      File.delete(fei_path)
     end
 
     #
@@ -172,7 +143,7 @@ module OpenWFE
         object = YAML.load_file(path)
 
         object.application_context = @application_context \
-          if object.respond_to? :application_context=
+          if object.respond_to?(:application_context=)
 
         object
       end
@@ -189,7 +160,7 @@ module OpenWFE
           next unless File.exist? path
           next if File.stat(path).directory?
 
-          count += 1 if OpenWFE::ends_with(path, ".yaml")
+          count += 1 if path[-5..-1] == '.yaml'
         end
 
         count
@@ -199,18 +170,17 @@ module OpenWFE
       # Passes each object path to the given block
       #
       def each_object_path (path=@basepath, &block)
-        #synchronize do
 
         Find.find(path) do |p|
 
           next unless File.exist?(p)
           next if File.stat(p).directory?
-          next unless OpenWFE::ends_with(p, ".yaml")
+          #next unless OpenWFE::ends_with(p, '.yaml')
+          next if p[-5..-1] != '.yaml'
 
-          ldebug { "each_object_path() considering #{p}" }
-          block.call p
+          #ldebug { "each_object_path() considering #{p}" }
+          block.call(p)
         end
-        #end
       end
 
       #
@@ -219,7 +189,7 @@ module OpenWFE
       def each_object (&block)
 
         each_object_path do |path|
-          block.call load_object(path)
+          block.call(load_object(path))
         end
       end
 
@@ -237,6 +207,7 @@ module OpenWFE
         # be provided by extending classes.
         #
         def compute_file_path (object)
+
           raise NotImplementedError.new
         end
 

data/lib/openwfe/representations.rb

@@ -0,0 +1,770 @@
+#--
+# Copyright (c) 2008-2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'openwfe/workitem'
+require 'openwfe/expool/errorjournal'
+require 'openwfe/engine/status_methods'
+require 'openwfe/expressions/flowexpression'
+require 'openwfe/util/xml'
+require 'openwfe/util/json'
+
+
+module OpenWFE
+
+  #
+  # Swaps from dots to underscores
+  #
+  #   swapdots "0_0_1" # => "0.0.1"
+  #
+  #   swapdots "0.0.1" # => "0_0_1"
+  #
+  def self.swapdots (s)
+
+    s.index('.') ? s.gsub(/\./, '_') : s.gsub(/\_/, '.')
+  end
+
+  #
+  # a 'plain' implementation of a link generator
+  #
+  # TODO : what about inserting service links (main menu) ?
+  #
+  class PlainLinkGenerator
+
+    def links (item, hint)
+
+      #p [ 0, item.class, hint ]
+
+      key_class = item.class
+      content = if item.respond_to?(:first)
+        item.first
+      elsif item.respond_to?(:values)
+        item.values.first
+      end
+
+      content_class = content ? content.class : hint
+
+      key_class = flatten_class(key_class)
+      content_class = flatten_class(content_class)
+
+      key_class = [ key_class, content_class ] if content_class
+
+      #p [ 1, key_class, GENS[key_class] ]
+
+      method = GENS[key_class] || (return [])
+
+      send(method, item)
+    end
+
+    #
+    # Override me (message to ruote-rest and ruote-web2)
+    #
+    # (Warning : this method turns dots to underscores in the id)
+    #
+    def link (rel, res, opts={})
+
+      id = nil
+      if opts.is_a?(Hash)
+        id = opts.delete(:id)
+      else
+        id = opts
+        opts = {}
+      end
+
+      href = "/#{res}"
+
+      href = "#{href}/#{OpenWFE.swapdots(id)}" if id
+
+      href = "#{href}?#{opts.collect { |k, v| "#{k}=#{v}" }.join('&')}" \
+        if opts.size > 0
+
+      [ href, rel ]
+    end
+
+    #
+    # Calls link() and converts its result from array to hash
+    # { 'href' => x, 'rel' => y }
+    #
+    def hlink (rel, res, id=nil)
+
+      l = link(rel, res, id)
+      { 'href' => l[0], 'rel' => l[1] }
+    end
+
+    def insert_links (item, options, target, hint)
+
+      links(item, hint).each do |href, rel|
+
+        do_insert_link(target, options, href, rel)
+      end
+
+      target
+    end
+
+    protected
+
+    def do_insert_link (target, options, href, rel)
+
+      atts = { 'href' => href, 'rel' => rel }
+
+      if options[:builder] # target is xml
+        target.link(atts)
+      else # target is a Hash
+        (target['links'] ||= []) << atts
+      end
+
+      target
+    end
+
+    def flatten_class (c)
+
+      return c unless c.is_a?(Class)
+
+      c.ancestors.each do |a|
+        return a if [ Array, Hash, OpenWFE::FlowExpression ].include?(a)
+      end
+
+      return OpenWFE::ProcessError if c.to_s.downcase.match(/processerror/)
+        # OpenWFE::Extras::ProcessError...
+
+      return OpenWFE::InFlowWorkItem if c.to_s.downcase.match(/workitem/)
+        # OpenWFE::Extras::Workitem...
+
+      c
+    end
+
+    #
+    # some kind of 'case'
+    #
+    GENS = {
+      OpenWFE::InFlowWorkItem => 'workitem',
+      [ Array, OpenWFE::InFlowWorkItem ] => 'workitems',
+      OpenWFE::ProcessStatus => 'process',
+      [ Array, OpenWFE::ProcessStatus ] => 'processes',
+      [ Hash, OpenWFE::ProcessStatus ] => 'processes',
+      OpenWFE::FlowExpression => 'expression',
+      [ Array, OpenWFE::FlowExpression ] => 'expressions',
+      #[ Hash, OpenWFE::FlowExpression ] => 'expressions',
+      OpenWFE::ProcessError => 'error',
+      [ Array, OpenWFE::ProcessError ] => 'errors',
+      [ Hash, OpenWFE::ProcessError ] => 'errors',
+
+      [ OpenWFE::FlowExpressionId, :environment ] => 'to_environment',
+      [ OpenWFE::FlowExpressionId, :child ] => 'to_child',
+      [ OpenWFE::FlowExpressionId, :parent ] => 'to_parent'
+    }
+
+    #
+    # generate the links for a given item
+    #
+    def gen_links (res, item, &block)
+
+      if block # unique element
+
+        [ link('via', res), link('self', res, block.call(item)) ]
+
+      elsif item.respond_to?(:current_page) and item.total_pages > 1
+
+        a = [
+          link('via', ''),
+          link('self', res, 'page' => item.current_page)
+        ]
+        a << link('prev', res, 'page' => item.current_page - 1) \
+          if item.current_page > 1
+        a << link('next', res, 'page' => item.current_page + 1) \
+          if item.current_page < item.total_pages
+        a
+
+      else # collection
+
+        [ link('via', ''), link('self', res) ]
+      end
+    end
+
+    def workitem (item)
+      gen_links('workitems', item) { |i| "#{i.fei.wfid}/#{i.fei.expid}" }
+    end
+    def workitems (item)
+      gen_links('workitems', item)
+    end
+
+    def process (item)
+      gen_links('processes', item) { |i| i.wfid } +
+      [ link('related', 'processes', "#{item.wfid}/tree") ]
+    end
+    def processes (item)
+      gen_links('processes', item)
+    end
+
+    def error (item)
+      gen_links('errors', item) { |i| "#{i.fei.wfid}/#{i.fei.expid}" }
+    end
+    def errors (item)
+      gen_links('errors', item)
+    end
+
+    # all about expressions...
+
+    def expression_id (item)
+
+      fei = item.fei
+
+      e = (
+        item.is_a?(OpenWFE::Environment) ||
+        OpenWFE::Environment.expression_names.include?(fei.expname)
+      ) ? 'e' : ''
+
+      "#{fei.wfid}/#{fei.expid}#{e}"
+    end
+
+    def expression (item)
+      gen_links('expressions', item) { |fexp| expression_id(fexp) }
+    end
+    def expressions (item)
+      gen_links('expressions', item)
+    end
+
+    def to_environment (env)
+      [ link('environment_expression', 'expressions', expression_id(env)) ]
+    end
+    def to_parent (par)
+      [ link('parent_expression', 'expressions', expression_id(par)) ]
+    end
+    def to_child (child)
+      [ link('child_expression', 'expressions', expression_id(child)) ]
+    end
+  end
+
+  def self.rep_insert_link (item, options, target, rel_symbol)
+
+    rep.insert_links(item, options, target, rel_symbol)
+  end
+
+  def self.rep_insert_links (item, options, target, hint=nil)
+
+    lgen = options[:linkgen] || (return target)
+    lgen = PlainLinkGenerator.new if lgen == :plain
+
+    lgen.insert_links(item, options, target, hint)
+  end
+
+  #
+  # (don't use directly)
+  #
+  def Json.collection_to_h (col, opts, hint, &block)
+
+    elts = col.collect(&block)
+
+    return elts if opts[:nometa]
+
+    OpenWFE.rep_insert_links(col, opts, { 'elements' => elts }, hint)
+  end
+
+  #
+  # (don't use directly)
+  #
+  def Xml.collection_to_xml (tag, col, opts, hint, &block)
+
+    builder(opts) do |xml|
+
+      xml.tag!(tag, :count => col.size) do
+
+        OpenWFE.rep_insert_links(col, opts, xml, hint)
+
+        col.each(&block)
+      end
+    end
+  end
+
+  #--
+  # launchitems
+  #++
+
+  #
+  # Turns a launchitem into an XML String
+  #
+  def Xml.launchitem_to_xml (li, options={})
+
+    builder(options) do |xml|
+      xml.launchitem do
+        xml.workflow_definition_url(li.workflow_definition_url)
+        xml.attributes do
+          hash_to_xml(li.attributes, options)
+        end
+      end
+    end
+  end
+
+  #
+  # Given some XML (string or rexml doc/elt), extracts the LaunchItem
+  # instance.
+  #
+  # (getting tolerant, also accepting <process/> representations)
+  #
+  def Xml.launchitem_from_xml (xml)
+
+    li = LaunchItem.new
+
+    root =
+      to_element(xml, 'launchitem') ||
+      to_element(xml, 'process')
+
+    li.wfdurl =
+      text(root, 'workflow_definition_url') ||
+      text(root, 'definition_url')
+
+    attributes =
+      root.owfe_first_elt_child('attributes') ||
+      root.owfe_first_elt_child('fields')
+
+    li.attributes = attributes ?
+      object_from_xml(attributes.owfe_first_elt_child) : {}
+
+    definition = text(root, 'definition')
+    li.attributes['__definition'] = definition if definition
+
+    li
+  end
+
+  #
+  # Turns a launchitem into a hash
+  #
+  def Json.launchitem_to_h (li)
+
+    li.to_h
+  end
+
+  #
+  # Creates a LaunchItem instance from a hash (or a JSON string)
+  #
+  def Json.launchitem_from_h (h_or_json)
+
+    OpenWFE::LaunchItem.from_h(as_h(h_or_json))
+  end
+
+  #--
+  # flow expression id
+  #++
+
+  def Xml.fei_to_xml (fei, options={})
+
+    builder(options) do |xml|
+      xml.flow_expression_id do
+        FlowExpressionId::FIELDS.each do |f|
+          xml.tag!(f.to_s, fei.send(f))
+        end
+
+        xml.fei_short(fei.to_s)
+          # a short, 1 string version of the fei
+      end
+    end
+  end
+
+  def Xml.fei_from_xml (xml)
+
+    xml = to_element(xml, 'flow_expression_id')
+
+    FlowExpressionId::FIELDS.inject(FlowExpressionId.new) do |fei, f|
+      fei.send("#{f}=", text(xml, f.to_s)); fei
+    end
+  end
+
+  #--
+  # workitems
+  #++
+
+  #
+  # Turns an [InFlow]WorkItem into some XML.
+  #
+  def Xml.workitem_to_xml (wi, options={})
+
+    wi = wi.to_owfe_workitem if wi.respond_to?(:to_owfe_workitem)
+
+    builder(options) do |xml|
+
+      xml.workitem do
+
+        OpenWFE.rep_insert_links(wi, options, xml)
+
+        fei_to_xml(wi.fei, options)
+
+        xml.last_modified to_httpdate(wi.last_modified)
+
+        xml.participant_name wi.participant_name
+
+        xml.dispatch_time to_httpdate(wi.dispatch_time)
+        xml.store wi.store
+
+        xml.attributes do
+          hash_to_xml wi.attributes, options
+        end
+      end
+    end
+  end
+
+  #
+  # Turns a list of workitems into a XML document (String)
+  #
+  def Xml.workitems_to_xml (wis, options={})
+
+    collection_to_xml(
+      options[:tag] || 'workitems', wis, options, OpenWFE::InFlowWorkItem
+    ) { |wi|
+      workitem_to_xml(wi, options)
+    }
+  end
+
+  #
+  # Extracts an [InFlow]WorkItem instance from some XML.
+  #
+  def Xml.workitem_from_xml (xml)
+
+    root = to_element(xml, 'workitem')
+
+    wi = InFlowWorkItem.new
+
+    self_link = root.elements["link[@rel='self']"]
+    wi.uri = self_link ? self_link.attributes['href'] : nil
+
+    wi.fei = fei_from_xml root.elements['flow_expression_id']
+
+    wi.last_modified = from_httpdate(text(root, 'last_modified'))
+    wi.participant_name = text(root, 'participant_name')
+    wi.dispatch_time = from_httpdate(text(root, 'dispatch_time'))
+
+    wi.attributes = object_from_xml(
+      root.owfe_first_elt_child('attributes').owfe_first_elt_child)
+
+    wi
+  end
+
+  #
+  # Extracts a list of workitems from some XML.
+  #
+  def Xml.workitems_from_xml (xml)
+
+    root = to_element(xml, 'workitems')
+
+    root.owfe_elt_children.select { |elt|
+      elt.name == 'workitem'
+    }.collect { |elt|
+      workitem_from_xml(elt)
+    }
+  end
+
+  #
+  # Turns an array of workitems into a hash
+  #
+  def Json.workitems_to_h (wis, opts={})
+
+    collection_to_h(wis, opts, OpenWFE::InFlowWorkItem) { |wi|
+      workitem_to_h(wi, opts)
+    }
+  end
+
+  #
+  # Turns a workitem into a hash
+  #
+  def Json.workitem_to_h (wi, opts={})
+
+    wi = wi.to_owfe_workitem if wi.respond_to?(:to_owfe_workitem)
+
+    OpenWFE.rep_insert_links(wi, opts, wi.to_h)
+  end
+
+  #--
+  # cancelitems
+  #
+  #def Xml.cancelitem_to_xml (ci)
+  #end
+  #def Xml.cancelitem_from_xml (xml)
+  #end
+  #def Json.cancelitem_to_h (ci)
+  #end
+  #def Json.cancelitem_from_h (h)
+  #end
+  #++
+
+  #--
+  # processes (instances of ProcessStatus)
+  #++
+
+  def Xml.processes_to_xml (pss, options={ :indent => 2 })
+
+    collection_to_xml(
+      'processes', pss, options, OpenWFE::ProcessStatus
+    ) { |fei, ps|
+      ps = ps || fei # accomodating arrays and hashes
+      process_to_xml(ps, options.merge(:short => true))
+    }
+  end
+
+  def Xml.process_to_xml (pr, options={ :indent => 2 })
+
+    builder(options) do |xml|
+
+      xml.process do
+
+        OpenWFE.rep_insert_links(pr, options, xml)
+
+        xml.wfid pr.wfid
+        xml.wfname pr.wfname
+        xml.wfrevision pr.wfrevision
+
+        xml.launch_time pr.launch_time
+        xml.paused pr.paused
+
+        xml.timestamp pr.timestamp.to_s
+
+        xml.tags do
+          pr.tags.each { |t| xml.tag t }
+        end
+
+        xml.branches pr.branches
+
+        unless options[:short]
+
+          hash_to_xml(
+            pr.variables, options.merge(:tag => 'variables'))
+
+          #workitems_to_xml(
+          #  pr.applied_workitems, options.merge(:tag => 'applied_workitems'))
+        end
+
+        xml.applied_workitems :count => pr.applied_workitems.size
+
+        xml.scheduled_jobs do
+          pr.scheduled_jobs.each do |j|
+            xml.job do
+              xml.type j.class.name
+              xml.schedule_info j.schedule_info
+              xml.next_time j.next_time.to_s
+              xml.tags do
+                j.tags.each { |t| xml.tag t }
+              end
+            end
+          end
+        end
+
+        expressions_to_xml(pr.expressions, options.merge(:short => true))
+
+        errors_to_xml(pr.errors, options.merge(:short => true))
+
+        tree = pr.all_expressions.tree
+        tree = tree.respond_to?(:to_json) ? tree.to_json : tree.inspect
+
+        xml.tree(tree)
+      end
+    end
+  end
+
+  #
+  # Turns a serie of process [status] instances into a hash.
+  #
+  def Json.processes_to_h (pss, opts={})
+
+    collection_to_h(pss, opts, OpenWFE::ProcessStatus) { |fei, ps|
+      ps = ps || fei # accomodating arrays and hashes
+      process_to_h(ps, opts.merge(:short => true))
+    }
+  end
+
+  #
+  # Turns a process [status] into a JSON string.
+  #
+  def Json.process_to_h (pr, opts={})
+
+    h = OpenWFE.rep_insert_links(pr, opts, {})
+
+    %w{
+      wfid wfname wfrevision launch_time paused timestamp branches
+    }.inject(h) { |r, m|
+      r[m] = pr.send(m).to_s; r
+    }
+
+    h['tags'] = pr.tags
+    h['variables'] = pr.variables unless opts[:short]
+
+    h['scheduled_jobs'] = pr.scheduled_jobs.collect { |job|
+      {
+        'type' => job.class.name,
+        'schedule_info' => job.schedule_info,
+        'next_time' => job.next_time.to_s,
+        'tags' => job.tags
+      }
+    }
+
+    h['expressions'] = expressions_to_h(
+      pr.expressions, opts.merge(:short => true))
+
+    h['applied_workitem_count'] = pr.applied_workitems.size
+
+    h['errors'] = errors_to_h(
+      pr.errors, opts.merge(:short => true))
+
+    tree = pr.all_expressions.tree
+    tree = tree.respond_to?(:to_json) ? tree.to_json : tree.inspect
+    h['tree'] = tree
+
+    h
+  end
+
+  #--
+  # expressions
+  #++
+
+  def Xml.expressions_to_xml (exps, opts={})
+
+    collection_to_xml('expressions', exps, opts, OpenWFE::FlowExpression) { |e|
+      expression_to_xml(e, opts)
+    }
+  end
+
+  def Xml.expression_to_xml (exp, opts={})
+
+    builder(opts) do |xml|
+      xml.expression do
+
+        OpenWFE.rep_insert_links(exp, opts, xml)
+
+        xml.fei exp.fei.to_s
+        xml.name exp.fei.expname
+        xml.tag! 'class', exp.class.name
+        xml.apply_time OpenWFE::Xml.to_httpdate(exp.apply_time)
+
+        unless opts[:short]
+
+          OpenWFE.rep_insert_links(exp.parent_id, opts, xml, :parent)
+          OpenWFE.rep_insert_links(exp.environment_id, opts, xml, :environment)
+          (exp.children || []).each do |cfei|
+            OpenWFE.rep_insert_links(cfei, opts, xml, :child)
+          end
+
+          rep = exp.raw_representation
+          rep = rep.respond_to?(:to_json) ? rep.to_json : rep.inspect
+
+          xml.raw rep
+          xml.raw_updated(exp.raw_rep_updated == true)
+
+          # TODO : variables ?
+        end
+      end
+    end
+  end
+
+  def Json.expressions_to_h (exps, opts={})
+
+    collection_to_h(exps, opts, OpenWFE::FlowExpression) { |e|
+      expression_to_h(e, opts)
+    }
+  end
+
+  def Json.expression_to_h (exp, opts={})
+
+    h = OpenWFE.rep_insert_links(exp, opts, {})
+
+    h['fei'] = exp.fei.to_s
+    h['name'] = exp.fei.expname
+    h['class'] = exp.class.to_s
+    h['apply_time'] = exp.apply_time.to_s
+
+    return h if opts[:short]
+
+    OpenWFE.rep_insert_links(exp.parent_id, opts, h, :parent)
+    OpenWFE.rep_insert_links(exp.environment_id, opts, h, :environment)
+    (exp.children || []).each do |cfei|
+      OpenWFE.rep_insert_links(cfei, opts, h, :child)
+    end
+
+    h['raw'] = exp.raw_representation
+    h['raw_updated'] = (exp.raw_rep_updated == true)
+
+    # TODO : variables ?
+
+    h
+  end
+
+  #--
+  # errors
+  #++
+
+  def Xml.errors_to_xml (errs, opts={})
+
+    collection_to_xml('errors', errs, opts, OpenWFE::ProcessError) { |k, err|
+      error_to_xml(err || k, opts)
+    }
+  end
+
+  def Xml.error_to_xml (err, options={})
+
+    err = err.as_owfe_error if err.respond_to?(:as_owfe_error)
+
+    builder(options) do |xml|
+      xml.error do
+
+        OpenWFE.rep_insert_links(err, options, xml)
+
+        xml.date err.date # when
+        xml.fei err.fei.to_s # what
+        xml.call err.message.to_s # how
+        xml.message err.stacktrace.split("\n")[0] # how
+
+        unless options[:short]
+
+          xml.wfid err.wfid
+          xml.expid err.fei.expid
+          #xml.stacktrace do
+          #  xml.cdata! "\n#{v.stacktrace}\n"
+          #end
+        end
+      end
+    end
+  end
+
+  def Json.errors_to_h (errs, opts={})
+
+    collection_to_h(errs, opts, OpenWFE::ProcessError) { |k, err|
+      error_to_h(err || k, opts)
+    }
+  end
+
+  def Json.error_to_h (err, opts={})
+
+    err = err.as_owfe_error if err.respond_to?(:as_owfe_error)
+
+    h = {}
+    h['date'] = err.date
+    h['fei'] = err.fei.to_s
+    h['message'] = err.stacktrace.split("\n").first
+
+    OpenWFE.rep_insert_links(err, opts, h)
+
+    return h if opts[:short]
+
+    h['wfid'] = err.wfid
+    h['expid'] = err.fei.expid
+    h
+  end
+end
+