ruote 2.2.0 → 2.3.0

data/lib/ruote/part/template.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/participant.rb

@@ -1,6 +1,8 @@
 
+require 'ruote/part/participant'
 require 'ruote/part/storage_participant'
 require 'ruote/part/no_op_participant'
 require 'ruote/part/null_participant'
 require 'ruote/part/engine_participant'
+require 'ruote/part/rev_participant'
 

data/lib/ruote/reader.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,12 +22,14 @@
 # Made in Japan.
 #++
 
-
 require 'uri'
 require 'open-uri'
 require 'rufus/json'
-require 'ruote/reader/ruby_dsl' # just making sure it's loaded
 require 'ruote/reader/xml'
+require 'ruote/reader/json'
+require 'ruote/reader/radial'
+require 'ruote/reader/ruby_dsl' # just making sure it's loaded
+require 'ruote/util/mpatch'
 require 'ruote/util/subprocess'
 
 
@@ -40,6 +42,32 @@ module Ruote
   #
   class Reader
 
+    # This error is emitted by the reader when it failed to read a process
+    # definition (passed as a string).
+    #
+    class Error < ArgumentError
+
+      attr_reader :definition
+      attr_reader :ruby, :radial, :xml, :json
+
+      def initialize(definition)
+        super('cannot read process definition')
+        @definition = definition
+      end
+
+      def <<(args)
+        type, error = args
+        type = type.to_s.match(/^Ruote::(.+)Reader$/)[1].downcase
+        instance_variable_set("@#{type}", error)
+      end
+
+      # Returns the most likely error cause...
+      #
+      def cause
+        @ruby || @radial || @xml || @json
+      end
+    end
+
     def initialize(context)
 
       @context = context
@@ -52,22 +80,41 @@ module Ruote
 
       return definition if Ruote.is_tree?(definition)
 
-      (return XmlReader.read(definition)) rescue nil
-      (return Rufus::Json.decode(definition)) rescue nil
-      (return ruby_eval(definition)) rescue nil
+      raise ArgumentError.new(
+        "cannot read process definitions of class #{definition.class}"
+      ) unless definition.is_a?(String)
 
-      if definition.index("\n").nil? && definition.index(' ').nil?
+      if is_uri?(definition)
 
-        raise ArgumentError.new(
-          "remote process definitions are not allowed"
-        ) if Ruote::Reader.remote?(definition) && @context['remote_definition_allowed'] != true
+        if
+          Ruote::Reader.remote?(definition) &&
+          @context['remote_definition_allowed'] != true
+        then
+          raise ArgumentError.new('remote process definitions are not allowed')
+        end
 
         return read(open(definition).read)
       end
 
-      raise ArgumentError.new(
-        "doesn't know how to read definition (#{definition.class}) " +
-        "or error in process definition")
+      tree = nil
+      error = Error.new(definition)
+
+      [
+        Ruote::RubyReader, Ruote::RadialReader,
+        Ruote::XmlReader, Ruote::JsonReader
+      ].each do |reader|
+
+        next if tree
+        next unless reader.understands?(definition)
+
+        begin
+          tree = reader.read(definition, @context.treechecker)
+        rescue => e
+          error << [ reader, e ]
+        end
+      end
+
+      tree || raise(error)
     end
 
     # Class method for parsing process definition (XML, Ruby, from file or
@@ -94,30 +141,55 @@ module Ruote
     #
     def self.to_xml(tree, options={})
 
-      require 'builder'
+      s = StringIO.new
+      s.puts('<?xml version="1.0" encoding="UTF-8"?>')
+
+      _to_xml(tree, options[:indent], 0, s)
+
+      s.string
+    end
 
-      # TODO : deal with "participant 'toto'"
+    # Not as good as the builder gem, but at least doesn't come bundled with
+    # lib/blankslate.rb
+    #
+    def self._to_xml(tree, indent, level, s) # :nodoc:
 
-      builder(options) do |xml|
+      atts = tree[1].dup
 
