orfeas_petri_flow 0.6.0

data/lib/petri_flow/core/net.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Core
+    # Represents a Petri net
+    # A Petri net consists of places, transitions, and arcs connecting them
+    class Net
+      attr_reader :places, :transitions, :arcs, :name
+
+      def initialize(name: "PetriNet")
+        @name = name
+        @places = {}
+        @transitions = {}
+        @arcs = []
+      end
+
+      # Add a place to the net
+      def add_place(id:, name: nil, initial_tokens: 0, capacity: Float::INFINITY)
+        place = Place.new(
+          id: id,
+          name: name,
+          initial_tokens: initial_tokens,
+          capacity: capacity
+        )
+        @places[id] = place
+        place
+      end
+
+      # Add a transition to the net
+      def add_transition(id:, name: nil, guard: nil)
+        transition = Transition.new(id: id, name: name, guard: guard)
+        @transitions[id] = transition
+        transition
+      end
+
+      # Add an arc connecting a place and transition
+      def add_arc(source_id:, target_id:, weight: 1, expression: nil)
+        source = @places[source_id] || @transitions[source_id]
+        target = @transitions[target_id] || @places[target_id]
+
+        raise "Source #{source_id} not found" unless source
+        raise "Target #{target_id} not found" unless target
+
+        arc = Arc.new(source: source, target: target, weight: weight, expression: expression)
+        @arcs << arc
+
+        # Register arc with transition
+        if arc.input_arc?
+          target.add_input_arc(arc)
+        else
+          source.add_output_arc(arc)
+        end
+
+        arc
+      end
+
+      # Get current marking
+      def current_marking
+        marking = Marking.new
+        @places.each do |id, place|
+          marking.set_tokens(id, place.tokens)
+        end
+        marking
+      end
+
+      # Set marking (restore state)
+      def set_marking(marking)
+        @places.each do |id, place|
+          place.instance_variable_set(:@tokens, marking.tokens_at(id))
+        end
+      end
+
+      # Get all enabled transitions
+      def enabled_transitions(context = {})
+        @transitions.values.select { |t| t.enabled?(context) }
+      end
+
+      # Fire a transition by id
+      def fire_transition(transition_id, context = {})
+        transition = @transitions[transition_id]
+        raise "Transition #{transition_id} not found" unless transition
+
+        transition.fire!(context)
+      end
+
+      # Check if net is in a deadlock state (no transitions enabled)
+      def deadlocked?(context = {})
+        enabled_transitions(context).empty?
+      end
+
+      # Get place by id
+      def place(id)
+        @places[id]
+      end
+
+      # Get transition by id
+      def transition(id)
+        @transitions[id]
+      end
+
+      # Get statistics about the net
+      def stats
+        {
+          places: @places.size,
+          transitions: @transitions.size,
+          arcs: @arcs.size,
+          total_tokens: @places.values.sum(&:tokens),
+          enabled_transitions: enabled_transitions.size
+        }
+      end
+
+      def to_s
+        "Net(#{@name}, P=#{@places.size}, T=#{@transitions.size}, A=#{@arcs.size})"
+      end
+
+      def inspect
+        "#<PetriFlow::Core::Net name=#{@name} #{stats}>"
+      end
+    end
+  end
+end

data/lib/petri_flow/core/place.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Core
+    # Represents a place in a Petri net
+    # Places hold tokens and represent states in the system
+    class Place
+      attr_reader :id, :name, :tokens
+      attr_accessor :capacity
+
+      def initialize(id:, name: nil, initial_tokens: 0, capacity: Float::INFINITY)
+        @id = id
+        @name = name || id.to_s
+        @tokens = initial_tokens
+        @capacity = capacity
+      end
+
+      # Add tokens to this place
+      def add_tokens(count = 1)
+        raise CapacityError, "Cannot add #{count} tokens: would exceed capacity #{@capacity}" if @tokens + count > @capacity
+
+        @tokens += count
+      end
+
+      # Remove tokens from this place
+      def remove_tokens(count = 1)
+        raise InsufficientTokensError, "Cannot remove #{count} tokens: only #{@tokens} available" if @tokens < count
+
+        @tokens -= count
+      end
+
+      # Check if place has at least n tokens
+      def has_tokens?(count = 1)
+        @tokens >= count
+      end
+
+      # Check if place can accept n tokens
+      def can_accept?(count = 1)
+        @tokens + count <= @capacity
+      end
+
+      def to_s
+        "Place(#{@name}, tokens: #{@tokens})"
+      end
+
+      def inspect
+        "#<PetriFlow::Core::Place id=#{@id} name=#{@name} tokens=#{@tokens} capacity=#{@capacity}>"
+      end
+    end
+
+    class CapacityError < StandardError; end
+    class InsufficientTokensError < StandardError; end
+  end
+end

