ruote 2.2.0 → 2.3.0

data/lib/ruote/util/hashdot.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -32,18 +32,14 @@ module Ruote
       m = m.to_s
 
       if m[-1, 1] == '='
-
-        val = args.first
-        self[m[0..-2]] = val
-
-        return val
-
+        if args.first.nil?
+          self.delete(m[0..-2]); nil
+        else
+          self[m[0..-2]] = args.first
+        end
       else
-
-        return self[m] #if self.has_key?(m)
+        self[m]
       end
-
-      #super
     end
 
     def dump
@@ -55,9 +51,15 @@ module Ruote
         s << "\n"
       end
       s << "~~ . ~~"
-
-      s
     end
+
+    #--
+    # Useful when debugging some 'stack too deep' issue
+    #
+    #def self.included(target)
+    #  raise target.to_s unless target.to_s.match(/\bHash\b/)
+    #end
+    #++
   end
 
   module WithH

data/lib/ruote/util/look.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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

data/lib/ruote/util/lookup.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -25,23 +25,49 @@
 
 module Ruote
 
+  #--
+  # methods that accept a small "dot notation" for looking up
+  # into nested hashes and arrays
+  #++
+
   #   h = { 'a' => { 'b' => [ 1, 3, 4 ] } }
   #
   #   p Ruote.lookup(h, 'a.b.1') # => 3
   #
-  def Ruote.lookup(collection, key, container_lookup=false)
+  def self.lookup(collection, key, container_lookup=false)
 
     return collection if key == '.'
 
     key, rest = pop_key(key)
-    value = flookup(collection, key)
+    value = fetch(collection, key)
 
     return [ key, collection ] if container_lookup && rest.size == 0
     return [ rest.first, value ] if container_lookup && rest.size == 1
     return value if rest.size == 0
     return nil if value == nil
 
-    lookup(value, rest)
+    lookup(value, rest, container_lookup)
+  end
+
+  #   h = { 'a' => { 'b' => [ 1, 3, 4 ] } }
+  #
+  #   p Ruote.lookup(h, 'a.b.1') # => true
+  #
+  def self.has_key?(collection, key)
+
+    return collection if key == '.'
+
+    key, rest = pop_key(key)
+
+    return has_key?(fetch(collection, key), rest) if rest.any?
+
+    if collection.respond_to?(:has_key?)
+      collection.has_key?(key)
+    elsif collection.respond_to?(:[])
+      key.to_i < collection.size
+    else
+      false
+    end
   end
 
   #   h = { 'customer' => { 'name' => 'alpha' } }
@@ -50,7 +76,7 @@ module Ruote
   #
   #   h #=> { 'customer' => { 'name' => 'bravo' } }
   #
-  def Ruote.set(collection, key, value)
+  def self.set(collection, key, value)
 
     k, c = lookup(collection, key, true)
 
@@ -68,47 +94,59 @@ module Ruote
   #   h # => { 'customer' => { 'name' => 'alpha' } }
   #   r # => '1st'
   #
-  def Ruote.unset(collection, key)
+  def self.unset(collection, key)
 
     k, c = lookup(collection, key, true)
 
-    return collection.delete(key) unless c
-
-    if c.is_a?(Array)
+    if c.nil?
+      collection.delete(key)
+    elsif c.is_a?(Array)
       c.delete_at(Integer(k)) rescue nil
-    else
+    elsif c.is_a?(Hash)
       c.delete(k)
+    else
+      nil
     end
   end
 
   protected # well...
 
-  def Ruote.pop_key(key)
+  # Pops the first key in a path key.
+  #
+  #   Ruote.pop_key('a.b.c') # => 'a'
+  #   Ruote.pop_key('1.2.3') # => 1
+  #
+  # (note the narrowing to an int that happens)
+  #
+  def self.pop_key(key)
 
     ks = key.is_a?(String) ? key.split('.') : key
 
     [ narrow_key(ks.first), ks[1..-1] ]
   end
 
-  def Ruote.narrow_key(key)
-
-    return 0 if key == '0'
-
-    i = key.to_i
-    return i if i != 0
+  # If the key holds an integer returns it, else return the key as is.
+  #
+  def self.narrow_key(key)
 
-    key
+    key.match(/^-?\d+$/) ? key.to_i : key
   end
 
