ruote-kit 2.1.10 → 2.1.11

data/lib/ruote-kit/helpers/json_helpers.rb

@@ -0,0 +1,280 @@
+
+# license is MIT, see LICENSE.txt
+
+module RuoteKit
+  module Helpers
+
+    # Helpers for JSON rendering
+    #
+    module JsonHelpers
+
+      def json(resource, *args)
+
+        object = respond_to?("json_#{resource}") ?
+          send("json_#{resource}", *args) : nil
+
+        Rufus::Json.encode(
+          'links' => links(resource), resource.to_s => object || args.first
+        )
+      end
+
+      #def json_exception(code, exception)
+      #  { 'code' => code, 'exception' => { 'message' => exception.message } }
+      #end
+
+      def json_processes
+
+        @processes.map { |p| json_process(p) }
+      end
+
+      def json_process(process=@process)
+
+        detailed = (@process != nil)
+
+        process.as_h(detailed).merge('links' => [
+          hlink('processes', process.wfid, :rel => 'self'),
+          hlink('processes', process.wfid, :rel => '#process'),
+          hlink('expressions', process.wfid, :rel => '#process_expressions'),
+          hlink('workitems', process.wfid, :rel => '#process_workitems'),
+          hlink('errors', process.wfid, :rel => '#process_errors'),
+          hlink('schedules', process.wfid, :rel => '#process_schedules')
+        ])
+      end
+
+      def json_expressions
+
+        @process.expressions.map { |e| json_expression(e) }
+      end
+
+      def json_expression(expression=@expression)
+
+        detailed = (@expression != nil)
+
+        links = [
+          hlink('expressions', expression.fei.sid, :rel => 'self'),
+          hlink('processes', expression.fei.wfid, :rel => '#process'),
+          hlink('expressions', expression.fei.wfid, :rel => '#process_expressions')
+        ]
+        links << hlink(
+          'expressions', expression.parent.fei.sid, 'parent'
+        ) if expression.parent
+
+        expression.as_h(detailed).merge('links' => links)
+      end
+
+      def json_workitems
+
+        @workitems.map { |w| json_workitem(w) }
+      end
+
+      def json_workitem(workitem=@workitem)
+
+        detailed = (@workitem != nil)
+
+        links = [
+          hlink('expressions', workitem.fei.sid, :rel => 'self'),
+          hlink('processes', workitem.fei.wfid, :rel => '#process'),
+          hlink('expressions', workitem.fei.wfid, :rel => '#process_expressions'),
+          hlink('errors', workitem.fei.wfid, :rel => '#process_errors')
+        ]
+
+        workitem.as_h(detailed).merge('links' => links)
+      end
+
+      def json_errors
+
+        @errors.collect { |e| json_error(e) }
+      end
+
+      def json_error(error=@error)
+
+        fei = error.fei
+        wfid = fei.wfid
+
+        error.to_h.merge('links' => [
+          hlink('errors', fei.sid, :rel => 'self'),
+          hlink('errors', wfid, :rel => '#process_errors'),
+          hlink('processes', wfid, :rel => '#process')
+        ])
+      end
+
+      def json_participants
+
+        @participants.collect { |pa|
+          pa.as_h.merge('links' => [ hlink('participants', :rel => 'self') ])
+        }
+      end
+
+      def json_schedules
+
+        @schedules.each do |sched|
+
+          owner_fei = sched.delete('owner')
+          target_fei = sched.delete('target')
+
+          sched['owner'] = owner_fei.to_h
+          sched['target'] = target_fei.to_h
+
+          sched['links'] = [
+            hlink('expressions', owner_fei.sid, :rel => '#schedule_owner'),
+            hlink('expressions', target_fei.sid, :rel => '#schedule_target')
+          ]
+        end
+
+        @schedules
+      end
+
+      def json_http_error(err)
+
+        { 'code' => err[0], 'message' => err[1], 'cause' => err[2].to_s }
+      end
+
+      def links(resource)
+
+        result = [
+          hlink(:rel => '#root'),
+          hlink('processes', :rel => '#processes'),
+          hlink('workitems', :rel => '#workitems'),
+          hlink('errors', :rel => '#errors'),
+          hlink('participants', :rel => '#participants'),
+          hlink('schedules', :rel => '#schedules'),
+          hlink('history', :rel => '#history'),
+          hlink(request.fullpath, :rel => 'self')
+        ]
+
+        if @skip # pagination is active
+
+          result << hlink(resource.to_s, :rel => 'all')
+
+          lim = @limit || settings.limit
+          las = (@count / lim) * lim
+          pre = [ 0, @skip - lim ].max
+          nex = [ @skip + lim, las ].min
+
+          result << hlink(
+            resource.to_s,
+            :skip => 0, :limit => lim, :rel => 'first')
+          result << hlink(
+            resource.to_s,
+            :skip => las, :limit => lim, :rel => 'last')
+          result << hlink(
+            resource.to_s,
+            :skip => pre, :limit => lim, :rel => 'previous')
+          result << hlink(
+            resource.to_s,
+            :skip => nex, :limit => lim, :rel => 'next')
+        end
+
+        result
+      end
+    end
+  end
+end
+
+module Ruote
+
+  #
+  # Re-opening to provide an as_h method
+  #
+  class ProcessStatus
+
+    def as_h(detailed=true)
+
+      h = {}
+
+      #h['expressions'] = @expressions.collect { |e| e.fei.to_h }
+      #h['errors'] = @errors.collect { |e| e.to_h }
+
+      h['type'] = 'process'
+      h['detailed'] = detailed
+      h['expressions'] = @expressions.size
+      h['errors'] = @errors.size
+      h['stored_workitems'] = @stored_workitems.size
+      h['workitems'] = workitems.size
+
+      properties = %w[
+        wfid
+        definition_name definition_revision
+        current_tree
+        launched_time
+        last_active
+        tags
+      ]
+
+      properties += %w[
+        original_tree
+        variables
+      ] if detailed
+
+      properties.each { |m|
+        h[m] = self.send(m)
+      }
+
+      h
+    end
+  end
+
+  #
+  # Re-opening to provide an as_h method
+  #
+  class Workitem
+
+    def as_h(detailed=true)
+
+      r = {}
+
+      r['id'] = fei.sid
+      r['fei'] = fei.sid
+      r['wfid'] = fei.wfid
+      r['type'] = 'workitem'
+      r['participant_name'] = participant_name
+
+      r['fields'] = h.fields
+
+      r['put_at'] = h.put_at
+
+      r
+    end
+  end
+
+  #
+  # Re-opening to provide an as_h method
+  #
+  class ParticipantEntry
+
+    def as_h(detailed=true)
+
+      { 'regex' => @regex, 'classname' => @classname, 'options' => @options }
+    end
+  end
+
+  module Exp
+
+    #
+    # Re-opening to provide an as_h method
+    #
+    class FlowExpression
+
+      def as_h(detailed=true)
+
+        r = {}
+
+        r['fei'] = fei.sid
+        r['parent'] = h.parent_id ? parent_id.sid : nil
+        r['name'] = h.name
+        r['class'] = self.class.name
+
+        if detailed
+          r['variables'] = variables
+          r['applied_workitem'] = h.applied_workitem['fields']
+          r['tree'] = tree
+          r['original_tree'] = original_tree
+          r['timeout_schedule_id'] = h.timeout_schedule_id
+        end
+
+        r
+      end
+    end
+  end
+end
+

