ruote-maestrodev 2.2.1

data/lib/ruote/part/template.rb

@@ -0,0 +1,84 @@
+#--
+# Copyright (c) 2005-2011, 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'
+
+
+module Ruote
+
+  #
+  # Template rendering helper.
+  #
+  # (Currently only used by the SmtpParticipant, could prove useful for
+  # custom participants)
+  #
+  # This module expects to find the ruote @context available (probably
+  # accessible thanks to the Ruote::LocalParticipant module, see
+  # Ruote::SmtpParticipant as an example).
+  #
+  module TemplateMixin
+
+    # Do the rendering.
+    #
+    def render_template(template, flow_expression, workitem)
+
+      template = (File.read(template) rescue nil) if is_a_file?(template)
+
+      return render_default_template(workitem) unless template
+
+      template = template.to_s
+      workitem = workitem.to_h if workitem.respond_to?(:to_h)
+
+      @context.dollar_sub.s(template, flow_expression, workitem)
+    end
+
+    # Simply returns a pretty-printed view of the workitem
+    #
+    def render_default_template(workitem)
+
+      workitem = workitem.to_h if workitem.respond_to?(:to_h)
+
+      s = []
+      s << "workitem for #{workitem['participant_name']}"
+      s << ''
+      s << Rufus::Json.pretty_encode(workitem['fei'])
+      s << ''
+      workitem['fields'].keys.sort.each do |key|
+        s << " - '#{key}'  ==>  #{Rufus::Json.encode(workitem['fields'][key])}"
+      end
+      s.join("\n")
+    end
+
+    protected
+
+    def is_a_file?(s)
+
+      return false unless s
+      return false if s.index("\n")
+
+      File.exist?(s)
+    end
+  end
+end
+

data/lib/ruote/participant.rb

@@ -0,0 +1,7 @@
+
+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

