petri 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 499cdfa50c7df671582543bc17bbd5db4a7cab6f
-  data.tar.gz: a96adde8d148ed7cee62f2013c54ae54eda2dfaa
+  metadata.gz: d2e16e5fcbb59acc715a976e7aa7d4413fc82cca
+  data.tar.gz: 2079de4b12c5e40cf2acd911d11d2f5333671fa9
 SHA512:
-  metadata.gz: 21305eb0658d4b29b8696d287d69a83eff4fb150e4fd842f8cfc47622953c393f30ea93cc3f56ac6398470c60cdc367c9b6e0f54053417e7d805c891a54f5112
-  data.tar.gz: 07e2b532eb5edd038761de2300270073e4658c1172d92024b0288e2ede9ed66cd37ba7738ae4036b1210200bd62f06394f4ab6857e03ea22657a303fba50cf02
+  metadata.gz: 23a78414f842e70b17926cbaaa9e78f421cc29897a09392b3da99711c183e14aba1033c88a1fbb02b26e08a3da227a84dcc6d37264b7b8494f14776262de356f
+  data.tar.gz: 547dd41631abe1893d187dc7de37a0c36bb0212cbe0e95587b61e6a15b3b058ac3ea9b8d54f5a30bcbc723f5fc2239304ab2d51205e64dc1d32fb19bf8e733f4

data/README.md

@@ -0,0 +1 @@
+# IT ROCKS

data/lib/petri/arc.rb

@@ -2,11 +2,40 @@ module Petri
   class Arc < Element
     attr_reader :from_node, :to_node, :type
 
-    def initialize(net, from: nil, to: nil, type: nil, guid: nil)
-      super(net, {guid: guid})
+    def initialize(net, from: nil, to: nil, type: nil, guid: nil, production_rule: nil, guard: nil)
+      super(net, {guid: guid, production_rule: production_rule, guard: guard})
       @from_node = from
       @to_node = to
-      @type = type || :regular
+      @type = type.try(:to_sym) || :regular
+    end
+
+    def reset?
+      @type == :reset
+    end
+
+    def regular?
+      @type == :regular
+    end
+
+    def inhibitor?
+      @type == :inhibitor
+    end
+
+    def production_rule
+      data[:production_rule]
+    end
+
+    def guard
+      data[:guard]
+    end
+
+    def normalized_guard
+      self.class.normalize_guard(guard)
+    end
+
+    def self.normalize_guard(guard)
+      return unless guard
+      guard.to_s.gsub(/\s+/, ' ').strip
     end
   end
 end

data/lib/petri/element.rb

@@ -1,3 +1,5 @@
+require 'securerandom'
+
 module Petri
   class Element
     attr_reader :net, :data, :guid
@@ -7,7 +9,21 @@ module Petri
     def initialize(net, data = {})
       @net = net
       @data = data.symbolize_keys || {}
-      @guid ||= data[:guid] if data[:guid]
+      @guid ||= (data[:guid] ||= generate_guid)
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(k, v)
+      @data[k] = v
+    end
+
+    private
+
+    def generate_guid
+      SecureRandom.uuid
     end
   end
 end

data/lib/petri/message.rb

@@ -0,0 +1,31 @@
+module Petri
+  class Message < Transition
+
+    # @return [String, nil]
+    def action
+      nil
+    end
+
+    def automated?
+      true
+    end
+
+    def input_places
+      input_nodes
+    end
+
+    def output_places
+      output_nodes
+    end
+
+    # @return [Array<Place>]
+    def places_to_reset
+      reset_arcs.map(&:to_node)
+    end
+
+    # @return [Array<Arc>]
+    def reset_arcs
+      net.arcs.select { |arc| arc.from_node == self && arc.reset? }
+    end
+  end
+end

data/lib/petri/net.rb

@@ -2,49 +2,114 @@ module Petri
   class Net
     include NetLoader
 
-    attr_reader :places, :transitions, :arcs, :tokens
+    attr_reader :places, :transitions, :arcs
 
     def initialize
       @transitions = []
       @places = []
       @arcs = []
-      @tokens = []
+      @data = {}
     end
 