-        atts = tree[1].dup
+      if t = atts.find { |k, v| v == nil }
+        atts.delete(t.first)
+        atts[tree[0] == 'if' ? 'test' : 'ref'] = t.first
+      end
 
-        t = atts.find { |k, v| v == nil }
-        if t
-          atts.delete(t.first)
-          key = tree[0] == 'if' ? 'test' : 'ref'
-          atts[key] = t.first
-        end
+      atts = atts.remap { |(k, v), h| h[k.to_s.gsub(/\_/, '-')] = v }
+      atts = atts.to_a.sort_by { |k, v| k }
 
-        atts = atts.inject({}) { |h, (k, v)| h[k.to_s.gsub(/\_/, '-')] = v; h }
+      s.print ' ' * level
 
-        if tree[2].empty?
-          xml.tag!(tree[0], atts)
-        else
-          xml.tag!(tree[0], atts) do
-            tree[2].each { |child| to_xml(child, options) }
-          end
-        end
+      s.print '<'
+      s.print tree[0]
+
+      if atts.any?
+        s.print ' '
+        s.print atts.collect { |k, v|
+          "#{k}=#{v.is_a?(String) ? v.inspect : v.inspect.inspect}"
+        }.join(' ')
+      end
+
+      if tree[2].empty?
+
+        s.puts '/>'
+
+      else
+
+        s.puts '>'
+
+        tree[2].each { |child| _to_xml(child, indent, level + (indent || 0), s) }
+
+        s.print ' ' * level
+        s.print '</'
+        s.print tree[0]
+        s.puts '>'
       end
     end
 
@@ -129,10 +201,9 @@ module Ruote
     def self.to_ruby(tree, level=0)
 
       expname = tree[0]
-
       expname = 'Ruote.process_definition' if level == 0 && expname == 'define'
 
-      s = "#{'  ' * level}#{expname}#{atts_to_ruby(tree[1])}"
+      s = '  ' * level + expname + atts_to_ruby(tree[1])
 
       return "#{s}\n" if tree[2].empty?
 
@@ -143,6 +214,61 @@ module Ruote
       s
     end
 
+    # Turns the given tree into a radial process definition.
+    #
+    def self.to_radial(tree, level=0)
+
+      s = '  ' * level + tree[0] + atts_to_radial(tree[1]) + "\n"
+
+      return s if tree[2].empty?
+
+      tree[2].inject(s) { |ss, child| ss << to_radial(child, level + 1); ss }
+    end
+
+    # Produces an expid annotated radial version of the process definition,
+    # like:
+    #
+    #   0  define name: "nada"
+    #     0_0  sequence
+    #       0_0_0  alpha
+    #       0_0_1  participant "bravo", timeout: "2d", on_board: true
+    #
+    # Can be useful when debugging noisy engines.
+    #
+    def self.to_expid_radial(tree)
+
+      lines = to_raw_expid_radial(tree, '0')
+      max = lines.collect { |l| l[1].length }.max
+
+      lines.collect { |l|
+        "%#{max}s  " % l[1] + "  " * l[0] + l[2] + l[3]
+      }.join("\n")
+    end
+
+    # Used by .to_expid_radial. Outputs an array of 'lines'. Each line
+    # is a process definition line, represented as an array:
+    #
+    #   [ level, expid, name, atts ]
+    #
+    # Like in:
+    #
+    #   [[0, "0", "define", " name: \"nada\""],
+    #    [1, "0_0", "sequence", ""],
+    #    [2, "0_0_0", "alpha", ""],
+    #    [2, "0_0_1", "participant", " \"bravo\", timeout: \"2d\"]]
+    #
+    def self.to_raw_expid_radial(tree, expid='0')
+
+      i = -1
+
+      [
+        [ expid.split('_').size - 1, expid, tree[0], atts_to_radial(tree[1]) ]
+      ] +
+      tree[2].collect { |t|
+        i = i + 1; to_raw_expid_radial(t, "#{expid}_#{i}")
+      }.flatten(1)
+    end
+
     # Turns the process definition tree (ruote syntax tree) to a JSON String.
     #
     def self.to_json(tree)
