ruote-kit 2.1.10 → 2.1.11

data/lib/ruote-kit/resources/expressions.rb

@@ -1,55 +1,112 @@
+
+# license is MIT, see LICENSE.txt
+
 class RuoteKit::Application
 
-  get "/_ruote/expressions/?" do
-    respond_to do |format|
-      format.html { haml :expressions }
-      format.json { json( :status, :ok ) }
+  get '/_ruote/expressions/:id' do
+
+    @process, @expression, fei = fetch_pe
+
+    return http_error(404) unless @process
+
+    if fei
+
+      return http_error(404) unless @expression
+
+      respond_with :expression
+    else
+
+      respond_with :expressions
     end
   end
 
-  get "/_ruote/expressions/:wfid" do
-    @process = engine.process( params[:wfid] )
+  delete '/_ruote/expressions/:id' do
 
-    if @process
-      respond_to do |format|
-        format.html { haml :expressions }
-        format.json { json( :expressions, @process.expressions ) }
-      end
+    process, expression, fei = fetch_pe
+
+    return http_error(404) unless expression
+
+    if params[:_kill]
+      RuoteKit.engine.kill_expression(expression.fei)
     else
-      resource_not_found
+      RuoteKit.engine.cancel_expression(expression.fei)
+    end
+
+    respond_to do |format|
+      format.html { redirect "/_ruote/expressions/#{expression.fei.wfid}" }
+      format.json { json :status, :ok }
     end
   end
 
-  get "/_ruote/expressions/:wfid/:expid" do
-    @process = engine.process( params[:wfid] )
+  put '/_ruote/expressions/:id' do
 
-    if @process && @expression = @process.expressions.detect { |exp| exp.fei.expid == params[:expid] }
-      respond_to do |format|
-        format.html { haml :expression }
-        format.json { json( :expression, @expression ) }
-      end
-    else
-      resource_not_found
+    process, expression, fei = fetch_pe
+
+    return http_error(404) unless expression
+
+    info = begin
+      fetch_re_apply_info
+    rescue Rufus::Json::ParserError => pe
+      return http_error(400, pe)
+    end
+
+    #puts '-' * 80
+    #p params
+    #p info
+    #puts '-' * 80
+
+    options = {}
+    options[:fields] = info.fields if info.fields
+    options[:tree] = info.tree if info.tree
+
+    RuoteKit.engine.re_apply(expression.fei, options)
+
+    respond_to do |format|
+      format.html { redirect "/_ruote/expressions/#{expression.fei.wfid}" }
+      format.json { json :status, :ok }
     end
   end
 
-  delete "/_ruote/expressions/:wfid/:expid" do
-    process = engine.process( params[:wfid] )
+  protected
 
-    if process && expression = process.expressions.detect { |exp| exp.fei.expid == params[:expid] }
-      if params[:_kill]
-        engine.kill_expression( expression.fei )
-      else
-        engine.cancel_expression( expression.fei )
-      end
+  def fetch_pe
+
+    fei = params[:id].split('!')
+    wfid = fei.last
+
+    process = RuoteKit.engine.process(wfid)
+
+    expression = process ?
+      process.expressions.detect { |exp| exp.fei.sid == params[:id] } :
+      nil
+
+    fei = (fei.length > 1)
+
+    [ process, expression, fei ]
+  end
+
+  def fetch_re_apply_info
+
+    if request.content_type == 'application/json' then
+
+      data = Rufus::Json.decode(request.body.read)
+      if exp = data['expression']; data = exp; end
+
+      OpenStruct.new(data)
 
-      respond_to do |format|
-        format.html { redirect "/_ruote/expressions/#{params[:wfid]}" }
-        format.json { json( :status, :ok ) }
-      end
     else
-      resource_not_found
+
+      o = OpenStruct.new
+
+      if fields = params[:fields]
+        o.fields = Rufus::Json.decode(fields)
+      end
+      if tree = params[:tree]
+        o.tree = Rufus::Json.decode(tree)
+      end
+
+      o
     end
   end