-    # Lets the process be started
-    # Populates tokens in start places
-    def init
-      places.each do |place|
-        put_token(place) if place.start?
-      end
+    # @return [Array<Transition>]
+    def automated_transitions
+      transitions.select(&:automated?)
+    end
+
+    # @return [Array<Message>]
+    def messages
+      transitions.select { |transition| transition.is_a?(Petri::Message) }
     end
 
-    # @param place [Place]
-    # @return [Token]
-    def put_token(place)
-      Token.new(place).tap do |token|
-        @tokens << token
+    # @return [Place]
+    def start_place
+      start_places = @places.select(&:start?).select do |place|
+        place.identifier.blank? ||
+          places_by_identifier(place.identifier).select(&:finish?).empty?
       end
+
+      raise ArgumentError, 'There are more than one start places' if start_places.many?
+      raise ArgumentError, 'There is no start place' if start_places.empty?
+
+      start_places.first
     end
 
-    # @param place [Place]
-    # @return [Token, nil]
-    def remove_token(place)
-      @tokens.each do |token|
-        if token.place == place
-          @tokens.delete(token)
-          return token
+    # @param identifier [String]
+    # @return [Place, nil]
+    def place_by_identifier(identifier)
+      identifier = identifier.to_s
+      @places.each { |node| return node if node.identifier == identifier }
+      nil
+    end
+
+    # @param identifier [String]
+    # @return [Transition, nil]
+    def transition_by_identifier(identifier, automated: nil)
+      identifier = identifier.to_s
+      transitions = @transitions.select do |transition|
+        if automated
+          transition.automated?
+        elsif automated == false
+          !transition.automated?
+        else
+          true
         end
       end
+
+      transitions.each { |node| return node if node.identifier == identifier }
+
+      nil
+    end
+
+    # @param identifier [String]
+    # @return [Array<Transition>]
+    def transitions_by_identifier(identifier)
+      @transitions.select { |node| node.identifier == identifier }
+    end
+
+    # @param guard [String]
+    # @return [Arc, nil]
+    def arc_by_guard(guard)
+      return if guard.blank?
+
+      guard = Arc.normalize_guard(guard)
+      @arcs.each { |arc| return arc if arc.normalized_guard == guard }
       nil
     end
 
+    # @param identifier [String]
+    # @return [Node, nil]
+    def node_by_identifier(identifier)
+      place_by_identifier(identifier) || transition_by_identifier(identifier)
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(k, v)
+      @data[k] = v
+    end
+
+    def inspect
+      "Petri::Net#{hash}"
+    end
+
     protected
 
+    # @param guid [String]
+    # @return [Node, nil]
     def node_by_guid(guid)
       @places.each { |node| return node if node.guid == guid }
       @transitions.each { |node| return node if node.guid == guid }
       nil
     end
+
+    # @param identifier [String]
+    # @return [Array<Place>]
+    def places_by_identifier(identifier)
+      identifier = identifier.to_s
+      @places.select { |node| node.identifier == identifier }
+    end
   end
 end

data/lib/petri/net_loader.rb

@@ -1,33 +1,110 @@
 module Petri
   module NetLoader
-    extend ActiveSupport::Concern
+    # @param val [String, Class]
+    def tasks_process_class=(val)
+      @tasks_process_class = val
+    end
+
+    # @return [String, Class]
+    def tasks_process_class
+      @tasks_process_class || 'TasksProcess'
+    end
 
     # @param guid [String]
-    # @param title [String]
+    # @param identifier [String]
     # @param start [true, false]
-    def add_place(guid: , title: , start: )
-      @places << Place.new(self, {guid: guid, title: title, start: start})
+    def add_place(guid: nil, identifier: , start: false, finish: false)
+      Place.new(self, {guid: guid, identifier: identifier, start: start, finish: finish}).tap do |place|
+        @places << place
+      end
+    end
+
+    # @param guid [String]
+    # @param identifier [String]
+    # @param action [String]
+    def add_transition(guid: nil, identifier: , action: nil, automated: )
+      Transition.new(self, {guid: guid, identifier: identifier, action: action, automated: automated}).tap do |transition|
+        @transitions << transition
+      end
     end
 
     # @param guid [String]
-    # @param title [String]
+    # @param identifier [String]
     # @param action [String]