data/lib/petri_flow/core/token.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Core
+    # Represents a token in a colored Petri net
+    # Basic Petri nets just count tokens, colored nets attach data to tokens
+    class Token
+      attr_reader :id, :color, :data, :timestamp
+
+      def initialize(id: SecureRandom.uuid, color: :default, data: {}, timestamp: Time.current)
+        @id = id
+        @color = color
+        @data = data
+        @timestamp = timestamp
+      end
+
+      # Create a copy of this token with updated data
+      def with_data(new_data)
+        self.class.new(
+          id: SecureRandom.uuid,
+          color: @color,
+          data: @data.merge(new_data),
+          timestamp: Time.current
+        )
+      end
+
+      # Create a copy of this token with a different color
+      def with_color(new_color)
+        self.class.new(
+          id: SecureRandom.uuid,
+          color: new_color,
+          data: @data,
+          timestamp: Time.current
+        )
+      end
+
+      def to_h
+        {
+          id: @id,
+          color: @color,
+          data: @data,
+          timestamp: @timestamp
+        }
+      end
+
+      def to_s
+        "Token(#{@color}, #{@data})"
+      end
+
+      def inspect
+        "#<PetriFlow::Core::Token id=#{@id} color=#{@color} data=#{@data}>"
+      end
+    end
+  end
+end

data/lib/petri_flow/core/transition.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Core
+    # Represents a transition in a Petri net
+    # Transitions are the active components that consume and produce tokens
+    class Transition
+      attr_reader :id, :name, :input_arcs, :output_arcs
+      attr_accessor :guard
+
+      def initialize(id:, name: nil, guard: nil)
+        @id = id
+        @name = name || id.to_s
+        @guard = guard
+        @input_arcs = []
+        @output_arcs = []
+      end
+
+      # Add an input arc from a place
+      def add_input_arc(arc)
+        @input_arcs << arc
+      end
+
+      # Add an output arc to a place
+      def add_output_arc(arc)
+        @output_arcs << arc
+      end
+
+      # Check if transition is enabled (can fire)
+      # A transition is enabled if all input places have sufficient tokens
+      # and all output places can accept tokens
+      #
+      # @param context [Hash] Context for guard evaluation
+      # @option context [Boolean] :ignore_guards Skip guard evaluation (P/T abstraction)
+      def enabled?(context = {})
+        ignore_guards = context[:ignore_guards]
+        return false unless ignore_guards || guard_satisfied?(context)
+
+        # Check input places have sufficient tokens
+        @input_arcs.all? { |arc| arc.source.has_tokens?(arc.weight) } &&
+          # Check output places can accept tokens
+          @output_arcs.all? { |arc| arc.target.can_accept?(arc.weight) }
+      end
+
+      # Fire the transition
+      # Consumes tokens from input places and produces tokens in output places
+      def fire!(context = {})
+        raise TransitionNotEnabledError, "Transition #{@name} is not enabled" unless enabled?(context)
+
+        # Remove tokens from input places
+        @input_arcs.each { |arc| arc.source.remove_tokens(arc.weight) }
+
+        # Add tokens to output places
+        @output_arcs.each { |arc| arc.target.add_tokens(arc.weight) }
+
+        # Return the transition for chaining
+        self
+      end
+
+      def to_s
+        "Transition(#{@name})"
+      end
+
+      def inspect
+        "#<PetriFlow::Core::Transition id=#{@id} name=#{@name} " \
+          "inputs=#{@input_arcs.size} outputs=#{@output_arcs.size}>"
+      end
+
+      private
+
+      def guard_satisfied?(context)
+        return true unless @guard
+
+        if @guard.respond_to?(:satisfied?)
+          @guard.satisfied?(context)
+        elsif @guard.respond_to?(:call)
+          @guard.call(context)
+        elsif @guard.is_a?(Symbol)
+          context[@guard]
+        else
+          !!@guard
+        end
+      end
+    end
+
+    class TransitionNotEnabledError < StandardError; end
+  end
+end