@@ -161,58 +287,69 @@ module Ruote
 
     protected
 
-    # Evaluates the ruby string in the code, but at fist, thanks to the
-    # treechecker, makes sure it doesn't code malicious ruby code (at least
-    # tries very hard).
+    # Minimal test. Used by #read.
     #
-    def ruby_eval(s)
+    def is_uri?(s)
 
-      @context.treechecker.definition_check(s)
-      eval(s)
+      return false if s.index("\n")
 
-    rescue Exception => e
-      #
-      # have to catch everything (SyntaxError included)
+      ((URI.parse(s); true) rescue false)
+    end
+
+    def self.to_ra_string(o)
+
+      return 'nil' if o == nil
 
-      #puts '=' * 80
-      #p s
-      #puts '-' * 80
-      #puts e
-      #e.backtrace.each { |l| puts l }
+      s = o.to_s
 
-      raise ArgumentError.new('probably not ruby')
+      return s if [ true, false ].include?(o)
+
+      i = o.inspect
+
+      return i if %w[ true false nil ].include?(s)
+      return i if s.match(/[\s:]/)
+      return s if i == "\"#{o.to_s}\""
+
+      i
     end
 
-    # A convenience method when building XML
+    # split the txt => nil entry and sorts the rest of the attributes.
     #
-    def self.builder(options={}, &block)
+    def self.split_atts(atts)
 
-      if b = options[:builder]
-        block.call(b)
-      else
-        b = Builder::XmlMarkup.new(:indent => (options[:indent] || 0))
-        options[:builder] = b
-        b.instruct! unless options[:instruct] == false
-        block.call(b)
-        b.target!
-      end
+      atts = atts.to_a.sort_by { |k, v| k }
+      txt = atts.find { |k, v| v == nil }
+      atts.delete(txt) if txt
+
+      [ txt ? txt.first : nil, atts ]
     end
 
-    # As used by to_ruby.
+    # As used by to_radial
     #
-    def self.atts_to_ruby(atts)
+    def self.atts_to_radial(atts, &block)
+
+      s = []
+      txt, atts = split_atts(atts)
+
+      s << to_ra_string(txt) if txt
+      s += atts.collect { |k, v| "#{to_ra_string(k)}: #{to_ra_string(v)}" }
+
+      s = s.join(', ')
 
-      return '' if atts.empty?
+      s.length > 0 ? " #{s}" : s
+    end
+
+    # As used by to_ruby
+    #
+    def self.atts_to_ruby(atts, &block)
 
       s = []
+      txt, atts = split_atts(atts)
 
-      t = atts.find { |k, v| v == nil }
-      s << t.first.inspect if t
+      s << txt.inspect if txt
+      s += atts.collect { |k, v| ":#{k} => #{v.inspect}" }
 
-      s = atts.inject(s) { |a, (k, v)|
-        a << ":#{k} => #{v.inspect}" if t.nil? || k != t.first
-        a
-      }.join(', ')
+      s = s.join(', ')
 
       s.length > 0 ? " #{s}" : s
     end

data/lib/ruote/reader/json.rb

@@ -0,0 +1,49 @@
+#--
+# 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
+
+  #
+  # Turns an XML string into a process definition tree.
+  #
+  module JsonReader
+
+    # Returns true if s seems to be a JSON string
+    #
+    def self.understands?(s)
+
+      s = s.strip
+      true
+    end
+
+    # Simply parses the JSON string
+    #
+    def self.read(s, opt=nil)
+
+      Rufus::Json.decode(s)
+    end
+  end
+end
+

data/lib/ruote/reader/radial.rb

