ruote 0.9.20 → 2.1.1

data/lib/ruote/storage/fs_storage.rb

@@ -0,0 +1,89 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+require 'yajl' rescue require 'json'
+  # gem install yajl-ruby OR json OR json_pure OR json-jruby
+
+require 'rufus/json'
+Rufus::Json.detect_backend
+
+require 'rufus/cloche'
+  # gem install rufus-cloche
+
+
+module Ruote
+
+  class FsStorage
+
+    include StorageBase
+
+    def initialize (dir, options={})
+
+      FileUtils.mkdir_p(dir)
+
+      @cloche = Rufus::Cloche.new(:dir => dir)
+      @options = options
+
+      @cloche.put(@options.merge('type' => 'configurations', '_id' => 'engine'))
+    end
+
+    def put (doc, opts={})
+
+      @cloche.put(doc.merge!('put_at' => Ruote.now_to_utc_s))
+    end
+
+    def get (type, key)
+
+      @cloche.get(type, key)
+    end
+
+    def delete (doc)
+
+      @cloche.delete(doc)
+    end
+
+    def get_many (type, key=nil, opts={})
+
+      @cloche.get_many(type, key, opts)
+    end
+
+    def purge!
+
+      FileUtils.rm_rf(@cloche.dir)
+    end
+
+    def dump (type)
+
+      s = "=== #{type} ===\n"
+
+      @cloche.get_many(type).inject(s) do |s1, e|
+        s1 << "\n"
+        e.keys.sort.inject(s1) do |s2, k|
+          s2 << "  #{k} => #{e[k].inspect}\n"
+        end
+      end
+    end
+  end
+end
+

data/lib/ruote/storage/hash_storage.rb

@@ -0,0 +1,171 @@
+#--
+# Copyright (c) 2005-2010, 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.
+#++
+
+require 'rufus/json'
+require 'ruote/util/misc'
+require 'ruote/storage/base'
+require 'monitor'
+
+
+module Ruote
+
+  class HashStorage
+
+    include StorageBase
+    include MonitorMixin
+
+    attr_reader :h
+
+    def initialize (options={})
+
+      super()
+
+      @options = options
+
+      purge!
+    end
+
+    def put (doc, opts={})
+
+      synchronize do
+
+        pre = get(doc['type'], doc['_id'])
+
+        if pre && ( ! opts[:update_rev]) && pre['_rev'] != doc['_rev']
+          return pre
+        end
+
+        if pre.nil? && doc['_rev']
+          return true
+        end
+
+        doc = if opts[:update_rev]
+          doc['_rev'] = pre ? pre['_rev'] : -1
+          doc
+        else
+          doc.merge('_rev' => doc['_rev'] || -1)
+        end
+
+        doc['put_at'] = Ruote.now_to_utc_s
+        doc['_rev'] = doc['_rev'] + 1
+
+        (@h[doc['type']] ||= {})[doc['_id']] = Rufus::Json.dup(doc)
+
+        nil
+      end
+    end
+
+    def get (type, key)
+
+      synchronize do
+        Ruote.fulldup(@h[type][key])
+      end
+    end
+
+    def delete (doc)
+
+      drev = doc['_rev']
+
+      raise ArgumentError.new("can't delete doc without _rev") unless drev
+
+      synchronize do
+
+        prev = get(doc['type'], doc['_id'])
+
+        return true if prev.nil?
+
+        doc['_rev'] ||= 0
+
+        if prev['_rev'] == drev
+
+          @h[doc['type']].delete(doc['_id'])
+
+          nil
+
+        else
+
+          prev
+        end
+      end
+    end
+
+    def get_many (type, key=nil, opts={})
+
+      # NOTE : no dup here for now
+
+      synchronize do
+
+        docs = key ?
+          @h[type].values.select { |doc| doc['_id'].match(key) } :
+          @h[type].values
+
+        if l = opts[:limit]
+          docs[0, l]
+        else
+          docs
+        end
+      end
+    end
+
+    def purge!
+
+      @h = %w[
+
+        variables
+
+        msgs
+        expressions
+        errors
+        schedules
+        configurations
+        workitems
+
+      ].inject({}) { |h, k|
+        h[k] = {}
+        h
+      }
+
+      @h['configurations']['engine'] = @options
+    end
+
+    def dump (type)
+
+      s = "=== #{type} ===\n"
+
+      @h[type].inject(s) do |s1, (k, v)|
+        s1 << "\n"
+        s1 << "#{k} :\n"
+        v.keys.sort.inject(s1) do |s2, k1|
+          s2 << "  #{k1} => #{v[k1].inspect}\n"
+        end
+      end
+    end
+
+    def add_test_type (type)
+
+      @h[type] = {}
+    end
+  end
+end
+

data/lib/ruote/tree_dot.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright (c) 2005-2010, 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
+
+  # Turns a process definition tree to a graphviz dot representation.
+  #
+  # http://www.graphviz.org
+  #
+  def self.tree_to_dot (tree, name='ruote process definition')
+
+    s = "digraph \"#{name}\" {\n"
+    s << branch_to_dot('0', tree).join("\n")
+    s << "\n}\n"
+  end
+
+  protected
+
+  def self.branch_to_dot (expid, exp)
+
+    [
+      "  \"#{expid}\" "+
+      "[ label = \"#{exp[0]} #{exp[1].inspect.gsub("\"", "'")}\" ];"
+    ] +
+    children_to_dot(expid, exp)
+  end
+
+  def self.children_to_dot (expid, exp)
+
+    exp_name = exp[0]
+    child_count = exp[2].size
+
+    i = -1
+
+    a = exp[2].collect do |child|
+      i += 1
+      branch_to_dot("#{expid}_#{i}", child)
+    end
+
+    if child_count > 0 # there are children
+
+      if %w[ concurrence if ].include?(exp_name)
+
+        (0..child_count - 1).each do |i|
+          a << "  \"#{expid}\" -> \"#{expid}_#{i}\";"
+          a << "  \"#{expid}_#{i}\" -> \"#{expid}\";"
+        end
+
+      else
+
+        a << "  \"#{expid}\" -> \"#{expid}_0\";"
+        a << "  \"#{expid}_#{child_count -1}\" -> \"#{expid}\";"
+
+        (0..child_count - 2).each do |i|
+          a << "  \"#{expid}_#{i}\" -> \"#{expid}_#{i + 1}\";"
+        end
+      end
+    end
+
+    a
+  end
+end
+