-    def add_transition(guid: , title: , action: )
-      @transitions << Transition.new(self, {guid: guid, title: title, action: action})
+    def add_message(guid: nil, identifier:)
+      Message.new(self, {guid: guid, identifier: identifier}).tap do |message|
+        @transitions << message
+      end
+    end
+
+    # @param task_identifier [String]
+    # @param pin [String]
+    # @param automated [true, false]
+    def add_task_transition(task_identifier:, pin:, automated:)
+      TaskTransition.new(self, {task_identifier: task_identifier, pin: pin, automated: automated, process_class: tasks_process_class}).tap do |transition|
+        @transitions << transition
+      end
     end
 
     # @param guid [String]
-    # @param title [String]
+    # @param identifier [String]
     # @param from_guid [String]
     # @param to_guid [String]
     # @param type [String]
-    def add_arc(guid: , from_guid: , to_guid: , type: )
+    # @param production_rule [String, nil]
+    def add_arc(guid: nil, from_guid: , to_guid: , type: , production_rule: nil, guard: nil)
       from_node = node_by_guid(from_guid)
       to_node = node_by_guid(to_guid)
-      @arcs << Arc.new(self, from: from_node, to: to_node, type: type.try(:to_sym), guid: guid)
+
+      if type == 'test'
+        @arcs << Arc.new(self, from: from_node, to: to_node, type: :regular, guid: guid, guard: guard)
+        @arcs << Arc.new(self, from: to_node, to: from_node, type: :regular, guid: guid)
+      else
+        @arcs << Arc.new(self, from: from_node, to: to_node, type: type.try(:to_sym), guid: guid, production_rule: production_rule, guard: guard)
+      end
+    end
+
+    # @param task_data [Hash]
+    # @param net_data [Hash] full bpf
+    def add_task(task_data, net_data)
+      identifier = task_data['identifier']
+
+      add_task_transition(task_identifier: identifier, pin: 'Finish', automated: false) if task_data['manual_finish_enabled']
+      add_task_transition(task_identifier: identifier, pin: 'Cancel', automated: false) # Manual cancel is always enabled?
+
+      task_arcs = net_data['arcs'].select { |arc| arc['to_guid'] == task_data['guid'] }.group_by { |arc| arc['pin'] }
+      task_arcs.each { |pin, arcs| connect_task_arcs(identifier, pin, arcs) }
+    end
+
+    # @param task_identifier [String]
+    # @param pin [String] Create, Pause, Finish, Cancel
+    # @param arcs [Array<Petri::Arc>]
+    def connect_task_arcs(task_identifier, pin, arcs)
+      return if arcs.empty?
+
+      transition = add_task_transition(task_identifier: task_identifier, pin: pin, automated: true)
+
+      # (p*) <?-> [(T) task pin]
+      arcs.each_with_index do |arc, index|
+        front_arc_type = arc['type'] == 'test' ? 'regular' : arc['type']
+
+        add_arc(from_guid: arc['from_guid'],
+                to_guid: transition.guid,
+                type: front_arc_type,
+                guard: arc['guard'])
+
+        add_arc(from_guid: transition.guid,
+                to_guid: arc['from_guid'],
+                type: 'regular') if arc['type'] == 'test'
+      end
+    end
+
+    def self.included(base_class)
+      base_class.extend(ClassMethods)
     end
 
     module ClassMethods
+
       # @param path [String]
       # @return [Net]
       def from_file(path)
@@ -52,21 +129,34 @@ module Petri
         self.new.tap do |net|
           hash['places'].each do |data|
             net.add_place(guid: data['guid'],
-                          title: data['title'],
-                          start: data['start'])
+                          identifier: data['identifier'],
+                          start: data['start'],
+                          finish: data['finish'])
           end
 
           hash['transitions'].each do |data|
             net.add_transition(guid: data['guid'],
-                               title: data['title'],
+                               identifier: data['identifier'],
+                               automated: data['automated'],
                                action: data['action'])
           end
 
+          hash['messages'].each do |data|
+            net.add_message(guid: data['guid'],
+                            identifier: data['identifier'])
+          end if hash['messages']
+
+          hash['tasks'].each do |data|
+            net.add_task(data, hash)
+          end if hash['tasks']
+
           hash['arcs'].each do |data|
             net.add_arc(guid: data['guid'],
                         from_guid: data['from_guid'],
                         to_guid: data['to_guid'],
-                        type: data['type'])
+                        type: data['type'],
+                        production_rule: data['production_rule'],
+                        guard: data['guard'])
           end
         end
       end

