ruote 2.2.0 → 2.3.0

data/lib/ruote/svc/tracker.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
@@ -37,28 +37,18 @@ module Ruote
     def initialize(context)
 
       @context = context
-
-      if @context.worker
-        #
-        # this is a worker context, DO log
-        #
-        @context.worker.subscribe(:all, self)
-      #else
-        #
-        # this is not a worker context, no notifications. BUT
-        # honour calls to add_tracker/remove_tracker
-        #
-      end
     end
 
-    # The worker passes all the messages it has to process to the tracker via
-    # this method.
+    # The context calls this method for each successfully processed msg
+    # in the worker.
     #
-    def notify(msg)
+    def on_msg(message)
+
+      m_error = message['error']
+      m_wfid = message['wfid'] || (message['fei']['wfid'] rescue nil)
+      m_action = message['action']
 
-      m_error = msg['error']
-      m_wfid = msg['wfid'] || (msg['fei']['wfid'] rescue nil)
-      m_action = msg['action']
+      msg = m_action == 'error_intercepted' ? message['msg'] : message
 
       @context.storage.get_trackers['trackers'].each do |tracker_id, tracker|
 
@@ -70,9 +60,7 @@ module Ruote
         next if t_wfid && t_wfid != m_wfid
         next if t_action && t_action != m_action
 
-        next unless does_match?(msg, tracker['conditions'])
-
-        msg = msg['msg'] if m_action == 'error_intercepted'
+        next unless does_match?(message, tracker['conditions'])
 
         if tracker_id == 'on_error' || tracker_id == 'on_terminate'
 
@@ -84,7 +72,7 @@ module Ruote
 
         # prepare and emit/put 'reaction' message
 
-        m = tracker['msg']
+        m = Ruote.fulldup(tracker['msg'])
 
         action = m.delete('action')
 
@@ -93,7 +81,9 @@ module Ruote
 
         m['workitem'] = msg['workitem'] if m['workitem'] == 'replace'
 
-        if tracker_id == 'on_error' && m_action == 'error_intercepted'
+        if t_action == 'error_intercepted'
+          m['workitem']['fields']['__error__'] = m_error
+        elsif tracker_id == 'on_error' && m_action == 'error_intercepted'
           m['workitem']['fields']['__error__'] = m_error
         elsif tracker_id == 'on_terminate' && m_action == 'terminated'
           m['workitem']['fields']['__terminate__'] = { 'wfid' => m_wfid }
@@ -112,6 +102,9 @@ module Ruote
     #
     def add_tracker(wfid, action, id, conditions, msg)
 
+      conditions =
+        conditions && conditions.remap { |(k, v), h| h[k] = Array(v) }
+
       doc = @context.storage.get_trackers
 
       doc['trackers'][id] =
@@ -123,7 +116,7 @@ module Ruote
 
       r = @context.storage.put(doc)
 
-      add_tracker(wfid, action, id, msg) if r
+      add_tracker(wfid, action, id, conditions, msg) if r
         # the put failed, have to redo the work
     end
 
@@ -150,13 +143,20 @@ module Ruote
 
       conditions.each do |k, v|
 
-        val = msg[k]
-        v = Ruote.regex_or_s(v)
+        return false unless Array(v).find do |vv|
+
+          # the Array(v) is for backward compatibility, although newer
+          # track conditions are already stored as arrays.
+
+          vv = Ruote.regex_or_s(vv)
+
+          val = case k
+            when 'class' then msg['error']['class']
+            when 'message' then msg['error']['message']
+            else msg[k]
+          end
 
-        if v.is_a?(String)
-          return false unless val && v == val
-        else
-          return false unless val && v.match(val)
+          val && (vv.is_a?(String) ? (vv == val) : vv.match(val))
         end
       end
 

data/lib/ruote/svc/treechecker.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
@@ -37,7 +37,7 @@ module Ruote
 
     def initialize(context)
 
-      (context['use_ruby_treechecker'] == false) and return
+      return if context['use_ruby_treechecker'] == false
 
       checker = Rufus::TreeChecker.new do
 