-
 end
+

data/lib/ruote-kit/resources/participants.rb

@@ -0,0 +1,53 @@
+
+# license is MIT, see LICENSE.txt
+
+class RuoteKit::Application
+
+  get '/_ruote/participants/?' do
+
+    @participants = RuoteKit.engine.participant_list
+
+    respond_with :participants
+  end
+
+  put '/_ruote/participants/?' do
+
+    list = []
+
+    if request.content_type.match(/\/json/)
+
+      list = Rufus::Json.decode(request.body.read)
+      list = list['participants'] if list.is_a?(Hash)
+
+    else
+
+      index = 0
+
+      loop do
+
+        break unless params["regex_#{index}"]
+
+        list << {
+          'regex' => params["regex_#{index}"],
+          'classname' => params["classname_#{index}"],
+          'options' => Rufus::Json.decode(params["options_#{index}"])
+        }
+        index = index + 1
+      end
+    end
+
+    RuoteKit.engine.participant_list = list
+
+    respond_to do |format|
+
+      format.html do
+        redirect '/_ruote/participants'
+      end
+      format.json do
+        @participants = RuoteKit.engine.participant_list
+        json :participants
+      end
+    end
+  end
+end
+

data/lib/ruote-kit/resources/processes.rb

@@ -1,59 +1,91 @@
+
+# license is MIT, see LICENSE.txt
+
+
 class RuoteKit::Application
 
-  get "/_ruote/processes/?" do
-    @processes = engine.processes
+  get '/_ruote/processes/?' do
 
-    respond_to do |format|
-      format.html { haml :processes }
-      format.json { json( :processes, @processes ) }
-    end
+    @count = RuoteKit.engine.processes(:count => true)
+    paginate
+
+    @processes = RuoteKit.engine.processes(
+      :descending => true, :skip => @skip, :limit => @limit)
+
+    respond_with :processes
   end
 
-  get "/_ruote/processes/new" do
-    haml :launch_process
+  get '/_ruote/processes/new' do
+
+    haml :processes_new
   end
 
-  get "/_ruote/processes/:wfid" do
+  get '/_ruote/processes/:wfid' do
 
-    @process = engine.process( params[:wfid] )
+    @process = RuoteKit.engine.process(params[:wfid])
 
-    if @process
-      respond_to do |format|
-        format.html { haml :process }
-        format.json { json( :process, @process ) }
-      end
-    else
-      resource_not_found
-    end
+    return http_error(404) unless @process
+
+    respond_with :process
   end
 
-  post "/_ruote/processes" do
-    launch_item = launch_item_from_post
+  post '/_ruote/processes' do
+
+    begin
+
+      @info = fetch_launch_info
+
+      @wfid = RuoteKit.engine.launch(
+        @info.definition, @info.fields || {}, @info.variables || {})
+
+    rescue Exception => e
+      return http_error(400, e)
+    end
+
+    status 201 # created
 
     respond_to do |format|
-      begin
-        @wfid = engine.launch( launch_item['pdef'], launch_item['fields'], launch_item['variables'] )
-      rescue ArgumentError => @error
-        status 422
-        format.html { haml :process_failed_to_launch }
-        format.json { { "error" => { "code" => 422, "message" => @error.message } }.to_json }
-      else
-        format.html { haml :process_launched }
-        format.json { json( :launched, @wfid ) }
-      end
+      format.html { haml :process_launched }
+      format.json { json :launched, @wfid }
     end
   end
 
-  delete "/_ruote/processes/:wfid" do
-    if params[:_kill] == "1"
-      engine.kill_process( params[:wfid] )
+  delete '/_ruote/processes/:wfid' do
+
+    if params[:_kill] == '1'
+      RuoteKit.engine.kill_process(params[:wfid])
     else
-      engine.cancel_process( params[:wfid] )
+      RuoteKit.engine.cancel_process(params[:wfid])
     end
 
     respond_to do |format|
