ruote-jig 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+nbproject
+work

data/LICENSE.txt

@@ -0,0 +1,22 @@
+
+Copyright (c) 2001-2009, Torsten Schönebaum (http://github.com/tosch/),
+  Planquadrat Software-Integration GmbH
+
+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/README.rdoc

@@ -0,0 +1,79 @@
+= ruote-jig
+
+Ruote 2.0 participant which does a HTTP call using rufus-jig
+(http://rufus.rubyforge.org/rufus-jig/), a HTTP client, greedy with JSON
+content.
+
+By default, it POSTs received workitems as JSON to a HTTP server and stores the
+answer back into the workitem. If the answer is in JSON, it is automatically
+converted into Ruby data types (this magic is thanks to rufus-jig).
+
+The handling of outgoing and incoming data may be customized by Procs.
+
+== usage
+
+   require 'yajl' # by default, you will need some JSON lib (yajl-ruby or json_pure or ActiveSupport)
+
+   # require this lib
+   require 'ruote/jig/part/jig_participant'
+
+   # let's assume you have a ruote engine in '''engine'''
+   engine.register_participant :jig_default, Ruote::Jig::JigParticipant
+   engine.register_participant :jig_advanced, Ruote::Jig::JigParticipant.new(
+     :host              => 'somehost',
+     :port              => 80,
+     :path              => '/path/to/the/magic',
+     :method            => :post,
+     :content_type      => 'foo/bar',
+     :data_preparition  => Proc.new {|workitem| workitem.fields['foo_bar'].to_s},
+     :response_handling => Proc.new do |response, workitem|
+       workitem.set_field('incoming_foo_bar', FooBar.from_str(response.body))
+     end
+   )
+
+   # in a workflow definition...
+   participant :ref => 'jig_default' # will POST the current workitem as JSON
+                                     # to http://127.0.0.1:3000/ and save the
+                                     # responded data in the workitem field
+                                     # \_\_jig_response__
+
+   participant :ref => 'jig_advanced', # will PUT the the string returned by
+     :host   => 'anotherhost',         # workitem.fields['foo_bar'].to_s to
+     :path   => '/path/to/bar',        # http://anotherhost:80/path/to/bar,
+     :method => :put                   # processes the response body and
+                                       # saves the result in the workitem
+                                       # field 'incoming_foo_bar'
+
+== running tests
+
+to run unit tests
+
+  ruby test/test.rb
+
+fakeweb and yajl-ruby have to be installed.
+
+
+== license
+
+MIT
+
+
+== links
+
+* http://github.com/tosch/ruote-jig
+* http://rufus.rubyforge.org/rufus-jig/
+* http://ruote.rubyforge.org/
+
+
+== feedback
+
+mailing list:: http://groups.google.com/group/openwferu-users
+irc:: irc.freenode.net \#ruote
+
+== credits
+
+* Torsten Schönebaum, Planquadrat Software-Integration GmbH (http://github.com/tosch)
+
+Many thanks to John Mettraux (http://jmettraux.wordpress.com) for his tireless
+work on Ruote and the many rufus libs. Thanks to Kenneth Kalmer
+(http://github.com/kennethkalmer) for his work on rufus-jig.

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "ruote-jig"
+    gemspec.summary = "Ruote participant using rufus-jig"
+    gemspec.description = "A ruote 2.0 participant implementation using rufus-jig to notify HTTP interfaces (mostly JSON-aware) about workitems."
+    gemspec.email = "torsten.schoenebaum@planquadrat-software.de"
+    gemspec.homepage = "http://github.com/tosch/ruote-jig"
+    gemspec.authors = ["Torsten Schönebaum"]
+    gemspec.add_dependency('ruote', '>= 2.0.0')
+    gemspec.add_dependency('rufus-jig', '>= 0.1.2')
+    gemspec.rdoc_options << '--line-numbers' << '--main' << 'README.rdoc'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/example.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+
+require 'ruote/engine'     # gem install ruote
+require 'ruote/log/logger'
+
+require 'patron' # gem install patron
+require 'yajl'   # gem install yajl-ruby
+
+require 'lib/ruote/jig/part/jig_participant'
+
+
+e = Ruote::Engine.new
+
+# e.register_listener Ruote::Logger.new, :name => :s_logger # uncomment to have some debug output
+
+e.register_participant :jig, Ruote::Jig::JigParticipant
+e.register_participant :put_fields do |wi|
+  puts wi.fields.inspect
+end
+
+pdef = Ruote.process_definition :name => 'test' do
+  sequence do
+    jig :path => '/my/index', :method => :post
+    put_fields
+  end
+end
+
+wfid = e.launch(pdef)
+
+e.wait_for(wfid)

data/lib/ruote/jig/part/jig_participant.rb

@@ -0,0 +1,204 @@
+#--
+# Copyright (c) 2009, Torsten Schönebaum (http://github.com/tosch/)
+#
+# 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 Europe.
+#++
+
+require 'rufus/jig' # gem install rufus-jig
+
+require 'ruote/engine/context'         # gem install ruote
+require 'ruote/part/local_participant' # gem install ruote
+
+module Ruote #:nodoc:
+  module Jig #:nodoc:
+    #
+    # Ruote 2.0 participant which does a HTTP call using rufus-jig
+    # (http://rufus.rubyforge.org/rufus-jig/), a HTTP client, greedy with JSON
+    # content.
+    #
+    # By default, it POSTs received workitems as JSON to a HTTP server and
+    # stores the answer back into the workitem. If the answer is in JSON, it is
+    # automatically converted into Ruby data types (this magic is thanks to
+    # rufus-jig).
+    #
+    # The handling of outgoing and incoming data may be customized by Procs.
+    #
+    # == Using it
+    #   require 'yajl' # by default, you will need some JSON lib (yajl-ruby or json_pure or ActiveSupport)
+    #
+    #   # require this lib
+    #   require 'ruote/jig/part/jig_participant'
+    #
+    #   # let's assume you have a ruote engine in '''engine'''
+    #   engine.register_participant :jig_default, Ruote::Jig::JigParticipant
+    #   engine.register_participant :jig_advanced, Ruote::Jig::JigParticipant.new(
+    #     :host              => 'somehost',
+    #     :port              => 80,
+    #     :path              => '/path/to/the/magic',
+    #     :method            => :post,
+    #     :content_type      => 'foo/bar',
+    #     :data_preparition  => Proc.new {|workitem| workitem.fields['foo_bar'].to_s},
+    #     :response_handling => Proc.new do |response, workitem|
+    #       workitem.set_field('incoming_foo_bar', FooBar.from_str(response.body))
+    #     end
+    #   )
+    #
+    #   # in a workflow definition...
+    #   participant :ref => 'jig_default' # will POST the current workitem as JSON
+    #                                     # to http://127.0.0.1:3000/ and save the
+    #                                     # responded data in the workitem field
+    #                                     # __jig_response__
+    #
+    #   participant :ref => 'jig_advanced', # will PUT the the string returned by
+    #     :host   => 'anotherhost',         # workitem.fields['foo_bar'].to_s to
+    #     :path   => '/path/to/bar',        # http://anotherhost:80/path/to/bar,
+    #     :method => :put                   # processes the response body and
+    #                                       # saves the result in the workitem
+    #                                       # field 'incoming_foo_bar'
+    #
+    # == Getting help
+    # * http://groups.google.com/group/openwferu-users
+    # * irc.freenode.net #ruote
+    #
+    # == Issue tracker
+    # http://github.com/tosch/ruote-jig/issues
+    #
+    class JigParticipant
+      include Ruote::EngineContext
+      include Ruote::LocalParticipant
+
+      #
+      # ==options hash
+      # :host <String>:: The host to connect to (defaults to 127.0.0.1)
+      # :port <Fixnum>:: ...and its port (defaults to 3000)
+      # :path <String>:: The path part of the URL. Defaults to '/'.
+      # :method <Symbol>:: Which HTTP method shall be used? One of :get, :post, :put and :delete.
+      # :options_for_jig <Hash>:: Hash of options which will be passed to Rufus::Jig::Http.new.
+      # :options_for_jig_requests <Hash>:: Hash of options which will be passed to the get, put, post or delete method of Rufus::Jig::Http
+      # :response_handling <Proc>:: An optional Proc which handles the results Rufus::Jig::Http returns. Takes the results and the workitem as arguments. By default (when no Proc is given), the server's response is stored in the workitem field \_\_jig_response__ and the HTTP status code in \_\_jig_status__.
+      # :data_preparition <Proc>:: An optional Proc which prepares the data being sent with POST or PUT requests. Takes the workitem as argument. Should return a string or another type Rufus::Jig::Http can handle. By default (if no Proc is given), the workitem will be converted into a Hash (and then into a JSON string by rufus-jig).
+      # :content_type <String or Symbol>:: The content type to use for the HTTP request. Defaults to :json. Other types has to be submitted as strings. Note that you really should provide a :data_preparition-Proc if you don't use JSON!
+      #
+      # All options may be overridden by params when calling the participant in
+      # a workflow definition.
+      #
+      def initialize(options = {})
+        @options = options
+
+        # some defaults
+        @options[:host] ||= '127.0.0.1'
+        @options[:port] ||= 3000
+        @options[:method] ||= :post
+        @options[:path] ||= '/'
+        @options[:content_type] ||= :json
+
+        @http = Rufus::Jig::Http.new @options[:host], @options[:port], @options[:options_for_jig] || {}
+      end
+
+      #
+      # This is where the work is done...
+      #
+      # The engine calls this method and passes it a workitem as argument. The
+      # HTTP request will be processed and the workitem will be returned to the
+      # engine immediately after that.
+      #
+      def consume workitem
+        # do we need a new instance of the http client?
+        http = if(@http.host == param(workitem, :host) and @http.port == param(workitem, :port))
+          @http
+        else
+          Rufus::Jig::Http.new param(workitem, :host), param(workitem, :port), @options[:options_for_jig] || {}
+        end
+
+        # fire the request...
+        response = case param(workitem, :method).to_sym
+        when :get
+          http.get param(workitem, :path), prepare_request_options(workitem)
+        when :post
+          http.post param(workitem, :path), prepare_data(workitem), prepare_request_options(workitem)
+        when :put
+          http.put param(workitem, :path), prepare_data(workitem), prepare_request_options(workitem)
+        when :delete
+          http.delete param(workitem, :path), prepare_request_options(workitem)
+        else
+          raise "Method #{param(workitem, :method).to_s} not supported"
+        end
+
+        # ... and handle the response
+        if (block = param(workitem, :response_handling)).is_a?(Proc)
+          # there is a proc which does the response handling for us
+          block.call(response, workitem)
+        else
+          # we'll have to do the handling by ourselves
+          case response
+          when Rufus::Jig::HttpResponse
+            workitem.set_field '__jig_response__', response.body
+            workitem.set_field '__jig_status__', response.status
+          else
+            workitem.set_field '__jig_response__', response
+            workitem.set_field '__jig_status__', http.last_response.status
+          end
+        end
+
+        # reply the workitem to the engine
+        reply_to_engine(workitem)
+      end
+
+      # For now, does nothing.
+      # Could stop a running consume method some day?
+      def cancel
+      end
+
+      protected
+
+      #
+      # extract parameter from params field of workitem or use default from
+      # options hash
+      #
+      def param workitem, key
+        workitem.fields['params'][key.to_s] || @options[key]
+      end
+
+      #
+      # Prepare the data for post and put requests. Returns the workitem as
+      # hash by default or the results of the executed Proc given in the options
+      # as :data_preparition.
+      #
+      def prepare_data workitem
+        if((block = param(workitem, :data_preparition)).is_a?(Proc))
+          block.call workitem
+        else
+          workitem.to_h
+        end
+      end
+
+      #
+      # Prepare the request options to be submitted to rufus-jig.
+      #
+      def prepare_request_options workitem
+        {
+          :content_type => param(workitem, :content_type),
+          :params => param(workitem, :params) || nil
+        }.merge(param(workitem, :options_for_jig_request) || {})
+      end
+    end
+  end
+end

data/ruote-jig.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruote-jig}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Torsten Sch\303\266nebaum"]
+  s.date = %q{2009-12-08}
+  s.description = %q{A ruote 2.0 participant implementation using rufus-jig to notify HTTP interfaces (mostly JSON-aware) about workitems.}
+  s.email = %q{torsten.schoenebaum@planquadrat-software.de}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "example.rb",
+     "lib/ruote/jig/part/jig_participant.rb",
+     "ruote-jig.gemspec",
+     "test/test.rb",
+     "test/ut_0.rb"
+  ]
+  s.homepage = %q{http://github.com/tosch/ruote-jig}
+  s.rdoc_options = ["--charset=UTF-8", "--line-numbers", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Ruote participant using rufus-jig}
+  s.test_files = [
+    "test/test.rb",
+     "test/ut_0.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ruote>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<rufus-jig>, [">= 0.1.2"])
+    else
+      s.add_dependency(%q<ruote>, [">= 2.0.0"])
+      s.add_dependency(%q<rufus-jig>, [">= 0.1.2"])
+    end
+  else
+    s.add_dependency(%q<ruote>, [">= 2.0.0"])
+    s.add_dependency(%q<rufus-jig>, [">= 0.1.2"])
+  end
+end
+

data/test/test.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+
+require 'test/unit'
+require 'test/ut_0'

data/test/ut_0.rb

@@ -0,0 +1,97 @@
+class JigParticipantTests < Test::Unit::TestCase
+  def setup
+    require 'fakeweb' # gem install fakeweg
+    require 'yajl'    # gem install yaijl-ruby
+    require 'lib/ruote/jig/part/jig_participant'
+    require 'rufus/jig/json'
+
+    @engine = Engine.new
+    @jig_participant = new_jig_participant()
+    @test_hash = {'test' => {'foo' => 'bar', 'dash' => 'buzz'}}
+    @test_hash_json = Rufus::Jig::Json.encode(@test_hash)
+  end
+
+  # test if the default options are treated ok
+  def test_defaults
+    FakeWeb.register_uri(:post, "http://127.0.0.1:3000/", :body => @test_hash_json, :content_type => 'application/json')
+    @jig_participant.consume(wi = new_workitem) # ('params' => {'host' => 'localhost', 'port' => 3000, 'path' => '/'}))
+    assert_equal(wi, @engine.workitem)
+    assert_equal(@test_hash, @engine.workitem.fields['__jig_response__'])
+    assert_equal(200, @engine.workitem.fields['__jig_status__'])
+  end
+
+  # test if the default options are overridden when others are passed at initialization time
+  def test_initialization_options
+    FakeWeb.register_uri(:get, 'http://foo:123/bar', :body => 'this is just a test', :content_type => 'text/plain')
+    jp = new_jig_participant(:host => 'foo', :port => 123, :path => 'bar', :method => :get, :content_type => 'text/plain')
+    jp.consume(new_workitem)
+    assert_equal('this is just a test', @engine.workitem.fields['__jig_response__'])
+  end
+
+  # test if the options from the params field of the workitem are used above the defaults
+  def test_params
+    FakeWeb.register_uri(:post, 'http://127.100.100.100:80/baz', :body => @test_hash_json, :content_type => 'application/json')
+    @jig_participant.consume(new_workitem('params' => {'host' => '127.100.100.100', 'port' => 80, 'path' => '/baz'}))
+    assert_equal(@test_hash, @engine.workitem.fields['__jig_response__'])
+  end
+
+  def test_data_preparition
+    jp = new_jig_participant(
+      :content_type => 'text/plain',
+      :data_preparition => Proc.new { |workitem| workitem.fields['my_data'] }
+    )
+    # overwrite Rufus::Jig::Http#do_post
+    http = jp.instance_variable_get(:@http)
+    def http.do_post(path, data, opts)
+      r = {:status => 200, :body => data.reverse, :headers => {'Content-Type' => opts['Content-Type']}}
+      def r.method_missing sym
+        self[sym]
+      end
+      r
+    end
+    jp.consume(new_workitem('my_data' => '1234567890'))
+    assert_equal('0987654321', @engine.workitem.fields['__jig_response__'])
+  end
+
+  def test_response_handling
+    FakeWeb.register_uri(:post, "http://127.0.0.1:3000/", :body => '1234567890', :content_type => 'text/plain')
+    jp = new_jig_participant(
+      :content_type => 'text/plain',
+      :response_handling => Proc.new {|response, workitem| workitem.set_field('my_result', response.reverse)}
+    )
+    jp.consume(new_workitem)
+    assert_equal('0987654321', @engine.workitem.fields['my_result'])
+  end
+
+  protected
+
+  class Engine
+    attr_accessor :workitem
+    def reply (wi)
+      @workitem = wi
+    end
+  end
+
+  def new_jig_participant(opts = {})
+    jp = Ruote::Jig::JigParticipant.new opts
+    jp.instance_variable_set(:@engine, @engine)
+    def jp.engine
+      @engine
+    end
+    jp
+  end
+
+  def new_workitem(fields = {})
+    wi = {'params' => {}}.merge(fields)
+    def wi.fields
+      self
+    end
+    def wi.to_h
+      self
+    end
+    def wi.set_field(k, v)
+      self[k] = v
+    end
+    wi
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: ruote-jig
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Torsten Sch\xC3\xB6nebaum"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruote
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rufus-jig
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.2
+    version: 
+description: A ruote 2.0 participant implementation using rufus-jig to notify HTTP interfaces (mostly JSON-aware) about workitems.
+email: torsten.schoenebaum@planquadrat-software.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- example.rb
+- lib/ruote/jig/part/jig_participant.rb
+- ruote-jig.gemspec
+- test/test.rb
+- test/ut_0.rb
+has_rdoc: true
+homepage: http://github.com/tosch/ruote-jig
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --line-numbers
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruote participant using rufus-jig
+test_files: 
+- test/test.rb
+- test/ut_0.rb