@@ -50,7 +50,6 @@ module Ruote
 
         #exclude_raise             # no raise or throw
 
-        exclude_def               # no method definition
         exclude_eval              # no eval, module_eval or instance_eval
         exclude_backquotes        # no `rm -fR the/kitchen/sink`
         exclude_alias             # no alias or aliast_method
@@ -70,18 +69,16 @@ module Ruote
         exclude_call_to :instance_variable_get, :instance_variable_set
       end
 
-      # the checker used when reading process definitions
-
-      @def_checker = checker.clone # and not dup
-      @def_checker.add_rules do
-        exclude_raise # no raise or throw
+      stricter_checker = checker.clone
+      stricter_checker.add_rules do
+        exclude_def    # no method definition
+        exclude_raise  # no raise or throw
       end
-      @def_checker.freeze
 
-      # the checker used when dealing with BlockParticipant code
+      # the checker used when reading process definitions
 
-      @blo_checker = checker.clone # and not dup
-      @blo_checker.freeze
+      @def_checker = stricter_checker.clone # and not dup
+      @def_checker.freeze
 
       ## the checker used when dealing with conditionals
       #
@@ -100,12 +97,22 @@ module Ruote
 
       # the checker used when dealing with code in $(ruby:xxx}
 
-      @dol_checker = checker.clone # and not dup
-      @dol_checker.add_rules do
-        exclude_raise # no raise or throw
-      end
+      @dol_checker = stricter_checker.clone # and not dup
       @dol_checker.freeze
 
+      # the checker used when dealing with BlockParticipant code
+
+      @blo_checker = checker.clone # and not dup
+      @blo_checker.add_rules do
+        exclude_def    # no method definition
+      end
+      @blo_checker.freeze
+
+      # the checker used for CodeParticipant
+
+      @cod_checker = checker.clone # and not dup
+      @cod_checker.freeze
+
       freeze
         # preventing further modifications
     end
@@ -124,6 +131,11 @@ module Ruote
 
       @dol_checker.check(ruby_code) if @dol_checker
     end
+
+    def code_check(ruby_code)
+
+      @cod_checker.check(ruby_code) if @cod_checker
+    end
   end
 end
 

data/lib/ruote/tree_dot.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/deep.rb

@@ -0,0 +1,143 @@
+#--
+# 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.
+#++
+
+
+module Ruote
+
+  #--
+  # methods that go deep inside a nested structures of arrays and hashes
+  # (JSON output maybe).
+  #++
+
+  # Given a hash and a key, deletes all the entries with that key, in child
+  # hashes too.
+  #
+  # Note: this method is not related to the "dot notation" methods in this
+  # lookup.rb file.
+  #
+  # == example
+  #
+  #   h = { 'a' => 1, 'b' => { 'a' => 2 } }
+  #   Ruote.deep_delete(h, 'a')
+  #     # => { 'b' => {} }
+  #
+  def self.deep_delete(h, key)
+
+    h.delete(key)
+
+    h.each { |k, v| deep_delete(v, key) if v.is_a?(Hash) }
+  end
+
+  class << self
+    alias delete_all deep_delete
+  end
+
+  # Dives into a nested structure of hashes and arrays to find match hash keys.
+  #
+  # The method expects a block with 3 or 4 arguments.
+  #
+  # 3 arguments: collection, key and value
+  # 4 arguments: parent collection, collection, key and value
+  #
+  # Warning: .deep_mutate forces hash keys to be strings. It's a JSON world.
+  #
+  # == example
+  #
+  #   h = {
+  #     'a' => 0,
+  #     'b' => 1,
+  #     'c' => { 'a' => 2, 'b' => { 'a' => 3 } },
+  #     'd' => [ { 'a' => 0 }, { 'b' => 4 } ] }
+  #
+  #   Ruote.deep_mutate(h, 'a') do |coll, k, v|
+  #     coll['a'] = 10
+  #   end
+  #
+  #   h # =>
+  #     { 'a' => 10,
+  #       'b' => 1,
+  #       'c' => { 'a' => 10, 'b' => { 'a' => 10 } },
+  #       'd' => [ { 'a' => 10 }, { 'b' => 4 } ] }
+  #
+  # == variations
+  #
+  # Instead of a single key, it's OK to pass an array of keys:
+  #
+  #   Ruote.deep_mutate(a, [ 'a', 'b' ]) do |coll, k, v|
+  #     # ...
+  #   end
+  #
+  # Regular expressions are made to match:
+  #
+  #   Ruote.deep_mutate(a, [ 'a', /^a\./ ]) do |coll, k, v|
+  #     # ...
+  #   end
+  #
+  # A single regular expression is OK:
+  #
+  #   Ruote.deep_mutate(a, /^user\./) do |coll, k, v|
+  #     # ...
+  #   end
+  #
+  def self.deep_mutate(coll, key_or_keys, parent=nil, &block)
+
+    keys = key_or_keys.is_a?(Array) ? key_or_keys : [ key_or_keys ]
+
+    if coll.is_a?(Hash)
+
+      coll.dup.each do |k, v|
+
+        # ensure that all keys are strings
+
+        unless k.is_a?(String)
+          coll.delete(k)
+          k = k.to_s
+          coll[k] = v
+        end
+
+        # call the mutation blocks for each match
+
+        if keys.find { |kk| kk.is_a?(Regexp) ? kk.match(k) : kk == k }
+
+          if block.arity > 3
+            block.call(parent, coll, k, v)
+          else
+            block.call(coll, k, v)
+          end
+
+        elsif v.is_a?(Array) || v.is_a?(Hash)
+
+          deep_mutate(v, keys, coll, &block)
+        end
+      end
+
+    elsif coll.is_a?(Array)
+
+      coll.each { |e| deep_mutate(e, keys, coll, &block) }
+
+    #else # nothing
+    end
+  end
+end
+

