ruote-kit 2.1.4

data/.gitignore

@@ -0,0 +1,8 @@
+*.swp
+work*/
+.DS_Store
+bin/*
+vendor/gems
+.yardoc
+doc/*
+pkg/*

data/Gemfile

@@ -0,0 +1,10 @@
+# Dependencies for ruote-kit
+
+# ruote-kit itself
+gem 'sinatra'
+gem 'haml'
+gem 'json'
+
+# ruote
+#gem 'ruote', :git => "git://github.com/kennethkalmer/ruote", :branch => "ruote-kit"
+gem 'ruote', '>= 2.1.4'

data/README.rdoc

@@ -0,0 +1,132 @@
+= ruote-kit (RESTful BPM & middleware)
+
+* http://kit.rubyforge.org/ruote (soon)
+* http://kit.rubyforge.org/ruote/rdoc (soon)
+
+A RESTful wrapper around the ruote[http://ruote.rubyforge.org] workflow engine,
+built as a modular sinatra[http://www.sinatrarb.com/] application.
+
+Follow development:
+
+* #ruote on Freenode
+* http://groups.google.com/group/openwferu-users
+* http://opensourcery.co.za
+* @kennethkalmer on Twitter
+
+== Alpha Status
+
+ruote-kit is under heavy development and will likely change violently over the
+coming weeks (albeit for the better).
+
+Dependencies you currently need is:
+
+* bundler (gem install bundler)
+* sinatra
+* haml
+* json
+* rspec (only to run the specs)
+
+ruote-kit uses bundler to setup and maintain its environment. Before running
+ruote-kit for the first time you need to install bundler and then run:
+
+  $ gem bundle
+
+Bundler will download all the required gems and unpack them in 'vendor/gems'
+for you.
+
+== Getting started quickly
+
+Once you have the dependencies installed, get going by running 'rackup'
+from inside the ruote-kit project.
+
+If ruote-kit starts up without any issues (ie missing dependencies), you can
+point your browser to 'http://localhost:9292/_ruote/' to get going. By default ruote-kit
+binds to all IP addresses, so this works out the box remotely too.
+
+== Plugging ruote-kit into your rack-stack
+
+ruote-kit is fully self-sufficient piece of rack, but can be slotted into any
+rack middleware stack without issues.
+
+Example:
+
+  RuoteKit.configure do |config|
+    # make changes if needed
+  end
+
+  # Register participants if needed
+  RuoteKit.engine.register_participant :toto do |wi|
+    # 
+  end
+
+  # Slot into the stack
+  use RuoteKit::Application
+
+== Configuring ruote-kit & ruote
+
+ruote-kit can be configured using RuoteKit#configure, after which it will start
+the engine. From that point the engine is accessible through RuoteKit.engine.
+
+Without any configuration ruote-kit will use file system persistence, and save
+the work in a sub-folder of the current working directory named +work_<env>+,
+where +env+ is the RACK_ENV or RAILS_ENV.
+
+== Running workers
+
+If you're using ruote-kit as part of your rack stack you'll need to start at
+least one worker separately or the workflows will be executed. You won't need
+more than one worker unless you are running hundreds of processes at the same
+time.
+
+To run a worker you need to setup a worker scripts similar to the rake example
+below:
+
+  require 'rake'
+  require 'ruote-kit'
+
+  desc "Run a ruote-kit worker"
+  task :ruote_kit_worker do
+
+    RuoteKit.configure do |config|
+      # Setup your configuration
+    end
+
+    RuoteKit.run_worker!
+  end
+
+This will only work correctly if using the default file system persistence.
+Support for ruote-couch[http://github.com/jmettraux/ruote-couch] is coming
+soon.
+
+== Feedback & bug reports
+
+Please bear in mind that the project is still in its alpha days. Keep bug reports
+and suggestions limited to the google group and #ruote channel, at least for the
+time being.
+
+Please do not hesitate to come back with *any* feedback.
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2009 Kenneth Kalmer (Internet Exchange CC, Clear Planet Information Solutions Pty Ltd)
+
+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.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+require 'vendor/gems/environment' if File.exist?('vendor/gems/environment.rb')
+
+require 'lib/ruote-kit'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'ruote-kit'
+    gemspec.version = RuoteKit::VERSION
+    gemspec.summary = 'ruote workflow engine, wrapped in a loving rack embrace'
+    gemspec.description = 'ruote-kit is a RESTful Rack app for the ruote workflow engine'
+    gemspec.email = 'kenneth.kalmer@gmail.com'
+    gemspec.homepage = 'http://github.com/kennethkalmer/ruote-kit'
+    gemspec.authors = ['kenneth.kalmer@gmail.com']
+    gemspec.extra_rdoc_files.include '*.txt'
+
+    gemspec.files.include 'lib/ruote-kit/public/**/*'
+    gemspec.executables.clear
+
+    gemspec.add_dependency 'sinatra', '>=0.9.4'
+    gemspec.add_dependency 'haml', '>= 2.2.5'
+    gemspec.add_dependency 'json'
+    gemspec.add_dependency 'ruote', '= 2.1.4'
+    gemspec.add_development_dependency 'rspec'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with 'gem install jeweler'"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec #=> :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/config.ru