-      format.html { redirect "/_ruote/processes" }
-      format.json { json( :status, :ok ) }
+      format.html { redirect '/_ruote/processes' }
+      format.json { json :status, :ok }
+    end
+  end
+
+  protected
+
+  def fetch_launch_info
+
+    if request.content_type == 'application/json' then
+
+      OpenStruct.new(Rufus::Json.decode(request.body.read))
+
+    else
+
+      info = OpenStruct.new('definition' => params[:definition])
+
+      fields = params[:fields] || ''
+      fields = '{}' if fields.empty?
+      info.fields = Rufus::Json.decode(fields)
+
+      vars = params[:variables] || ''
+      vars = '{}' if vars.empty?
+      info.variables = Rufus::Json.decode(vars)
+
+      info
     end
   end
 end
+

data/lib/ruote-kit/resources/schedules.rb

@@ -0,0 +1,27 @@
+
+# license is MIT, see LICENSE.txt
+
+class RuoteKit::Application
+
+  get '/_ruote/schedules/?' do
+
+    @count = RuoteKit.engine.processes(:count => true)
+    paginate
+
+    @schedules = RuoteKit.engine.schedules(:skip => @skip, :limit => @limit)
+
+    respond_with :schedules
+  end
+
+  get '/_ruote/schedules/:wfid' do
+
+    @schedules = RuoteKit.engine.schedules(params[:wfid])
+
+    @count = @schedules.size
+    @skip = 0
+    @limit = @count
+
+    respond_with :schedules
+  end
+end
+

data/lib/ruote-kit/resources/workitems.rb

@@ -1,65 +1,127 @@
+
+# license is MIT, see LICENSE.txt
+
 class RuoteKit::Application
 
-  get "/_ruote/workitems/?" do
+  get '/_ruote/workitems/?' do
 
     query = params.inject({}) { |h, (k, v)|
       h[k] = (Rufus::Json.decode(v) rescue v)
       h
     }
 
-    @workitems = storage_participant.query(query)
+    @count = RuoteKit.engine.storage_participant.query(:count => true)
 
-    respond_to do |format|
-      format.html { haml :workitems }
-      format.json { json( :workitems, @workitems ) }
+    if (query.keys - %w[ limit skip ]).empty?
+      paginate
+    else
+      @skip = 0
+      @limit = @count
     end
-  end
 
-  get "/_ruote/workitems/:wfid" do
-    @wfid = params[:wfid]
-    @workitems = find_workitems( params[:wfid] )
+    query['skip'] = @skip
+    query['limit'] = @limit
 
-    respond_to do |format|
-      format.html { haml( :workitems ) }
-      format.json { json( :workitems, @workitems ) }
-    end
+    @workitems = RuoteKit.engine.storage_participant.query(query)
+
+    respond_with :workitems
   end
 
-  get "/_ruote/workitems/:wfid/:expid" do
-    @workitem = find_workitem( params[:wfid], params[:expid] )
+  get '/_ruote/workitems/:id' do
+
+    @workitem, @workitems, @wfid = fetch_wi
+
+    return http_error(404) if @workitem.nil? && @workitems.nil?
 
     if @workitem
-      respond_to do |format|
-        format.html { haml :workitem }
-        format.json { json( :workitem, @workitem ) }
-      end
+      respond_with :workitem
     else
-      resource_not_found
+      respond_with :workitems
     end
   end
 
-  put "/_ruote/workitems/:wfid/:expid" do
-    workitem = find_workitem( params[:wfid], params[:expid] )
+  put '/_ruote/workitems/:id' do
 
-    (resource_not_found and return) if workitem.nil?
+    @workitem, _, _ = fetch_wi
 
-    options = field_updates_and_proceed_from_put
+    return http_error(404) unless @workitem
+
+    options = begin
+      field_updates_and_proceed_from_put
+    rescue Rufus::Json::ParserError => pe
+      return http_error(400, pe)
+    end
 
     unless options[:fields].empty?
