cpee 1.3.129 → 1.3.130

data/lib/cpee/processtransformation/bpmn2.rb

@@ -0,0 +1,273 @@
+# 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 
+                  branch.condition_type = "text/javascript"
+                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
+                  ### 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
+                    traces.shift_all
+                    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/processtransformation/cpee.rb

@@ -0,0 +1,118 @@
+# 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(node,res)
+          s1 = res.add('loop', 'pre_test' => node.condition.join(' && '))
+          s1.attributes['language'] = node.condition_type unless node.condition_type.nil?
+          generate_for_list(node,s1)
+        end
+
+        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(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
+        end
+        private :print_Parallel
+
+        def print_Conditional(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
+        end
+        private :print_Conditional
+      end
+
+    end
+
+  end  
+
+end

data/lib/cpee/processtransformation/structures.rb

@@ -0,0 +1,426 @@
+# 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
+      def initialize(from,to,cond=nil)
+        @from  = from
+        @to = to
+        @condition = cond
+      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
+      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
+      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
+      def condition?; true; end
+      def initialize(id)
+        @container = true
+        @id = id
+        @type = :loop
+        @condition = []
+        @condition_type = nil
+      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_accessor :type
+      def initialize(id,mode,type)
+        @container = true
+        @id = id
+        @sub = []
+        @mode = mode
+        @type = type
+      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 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