-  def Ruote.flookup(collection, key)
+  # Given a collection and a key returns the corresponding value
+  #
+  #   Ruote.fetch([ 12, 13, 24 ], 1) # => 13
+  #   Ruote.fetch({ '1' => 13 }, 1) # => 13
+  #   Ruote.fetch({ 1 => 13 }, 1) # => 13
+  #
+  def self.fetch(collection, key)
 
     value = (collection[key] rescue nil)
 
     if value == nil and key.is_a?(Fixnum)
-      value = (collection[key.to_s] rescue nil)
+      (collection[key.to_s] rescue nil)
+    else
+      value
     end
-
-    value
   end
 end
 

data/lib/ruote/util/misc.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -22,6 +22,8 @@
 # Made in Japan.
 #++
 
+require 'socket'
+
 
 module Ruote
 
@@ -82,7 +84,7 @@ module Ruote
       value = fulldup(value)
       begin
         o.instance_variable_set(v, value)
-      rescue => e
+      rescue
         # ignore, must be readonly
       end
     end
@@ -124,22 +126,23 @@ module Ruote
     s.split('::').inject(Object) { |c, n| n == '' ? c : c.const_get(n) }
   end
 
-#  # Upon receiving something like
-#  #
-#  #   "(?-mix:nada)"
-#  #
-#  # will return
-#  #
-#  #   /nada/
-#  #
-#  def self.regex_from_s(s)
-#
-#    if s.is_a?(String) && m = s.match(/^\(\?-mix:(.+)\)$/)
-#      Regexp.new(m[1])
-#    else
-#      nil
-#    end
-#  end
+  # Makes sure all they keys in the given hash are turned into strings
+  # in the resulting hash.
+  #
+  def self.keys_to_s(h)
+
+    h.remap { |(k, v), h| h[k.to_s] = v }
+  end
+
+  # Makes sure all they keys in the given hash are turned into symbols
+  # in the resulting hash.
+  #
+  # Mostly used in ruote-amqp.
+  #
+  def self.keys_to_sym(h)
+
+    h.remap { |(k, v), h| h[k.to_sym] = v }
+  end
 
   REGEX_IN_STRING = /^\s*\/(.*)\/\s*$/
 
@@ -155,5 +158,47 @@ module Ruote
       s
     end
   end
+
+  # From http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+  #
+  # Returns the (one of the) local IP address.
+  #
+  def self.local_ip
+
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+      # turn off reverse DNS resolution temporarily
+
+    UDPSocket.open do |s|
+      s.connect('64.233.187.99', 1)
+      s.addr.last
+    end
+
+  rescue
+
+    nil
+
+  ensure
+    Socket.do_not_reverse_lookup = orig
+  end
+
+  # Attempts to parse a string of Ruby code (and return the AST).
+  #
+  def self.parse_ruby(ruby_string)
+
+    Rufus::TreeChecker.parse(ruby_string)
+
+  rescue NoMethodError
+
+    raise NoMethodError.new(
+      "/!\\ please upgrade your rufus-treechecker gem /!\\")
+  end
+
+  # Returns an array. If the argument is an array, return it as is. Else
+  # turns the argument into a string and "comma splits" it.
+  #
+  def self.comma_split(o)
+
+    o.is_a?(Array) ? o : o.to_s.split(/\s*,\s*/).collect { |e| e.strip }
+  end
 end
 

data/lib/ruote/util/mpatch.rb

@@ -0,0 +1,53 @@
+#--
+# Copyright (c) 2005-2012, 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.
+#
+# Made in Japan.
+#++
+
+
+# Adding some 1.9 methods to 1.8 Rubies.
+#
+unless {}.respond_to?(:each_with_object)
+
+  module Enumerable
+
+    def each_with_object(o, &block)
+
+      self.inject(o) do |oo, e|
+        block.call(e, oo)
+        oo
+      end
+    end
+  end
+end
+
+class Hash
+
+  # A shortcut for
+  #
+  #   hash.each_with_object({}) { |(k, v), h)| ... }
+  #
+  def remap(&block)
+
+    each_with_object({}, &block)
+  end
+end
+

data/lib/ruote/util/ometa.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2012, 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
@@ -26,7 +26,6 @@
 # note, it's ometa, not omerta.
 #++
 
-
 module Ruote
 
   # meta a la lucky stiff

data/lib/ruote/util/process_observer.rb

