cpee 1.3.137 → 1.3.138

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d48178530a9f9c1885a88d46053086ae0cf9eed
+  data.tar.gz: 75e0da4973eb3d5b7db31e52859e5df70850c813
+SHA512:
+  metadata.gz: 620e2cd33e1179c9affa8830f0854d74d796e170df7612361156a3d62d1900e79b3e14ab3cec58146581482d4a0e5c3015223a3d3d868dd1969aaa65f89f21a5
+  data.tar.gz: 61a3fed144b5e8d248d9296491d44aa317673ece5a2c2db43e1738cb0bbde67ee45570880e26c2bd91200424a5379492b04991f625d54acf0961fbbf84f5b9b1

data/cpee.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name             = "cpee"
-  s.version          = "1.3.137"
+  s.version          = "1.3.138"
   s.platform         = Gem::Platform::RUBY
   s.license          = "LGPL-3"
   s.summary          = "Preliminary release of cloud process execution engine (cpee). If you just need workflow execution, without a rest/xmpp service exposing it, then use WEEL"

data/lib/cpee/processtransformation/bpmn2.rb

@@ -199,15 +199,15 @@ module CPEE
                 end
               else
                 loops = traces.loops
-                if node.type == :exclusiveGateway || traces.length == 1
+                if node.type == :exclusiveGateway || traces.all_loops?
                   ### as the first is a decision node, just remove and continue
                   if node.incoming == 2
                     node.incoming = 1
                     branch << Loop.new(node.id)
                     ### remove the gateway itself, as for a single loop it is no longer used.
                     ### the condition will the loop condition
-                    if traces.length == 1
-                      loops.first.pop
+                    if traces.all_loops?
+                      loops.pop_all
                     else
                       traces.shift_all
                     end

data/lib/cpee/processtransformation/structures.rb

@@ -286,6 +286,9 @@ module CPEE
         def shift_all
           self.each{ |tr| tr.shift }
         end  
+        def pop_all
+          self.each{ |tr| tr.pop }
+        end  
 
         def finished?
           self.reduce(0){|sum,t| sum += t.length} == 0
@@ -300,12 +303,19 @@ module CPEE
           self.each{|n| num += 1 if n.include?(e)} 
           num == self.length
         end
+        def same_position_in_all?(e,i)
+          num = 0
+          self.each{|n| num += 1 if n[i] == e}
+          num == self.length
+        end
 
-        def infinite_loop_fix
-          self << self.first.dup
-          self.last.pop
+        def all_loops?
+          num = 0
+          self.each{|n| num += 1 if n.first == n.last }
+          num == self.length
         end
 
+
         def add_breaks
           trueloops = self.find_all{ |t| t.last == t.first }.length
           if trueloops == self.length
@@ -364,8 +374,8 @@ module CPEE
           max = nil
           sh = self.shortest
           sh = sh[0..-2] if sh.first == sh.last
-          sh.each do |e,i|
-            if self.include_in_all?(e)
+          sh.each_with_index do |e,i|
+            if self.same_position_in_all?(e,i)
               max = e
             else  
               break

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cpee
 version: !ruby/object:Gem::Version
-  version: 1.3.137
-  prerelease: 
+  version: 1.3.138
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -11,70 +10,62 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-21 00:00:00.000000000 Z
+date: 2014-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riddl
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: weel
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: savon
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: see http://cpee.org
@@ -110,7 +101,6 @@ files:
 - server/handlerwrappers/default.rb
 - lib/engine.xml
 - lib/cpee/callback.rb
-- lib/cpee/bpmn2.rb
 - lib/cpee/handler_notifications.rb
 - lib/cpee/controller.rb
 - lib/cpee/processtransformation/bpmn2.rb
@@ -125,9 +115,7 @@ files:
 - lib/cpee/processtransformation/bpel/Repository/booking.wsdl
 - lib/cpee/processtransformation/bpel/Repository/booking.bpel
 - lib/cpee/processtransformation/bpel/lib/BPEL_Transform.rb
-- lib/cpee/cpee.rb
 - lib/cpee/handler_properties.rb