@@ -0,0 +1,278 @@
+#--
+# Copyright (c) 2005-2011, 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 'uri'
+require 'open-uri'
+require 'rufus/json'
+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/subprocess'
+
+
+module Ruote
+
+  #
+  # A process definition reader.
+  #
+  # Can reader XML, JSON, Ruby (and more) process definition representations.
+  #
+  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)
+        @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
+
+      def inspect
+        s = "#<#{self.class}: "
+        [ @ruby, @radial, @xml, @json ].each { |e| s << e.inspect; s << ' ' }
+        s << '>'
+        s
+      end
+    end
+
+    def initialize(context)
+
+      @context = context
+    end
+
+    # Turns the input into a ruote syntax tree (raw process definition).
+    # This method is used by engine.launch(x) for example.
+    #
+    def read(definition)
+
+      return definition if Ruote.is_tree?(definition)
+
+      raise ArgumentError.new(
+        "cannot read process definitions of class #{definition.class}"
+      ) unless definition.is_a?(String)
+
+      if is_uri?(definition)
+
+        raise ArgumentError.new(
+          "remote process definitions are not allowed"
+        ) if Ruote::Reader.remote?(definition) && @context['remote_definition_allowed'] != true
+
+        return read(open(definition).read)
+      end
+
+      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
+    # from a string, ...) to syntax trees. Used by ruote-fluo for example.
+    #
+    def self.read(d)
+
+      unless @reader
+
+        require 'ostruct'
+        require 'ruote/svc/treechecker'
+
+        @reader = Ruote::Reader.new(
+          OpenStruct.new('treechecker' => Ruote::TreeChecker.new({})))
+      end
+
+      @reader.read(d)
+    end
+
+    # Turns the given process definition tree (ruote syntax tree) to an XML
+    # String.
+    #
+    # Mainly used by ruote-fluo.
+    #
+    def self.to_xml(tree, options={})
+
+      require 'builder'
+
+      # TODO : deal with "participant 'toto'"
+
+      builder(options) do |xml|
+
+        atts = tree[1].dup
+
+        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.inject({}) { |h, (k, v)| h[k.to_s.gsub(/\_/, '-')] = v; h }
+
+        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
+      end
+    end
+
+    # Turns the given process definition tree (ruote syntax tree) to a Ruby
+    # process definition (a String containing that ruby process definition).
+    #
+    # Mainly used by ruote-fluo.
+    #
+    def self.to_ruby(tree, level=0)
+
+      expname = tree[0]
+      expname = 'Ruote.process_definition' if level == 0 && expname == 'define'
+
+      s =
+        '  ' * level +
+        expname +
+        atts_to_x(tree[1]) { |k, v|
+          ":#{k} => #{v.inspect}"
+        }
+
+      return "#{s}\n" if tree[2].empty?
+
+      s << " do\n"
+      tree[2].each { |child| s << to_ruby(child, level + 1) }
+      s << "#{'  ' * level}end\n"
+
+      s
+    end
+
+    def self.to_radial(tree, level=0)
+
+      s =
+        '  ' * level +
+        tree[0] +
+        atts_to_x(tree[1]) { |k, v|
+          "#{k}: #{v.inspect}"
+        }
+
+      return "#{s}\n" if tree[2].empty?
+
+      s << "\n"
+      tree[2].each { |child| s << to_radial(child, level + 1) }
+
+      s
+    end
+
+    # Turns the process definition tree (ruote syntax tree) to a JSON String.
+    #
+    def self.to_json(tree)
+
+      tree.to_json
+    end
+
+    # Returns true if the defintion is a remote URI
+    #
+    def self.remote?(definition)
+
+      u = URI.parse(definition)
+
+      (u.scheme != nil) && ( ! ('A'..'Z').include?(u.scheme))
+    end
+
+    protected
+
+    # Minimal test. Used by #read.
+    #
+    def is_uri?(s)
+
+      return false if s.index("\n")
+
+      ((URI.parse(s); true) rescue false)
+    end
+
+    # A convenience method when building XML
+    #
+    def self.builder(options={}, &block)
+
+      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
+    end
+
+    # As used by to_ruby and to_radial
+    #
+    def self.atts_to_x(atts, &block)
+
+      s = []
+
+      t = atts.find { |k, v| v == nil }
+      s << t.first.inspect if t
+
+      s = atts.inject(s) { |a, (k, v)|
+        #a << ":#{k} => #{v.inspect}" if t.nil? || k != t.first
+        a << block.call(k, v) if t.nil? || k != t.first
+        a
+      }.join(', ')
+
+      s.length > 0 ? " #{s}" : s
+    end
+  end
+end
+

data/lib/ruote/reader/json.rb

@@ -0,0 +1,49 @@
+#--
+# Copyright (c) 2005-2011, 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,290 @@
+#--
+# Copyright (c) 2005-2011, 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(: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(:value) {
+        array | object |
+        string | number |
+        str('true').as(:true) | str('false').as(:false) |
+        str('null').as(:nil) | str('nil').as(:nil) |
+        text
+      }
+
+      rule(:entry) {
+        ((string | 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) >>
+          (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(/-/, '_')
+        @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).inject({}) { |h, att| h[att.key] = att.val; h }
+        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).inject({}) { |h, att| h[att.key] = att.val; h }
+        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(:text => simple(:te)) { te.to_s }
+      rule(:string => simple(:st)) { st.to_s }
+      rule(:number => simple(:n)) { n.match(/[eE\.]/) ? Float(n) : Integer(n) }
+      rule(:false => simple(:b)) { false }
+      rule(:true => simple(:b)) { true }
+      rule(:nil => simple(:n)) { nil }
+
+      rule(:array => subtree(:ar)) {
+        ar.is_a?(Array) ? ar : [ ar ]
+      }
+      rule(:object => subtree(:es)) {
+        (es.is_a?(Array) ? es : [ es ]).inject({}) { |h, e|
+          e = e[:ent]; h[e[:key]] = e[:val]; h
+        }
+      }
+    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
+
+    rescue Parslet::ParseFailed => e
+      class << e; attr_accessor :error_tree; end
+      e.error_tree = parser.root.error_tree
+      raise e
+    end
+  end
+end
+