@@ -0,0 +1,303 @@
+#--
+# 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.
+#++
+
+require 'parslet'
+
+
+module Ruote
+
+  #
+  # Turning radial strings into ruote trees.
+  #
+  module RadialReader
+
+    #
+    # Turns radial strings into intermediate trees.
+    #
+    class Parser < Parslet::Parser
+
+      rule(:spaces) {
+        match('\s').repeat >>
+        (str('#') >> match('[^\n]').repeat >> str("\n").present?).maybe >>
+        match('\s').repeat
+      }
+      rule(:spaces?) { spaces.maybe }
+
+      rule(:comma) { spaces? >> str(',') >> spaces? }
+      rule(:digit) { match('[0-9]') }
+
+      rule(:text) { match('[^\s:,=\[\]#]').repeat(1).as(:text) }
+
+      rule(:number) {
+        (
+          str('-').maybe >> (
+            str('0') | (match('[1-9]') >> digit.repeat)
+          ) >> (
+            str('.') >> digit.repeat(1)
+          ).maybe >> (
+            match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+          ).maybe
+        ).as(:number) >> match('[ \n,]').present?
+      }
+
+      rule(:string) {
+        str('"') >> (
+          str('\\') >> any | str('"').absent? >> any
+        ).repeat.as(:string) >> str('"') |
+        str("'") >> (
+          str('\\') >> any | str("'").absent? >> any
+        ).repeat.as(:string) >> str("'")
+      }
+
+      rule(:regex) {
+        str('/') >> (
+          str('\\') >> any | str('/').absent? >> any
+        ).repeat.as(:regex) >> str('/')
+      }
+
+      rule(:array) {
+        str('[') >> spaces? >>
+        (value >> (comma >> value).repeat).maybe.as(:array) >>
+        spaces? >> str(']')
+      }
+
+      rule(:object) {
+        str('{') >> spaces? >>
+        (entry >> (comma >> entry).repeat).maybe.as(:object) >>
+        spaces? >> str('}')
+      }
+
+      rule(:null) {
+        (str('null') | str('nil')).as(:null)
+      }
+
+      rule(:value) {
+        array | object |
+        string | number |
+        str('true').as(:true) | str('false').as(:false) |
+        null | regex | text
+      }
+
+      rule(:entry) {
+        ((string | null | regex | text).as(:key) >> spaces? >>
+         (str(':') | str('=>')) >> spaces? >>
+         value.as(:val)).as(:ent)
+      }
+
+      rule(:attribute) { (entry | value).as(:att) }
+
+      rule(:blanks) { match('[ \t]').repeat(1) }
+
+      rule(:blank_line) { blanks.maybe }
+      rule(:line) {
+        (
+          str(' ').repeat.as(:ind) >>
+          match('[^ \n#"\',]').repeat(1).as(:exp) >>
+          (
+            (comma | blanks) >> attribute >> (comma >> attribute).repeat
+          ).as(:atts).maybe
+        ).as(:line)
+      }
+
+      rule(:comment) {
+        str(' ').repeat >>
+        (str('#') >> match('[^\n]').repeat).maybe >>
+        str("\n").present?
+      }
+
+      rule(:lines) {
+        (str("\n") >> (line | blank_line) >> comment.maybe).repeat
+      }
+
+      root(:lines)
+    end
+
+    #
+    # A helper class to store the temporary tree while it gets read.
+    #
+    class Node
+
+      attr_reader :parent, :indentation, :children
+
+      def initialize(indentation, expname, attributes)
+
+        @parent = nil
+        @indentation = indentation
+        @children = []
+
+        @expname = expname#.gsub(/-/, '_')
+        @expname.gsub!(/-/, '_') if @expname.match(/^[a-z\-]+$/)
+        @attributes = attributes
+      end
+
+      def parent=(node)
+
+        @parent = node
+        @parent.children << self
+      end
+
+      def to_a
+
+        [ @expname, @attributes, @children.collect { |c| c.to_a } ]
+      end
+    end
+
+    #
+    # Turns intermediate trees into ruote trees.
+    #
+    class Transformer < Parslet::Transform
+
+      class Attribute
+        attr_reader :key, :val
+        def initialize(key, val)
+          @key = key.to_s.gsub(/-/, '_')
+          @val = val
+        end
+      end
+      class Value < Attribute
+        def initialize(key)
+          @key = key
+          @val = nil
+        end
+      end
+
+      rule(:line => subtree(:line)) { line }
+
+      rule(:ind => simple(:i), :exp => simple(:e), :atts => subtree(:as)) {
+        atts = Array(as).each_with_object({}) { |att, h| h[att.key] = att.val }
+        Node.new(i.to_s.length, e.to_s, atts)
+      }
+      rule(:ind => simple(:i), :exp => simple(:e)) {
+        Node.new(i.to_s.length, e.to_s, {})
+      }
+      rule(:ind => sequence(:i), :exp => simple(:e), :atts => subtree(:as)) {
+        atts = Array(as).each_with_object({}) { |att, h| h[att.key] = att.val }
+        Node.new(0, e.to_s, atts)
+      }
+      rule(:ind => sequence(:i), :exp => simple(:e)) {
+        Node.new(0, e.to_s, {})
+      }
+
+      rule(:att => { :ent => { :key => subtree(:k), :val => subtree(:v) } }) {
+        Attribute.new(k, v)
+      }
+      rule(:att => subtree(:t)) {
+        Value.new(t)
+      }
+
+      rule(:string => simple(:st)) {
+        st.to_s.gsub(/\\(.)/) { eval("\"\\" + $~[1] + '"') }
+      }
+      rule(:regex => simple(:re)) {
+        '/' + re.to_s.gsub(/\\(.)/) { eval("\"\\" + $~[1] + '"') } + '/'
+      }
+
+      rule(:text => simple(:te)) { te.to_s }
+      rule(:number => simple(:n)) { n.match(/[eE\.]/) ? Float(n) : Integer(n) }
+      rule(:false => simple(:b)) { false }
+      rule(:true => simple(:b)) { true }
+      rule(:null => simple(:n)) { nil }
+
+      rule(:array => subtree(:ar)) {
+        ar.is_a?(Array) ? ar : [ ar ]
+      }
+      rule(:object => subtree(:es)) {
+        (es.is_a?(Array) ? es : [ es ]).each_with_object({}) { |e, h|
+          e = e[:ent]; h[e[:key]] = e[:val]
+        }
+      }
+    end
+
+    #
+    # Some kind of "root container", to avoid having to deal with nils
+    # and making the parsing code more complicated (hopefully).
+    #
+    class PreRoot < Node
+
+      def initialize(first_line)
+
+        @first_line = first_line
+
+        @parent = nil
+        @indentation = -1
+        @children = []
+      end
+
+      def to_a
+
+        raise ArgumentError.new(
+          "couldn't parse process definition out of >#{@first_line}<"
+        ) unless @children.first
+
+        @children.first.to_a
+      end
+    end
+
+    # Returns tree if s seems to contain a radial process definition
+    #
+    def self.understands?(s)
+
+      return false if s.match(/\n *end\b/)
+      return false if s.match(/\bRuote\.(process_definition|workflow_definition|define)\b/)
+      true
+    end
+
+    # The entry point : takes a radial string and returns, if possible,
+    # a ruote tree.
+    #
+    def self.read(s, opt=nil)
+
+      parser = Parser.new
+      transformer = Transformer.new
+
+      lines = parser.parse("\n#{s}\n")
+      nodes = transformer.apply(lines)
+
+      root = PreRoot.new("#{s.strip.split("\n").first}...")
+      current = root
+
+      nodes = [] unless nodes.is_a?(Array)
+        # force ArgumentError via empty PreRoot
+
+      nodes.each do |node|
+
+        parent = current
+
+        if node.indentation == current.indentation
+          parent = current.parent
+        elsif node.indentation < current.indentation
+          while node.indentation <= parent.indentation
+            parent = parent.parent
+          end
+        end
+
+        node.parent = parent
+        current = node
+      end
+
+      root.to_a
+    end
+  end
+end
+