data/lib/petri/node.rb

@@ -2,8 +2,38 @@ module Petri
   class Node < Element
 
     # @return [String, nil]
-    def title
-      @data[:title]
+    def identifier
+      @data[:identifier]
+    end
+
+    # @return [Array<Arc>]
+    def input_arcs
+      net.arcs.select { |arc| arc.to_node == self && arc.regular? }
+    end
+
+    # @return [Array<Node>]
+    def input_nodes
+      input_arcs.map(&:from_node)
+    end
+
+    # @return [Array<Arc>]
+    def output_arcs
+      net.arcs.select { |arc| arc.from_node == self && arc.regular? }
+    end
+
+    # @return [Array<Node>]
+    def output_nodes
+      output_arcs.map(&:to_node)
+    end
+
+    # @return [Array<Arc>]
+    def outgoing_arcs
+      net.arcs.select { |arc| arc.from_node == self }
+    end
+
+    # @return [Array<Arc>]
+    def ingoing_arcs
+      net.arcs.select { |arc| arc.to_node == self }
     end
   end
 end

data/lib/petri/place.rb

@@ -1,12 +1,38 @@
 module Petri
   class Place < Node
 
-    def has_token?
-      net.tokens.any? { |token| token.place == self }
-    end
-
     def start?
       !!@data[:start]
     end
+
+    def finish?
+      !!@data[:finish]
+    end
+
+    # @return [Array<Arc>]
+    def reset_arcs
+      net.arcs.select { |arc| arc.to_node == self && arc.reset? }
+    end
+
+    # @return [Array<Transition>]
+    def reset_transitions
+      reset_arcs.map(&:from_node)
+    end
+
+    # For a finish place returns start places with the same identifier.
+    # For nets where a finish place may be connected with start places
+    # in order to initialize one flow as a result of another.
+    # @return [Array<Place>]
+    def links
+      if finish?
+        @net.places.select { |place| place.start? && place.identifier == identifier }
+      else
+        []
+      end
+    end
+
+    def inspect
+      "Petri::Place<#{identifier}>"
+    end
   end
 end

data/lib/petri/subprocess.rb

@@ -0,0 +1,25 @@
+module Petri
+  module Subprocess
+
+    # Used as a key for caching
+    # @return [String]
+    def subprocess_identifier
+      fail NotImplementedError
+    end
+
+    # @return [Class]
+    def process_class
+      @process_class ||= begin
+        klass = @data[:process_class]
+        case klass
+        when String
+          klass.constantize
+        when Class
+          klass
+        else
+          fail ArgumentError, "Expected Class, String, got #{klass.class.name}"
+        end
+      end
+    end
+  end
+end

data/lib/petri/task_transition.rb

@@ -0,0 +1,60 @@
+module Petri
+  class TaskTransition < Transition
+    include Petri::Subprocess
+
+    attr_reader :task_identifier
+
+    # @param net [Net]
+    # @param data [Hash<Symbol>]
+    def initialize(net, data = {})
+      super
+      @task_identifier = @data[:task_identifier]
+      @data[:identifier] = generate_identifier
+    end
+
+    def create?
+      pin == 'Create'
+    end
+
+    def finish?
+      pin == 'Finish'
+    end
+
+    def pause?
+      pin == 'Pause'
+    end
+
+    def resume?
+      pin == 'Resume'
+    end
+
+    def cancel?
+      pin == 'Cancel'
+    end
+
+    def pin
+      @data[:pin]
+    end
+
+    # [Petri::Subprocess]
+    def subprocess_identifier
+      task_identifier
+    end
+
+    private
+
+    def generate_identifier
+      if create?
+        "Create \"#{@task_identifier}\" task"
+      elsif finish?
+        "Finish \"#{@task_identifier}\" task"
+      elsif pause?
+        "Pause \"#{@task_identifier}\" task"
+      elsif resume?
+        "Resume \"#{@task_identifier}\" task"
+      elsif cancel?
+        "Cancel \"#{@task_identifier}\" task"
+      end
+    end
+  end
+end

data/lib/petri/token.rb

@@ -1,10 +1,33 @@
 module Petri
   class Token
-    attr_reader :place
+    attr_reader :place, :source_transition, :data
 
     # @param place [Place]