@@ -0,0 +1,21 @@
+require 'vendor/gems/environment' if ::File.exist?( 'vendor/gems/environment.rb' )
+
+$:.unshift 'lib'
+
+require 'lib/ruote-kit'
+
+# Chance to configure ruote-kit
+RuoteKit.configure do |config|
+  
+  # storage mode
+  #config.mode = :transient
+
+  # run a worker
+  config.run_worker = true
+end
+
+use Rack::CommonLogger
+use Rack::Lint
+use Rack::ShowExceptions
+
+run RuoteKit::Application

data/lib/ruote-kit/application.rb

@@ -0,0 +1,50 @@
+require 'ruote-kit/vendor/sinatra-respond_to/lib/sinatra/respond_to'
+require 'haml'
+
+module RuoteKit
+  class Application < Sinatra::Base
+
+    # Delay these a bit
+    configure do
+      # We want to support Rails
+      if defined?( Rails )
+        set :environment, Rails.env
+        disable :raise_errors
+      end
+
+      RuoteKit.ensure_engine!
+    end
+
+    set :views, File.join( File.dirname( __FILE__), 'views' )
+
+    use Rack::Static, :urls => ['/_ruote/images', '/_ruote/javascripts', '/_ruote/stylesheets'], :root => File.join( File.dirname(__FILE__), 'public' )
+    use Rack::MethodOverride
+
+    helpers do
+      include RuoteKit::Helpers::EngineHelpers
+      include RuoteKit::Helpers::FormHelpers
+      include RuoteKit::Helpers::LaunchItemParser
+      include RuoteKit::Helpers::NavigationHelpers
+      include RuoteKit::Helpers::RenderHelpers
+    end
+
+    before do
+      # We allow the Accept header to be set to 'application/json'
+      format :json if env["HTTP_ACCEPT"] && env["HTTP_ACCEPT"] == "application/json"
+    end
+
+    not_found do
+      resource_not_found
+    end
+
+    get '/_ruote' do
+      respond_to do |format|
+        format.html { haml :index }
+        format.json { json :misc, "ruote-kit" => "welcome", "version" => RuoteKit::VERSION }
+      end
+    end
+
+    Dir[ File.dirname(__FILE__) + '/resources/*.rb' ].each { |r| load r }
+  end
+end
+

data/lib/ruote-kit/configuration.rb