data/lib/ruote/util/filter.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
@@ -23,7 +23,6 @@
 #++
 
 require 'ruote/util/misc'
-require 'ruote/util/lookup'
 
 
 module Ruote
@@ -52,6 +51,50 @@ module Ruote
       "not a filter : #{filter}"
     ) unless filter.is_a?(Array)
 
+    filters = or_split(filter)
+
+    result = nil
+
+    filters.each do |fl|
+
+      result = begin
+        do_filter(fl, hash, options)
+      rescue ValidationError => err
+        err
+      end
+
+      return result if result.is_a?(Hash)
+        # success
+    end
+
+    raise(result) if result.is_a?(ValidationError)
+
+    result
+  end
+
+  # Used by Ruote.filter
+  #
+  def self.or_split(filter)
+
+    return filter if filter.first.is_a?(Array)
+    return [ filter ] if filter.empty? or ( ! filter.include?('or'))
+
+    # [ {}, 'or', {}, {}, 'or', {} ]
+
+    filter.inject([ [] ]) do |result, fl|
+      if fl.is_a?(Hash)
+        result.last << fl
+      else
+        result << []
+      end
+      result
+    end
+  end
+
+  # Used by Ruote.filter
+  #
+  def self.do_filter(filter, hash, options)
+
     hash = Rufus::Json.dup(hash)
 
     hash['~'] = Rufus::Json.dup(hash)
@@ -64,6 +107,7 @@ module Ruote
 
     hash.delete('~')
     hash.delete('~~')
+    hash.delete('~~~')
       # remove the 'originals'
 
     if deviations.empty?
@@ -82,10 +126,13 @@ module Ruote
   class RuleSession
 
     SKIP = %w[ and or fields field f ]
+    BOOLEANS = %w[ and or ]
     NUMBER_CLASSES = [ Fixnum, Float ]
     BOOLEAN_CLASSES = [ TrueClass, FalseClass ]
     TILDE = /^~/
     RTILDE = /^\^~/
+    COMMA_SPLIT = / *, */
+    PIPE_SPLIT = / *\| */
 
     def initialize(hash, rule)
 
@@ -112,17 +159,24 @@ module Ruote
 
         # now only keep the keys that match our regexp
 