-      workitem.fields = options[:fields]
-      storage_participant.update( workitem )
+      @workitem.fields = options[:fields]
+      RuoteKit.engine.storage_participant.update(@workitem)
     end
 
     if options[:proceed]
-      storage_participant.reply( workitem )
+      RuoteKit.engine.storage_participant.reply(@workitem)
     end
 
     respond_to do |format|
-      format.html {
-        redirect options[:proceed] ? "/_ruote/workitems/#{params[:wfid]}" : "/_ruote/workitems/#{params[:wfid]}/#{params[:expid]}"
-      }
-      format.json { json( :workitem, workitem ) }
+
+      format.html do
+        redirect(options[:proceed] ?
+          "/_ruote/workitems/#{@workitem.fei.wfid}" :
+          "/_ruote/workitems/#{@workitem.fei.sid}")
+      end
+      format.json do
+        json :workitem
+      end
     end
   end
 
+  protected
+
+  def fetch_wi
+
+    fei = params[:id].split('!')
+    wfid = fei.last
+
+    workitem = nil
+    workitems = nil
+
+    wis = RuoteKit.engine.storage_participant.by_wfid(wfid)
+
+    if fei.length > 1
+      workitem = wis.find { |wi| wi.fei.sid == params[:id] }
+    else
+      workitems = wis
+    end
+
+    [ workitem, workitems, wfid ]
+  end
+
+  def field_updates_and_proceed_from_put
+
+    options = { :fields => {}, :proceed => false }
+
+    if request.content_type == 'application/json'
+
+      data = Rufus::Json.decode(env['rack.input'].read)
+      if wi = data['workitem']; data = wi; end
+
+      unless data['fields'].nil? || data['fields'].empty?
+        options[:fields] = data['fields']
+      end
+      unless data['_proceed'].nil? || data['_proceed'].empty?
+        options[:proceed] = data['_proceed']
+      end
+
+    else
+
+      unless params['fields'].nil? || params['fields'].empty?
+        options[:fields] = Rufus::Json.decode(params[:fields])
+      end
+      unless params[:_proceed].nil? || params[:_proceed].empty?
+        options[:proceed] = params[:_proceed]
+      end
+    end
+
+    options
+  end
 end
+

data/lib/ruote-kit/spec/ruote_helpers.rb

@@ -1,9 +1,15 @@
+
+# license is MIT, see LICENSE.txt
+
 module RuoteKit
   module Spec
+
     module RuoteHelpers
 
       # Launch a dummy process and return the wfid
-      def launch_test_process( &block )
+      #
+      def launch_test_process(&block)
+
         pdef = if block_given?
           yield
         else
@@ -14,34 +20,37 @@ module RuoteKit
           end
         end
 
-        wfid = RuoteKit.engine.launch( pdef )
-
-        # Wait for the process list to populate
-        sleep 0.1 while RuoteKit.engine.process( wfid ).nil?
+        wfid = RuoteKit.engine.launch(pdef)
 
-        # Give the process some time to traverse the expression tree
-        sleep 0.4
-        #wait_for( 1 )
+        # give the engine some time to run the process
+        # (remember it does it asynchronously)
+        sleep(0.350)
 
         wfid
       end
 
-      def noisy( on = true )
-        RuoteKit.engine.context[:noisy] = on
+      def noisy(on = true)
+        RuoteKit.engine.noisy = on
       end
 
-      def storage_participant
-        RuoteKit.storage_participant
+      def engine
+        RuoteKit.engine
       end
 
-      def find_workitem( wfid, expid )
-        storage_participant.by_wfid( wfid ).detect { |wi| wi.fei.expid == expid }
+      def storage_participant
+        RuoteKit.engine.storage_participant
       end
 