data/lib/{openwfe → ruote}/util/dollar.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2009, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2010, 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
@@ -24,18 +24,15 @@
 
 
 require 'rufus/dollar' # gem 'rufus-dollar'
+require 'ruote/util/treechecker'
 
-require 'openwfe/utils'
-require 'openwfe/util/treechecker'
 
+module Ruote
 
-module OpenWFE
-
-  #
   # Performs 'dollar substitution' on a piece of text with as input
   # a flow expression and a workitem (fields and variables).
   #
-  def OpenWFE.dosub (text, flow_expression, workitem)
+  def self.dosub (text, flow_expression, workitem)
 
     #
     # patch by Nick Petrella (2008/03/20)
@@ -43,7 +40,7 @@ module OpenWFE
 
     if text.is_a?(String)
 
-      Rufus::dsub(text, FlowDict.new(flow_expression, workitem))
+      Rufus.dsub(text, FlowDict.new(flow_expression, workitem))
 
     elsif text.is_a?(Array)
 
@@ -70,61 +67,65 @@ module OpenWFE
   #
   class FlowDict
 
-  def initialize (flow_expression, workitem, default_prefix='v')
+    def initialize (flow_expression, workitem, default_prefix='f')
 
-    @flow_expression = flow_expression
-    @workitem = workitem
-    @default_prefix = default_prefix
-  end
+      @fexp = flow_expression
+      @workitem = workitem
+      @default_prefix = default_prefix
+    end
 
-  def [] (key)
+    def [] (key)
 
-    pr, k = extract_prefix key
+      return @fexp.fei.wfid if key == 'wfid'
+      return @fexp.fei.parent_wfid if key == 'parent_wfid'
+      return @fexp.fei.expid if key == 'expid'
 
-    # stage 0
+      pr, k = extract_prefix(key)
 
-    v = lookup(pr[0, 1], k)
+      # stage 0
 
-    return v if v != nil
+      v = lookup(pr[0, 1], k)
 
-    # stage 1
+      return v if v != nil
 
-    return '' if pr.size < 2
+      # stage 1
 
-    lookup(pr[1, 1], k)
-  end
+      return '' if pr.size < 2
+
+      lookup(pr[1, 1], k)
+    end
 
-  def []= (key, value)
+    def []= (key, value)
 
-    pr, k = extract_prefix key
-    pr = pr[0, 1]
+      pr, k = extract_prefix(key)
+      pr = pr[0, 1]
 
-    if pr == 'f'
+      if pr == 'f'
 
-      @workitem.set_attribute(k, value)
+        @workitem.set_attribute(k, value)
 
-    elsif @flow_expression
+      elsif @fexp
 
-      @flow_expression.set_variable(k, value)
+        @fexp.set_variable(k, value)
+      end
     end
-  end
 
-  def has_key? (key)
+    def has_key? (key)
 
-    pr, k = extract_prefix key
+      pr, k = extract_prefix(key)
 
-    return true if pr == 'r'
+      return true if pr == 'r'
 
-    (self[key] != nil)
-  end
+      (self[key] != nil)
+    end
 
-  protected
+    protected
 
     def lookup (pr, key)
 
       case pr
-        when 'v' then @flow_expression.lookup_variable(key)
-        when 'f' then @workitem.lookup_attribute(key)
+        when 'v' then @fexp.lookup_variable(key)
+        when 'f' then Ruote.lookup(@workitem['fields'], key)
         when 'r' then call_ruby(key)
         else nil
       end
@@ -144,43 +145,26 @@ module OpenWFE
       [ pr, key[i+1..-1] ]
     end
 
-    #--
-    #def call_function (function_name)
-    #  #"function '#{function_name}' is not implemented"
-    #  "functions are not yet implemented"
-    #  #
-    #  # no need for them... we have Ruby :)
-    #end
-    #++
-
-    #
     # The ${r:1+2} stuff. ("3").
     #
     def call_ruby (ruby_code)
 
-      #if @flow_expression and @flow_expression.ac[:ruby_eval_allowed] != true
-      #  return ''
-      #end
-      return '' if @flow_expression.ac[:ruby_eval_allowed] != true
+      return '' if @fexp.context[:ruby_eval_allowed] != true
 
       wi = @workitem
       workitem = @workitem
 
-      #fexp = nil
-      #flow_expression = nil
-      #fei = nil
-
-      #if @flow_expression
-      fexp = @flow_expression
-      flow_expression = @flow_expression
-      fei = @flow_expression.fei
-      #end
+      fe = @fexp
+      fexp = @fexp
+      flow_expression = @fexp
+      fei = @fexp.fei
         #
         # some simple notations made available to ${ruby:...}
         # notations
 
-      #TreeChecker.check ruby_code
-      fexp.ac[:s_tree_checker].check(ruby_code)
+      @fexp.context.treechecker.check(ruby_code)
+
+      # clear for eval...
 
       eval(ruby_code, binding()).to_s
     end