-        keys.inject([]) { |a, k|
-          if m = fl.match(k)
-            a << [ k, Ruote.lookup(@hash, k), m[1..-1] ]
-          end
-          a
+        keys.each_with_object([]) { |k, a|
+          m = fl.match(k)
+          a << [ k, Ruote.lookup(@hash, k), m[1..-1] ] if m
         }
 
+      elsif fl.is_a?(String) and PIPE_SPLIT.match(fl)
+
+        fields = fl.split(PIPE_SPLIT).collect { |field|
+          val = Ruote.lookup(@hash, field)
+          val.nil? ? nil : [ field, val, nil ]
+        }.compact
+
+        fields.empty? ? [ [ fl, nil, nil ] ] : fields
+          # if no fields where found, place fake fl field to force failure
+
       else
 
-        (fl.is_a?(Array) ? fl : fl.to_s.split(',')).collect { |field|
-          field = field.strip
+        (fl.is_a?(Array) ? fl : fl.to_s.split(COMMA_SPLIT)).collect { |field|
           [ field,  Ruote.lookup(@hash, field), nil ]
         }
       end
@@ -130,20 +184,35 @@ module Ruote
 
     def run
 
+      keys = @rule.keys - SKIP
+      validation = (@rule.keys & BOOLEANS).empty?
+
+      if validation and @fields.empty? and keys.empty?
+        fl = @rule['fields'] || @rule['field'] || @rule['f']
+        return [ [ @rule, fl, nil ] ] # validation break
+      end
+
       @fields.collect { |field, value, matches|
 
         valid = nil
 
-        @rule.each do |k, v|
+        if keys.empty?
+
+          valid = (value != nil)
+
+        else
 
-          next if SKIP.include?(k)
+          keys.each do |k|
 
-          m = "_#{k}"
-          next unless self.respond_to?(m)
+            v = @rule[k]
 
-          r = self.send(m, field, value, matches, k, v)
+            m = "_#{k}"
+            next unless self.respond_to?(m)
 
-          valid = false if r == false
+            r = self.send(m, field, value, matches, k, v)
+
+            valid = false if r == false
+          end
         end
 
         raise_or_and(valid, field, value)
@@ -264,6 +333,30 @@ module Ruote
     alias _restore_from _restore
     alias _rs _restore
 
+    def _take(field, value, matches, m, v)
+
+      unless @hash.has_key?('~~~')
+
+        @hash['~~~'] = @hash.keys.select { |k|
+          ! k.match(/^\~+$/)
+        }.each_with_object({}) { |k, h|
+          h[k] = @hash.delete(k)
+        }
+
+        @hash.merge!(@hash['~~'])
+        @hash.merge!(@hash['~~~']) if m == 'discard' && v != 'all'
+      end
+
+      if m == 'take'
+        @hash[field] = @hash['~~~'][field]
+      elsif v != 'all'
+        @hash.delete(field)
+      end
+
+      nil
+    end
+    alias _discard _take
+
     def _size(field, value, matches, m, v)
 
       v = v.is_a?(String) ? v.split(',').collect { |i| i.to_i } : Array(v)
@@ -279,7 +372,9 @@ module Ruote
 
     def _empty(field, value, matches, m, v)
 
-      value.respond_to?(:empty?) ? value.empty? : false
+      # 'empty' => '30%' could be fun ;-)
+
+      (value.respond_to?(:empty?) ? value.empty? : false) == v
     end
     alias _e _empty
 
@@ -306,6 +401,15 @@ module Ruote
     end
     alias _h _has
 
+    def _includes(field, value, matches, m, v)
+
+      case value
+        when Array then value.include?(v)
+        when Hash then value.values.include?(v)
+        else false
+      end
+    end
+
     def _type(field, value, matches, m, v)
 
       of_type?(value, v)
@@ -352,8 +456,6 @@ module Ruote
           else
             raise ArgumentError.new("unknown type '#{type}'")
         end
-
-        valid
       end
     end
 
@@ -380,6 +482,11 @@ module Ruote
     end
     alias _sm _smatch
 
+    def _is(field, value, matches, m, v)
+
+      value == v
+    end
+
     def _valid(field, value, matches, m, v)
 
       v.to_s == 'true'