ruote-activeresource 2.0.0

data/.gitignore

@@ -0,0 +1 @@
+nbproject

data/CREDITS.txt

@@ -0,0 +1,15 @@
+
+= ruote-activeresource CREDITS.txt
+
+
+== authors
+
+- John Mettraux (http://jmettraux.wordpress.com)
+- Torsten Schönebaum (http://github.com/tosch)
+
+
+
+== many thanks to
+
+- the Rails team
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+
+Copyright (c) 2001-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.
+

data/README.rdoc

@@ -0,0 +1,34 @@
+
+= ruote-activeresource
+
+ruote 2.0 extension for a participant using ActiveResource to send messages around
+
+
+== usage
+
+well...
+
+
+== running tests
+
+to run unit tests
+
+  ruby test/test.rb
+
+
+== license
+
+MIT
+
+
+== links
+
+http://api.rubyonrails.org/files/vendor/rails/activeresource/README.html
+http://ruote.rubyforge.org/
+
+
+== feedback
+
+mailing list : http://groups.google.com/group/openwferu-users
+irc : irc.freenode.net #ruote
+

data/Rakefile

@@ -0,0 +1,16 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "ruote-activeresource"
+    gemspec.summary = "Ruote participant using ActiveResource"
+    gemspec.description = "A ruote participant implementation using ActiveResource to notify RESTful interfaces about workitems."
+    gemspec.email = "torsten.schoenebaum@planquadrat-software.de"
+    gemspec.homepage = "http://github.com/tosch/ruote-activeresource"
+    gemspec.authors = ["Torsten Schönebaum"]
+    gemspec.add_dependency('ruote', '>= 2.0.0')
+    gemspec.add_dependency('activeresource', '>= 2.0.0')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+2.0.0

data/lib/ruote/active_resource/part/active_resource_participant.rb

@@ -0,0 +1,223 @@
+#--
+# Copyright (c) 2008-2009, Torsten Schönebaum, John Mettraux (OpenWFE.org)
+#
+# 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 and Japan.
+#++
+
+
+require 'activeresource' # gem activeresource
+
+require 'ruote/engine/context'
+require 'ruote/part/local_participant'
+
+
+module Ruote
+  module ActiveResource
+
+    #
+    # Ruote participant which does a REST call. It's using ActiveResource to do
+    # the actual magic. You can call every class and instance method
+    # ActiveResource::Base and its mixins provide. You can also process the
+    # response of the REST request and save some of its data into the workitem
+    # for example.
+    #
+    # Before using this participant you *really* should make yourself familiar
+    # with ActiveResource and its usage.
+    #
+    # ==Using it
+    #
+    # The participant should be registered in the engine in a way like this:
+    #
+    #   engine.register_participant(
+    #     'reminder',
+    #     ActiveResourceParticipant.new(
+    #       {
+    #         :site => 'http://localhost:7000',
+    #         :resource_name => 'story',
+    #         :method => 'put', # we will use ActiveResource::CustomMethods::InstanceMethods#put
+    #         :argument => 'send_reminder', # put is happy with just one
+    #                                       # parameter: The action to be
+    #                                       # called. So we won't have to use a
+    #                                       # block to set the arguments of the
+    #                                       # ActiveResource method to call.
+    #       }
+    #     )
+    #   )
+    #
+    # Let's try a more complex example:
+    #
+    #   engine.register_participant(
+    #     'complex_ares',
+    #     ActiveResourceParticipant.new(
+    #       {
+    #         :site => 'http://localhost:7000',
+    #         :resource_name => 'story',
+    #         :method => 'find', # yes, even ActiveResource::Base#find method
+    #                            # may be used...
+    #         :response_handling => proc do |response, workitem| # define response
+    #                                                            # handling block
+    #           workitem.set_attribute('title', response.attributes['title'])
+    #                            # The type of the response object depends on
+    #                            # the method you use!
+    #         end
+    #       }
+    #     ) do |workitem| # define arguments to use with the find method
+    #       # each argument is an entry in an array the block has to return
+    #       [
+    #          workitem.attributes['story_id'], # the first argument
+    #          {:prefix => 'foo'} # the second one is an hash
+    #       ]
+    #     end
+    #   )
+    #
+    # You can now use the participant in your workflow definitions. An example
+    # using XML:
+    #
+    #     <concurrence count="1">
+    #       <participant ref="qa" />
+    #       <cron every="1m">
+    #         <participant
+    #           ref="reminder"
+    #           site="http://localhost:7000"
+    #           resource_name="story"
+    #           method="put"
+    #           action="send_reminder"
+    #           resource_id="${field:story_id}" />
+    #       </cron>
+    #     </concurrence>
+    #
+    # Here, the ActiveResourceParticipant is used to send a reminder.
+    #
+    # *Note:* prefer configuration of the participant at registration time,
+    # information like 'method', 'site' and 'resource_name' may clutter the
+    # process definition.
+    #
+    class ActiveResourceParticipant
+      include Ruote::EngineContext
+      include Ruote::LocalParticipant
+
+      #
+      # == options hash
+      #
+      # You have to set some default options by passing an options hash to the
+      # new method. It should contain the following keys:
+      #
+      # <tt>:site</tt>:: The URI (as string) of the site where your REST
+      #   interface sits. See <tt>site</tt> parameter in ActiveResource::Base.
+      # <tt>:resource_name</tt>:: The name of the resource you like to access.
+      #   See <tt>element_name</tt> parameter in ActiveResource::Base.
+      # <tt>:method</tt>:: The ActiveResource method to call. In most cases
+      #   should be "get", "put", "post" or "delete".
+      # <tt>:argument</tt>:: The first parameter which should be used as
+      #   argument to the ActiveResource method which will be called. This value
+      #   is ignored if a block is given (see below)
+      # <tt>:resource_id</tt>:: The ID of the resource on which the action
+      #   should be called on default. If negative, nil or false, the action
+      #   will be called on the complete set of resources instead of on a single
+      #   resource determined by its ID.
+      # <tt>:response_handling</tt>:: A proc object / block which gets called
+      #   after the request is done. It gets called with to arguments: The
+      #   response of the ActiveResource method called and the workitem.
+      #
+      # The new method also takes a block. It may be used to set the arguments
+      # of the ActiveResource method to call. The block must return an array of
+      # arguments. The array will be splitted and each entry will be used as
+      # argument to the ActiveResource method called. The block itself takes one
+      # or two arguments: Either only the current workitem or the workitem and
+      # expstorage[workitem.fei].
+      #
+      # All parameters except response_handling and the block set default values
+      # -- you can always override them in the process definition. Just use the
+      # corresponding symbol name (without ":") as attribute.
+      #
+      def initialize (options, &block)
+
+        @options = options
+
+        # some defaults
+        @options[:site] ||= 'http://127.0.0.1:3000'
+        @options[:method] ||= :get
+
+        @block = block
+      end
+
+      #
+      # This method is called each time the participant receives a workitem. It
+      # calls the requested ActiveResource method, calls the response handling
+      # code if present and then immediatly replies to the engine.
+      #
+      def consume (workitem)
+
+        # use block to determine the method's arguments if given
+        args = if @block
+          if @block.arity == 1
+            @block.call(workitem)
+          else
+            @block.call(workitem, expstorage[workitem.fei])
+          end
+        elsif a = param(workitem, :arg) || param(workitem, :argument)
+          Array(a)
+        else
+          [] # no arguments
+        end
+
+        # create new subclass of ActiveResource::Base
+        active_resource_class = Class.new(::ActiveResource::Base)
+        active_resource_class.site = param(workitem, :site) # set site parameter
+        active_resource_class.element_name = param(workitem, :resource_name) # set element name
+
+        # Do we work on a single or on a set of resources? If resource_id is nil
+        # or negative, it's a set of resources.
+
+        resource_id = param(workitem, :resource_id)
+
+        active_resource = if (!resource_id) || (resource_id.to_i < 0)
+          # set of resources
+          active_resource_class
+        else
+          # specific resource
+          active_resource_class.new(:id => resource_id)
+        end
+
+        response = active_resource.send(param(workitem, :method), args)
+
+        # we got our response, but what to do with it?
+        if (h = param(workitem, :response_handling)).is_a?(Proc)
+          h.call(response, workitem)
+        end
+
+        # reply to the engine
+        reply_to_engine(workitem)
+      end
+
+      # Does nothing.
+      def cancel (fei, flavour)
+      end
+
+      protected
+
+      def param (workitem, key)
+        workitem.fields['params'][key.to_s] || @options[key]
+      end
+    end
+
+  end
+end

data/lib/work/wfidgen.last

@@ -0,0 +1 @@
+2009/11/11 13:11:53.44553

data/test/path_helper.rb

@@ -0,0 +1,9 @@
+ruote_lib = File.expand_path(File.dirname(__FILE__) + '/../../ruota/lib')
+ruote_lib = File.expand_path(File.dirname(__FILE__) + '/../../ruote/lib') \
+  unless File.exist?(ruote_lib)
+
+ruote_dm_lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+$:.unshift(ruote_lib) unless $:.include?(ruote_lib)
+$:.unshift(ruote_dm_lib) unless $:.include?(ruote_dm_lib)
+

data/test/test.rb

@@ -0,0 +1,6 @@
+dirpath = File.dirname(__FILE__)
+
+ts = Dir.new(dirpath).entries.select { |e| e.match(/^[uf]t\_.*\.rb$/) }.sort
+
+ts.each { |e| load(File.join(dirpath, e)) }
+

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), 'path_helper')
+
+require 'test/unit'
+require 'rubygems'
+require 'json'
+