data/lib/petri_flow/export/cpn_tools_exporter.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module PetriFlow
+  module Export
+    # Exports Colored Petri Nets to CPN Tools XML format
+    # CPN Tools is a popular tool for editing, simulating and analyzing CPNs
+    class CpnToolsExporter
+      attr_reader :net
+
+      def initialize(net)
+        @net = net
+        @place_counter = 0
+        @trans_counter = 0
+        @arc_counter = 0
+      end
+
+      # Export to CPN Tools XML string
+      def to_cpn
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+
+        # Root workspaceElements element
+        workspace = doc.add_element('workspaceElements')
+
+        # Add generator info
+        generator = workspace.add_element('generator', {
+          'tool' => 'PetriFlow',
+          'version' => '1.0',
+          'format' => 'CPN'
+        })
+
+        # Add cpnet element
+        cpnet = workspace.add_element('cpnet')
+
+        # Add globbox (global declarations)
+        add_globbox(cpnet)
+
+        # Add page
+        page = add_page(cpnet)
+
+        # Add color declarations to page
+        add_page_attributes(page)
+
+        # Add places
+        @net.places.each do |place_id, place|
+          add_place_node(page, place)
+        end
+
+        # Add transitions
+        @net.transitions.each do |trans_id, transition|
+          add_transition_node(page, transition)
+        end
+
+        # Add arcs
+        @net.arcs.each do |arc|
+          add_arc_node(page, arc)
+        end
+
+        # Format XML nicely
+        formatter = REXML::Formatters::Pretty.new(2)
+        formatter.compact = true
+        output = String.new
+        formatter.write(doc, output)
+        output
+      end
+
+      # Save to file
+      def save_cpn(filename)
+        File.write(filename, to_cpn)
+      end
+
+      private
+
+      def colored_net?
+        @net.is_a?(PetriFlow::Colored::ColoredNet)
+      end
+
+      def add_globbox(cpnet)
+        globbox = cpnet.add_element('globbox')
+
+        # Add standard declarations
+        block = globbox.add_element('block', { 'id' => 'id1' })
+
+        # Add color declarations
+        if colored_net? && @net.colors.any?
+          @net.colors.each_with_index do |(color_name, color), index|
+            add_color_block(block, color_name, color, index + 2)
+          end
+        else
+          # Add default INT color
+          add_default_color(block)
+        end
+      end
+
+      def add_color_block(block, color_name, color, id_num)
+        color_elem = block.add_element('color', { 'id' => "id#{id_num}" })
+
+        # Color name
+        id_elem = color_elem.add_element('id')
+        id_elem.text = color_name.to_s.upcase
+
+        # Color type (record/product type)
+        if color.attributes.any?
+          record_elem = color_elem.add_element('record')
+
+          color.attributes.each do |attr_name, attr_type|
+            record_field = record_elem.add_element('recordfield')
+
+            field_id = record_field.add_element('id')
+            field_id.text = attr_name.to_s
+
+            field_type = record_field.add_element('id')
+            field_type.text = type_to_cpn_type(attr_type)
+          end
+        else
+          # Simple type
+          int_elem = color_elem.add_element('int')
+        end
+      end
+
+      def add_default_color(block)
+        color_elem = block.add_element('color', { 'id' => 'id2' })
+        id_elem = color_elem.add_element('id')
+        id_elem.text = 'INT'
+        int_elem = color_elem.add_element('int')
+      end
+
+      def type_to_cpn_type(type)
+        case type.to_s
+        when 'integer', 'int'
+          'INT'
+        when 'string'
+          'STRING'
+        when 'boolean', 'bool'
+          'BOOL'
+        when 'float', 'real'
+          'REAL'
+        when 'symbol'
+          'STRING'
+        when 'hash'
+          'STRING'  # Serialize hash as string
+        else
+          'STRING'  # Default to string
+        end
+      end
+
+      def add_page(cpnet)
+        page = cpnet.add_element('page', { 'id' => 'page1' })
+
+        # Page attributes
+        pageattr = page.add_element('pageattr', { 'name' => @net.name })
+
+        page
+      end
+
+      def add_page_attributes(page)
+        # Optional: Add color set references at page level
+      end
+
+      def add_place_node(page, place)
+        @place_counter += 1
+        place_id = "place_#{@place_counter}"
+
+        place_elem = page.add_element('place', { 'id' => place_id })
+
+        # Place text (name)
+        text_elem = place_elem.add_element('text')
+        text_elem.text = place.name
+
+        # Place type (color set)
+        type_elem = place_elem.add_element('type')
+        type_text = type_elem.add_element('text')
+
+        if colored_net? && @net.colored_places[place.id]
+          color = @net.colored_places[place.id][:color]
+          type_text.text = color ? color.to_s.upcase : 'INT'
+        else
+          type_text.text = 'INT'
+        end
+
+        # Initial marking
+        if place.tokens > 0 || (colored_net? && @net.token_pools[place.id]&.any?)
+          initmark_elem = place_elem.add_element('initmark')
+          mark_text = initmark_elem.add_element('text')
+
+          if colored_net? && @net.token_pools[place.id]&.any?
+            # Format colored tokens
+            tokens = @net.token_pools[place.id].map { |t| format_token(t) }
+            mark_text.text = tokens.join('++')
+          else
+            mark_text.text = place.tokens.to_s
+          end
+        end
+
+        # Position (for graphical layout)
+        posattr = place_elem.add_element('posattr', {
+          'x' => (100 + @place_counter * 150).to_s,
+          'y' => '100'
+        })
+
+        # Store mapping for arc creation
+        @place_mapping ||= {}
+        @place_mapping[place.id] = place_id
+      end
+
+      def format_token(token)
+        if token.data.any?
+          fields = token.data.map { |k, v| "#{k}=#{format_value(v)}" }
+          "{#{fields.join(', ')}}"
+        else
+          "1"
+        end
+      end
+
+      def format_value(value)
+        case value
+        when String
+          "\"#{value}\""
+        when Symbol
+          "\"#{value}\""
+        when Hash
+          "\"#{value.to_json}\""
+        else
+          value.to_s
+        end
+      end
+
+      def add_transition_node(page, transition)
+        @trans_counter += 1
+        trans_id = "trans_#{@trans_counter}"
+
+        trans_elem = page.add_element('trans', { 'id' => trans_id })
+
+        # Transition text (name)
+        text_elem = trans_elem.add_element('text')
+        text_elem.text = transition.name
+
+        # Guard condition
+        if transition.guard
+          cond_elem = trans_elem.add_element('cond')
+          cond_text = cond_elem.add_element('text')
+
+          guard_text = if transition.guard.respond_to?(:name) && transition.guard.name
+                        transition.guard.name
+                      else
+                        'true'
+                      end
+          cond_text.text = "[#{guard_text}]"
+        end
+
+        # Position
+        posattr = trans_elem.add_element('posattr', {
+          'x' => (100 + @trans_counter * 150).to_s,
+          'y' => '200'
+        })
+
+        # Store mapping for arc creation
+        @trans_mapping ||= {}
+        @trans_mapping[transition.id] = trans_id
+      end
+
+      def add_arc_node(page, arc)
+        @arc_counter += 1
+        arc_id = "arc_#{@arc_counter}"
+
+        # Determine arc orientation and get IDs
+        if arc.input_arc?
+          # Place -> Transition
+          from_place = @place_mapping[arc.source.id]
+          to_trans = @trans_mapping[arc.target.id]
+
+          arc_elem = page.add_element('arc', {
+            'id' => arc_id,
+            'orientation' => 'PtoT',
+            'order' => @arc_counter.to_s
+          })
+
+          arc_elem.add_element('posattr', { 'x' => '0', 'y' => '0' })
+          arc_elem.add_element('fillattr', { 'colour' => 'Black' })
+          arc_elem.add_element('lineattr', { 'colour' => 'Black' })
+          arc_elem.add_element('textattr', { 'colour' => 'Black' })
+
+          transend = arc_elem.add_element('transend', { 'idref' => to_trans })
+          placeend = arc_elem.add_element('placeend', { 'idref' => from_place })
+
+        elsif arc.output_arc?
+          # Transition -> Place
+          from_trans = @trans_mapping[arc.source.id]
+          to_place = @place_mapping[arc.target.id]
+
+          arc_elem = page.add_element('arc', {
+            'id' => arc_id,
+            'orientation' => 'TtoP',
+            'order' => @arc_counter.to_s
+          })
+
+          arc_elem.add_element('posattr', { 'x' => '0', 'y' => '0' })
+          arc_elem.add_element('fillattr', { 'colour' => 'Black' })
+          arc_elem.add_element('lineattr', { 'colour' => 'Black' })
+          arc_elem.add_element('textattr', { 'colour' => 'Black' })
+
+          transend = arc_elem.add_element('transend', { 'idref' => from_trans })
+          placeend = arc_elem.add_element('placeend', { 'idref' => to_place })
+        end
+
+        # Arc annotation (expression or weight)
+        annot_elem = arc_elem.add_element('annot')
+        annot_text = annot_elem.add_element('text')
+
+        if arc.expression && arc.expression.respond_to?(:name) && arc.expression.name
+          annot_text.text = arc.expression.name
+        elsif arc.weight > 1
+          annot_text.text = "#{arc.weight}*x"
+        else
+          annot_text.text = 'x'
+        end
+      end
+    end
+  end
+end