-- lib/cpee/structures.rb
 - lib/cpee/implementation.rb
 - lib/cpee/empty_workflow.rb
 - lib/engine/instance-info.rng
@@ -204,27 +192,26 @@ files:
 homepage: http://cpee.org/
 licenses:
 - LGPL-3
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Preliminary release of cloud process execution engine (cpee). If you just
   need workflow execution, without a rest/xmpp service exposing it, then use WEEL
 test_files:

data/lib/cpee/bpmn2.rb

@@ -1,280 +0,0 @@
-# encoding: UTF-8
-#
-# This file is part of CPEE.
-#
-# Apache License, Version 2.0
-# 
-# Copyright (c) 2013 Juergen Mangler
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require File.expand_path(File.dirname(__FILE__) + '/structures')
-require 'rubygems'
-require 'xml/smart'
-require 'highline'
-
-module CPEE
-
-  module ProcessTransformation
-
-    module Source
-
-      class BPMN2
-        attr_reader :dataelements, :endpoints, :start, :graph
-
-         def initialize(xml) #{{{
-          @tree = Tree.new
-          @hl = HighLine.new
-          @start = nil
-
-          doc = XML::Smart.string(xml)
-          doc.register_namespace 'bm',  "http://www.omg.org/spec/BPMN/20100524/MODEL" 
-
-          @dataelements = {}
-          @endpoints = {}
-          @graph = Graph.new
-
-          extract_dataelements(doc)
-          extract_endpoints(doc)
-          extract_nodelink(doc)
-
-          @traces = Traces.new [[@start]]
-        end #}}}
-
-        def extract_dataelements(doc)
-          doc.find("/bm:definitions/bm:process/bm:property[bm:dataState/@name='cpee:dataelement']").each do |ref|
-            if ref.attributes['itemSubjectRef']
-              doc.find("/bm:definitions/bm:itemDefinition[@id=\"" + ref.attributes['itemSubjectRef'] + "\"]").each do |sref|
-                @dataelements[ref.attributes['name']] = sref.attributes['structureRef'].to_s
-              end 
-            else
-              @dataelements[ref.attributes['name']] = ''
-            end  
-          end
-        end
-
-        def extract_endpoints(doc)
-          doc.find("/bm:definitions/bm:process/bm:property[bm:dataState/@name='cpee:endpoint']/@itemSubjectRef").each do |ref|
-            doc.find("/bm:definitions/bm:itemDefinition[@id=\"" + ref.value + "\"]/@structureRef").each do |sref|
-              @endpoints[ref.value] = sref.value
-            end  
-          end
-        end
-
-        def extract_nodelink(doc)
-          doc.find("/bm:definitions/bm:process/bm:*[@id and @name and not(@itemSubjectRef) and not(name()='sequenceFlow')]").each do |e|
-            n = Node.new(e.attributes['id'],e.qname.name.to_sym,e.attributes['name'].strip,e.find('count(bm:incoming)'),e.find('count(bm:outgoing)'))
-
-            if e.attributes['scriptFormat'] != ''
-              n.script_type = e.attributes['scriptFormat']
-            end
-
-            e.find("bm:property[@name='cpee:endpoint']/@itemSubjectRef").each do |ep|
-              n.endpoints << ep.value
-            end
-            e.find("bm:property[@name='cpee:method']/@itemSubjectRef").each do |m|
-              n.methods << m.value
-            end
-            e.find("bm:script").each do |s|
-              n.script ||= ''
-              n.script << s.text.strip
-            end
-            e.find("bm:ioSpecification/bm:dataInput").each do |a|
-              name = a.attributes['name']
-              value = a.attributes['itemSubjectRef']
-              if @dataelements.keys.include?(value)
-                n.parameters[name] = 'data.' + value
-              else  
-                n.parameters[name] = value
-              end
-            end
-            e.find("bm:ioSpecification/bm:dataOutput").each do |a|
-              ref = a.attributes['id']
-              e.find("bm:dataOutputAssociation[bm:sourceRef=\"#{ref}\"]").each do |d|
-                n.script_var = ref
-                n.script_id = d.find("string(bm:targetRef)")
-              end
-            end
-
-            @graph.add_node n
-            @start = n if n.type == :startEvent && @start == nil
-          end
-
-          # extract all sequences to a links
-          doc.find("/bm:definitions/bm:process/bm:sequenceFlow").each do |e|
-            source = e.attributes['sourceRef']
-            target = e.attributes['targetRef']
-            cond = e.find('bm:conditionExpression')
-            @graph.add_link Link.new(source, target, cond.empty? ? nil : cond.first.text.strip)
-          end
-
-          @graph.clean_up do |node|
-            if node.type == :scriptTask && (x = @graph.find_script_id(node.id)).any?
-              x.each do |k,n|
-                n.script = node.script
-                n.script_type = node.script_type
-              end
-              true
-            else
-              false
-            end  
-          end
-        end
-
-        def build_traces #{{{
-          build_extraces @traces, @start
-          @traces
-        end #}}}
-        def build_tree(debug=false) #{{{
-          build_ttree @tree, @traces.dup, nil, debug
-          debug_print debug, 'Tree finished'
-          @tree
-        end #}}}
-    
-        def build_extraces(traces, node) #{{{
-          dupt = traces.last.dup
-          @graph.next_nodes(node).each_with_index do |n,i|
-            traces << dupt.dup if i > 0
-            if traces.last.include?(n)
-              traces.last << n
-            else  
-              traces.last << n
-              build_extraces(traces,n)
-            end
-          end
-        end #}}}
-        private :build_extraces
-
-        def map_node(node) #{{{
-          case node.type
-            when :parallelGateway
-              Parallel.new(node.id,node.type)
-            when :exclusiveGateway
-              Conditional.new(node.id,:exclusive,node.type)
-            when :eventBasedGateway
-              Parallel.new(node.id,node.type,1)
-            when :inclusiveGateway
-              Conditional.new(node.id,:inclusive,node.type)
-            when :endEvent, :startEvent, nil
-              nil
-            else
-              node
-          end
-        end #}}}
-        private :map_node
-
-        def build_ttree(branch,traces,enode=nil,debug=false)
-          while not traces.finished?
-            ### if traces exist more than once, make it so they exist only once
-            ### if somebody creates a modell with an inclusive/exclusive that
-            ### has identical branches with different conditions, we are fucked
-            ### but how are the odds? right? right?
-            traces.uniq!
-            debug_print debug, traces
-            if node = traces.same_first
-              if branch.condition?
-                li = @graph.link(branch.id,traces.first_node.id)
-                unless li.nil?
-                  branch.condition << li.condition unless li.condition.nil?
-                  branch.condition_type = "text/javascript"
-                  li.attributes.each do |k,v|
-                    branch.attributes[k] = v
-                  end
-                end  
-              end
-              if node == enode
-                traces.shift_all
-              elsif node.incoming <= 1
-                traces.shift_all
-                n = map_node(node)
-                if !(n.nil? || (n.container? && (node.outgoing <=1 || traces.finished?)))
-                  (branch << n).compact!
-                end
-              else
-                loops = traces.loops
-                if node.type == :exclusiveGateway || traces.length == 1
-                  ### as the first is a decision node, just remove and continue
-                  if node.incoming == 2
-                    node.incoming = 1
-                    branch << Loop.new(node.id)
-                    ### remove the gateway itself, as for a single loop it is no longer used.
-                    ### the condition will the loop condition
-                    if traces.length == 1
-                      loops.first.pop
-                    else
-                      traces.shift_all
-                    end
-                    loops.remove_empty
-                    build_ttree branch.last, loops, nil, debug
-                  else  
-                    ### dont remove it, treat it as a normal conditional
-                    ### an infinite loop that can only be left by break is created
-                    node.incoming = 1
-                    branch << InfiniteLoop.new(node.id)
-                    ### add the blank conditional to get a break
-                    len = loops.length
-                    loops.add_breaks
-                    build_ttree branch.last, loops, nil, debug
-                    ### set outgoing to number of loops (without the break) so that it can be ignored (should be 1 all the time)
-                    node.outgoing -= len
-                  end   
-                else
-                  node.incoming -= loops.length
-                  ### throw away the loop traces, remove loop traces from front of all other traces
-                  traces.segment_by_loops loops
-                  build_ttree branch, loops, nil, debug
-                end
-                traces.remove(loops)
-                traces.remove_empty
-              end
-            else
-              endnode = traces.find_endnode || enode
-              tracesgroup, endnode = traces.segment_by endnode
-              tracesgroup.each do |trcs|
-                if trcs.finished?
-                  build_ttree branch.last.new_branch, Traces.new([[Break.new(1)]]), endnode, debug
-                else  
-                  build_ttree branch.last.new_branch, trcs, endnode, debug
-                end  
-                endnode.incoming -= 1 unless endnode.nil?
-              end
-              ### all before is reduced to one incoming arrow
-              ### if now there is still more than one incoming we have a loop situation
-              ### where the end of a branching statement is also the starting/endpoint 
-              ### of a loop
-              endnode.incoming += 1 unless endnode.nil?
-            end
-          end
-        end
-        private :build_ttree
-
-        def debug_print(debug,traces) #{{{
-          if debug
-            puts '-' * @hl.output_cols, @tree.to_s
-            puts traces.to_s
-            @hl.ask('Continue ... '){ |q| q.echo = false }
-          end  
-        end #}}}
-        private :debug_print
-
-        def generate_model(formater) #{{{
-          formater.new(@tree).generate
-        end #}}}
-
-      end  
-
-    end
-
-  end
-
-end