data/test/ut_1_participant.rb

@@ -0,0 +1,75 @@
+#
+# testing the ActiveResourceParticipant by Torsten Schoenebaum
+#
+# Tue Dec 16 09:01:28 JST 2008
+#
+
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+require 'ruote/active_resource/part/active_resource_participant'
+
+require 'active_resource/http_mock'
+
+class AresParticipantTest < Test::Unit::TestCase
+
+  def setup
+    @engine = Engine.new()
+
+    @fruit1 = { 'id' => 1, 'name' => 'apple' }
+    @fruits = [ @fruit1 ]
+
+    ActiveResource::HttpMock.respond_to do |mck|
+      mck.get '/fruits/.xml', {}, @fruits.to_xml(:root => 'fruits')
+      mck.get '/fruits/1/.xml', {}, @fruit1.to_xml(:root => 'fruit')
+        #
+        # why /.xml ??, well... it's just some mocking after all...
+        # no time to dig deeper
+    end
+  end
+
+  def test_basic
+
+    response = nil
+
+    par = new_ares_participant({
+      :resource_name => 'fruit',
+      :response_handling => lambda { |r, wi| response = r }
+    })
+
+    workitem = new_workitem(:resource_id => 1)
+
+    par.consume(workitem)
+
+    assert_equal(@fruit1, response)
+    assert_equal({'params'=>{:resource_id=>1}}, @engine.workitem)
+  end
+
+  protected
+
+    class Engine
+      attr_accessor :workitem
+      def reply (wi)
+        @workitem = wi
+      end
+    end
+
+    def new_workitem (opts={})
+      wi = { 'params' => opts }
+      def wi.params
+        self['params'] ||= {}
+      end
+      wi
+    end
+
+    def new_ares_participant(opts={})
+
+      par = Ruote::ActiveResource::ActiveResourceParticipant.new(opts)
+
+      par.instance_variable_set(:@engine, @engine)
+      def par.engine
+        @engine
+      end
+
+      par
+    end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: ruote-activeresource
+version: !ruby/object:Gem::Version 
+  version: 2.0.0
+platform: ruby
+authors: 
+- "Torsten Sch\xC3\xB6nebaum"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-11 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: activeresource
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: A ruote participant implementation using ActiveResource to notify RESTful interfaces about workitems.
+email: torsten.schoenebaum@planquadrat-software.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .gitignore
+- CREDITS.txt
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/ruote/active_resource/part/active_resource_participant.rb
+- lib/work/wfidgen.last
+- test/path_helper.rb
+- test/test.rb
+- test/test_helper.rb
+- test/ut_1_participant.rb
+has_rdoc: true
+homepage: http://github.com/tosch/ruote-activeresource
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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 ActiveResource
+test_files: 
+- test/test_helper.rb
+- test/test.rb
+- test/path_helper.rb
+- test/ut_1_participant.rb