-    def initialize(place)
+    # @param source_transition [Transition, nil]
+    def initialize(place, source_transition = nil)
       @place = place
+      @source_transition = source_transition
+      @data = {}
+    end
+
+    # @return [String, nil]
+    def production_rule
+      source_arc && source_arc.production_rule
+    end
+
+    # @return [Arc, nil]
+    def source_arc
+      if source_transition
+        place.input_arcs.find { |arc| arc.from_node == source_transition }
+      end
+    end
+
+    def []=(k, v)
+      @data[k] = v
+    end
+
+    def [](k)
+      @data[k]
     end
   end
 end

data/lib/petri/transition.rb

@@ -6,59 +6,39 @@ module Petri
       @data[:action].presence
     end
 
-    def enabled?
-      input_places.all?(&:has_token?)
+    def automated?
+      @data[:automated].present?
     end
 
-    def fire!
-      raise ArgumentError, 'Transition is not enabled' unless enabled?
-      consume_tokens
-      callback.try(:call)
-      produce_tokens
+    def inhibitor_places
+      ingoing_arcs.select(&:inhibitor?).map(&:from_node)
     end
 
-    # @param block [Proc]
-    def set_callback(&block)
-      @callback = block
-    end
-
-    # @return [Proc, nil]
-    def callback
-      @callback
+    def input_places
+      input_nodes
     end
 
-    private
-
-    def consume_tokens
-      input_places.each do |place|
-        net.remove_token(place)
-      end
+    def output_places
+      output_nodes
     end
 
-    def produce_tokens
-      output_places.each do |place|
-        net.put_token(place)
-      end
+    # @return [Array<Place>]
+    def places_to_reset
+      reset_arcs.map(&:to_node)
     end
 
     # @return [Array<Arc>]
-    def input_arcs
-      net.arcs.select { |arc| arc.to_node == self }
-    end
-
-    # @return [Array<Place>]
-    def input_places
-      input_arcs.map(&:from_node)
+    def reset_arcs
+      net.arcs.select { |arc| arc.from_node == self && arc.reset? }
     end
 
     # @return [Array<Arc>]
-    def output_arcs
-      net.arcs.select { |arc| arc.from_node == self }
+    def guard_arcs
+      ingoing_arcs.select { |arc| arc.guard.present? }
     end
 
-    # @return [Array<Place>]
-    def output_places
-      output_arcs.map(&:to_node)
+    def inspect
+      "Petri::Transition<#{identifier}>"
     end
   end
 end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Petri
+  VERSION = '0.0.1'
+end

data/petri.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = %q{petri}
+  s.version = Petri::VERSION
+
+  s.date = %q{2016-03-01}
+  s.authors = ["Sergei Zinin (einzige)"]
+  s.email = %q{szinin@gmail.com}
+  s.homepage = %q{http://github.com/einzige/petri}
+
+  s.licenses = ["MIT"]
+
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.md"]
+
+  s.description = %q{A petri nets framework}
+  s.summary = %q{Moves tokens around}
+end
+

metadata

@@ -1,50 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: petri
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
-- Sergei Zinin
+- Sergei Zinin (einzige)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.16
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.16
-description: A simple petri nets structure
+date: 2016-03-01 00:00:00.000000000 Z
+dependencies: []
+description: A petri nets framework
 email: szinin@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
-- lib/petri.rb
+- README.md
 - lib/petri/arc.rb
 - lib/petri/element.rb
+- lib/petri/message.rb
 - lib/petri/net.rb
 - lib/petri/net_loader.rb
 - lib/petri/node.rb
 - lib/petri/place.rb
+- lib/petri/subprocess.rb
+- lib/petri/task_transition.rb
 - lib/petri/token.rb
 - lib/petri/transition.rb
+- lib/version.rb
+- petri.gemspec
 homepage: http://github.com/einzige/petri
 licenses:
 - MIT
@@ -65,8 +51,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Petri nets
+summary: Moves tokens around
 test_files: []

data/lib/petri.rb

@@ -1,8 +0,0 @@
-require 'petri/element'
-require 'petri/node'
-require 'petri/place'
-require 'petri/transition'
-require 'petri/arc'
-require 'petri/token'
-require 'petri/net_loader'
-require 'petri/net'