data/lib/cpee/cpee.rb

@@ -1,129 +0,0 @@
-# encoding: UTF-8
-#
-# This file is part of CPEE.
-#
-# Apache License, Version 2.0
-# 
-# Copyright (c) 2013 Juergen Mangler
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module CPEE
-
-  module ProcessTransformation
-
-    module Target
-
-      class CPEE
-        def initialize(tree)
-          @tree = tree
-        end
-        def generate
-          res = XML::Smart.string("<description xmlns='http://cpee.org/ns/description/1.0'/>")
-          res.register_namespace 'd', 'http://cpee.org/ns/description/1.0'
-          generate_for_list(@tree,res.root)
-          res
-        end
-
-        def generate_for_list(list,res)
-          list.each do |e|
-            nam = e.class.name.gsub(/\w+:+/,'')
-            send("print_#{nam}".to_sym,e,res)
-          end
-        end
-        private :generate_for_list
-
-        def print_Break(node,res)
-          res.add('break')
-        end
-
-        def print_InfiniteLoop(node,res)
-          s1 = res.add('loop', 'pre_test' => 'true')
-          generate_for_list(node,s1)
-        end
-        def print_Loop_default(node,res)
-          s1 = res.add('loop', 'pre_test' => node.condition.empty? ? 'true' : node.condition.join(' && '))
-          s1.attributes['language'] = node.condition_type unless node.condition_type.nil?
-          generate_for_list(node,s1)
-          s1
-        end
-        private :print_Loop_default
-        def print_Loop(node,res); print_Loop_default(node,res); end
-        private :print_Loop
-
-        def print_Node(node,res)
-          if node.endpoints.empty? && !node.script.nil? && node.script.strip != ''
-            n = res.add('d:manipulate', 'id' => "a#{node.niceid}")
-            n.text = node.script
-            n.attributes['output'] = node.script_var unless node.script_var.nil?
-            n.attributes['language'] = node.script_type unless node.script_type.nil?
-          else  
-            n   = res.add('d:call', 'id' => "a#{node.niceid}", 'endpoint' => node.endpoints.join(','))
-            p   = n.add('d:parameters')
-                  p.add('d:label',node.label)
-                  p.add('d:method',node.methods.join(','))
-                  p.add('d:type',node.type)
-                  p.add('d:mid',node.id)
-            par = p.add('d:parameters')
-            node.parameters.each do |k,v|
-              par.add(k,v)
-            end
-            if !node.script.nil? && node.script.strip != ''
-              x = n.add('manipulate',node.script)
-              x.attributes['output'] = node.script_var unless node.script_var.nil?
-              x.attributes['language'] = node.script_type unless node.script_type.nil?
-            end
-          end
-        end
-        private :print_Node
-
-        def print_Parallel_default(node,res)
-          s1 = res.add('parallel','wait' => node.wait)
-          node.sub.each do |branch|
-            s2 = s1.add('parallel_branch')
-            generate_for_list(branch,s2)
-          end
-          s1
-        end
-        private :print_Parallel_default
-        def print_Parallel(node,res); print_Parallel_default(node,res); end
-        private :print_Parallel
-
-        def print_Conditional_default(node,res)
-          s1 = res.add('d:choose', 'mode' => node.mode)
-          node.sub.each do |branch|
-            s2 = if branch.condition.any?
-              a = s1.add('d:alternative','condition' => branch.condition.join(' or '))
-              a.attributes['language'] = branch.condition_type unless branch.condition_type.nil?
-              a
-            else
-              s1.add('d:otherwise')
-            end  
-            generate_for_list(branch,s2)
-          end
-          if (x = s1.find('d:otherwise')).any?
-            s1.add x
-          end
-          s1
-        end
-        private :print_Conditional_default
-        def print_Conditional(node,res); print_Conditional_default(node,res); end
-        private :print_Conditional
-
-      end
-
-    end
-
-  end  
-
-end