@@ -0,0 +1,52 @@
+module RuoteKit
+  # RuoteKit configuration handling
+  class Configuration
+
+    # Working directory for the engine (if using file system persistence)
+    attr_accessor :work_directory
+
+    # Number of workers to spawn (1 by default)
+    attr_accessor :workers
+
+    # Whether to run the engine or not (defaults to true)
+    attr_accessor :run_engine
+
+    # Whether to run a single worker or not (defaults to false)
+    attr_accessor :run_worker
+
+    def initialize
+      self.work_directory = File.join( Dir.pwd, "work_#{RuoteKit.env}" )
+      self.run_engine = true
+      self.run_worker = false
+    end
+
+    # Return the selected ruote-kit mode
+    def mode
+      @mode ||= :file_system
+    end
+
+    # Set the ruote-kit mode
+    def mode=( mode )
+      raise ArgumentError, "Unsupported mode (#{mode})" unless [ :transient, :file_system ].include?( mode )
+      @mode = mode
+    end
+
+    # Return the best suited storage class for the current mode
+    def storage_instance
+      case mode
+      when :transient
+        require 'ruote/storage/hash_storage'
+        Ruote::HashStorage.new
+      when :file_system
+        require 'ruote/storage/fs_storage'
+        Ruote::FsStorage.new( self.work_directory )
+      end
+    end
+
+    def catchall_participant
+      require 'ruote/part/storage_participant'
+      Ruote::StorageParticipant
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+module RuoteKit
+  module Helpers
+    module EngineHelpers
+
+      def engine
+        RuoteKit.engine
+      end
+
+      def store_participant
+        RuoteKit.engine.context.plist.lookup('.*')
+      end
+
+      def find_workitems( wfid )
+        store_participant.by_wfid( wfid )
+      end
+
+      def find_workitem( wfid, expid )
+        find_workitems( wfid ).detect { |wi| wi.fei.expid == expid }
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,11 @@
+module RuoteKit
+  module Helpers
+    module FormHelpers
+
+      def button( text, css_class = nil )
+        "<button type=\"submit\" class=\"#{css_class}\"><span><span>#{text}</span></span></button>"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module RuoteKit
+  module Helpers
+    module LaunchItemParser
+
+      # Extract the launch item parameters from a posted form or a JSON request body
+      def launch_item_from_post
+        case env["CONTENT_TYPE"]
+
+        when "application/json" then
+          data = JSON.parse( env["rack.input"].read )
+          launch_item = {}
+          launch_item['pdef'] = data["definition"]
+          launch_item['fields'] = data["fields"] || {}
+          launch_item['variables'] = data["variables"] || {}
+          return launch_item
+
+        when "application/x-www-form-urlencoded"
+          launch_item = { 'pdef' => params[:process_definition] }
+          fields = params[:process_fields] || ""
+          fields = "{}" if fields.empty?
+          launch_item['fields'] = JSON.parse( fields )
+          vars = params[:process_variables] || ""
+          vars = "{}" if vars.empty?
+          launch_item['variables'] = JSON.parse( vars )
+          return launch_item
+
+        else
+          raise "#{env['CONTENT_TYPE']} not supported as a launch mechanism yet"
+        end
+      end
+
+      def field_updates_and_proceed_from_put
+        options = {
+          :fields => {},
+          :proceed => false
+        }
+
+        case env['CONTENT_TYPE']
+
+        when "application/json" then
+          data = JSON.parse( env['rack.input'].read )
+          options[:fields] = data['fields'] unless data['fields'].nil? || data['fields'].empty?
+          options[:proceed] = data['_proceed'] unless data['_proceed'].nil? || data['_proceed'].empty?
+
+        when "application/x-www-form-urlencoded"
+          options[:fields] = JSON.parse( params[:fields] ) unless params['fields'].nil? || params['fields'].empty?
+          options[:proceed] = params[:_proceed] unless params[:_proceed].nil? || params[:_proceed].empty?
+
+        else
+          raise "#{evn['CONTENT_TYPE']} is not supported for workitem fields"
+        end
+
+        return options
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module RuoteKit
+  module Helpers
+    module NavigationHelpers
+
+      def navigate_to( text, path )
+        css_classes = []
+        css_classes << 'first' if @first.nil?
+        @first = true
+
+        css_classes << 'active' if path.split('/')[2] == request.path.split('/')[2]
+
+        "<li class=\"#{css_classes.join(' ')}\"><a href=\"#{ path }\">#{text}</a></li>"
+      end
+
+      def pluralize( number, word )
+        if number > 1
+          word << 's'
+        end
+
+        return [ number, word ].join(' ')
+      end
+
+      def link_to( object, *args )
+        case object
+        when Ruote::ProcessStatus
+          link_to_process( object )
+        when Ruote::Workitem
+          link_to_workitem( object )
+        when String
+          "<a href=\"#{args.first}\">#{object}</a>"
+        end
+      end
+
+      def link_to_workitem( workitem )
+        path = "/_ruote/workitems/#{workitem.fei.wfid}/#{workitem.fei.expid}"
+
+        "<a href=\"#{path}\">GET #{path}</a>"
+      end
+
+      def link_to_process( status )
+        path = "/_ruote/processes/#{status.wfid}"
+
+        "<a href=\"#{path}\">GET #{path}</a>"
+      end
+
+      def link_to_expression( expression )
+        path = "/_ruote/expressions/#{expression.fei.wfid}/#{expression.fei.expid}"
+
+        "<a href=\"#{path}\">GET #{path}</a>"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+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
+
+        {
+          "links" => links( resource ),
+          resource => object
+        }.to_json
+      end
+
+      def json_processes( processes )
+        processes.map { |p| json_process( p ) }
+      end
+
+      def json_process( process )
+        links = [
+          link( "/_ruote/processes/#{process.wfid}", rel('#process') ),
+          link( "/_ruote/expressions/#{process.wfid}", rel('#expressions') ),
+          link( "/_ruote/workitems/#{process.wfid}", rel('#workitems') )
+        ]
+
+        process.to_h.merge( 'links' => links )
+      end
+
+      def json_expression( expression )
+        links = [
+          link( "/_ruote/processes/#{expression.fei.wfid}", rel('#process') ),
+          link( "/_ruote/expressions/#{expression.fei.wfid}", rel('#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 )
+        links = [
+          link( "/_ruote/processes/#{workitem.fei.wfid}", rel('#process') ),
+          link( "/_ruote/expressions/#{workitem.fei.wfid}", rel('#expressions') )
+        ]
+
+        workitem.to_h.merge( 'links' => links )
+      end
+
+      def rel( fragment )
+        "http://ruote.rubyforge.org/rels.html#{ fragment }"
+      end
+
+      def links( resource )
+        links = [
+          link( '/_ruote', rel('#root') ),
+          link( '/_ruote/processes', rel('#processes') ),
+          link( '/_ruote/workitems', rel('#workitems') ),
+          link( '/_ruote/history', rel("#history") ),
+          link( request.fullpath, 'self' )
+        ]
+
+        links
+      end
+
+      def link( href, rel )
+        { 'href' => href, 'rel' => rel }
+      end
+
+      # Easy 404
+      def resource_not_found
+        status 404
+        respond_to do |format|
+          format.html { haml :resource_not_found }
+          format.json { { "error" => { "code" => "404", "message" => "Resource not found" } }.to_json }
+        end
+      end
+
+      # Extract the process tree
+      def process_tree( object )
+        case object
+        when Ruote::Workitem
+          process = engine.process( object.fei.wfid )
+          process.current_tree.to_json
+        when Ruote::ProcessStatus
+          object.current_tree.to_json
+        end
+      end
+
+    end
+  end
+end

data/lib/ruote-kit/helpers.rb

@@ -0,0 +1,9 @@
+module RuoteKit
+  module Helpers
+    autoload :EngineHelpers, 'ruote-kit/helpers/engine_helpers'
+    autoload :FormHelpers,   'ruote-kit/helpers/form_helpers'
+    autoload :LaunchItemParser, 'ruote-kit/helpers/launch_item_parser'
+    autoload :NavigationHelpers, 'ruote-kit/helpers/navigation_helpers'
+    autoload :RenderHelpers, 'ruote-kit/helpers/render_helpers'
+  end
+end