data/lib/ruote-kit/helpers/link_helpers.rb

@@ -0,0 +1,117 @@
+
+# license is MIT, see LICENSE.txt
+
+module RuoteKit
+  module Helpers
+
+    # Helpers about links
+    #
+    module LinkHelpers
+
+      # Computing the href for the "as_json" link at the bottom of each page
+      #
+      def as_json
+
+        href = request.path + '.json'
+
+        if request.query_string.length > 0
+          href = "#{href}?#{request.query_string}"
+        end
+
+        href
+      end
+
+      # Determining { 'href' => 'x', 'rel' => 'y', ... } and co
+      #
+      def hlink(*args)
+
+        query = args.last.is_a?(Hash) ? args.pop : {}
+        query = query.reject { |k, v| k == :text }
+
+        args = args.collect { |arg| arg.to_s }
+
+        if args.last == 'head'
+          args.pop
+          query[:skip] = 0
+          query[:limit] = settings.limit
+        end
+
+        rel = query.delete(:rel) || compute_rel(args)
+        title = query.delete(:title)
+
+        query = query.inject({}) { |h, (k, v)| h[k.to_s] = v; h }
+        query = query.keys.sort.collect { |k| "#{k}=#{query[k]}" }.join('&')
+        query = "?#{query}" if query.length > 0
+
+        if args.empty? or ( ! args.first.match(/^\/\_ruote/))
+          args.unshift('/_ruote')
+        end
+        href = args.join('/')
+
+        href = "#{href}#{query}"
+
+        result = {
+          'href' => href,
+          'rel' => rel.match(/^#/) ?
+            "http://ruote.rubyforge.org/rels.html#{rel}" : rel,
+        }
+
+        if title
+          result['title'] = title == true ? href : title
+        end
+
+        result
+      end
+
+      # Returns an <a href="x" rel="y">z</a>, uses #hlink.
+      #
+      def alink(*args)
+
+        args << {} unless args.last.is_a?(Hash)
+        args.last[:title] = true
+
+        opts = args.last
+
+        hl = hlink(*args)
+
+        attributes = %w[ href rel title ].inject([]) { |a, att|
+          if val = hl[att]
+            a << "#{att}=\"#{val}\""
+          end
+          a
+        }.join(' ')
+
+        "<a #{attributes}>#{opts[:text] || hl['href']}</a>"
+      end
+
+      protected
+
+      def compute_rel(args)
+
+        wfid, fei = if ( ! args[1])
+          [ false, false ]
+        elsif args[1].index('!')
+          [ false, true ]
+        else
+          [ true, false ]
+        end
+
+        case args.first
+          when 'processes'
+            wfid ? '#process' : '#processes'
+          when 'expressions'
+            fei ? '#expression' : '#process_expressions'
+          when 'errors'
+            fei ? '#error' : '#process_errors'
+          when 'workitems'
+            fei ? '#workitem' : '#process_workitems'
+          when 'schedules'
+            wfid ? '#process_schedules' : '#schedules'
+          else
+            ''
+        end
+      end
+    end
+  end
+end
+

data/lib/ruote-kit/helpers/misc_helpers.rb

@@ -0,0 +1,35 @@
+
+# license is MIT, see LICENSE.txt
+
+module RuoteKit
+  module Helpers
+
+    module MiscHelpers
+
+      def respond_with(template)
+
+        respond_to do |format|
+          format.html { haml(template) }
+          format.json { json(template) }
+        end
+      end
+
+      def sample_process
+        %{
+Ruote.process_definition :name => 'test', :revision => '0.1' do
+  sequence do
+    alice :task => 'clean car'
+    bob :task => 'sell car'
+  end
+end
+        }.strip
+      end
+
+      def sample_process_tree
+
+        Rufus::Json.encode(Ruote::Parser.parse(sample_process))
+      end
+    end
+  end
+end
+

data/lib/ruote-kit/helpers/pagination_helpers.rb

@@ -0,0 +1,30 @@
+
+# license is MIT, see LICENSE.txt
+
+module RuoteKit
+  module Helpers
+
+    # Pagination stuff
+    #
+    module PaginationHelpers
+
+      # Prerequesite : a @count var with the number of records (processes,
+      # workitems, errors or schedules) found.
+      #
+      def paginate
+
+        @skip = (params[:skip] || 0).to_i
+        @limit = (params[:limit] || settings.limit).to_i
+
+        #@skip = 0 if @skip < 0
+        #@skip = @count - @limit if @skip >= @count
+        if @skip <= 0
+          @skip = 0
+        elsif @skip >= @count
+          @skip = @count - @limit
+        end
+      end
+    end
+  end
+end
+

data/lib/ruote-kit/helpers/render_helpers.rb

@@ -1,96 +1,47 @@
+
+# license is MIT, see LICENSE.txt
+
 module RuoteKit
   module Helpers
+
     # Helpers for rendering stuff
+    #
     module RenderHelpers
 
-      def json( resource, object )
-        if respond_to?( "json_#{resource}" )
-          object = send( "json_#{resource}", object )
-        end
-
-        Rufus::Json.encode( {
-          "links" => links( resource ),
-          resource.to_s => object
-        } )
-      end
-
-      def json_processes( processes )
-        processes.map { |p| json_process( p ) }
-      end
-
-      def json_process( process )
-        links = [
-          link( "/_ruote/processes/#{process.wfid}", '#process' ),
-          link( "/_ruote/expressions/#{process.wfid}", '#expressions' ),
-          link( "/_ruote/workitems/#{process.wfid}", '#workitems' )
-        ]
-
-        process.to_h.merge( 'links' => links )
-      end
-
-      def json_expression( expression )
-        links = [
-          link( "/_ruote/processes/#{expression.fei.wfid}", '#process' ),
-          link( "/_ruote/expressions/#{expression.fei.wfid}", '#expressions' )
-        ]
-
-        if expression.parent
-          links << link( "/_ruote/expressions/#{expression.fei.wfid}/#{expression.parent.fei.expid}", 'parent' )
-        end
-
-        expression.to_h.merge( 'links' => links )
-      end
-
-      def json_expressions( expressions )
-        expressions.map { |e| json_expression( e ) }
-      end
-
-      def json_workitems( workitems )
-        workitems.map { |w| json_workitem( w ) }
-      end
-
-      def json_workitem( workitem )
+      def pluralize(number, word)
 
-        links = [
-          link( "/_ruote/processes/#{workitem.fei.wfid}", '#process' ),
-          link( "/_ruote/expressions/#{workitem.fei.wfid}", '#expressions' ),
-          link( "/_ruote/errors/#{workitem.fei.wfid}", '#errors' )
-        ]
-
-        workitem.to_h.merge( 'links' => links )
-      end
+        word << 's' if number > 1
 
-      def json_errors( errors )
-        errors.collect { |e| json_error( e, false ) }
+        return [ number, word ].join(' ')
       end
 
-      def json_error( error )
-        error.to_h.merge( 'links' => links )
-      end
+      # Escaping HTML, rack style.
+      #
+      def h(s)
 
-      def links( resource )
-        [
-          link( '/_ruote', '#root' ),
-          link( '/_ruote/processes', '#processes' ),
-          link( '/_ruote/workitems', '#workitems' ),
-          link( '/_ruote/errors', '#errors' ),
-          link( '/_ruote/history', '#history' ),
-          link( request.fullpath, 'self' )
-        ]
+        Rack::Utils.escape_html(s)
       end
 
-      def link( href, rel )
-        {
-          'href' => href,
-          'rel' => rel.match(/^#/) ? "http://ruote.rubyforge.org/rels.html#{rel}" : rel
-        }
-      end
+      # Used by #http_error
+      #
+      HTTP_CODES = {
+        400 => 'bad request',
+        404 => 'resource not found'
+      }
 
-      # Easy 404
+      # HTTP errors
       #
-      def resource_not_found
+      def http_error(code, cause=nil)
 
-        status 404
+        @code = code
+        @message = HTTP_CODES[code]
+        @cause = cause
+
+        @trace = if cause
+          [ cause.message ] + cause.backtrace
+        else
+          nil
+        end
 
         @format = if m = @format.to_s.match(/^[^\/]+\/([^;]+)/)
           m[1].to_sym
@@ -99,31 +50,27 @@ module RuoteKit
         end
           # freaking sinata-respond_to 0.4.0... (or is that it ?)
 
-        respond_to do |format|
-          format.html { haml :resource_not_found }
-          format.json { Rufus::Json.encode( { "error" => { "code" => 404, "message" => "Resource not found" } } ) }
-        end
-      end
+        status(@code)
 
-      # Easy 503
-      def workitems_not_available
-        status 503
         respond_to do |format|
-          format.html { haml :workitems_not_available }
-          format.json { Rufus::Json.encode( { "error" => { "code" => 503, "messages" => "Workitems not available" } } ) }
+          format.html { haml :http_error }
+          format.json { json(:http_error, [ @code, @message, @cause ]) }
         end
       end
 
       # Extract the process tree
-      def process_tree( object )
+      #
+      def process_tree(object)
+
         case object
         when Ruote::Workitem
-          process = engine.process( object.fei.wfid )
-          Rufus::Json.encode( process.current_tree )
+          process = RuoteKit.engine.process(object.fei.wfid)
+          Rufus::Json.encode(process.current_tree)
         when Ruote::ProcessStatus
-          Rufus::Json.encode( object.current_tree )
+          Rufus::Json.encode(object.current_tree)
         end
       end
     end
   end
 end
+