data/lib/cpee/structures.rb

@@ -1,437 +0,0 @@
-# encoding: UTF-8
-#
-# This file is part of CPEE.
-#
-# Apache License, Version 2.0
-# 
-# Copyright (c) 2013 Juergen Mangler
-# 
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module CPEE
-
-  module ProcessTransformation
-
-    class Link #{{{
-      attr_accessor :from, :to
-      attr_reader :condition, :attributes
-      def initialize(from,to,cond=nil)
-        @from  = from
-        @to = to
-        @condition = cond
-        @attributes = {}
-      end
-    end #}}}
-
-    module Container
-      def container?
-        @container || false
-      end
-    end
-
-    class Node #{{{ 
-      include Container
-      @@niceid = -1
-      attr_reader :id, :label, :niceid
-      attr_reader :endpoints, :methods, :parameters, :attributes
-      attr_accessor :script, :script_id, :script_var, :script_type, :incoming, :outgoing, :type
-      def initialize(id,type,label,incoming,outgoing)
-        @id = id
-        @niceid = (@@niceid += 1)
-        @type = type
-        @label = label
-        @endpoints = []
-        @methods = []
-        @script = nil
-        @script_type = nil
-        @script_id = nil
-        @script_var = 'result'
-        @parameters = {}
-        @incoming = incoming
-        @outgoing = outgoing
-        @attributes = {}
-      end
-    end # }}} 
-
-    module Struct #{{{
-      def each(&a)
-        @sub.each{|s| a.call(s)}
-      end
-      def length
-        @sub.length
-      end  
-    end #}}}
-
-    class Break < Node
-      def initialize(incoming)
-        super '-1', :break, 'BREAK', incoming, []
-      end
-    end
-
-    class Alternative < Array #{{{
-      include Container
-      attr_accessor :condition, :condition_type
-      attr_reader :id
-      def condition?; true; end
-      def initialize(id)
-        @container = true
-        @id = id
-        @condition = []
-        @condition_type = nil
-      end
-    end #}}}
-    class Branch < Array #{{{
-      include Container
-      attr_reader :id
-      def condition?; false; end
-      def initialize(id)
-        @container = true
-        @id = id
-      end
-    end #}}}
-    class InfiniteLoop < Array #{{{
-      include Container
-      def condition?; false; end
-      attr_accessor :id, :type
-      def initialize(id)
-        @container = true
-        @id = id
-        @type = :loop
-      end  
-    end #}}}
-    class Loop < Array #{{{
-      include Container
-      attr_accessor :id, :type, :condition, :condition_type
-      attr_reader :attributes
-      def condition?; true; end
-      def initialize(id)
-        @container = true
-        @id = id
-        @type = :loop
-        @condition = []
-        @condition_type = nil
-        @attributes = {}
-      end  
-    end #}}}
-
-    class Parallel #{{{
-      include Container
-      include Struct
-      include Enumerable
-      attr_reader :id, :sub
-      attr_accessor :type, :wait
-      def initialize(id,type,wait='-1')
-        @container = true
-        @id = id
-        @type = type
-        @sub = []
-        @wait = wait
-      end
-      def new_branch
-        (@sub << Branch.new(@id)).last
-      end
-    end #}}} 
-
-    class Conditional #{{{
-      include Container
-      include Struct
-      include Enumerable
-      attr_reader :container
-      attr_reader :id, :sub, :mode
-      attr_reader :attributes
-      attr_accessor :type
-      def initialize(id,mode,type)
-        @container = true
-        @id = id
-        @sub = []
-        @mode = mode
-        @type = type
-        @attributes = {}
-      end  
-      def new_branch
-        (@sub << Alternative.new(@id)).last
-      end
-    end #}}}
-
-    class Graph #{{{
-      attr_reader :flow, :nodes
-
-      def initialize
-        @nodes = {}
-        @links = []
-      end
-
-      def clean_up(&bl)
-        selnodes = []
-        @nodes.each do |k,n|
-          ret = bl.call(n)
-          selnodes << n if ret
-        end
-        selnodes.each do |n|
-          if n.incoming > 1 || n.outgoing > 1
-            raise "#{n.inspect} - not a simple node to remove"
-          end  
-          to,from = nil
-          @links.each do |f|
-            to = f if f.to == n.id
-            from = f if f.from == n.id
-          end
-          if to && from
-            to.to = from.to
-            @links.delete(from)
-            @nodes.delete(n.id)
-          else
-            raise "#{n.inspect} - could not remove flow"
-          end  
-        end
-      end
-
-      def find_script_id(s)
-        @nodes.find_all{|k,n| n.script_id == s}
-      end
-
-      def add_node(n)
-        @nodes[n.id] = n
-      end  
-
-      def link(f,t)
-        @links.find{ |x| x.from == f && x.to == t }
-      end
-
-      def add_link(l)
-        @links << l
-      end
-
-      def next_nodes(from)
-        links = @links.find_all { |x| x.from == from.id }
-        links.map{|x| @nodes[x.to] }
-      end
-
-      def next_node(from)
-        if (nodes = next_nodes(from)).length == 1
-          nodes.first
-        else
-          raise "#{from.inspect} - multiple outgoing connections"
-        end  
-      end
-    end #}}}
-
-      class Tree < Array #{{{
-        def condition?; false; end
-
-        def to_s
-          "TREE:\n" << print_tree(self)
-        end
-
-        def print_tree(ele,indent='  ')
-          ret = ''
-          ele.each_with_index do |e,i|
-            last  = (i == ele.length - 1)
-            pchar = last ? '└' : '├'
-            if e.container?
-              ret << indent + pchar + ' ' + e.class.to_s.gsub(/[^:]*::/,'') + "\n"
-              ret << print_tree(e,indent + (last ? '  ' : '│ '))
-            elsif e.is_a?(Break) && 
-              ret << indent + pchar + ' ' + e.class.to_s.gsub(/[^:]*::/,'') + "\n"
-            else
-              ret << indent + pchar + ' ' + e.niceid.to_s + "\n"
-            end
-          end
-          ret
-        end
-        private :print_tree
-      end #}}}
-
-      class Traces < Array #{{{
-        def initialize_copy(other)
-         super
-         self.map!{ |t| t.dup }
-        end
-
-        def remove(trcs)
-          trcs.each do |t|
-            self.delete(t)
-          end  
-        end
-
-        def remove_empty
-          self.delete_if{|t| t.empty? }
-        end
-
-        def first_node
-          self.first.first
-        end
-        def second_nodes
-          self.map { |t| t[1] }
-        end
-
-        def shortest
-          self.min_by{|e|e.length}
-        end
-
-        def to_s
-          "TRACES: " + self.collect { |t| t.empty? ? '∅' : t.collect{|n| "%2d" % n.niceid }.join('→ ') }.join("\n        ")
-        end
-
-        def shift_all
-          self.each{ |tr| tr.shift }
-        end  
-
-        def finished?
-          self.reduce(0){|sum,t| sum += t.length} == 0
-        end
-
-        def same_first
-          (n = self.map{|t| t.first }.uniq).length == 1 ? n.first : nil
-        end
-
-        def include_in_all?(e)
-          num = 0
-          self.each{|n| num += 1 if n.include?(e)} 
-          num == self.length
-        end
-
-        def infinite_loop_fix
-          self << self.first.dup
-          self.last.pop
-        end
-
-        def add_breaks
-          trueloops = self.find_all{ |t| t.last == t.first }.length
-          if trueloops == self.length
-            self << [self.first_node] ### the blank conditional so that we get a break
-          else
-            self.each do |t|
-              t << Break.new(1) unless t.last == t.first ### an explicit break
-            end
-          end  
-        end
-
-        def loops
-          lo = Traces.new self.find_all{ |t| t.first == t.last }
-          self.each do |t|
-            lo << t if lo.second_nodes.include?(t[1])
-          end
-          lo.uniq
-        end
-
-        def eliminate(loops)
-          ### find nested loops
-          self.each_with_index do |t,i|
-            maxcut = 0
-            ### find out which common parts the traces share with theloops
-            loops.each do |l|
-              maxcut.upto(l.length) do |i|
-                maxcut = i if t[0...i] == l[0...i]
-              end
-            end
-            ### in case of nested loop (common part occurs at end of loop), include the whole
-            0.upto (maxcut-1) do |j|
-              if self[i][j] == self[i].last
-                loops << self[i].shift(self[i].length)
-              end
-            end  
-          end
-          loops.uniq!
-          loops.remove_empty
-          self.remove_empty
-
-          ### cut from non-nested loops
-          self.each_with_index do |t,i|
-            maxcut = 0
-            ### find out which common parts the traces share with theloops
-            loops.each do |l|
-              maxcut.upto(l.length) do |i|
-                maxcut = i if t[0...i] == l[0...i]
-              end
-            end
-            loops << self[i].shift(maxcut)
-          end
-        end
-
-        def extend
-          # find largest common
-          max = nil
-          sh = self.shortest
-          sh = sh[0..-2] if sh.first == sh.last
-          sh.each do |e,i|
-            if self.include_in_all?(e)
-              max = e
-            else  
-              break
-            end
-          end
-
-          # if last is the largest common do nothing
-          # else append from last to largest common
-          self.each do |t|
-            unless t.last == max
-              last = t.last
-              t.last.incoming = 1
-              if t.index(last) && t.index(max)
-                (t.index(last) + 1).upto(t.index(max)) do |i|
-                  t << t[i]
-                end 
-              end
-            end  
-          end
-
-          max.incoming = self.length
-          max
-        end
-
-        def segment_by_loops(loops)
-          # supress loops
-          self.delete_if { |t| loops.include?(t) }
-          self.eliminate(loops)
-          loops.extend
-        end  
-
-        def find_endnode
-          # supress loops
-          trcs = self.dup
-          trcs.delete_if { |t| t.uniq.length < t.length }
-
-          # find common node (except loops)
-          enode = nil
-          trcs.first.each do |n|
-            if trcs.include_in_all?(n)
-              enode = n
-              break
-            end  
-          end
-          enode
-        end  
-
-        def segment_by(endnode)
-          # cut shit until common node, return the shit you cut away
-          tracesgroup = self.group_by{|t| t.first}.map do |k,trace|
-            coltrace = trace.map do |t|
-              # slice upto common node, collect the sliced away part
-              len = t.index(endnode)
-              if len
-                cut = t.slice!(0...len)
-                cut << t.first
-              else # if endnode is nil, then return the whole
-                t
-              end
-            end.uniq
-            Traces.new(coltrace)
-          end
-          [tracesgroup,endnode]
-        end
-      end #}}}
-
-  end
-
-end