@@ -0,0 +1,177 @@
+#--
+# Copyright (c) 2012, Hartog de Mik <hartog@organisedminds.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.
+#
+# Made in Germany.
+#++
+
+module Ruote
+
+  # A base class for process observers, just to provide convenience. It
+  # (heavily) sugar coats the Ruote::Observer and translate the messages into
+  # actions. Each such action is provided with pre-distilled information
+  # relevant for processes.
+  #
+  # == Example implementation
+  #   class WebsocketSubscriber < Ruote::ProcessObserver
+  #      # override initialize to warm-up a websocket client
+  #      def initialize(context, options={})
+  #        super
+  #        @client = WebsocketClient.new()
+  #      end
+  #
+  #      # tell the listeners that a new process launched
+  #      def on_launch(wfid, opts)
+  #        @client.publish(
+  #          "/process/launch",
+  #          { :name       => opts[:workitem].wf_name,
+  #            :wfid       => wfid,
+  #            :definition => opts[:pdef],
+  #          }
+  #        )
+  #      end
+  #
+  #      # tell the listeners that a new process ended
+  #      def on_end(wfid)
+  #        @client.publish("/process/#{wfid}", { :end => true })
+  #      end
+  #   end
+  #
+  # == Actions
+  # The ProcessObserver adheres closely to the message actions, it calls the
+  # following methods:
+  #
+  # on_launch::            When a process or sub-process starts
+  # on_terminated::        When a process ends
+  # on_error_intercepted:: When an error was intercepted
+  # on_cancel::            When a process or sub-process was canceled
+  # on_dispatch::          When a participant is dispatched
+  # on_receive::           Whenever a workitem is received
+  #
+  # And others, but if you are interested in those; you might be better of
+  # using the more low-level Ruote::Observer
+  #
+  # == Arguments
+  # The methods are called with (wfid[, options])
+  #
+  # You can provide a method-signature like:
+  #
+  #   def on_launch(wfid, options)
+  #   def on_launch(wfid)
+  #
+  # If the ProcessObserver cannot call the method with the options, it tries
+  # to call without options
+  #
+  # === Options
+  # The following options are provided:
+  #
+  # :workitem::  The workitem, if available
+  # :action::    The original name of the action
+  # :child::     Boolean; This is an event of a child, or sub-flow
+  # :error::     The intercepted error (only provided with
+  #              #on_error_intercepted)
+  # :pdef::      The (sub-)process definition (only provided with #on_launch)
+  # :variables:: The process variables, if available
+  # :flavour::   The flavour of canceling (only on_cancel)
+  #
+  # == Error handling
+  #
+  # If anywhere in your implementation an action raises an error, it is caught
+  # by the ProcessObserver and silently ignored.
+  #
+  class ProcessObserver
+
+    attr_reader :context, :options, :filtered_actions
+
+    def initialize(context, options={})
+      @filtered_actions = options.delete(:filtered_actions)
+      @filtered_actions ||= []
+      @filtered_actions |=  %w[dispatched participant_registered variable_set]
+
+      @context = context
+      @options = options
+    end
+
+    def on_msg(msg) # :nodoc:
+
+      return if @filtered_actions.include? msg['action']
+
+      wfid  = msg['wfid']
+      child = false
+
+      if !wfid && msg['parent_id']
+        wfid  = msg['parent_id']['wfid']
+        child = true
+      end
+
+      wfid ||= Ruote.extract_wfid(msg)
+      return if !wfid
+
+      workitem = begin
+        if msg['workitem']
+          Ruote::Workitem.new(Rufus::Json.dup(msg['workitem']))
+        else
+          Ruote::Workitem.new({})
+        end
+      rescue
+        Ruote::Workitem.new({})
+      end
+
+      data = {
+        :workitem  => workitem,
+        :action    => msg['action'],
+        :child     => child,
+        :variables => msg['variables'],
+      }
+
+      # the prelimenary method name
+      method = msg['action'].split('_').first
+
+      # change method or fields based on the action
+      case msg['action']
+      when 'launch'
+        data[:pdef] = msg['tree']
+
+      when 'cancel'
+        data[:flavour] = msg['flavour']
+
+      when 'error_intercepted'
+        error = Kernel.const_get(msg['error']['class']).new(msg['error']['message'])
+        error.set_backtrace msg['error']['trace']
+
+        data[:error] = error
+        method = msg['action']
+      end
+
+      callback = "on_#{method}"
+      if self.respond_to?(callback)
+        args = [ wfid ]
+        args << data if self.method(callback).arity.abs == 2
+
+        self.send(callback, *args)
+      end
+
+      return
+    rescue
+      return
+    end
+
+  end
+end