-      def wait_for( wfid )
-        @_spec_worker.context.logger.wait_for( [  wfid ] )
+      def find_workitem(wfid, expid)
+        RuoteKit.engine.storage_participant.by_wfid(wfid).first { |wi|
+          wi.fei.expid == expid
+        }
       end
 
+      def wait_for(wfid)
+        RuoteKit.engine.wait_for(wfid)
+      end
     end
   end
 end
+

data/lib/ruote-kit/version.rb

@@ -1,4 +1,6 @@
 
+# license is MIT, see LICENSE.txt
+
 # lib/ruote-kit/version.rb
 #
 # so that the Rakefile doesn't have to load all the deps
@@ -6,6 +8,6 @@
 
 module RuoteKit
 
-  VERSION = '2.1.10'
+  VERSION = '2.1.11'
 end
 

data/lib/ruote-kit/views/_pagination.html.haml

@@ -0,0 +1,38 @@
+
+#pagination
+
+  - res = request.path.split('/')[2]
+
+  - if @skip
+
+    - lim = @limit || settings.limit
+
+    - @skip = 0 if @skip < 0
+    - @skip = @count - lim if @skip >= @count
+
+    = (@count > 0) ? @skip + 1 : 0
+    to
+    = [ @skip + @limit, @count ].min
+    of
+    = @count
+    = res
+
+    - las = ((@count / lim.to_f).ceil - 1) * lim
+    - pre = [ 0, @skip - lim ].max
+    - nex = [ @skip + lim, las ].min
+
+    %a.pagination{ :href => request.path, :rel => 'all' } all
+    - if @skip > 0
+      %a.pagination{ :href => "#{request.path}?limit=#{lim}&skip=0", :rel => 'first' } first
+    - if @skip > 0 && pre != 0
+      %a.pagination{ :href => "#{request.path}?limit=#{lim}&skip=#{pre}", :rel => 'previous' } previous
+    - if nex != las
+      %a.pagination{ :href => "#{request.path}?limit=#{lim}&skip=#{nex}", :rel => 'next' } next
+    - if las > 0 && @skip < las
+      %a.pagination{ :href => "#{request.path}?limit=#{lim}&skip=#{las}", :rel => 'last' } last
+
+  - else
+
+    - if resources = instance_variable_get("@#{res}")
+      = "#{resources.size} #{res}"
+ 

data/lib/ruote-kit/views/_tree_editor.html.haml

@@ -0,0 +1,52 @@
+
+#overlay
+#editor
+  %canvas#efluo
+  #fluo_editor
+  %a.ruote_button.ruote_go_button{ :title => 'close and use that definition', :href => '', :onclick => 'hideEditor(true); return false;' }
+  %a.ruote_button.ruote_cross_button{ :title => 'close', :href => '', :onclick => 'hideEditor(false); return false;' }
+
+:javascript
+
+  $('textarea.variables').hide();
+
+  $('#overlay').hide();
+  $('#editor').hide();
+
+  function initEditor () {
+
+    var tree = tree || #{sample_process_tree};
+    var def = $('#tree')[0].value;
+    if (def.match(/\s*\[/)) tree = JSON.parse(def);
+
+    FluoEditor.renderFlow('fluo_editor', tree);
+    Fluo.renderFlow('efluo', tree);
+    Fluo.crop('efluo');
+
+    $('#fluo_editor')[0].onChange = function (tree) {
+      Fluo.renderFlow('efluo', tree);
+      Fluo.crop('efluo');
+    }
+    $('#fluo_editor')[0].onOver = function (expid) {
+      Fluo.highlight('efluo', expid);
+    }
+  }
+
+  function showEditor () {
+
+    initEditor();
+
+    document.getElementById('overlay').style.height =
+      '' + window.outerHeight + 'px';
+
+    $('#overlay').slideDown(function () { $('#editor').show(); });
+  }
+
+  function hideEditor (use) {
+
+    $('#editor').hide();
+    $('#overlay').hide();
+
+    if (use) $('#tree')[0].value = FluoEditor.asJson('fluo_editor');
+  }
+