orfeas_petri_flow 0.6.0

data/lib/petri_flow/registry.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  # Registry for storing and retrieving workflow classes.
+  # Workflows are auto-registered when they inherit from PetriFlow::Workflow.
+  #
+  # @example Register a workflow manually
+  #   PetriFlow::Registry.register(RefundRequestWorkflow)
+  #
+  # @example Get all workflows
+  #   PetriFlow::Registry.all
+  #
+  # @example Discover workflows in a directory
+  #   PetriFlow::Registry.discover_in("app/workflows")
+  #
+  class Registry
+    class << self
+      # Register a workflow class
+      # @param workflow_class [Class] A class that inherits from PetriFlow::Workflow
+      def register(workflow_class)
+        workflows[workflow_class.name] = workflow_class
+      end
+
+      # Get a workflow class by name
+      # @param name [String, Symbol] The workflow class name
+      # @return [Class, nil] The workflow class or nil if not found
+      def get(name)
+        workflows[name.to_s]
+      end
+
+      # Get all registered workflow classes
+      # @return [Array<Class>] All registered workflow classes
+      def all
+        workflows.values
+      end
+
+      # Get all workflow names
+      # @return [Array<String>] All registered workflow class names
+      def names
+        workflows.keys
+      end
+
+      # Check if a workflow exists
+      # @param name [String, Symbol] The workflow class name
+      # @return [Boolean] True if workflow is registered
+      def exists?(name)
+        workflows.key?(name.to_s)
+      end
+
+      # Unregister a workflow
+      # @param name [String, Symbol] The workflow class name to remove
+      def unregister(name)
+        workflows.delete(name.to_s)
+      end
+
+      # Clear all workflows (useful for testing)
+      def clear
+        @workflows = {}
+      end
+
+      # Count of registered workflows
+      # @return [Integer] Number of registered workflows
+      def count
+        workflows.count
+      end
+
+      # Discover and load workflows from a directory
+      # Loads all files matching *_workflow.rb pattern
+      # @param directory [String] Path to the workflows directory
+      def discover_in(directory)
+        return unless directory && Dir.exist?(directory)
+
+        Dir.glob(File.join(directory, "**", "*_workflow.rb")).sort.each do |file|
+          require file
+        end
+      end
+
+      private
+
+      def workflows
+        @workflows ||= {}
+      end
+    end
+  end
+end

data/lib/petri_flow/simulation/simulator.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Simulation
+    # Simulator for Petri nets
+    # Simulates execution and generates traces
+    class Simulator
+      attr_reader :net, :trace, :current_step
+
+      def initialize(net)
+        @net = net
+        @trace = Trace.new
+        @current_step = 0
+      end
+
+      # Run simulation for n steps or until no transitions enabled
+      def run(steps: 100, strategy: :random, context: {})
+        @current_step = 0
+        @trace.clear
+        @trace.record_initial_marking(@net.current_marking)
+
+        steps.times do |step|
+          @current_step = step
+
+          enabled = @net.enabled_transitions(context)
+          break if enabled.empty?
+
+          transition = select_transition(enabled, strategy)
+          fire_transition(transition, context)
+        end
+
+        @trace
+      end
+
+      # Run until a specific condition is met
+      def run_until(strategy: :random, max_steps: 1000, context: {}, &condition)
+        @current_step = 0
+        @trace.clear
+        @trace.record_initial_marking(@net.current_marking)
+
+        max_steps.times do |step|
+          @current_step = step
+
+          # Check condition
+          break if condition.call(@net.current_marking, @net)
+
+          enabled = @net.enabled_transitions(context)
+          break if enabled.empty?
+
+          transition = select_transition(enabled, strategy)
+          fire_transition(transition, context)
+        end
+
+        @trace
+      end
+
+      # Run simulation multiple times (Monte Carlo)
+      def run_multiple(runs: 100, steps: 50, strategy: :random, context: {})
+        traces = []
+        initial_marking = @net.current_marking.dup
+
+        runs.times do
+          # Reset to initial state
+          @net.set_marking(initial_marking.dup)
+
+          # Run simulation
+          trace = run(steps: steps, strategy: strategy, context: context)
+          traces << trace
+
+          # Reset for next run
+          @net.set_marking(initial_marking.dup)
+        end
+
+        analyze_traces(traces)
+      end
+
+      # Interactive simulation (step by step)
+      def step(transition_id = nil, context: {})
+        if transition_id
+          transition = @net.transition(transition_id)
+          raise "Transition #{transition_id} not found" unless transition
+          raise "Transition #{transition_id} not enabled" unless transition.enabled?(context)
+
+          fire_transition(transition, context)
+        else
+          enabled = @net.enabled_transitions(context)
+          return nil if enabled.empty?
+
+          transition = enabled.first
+          fire_transition(transition, context)
+        end
+
+        @current_step += 1
+        transition
+      end
+
+      # Reset simulation
+      def reset(initial_marking = nil)
+        @current_step = 0
+        @trace.clear
+
+        if initial_marking
+          @net.set_marking(initial_marking)
+        end
+
+        @trace.record_initial_marking(@net.current_marking)
+      end
+
+      private
+
+      def select_transition(enabled_transitions, strategy)
+        case strategy
+        when :random
+          enabled_transitions.sample
+        when :first
+          enabled_transitions.first
+        when :priority
+          # Transitions with higher priority (more input arcs) first
+          enabled_transitions.max_by { |t| t.input_arcs.size }
+        when :least_used
+          # Select least fired transition
+          firing_counts = @trace.transition_firing_counts
+          enabled_transitions.min_by { |t| firing_counts[t.id] || 0 }
+        else
+          enabled_transitions.first
+        end
+      end
+
+      def fire_transition(transition, context)
+        # Record state before firing
+        marking_before = @net.current_marking.dup
+
+        # Fire transition
+        transition.fire!(context)
+
+        # Record state after firing
+        marking_after = @net.current_marking.dup
+
+        # Add to trace
+        @trace.record_transition(
+          step: @current_step,
+          transition_id: transition.id,
+          transition_name: transition.name,
+          marking_before: marking_before,
+          marking_after: marking_after
+        )
+      end
+
+      def analyze_traces(traces)
+        {
+          total_runs: traces.size,
+          average_steps: traces.map(&:steps).sum.to_f / traces.size,
+          min_steps: traces.map(&:steps).min,
+          max_steps: traces.map(&:steps).max,
+          deadlocked_runs: traces.count { |t| t.deadlocked? },
+          transition_frequencies: aggregate_transition_frequencies(traces),
+          state_coverage: aggregate_state_coverage(traces),
+          traces: traces
+        }
+      end
+
+      def aggregate_transition_frequencies(traces)
+        frequencies = Hash.new(0)
+
+        traces.each do |trace|
+          trace.transition_firing_counts.each do |transition_id, count|
+            frequencies[transition_id] += count
+          end
+        end
+
+        total_firings = frequencies.values.sum
+        frequencies.transform_values { |count| count.to_f / total_firings }
+      end
+
+      def aggregate_state_coverage(traces)
+        all_states = Set.new
+
+        traces.each do |trace|
+          trace.visited_markings.each do |marking|
+            all_states.add(marking.to_h.sort.to_s)
+          end
+        end
+
+        all_states.size
+      end
+    end
+  end
+end

data/lib/petri_flow/simulation/trace.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Simulation
+    # Trace of a Petri net execution
+    # Records the sequence of transitions fired and markings visited
+    class Trace
+      attr_reader :transitions, :markings, :initial_marking
+
+      def initialize
+        @transitions = []
+        @markings = []
+        @initial_marking = nil
+      end
+
+      # Record initial marking
+      def record_initial_marking(marking)
+        @initial_marking = marking.dup
+        @markings << marking.dup
+      end
+
+      # Record a transition firing
+      def record_transition(step:, transition_id:, transition_name:, marking_before:, marking_after:)
+        @transitions << {
+          step: step,
+          transition_id: transition_id,
+          transition_name: transition_name,
+          marking_before: marking_before.dup,
+          marking_after: marking_after.dup,
+          timestamp: Time.current
+        }
+
+        @markings << marking_after.dup
+      end
+
+      # Get number of steps
+      def steps
+        @transitions.size
+      end
+
+      # Check if trace ended in deadlock
+      def deadlocked?
+        # If trace has transitions, check if last marking had no enabled transitions
+        # This is a heuristic - in practice we'd need to check the net state
+        false # Placeholder - would need net reference
+      end
+
+      # Get transition firing counts
+      def transition_firing_counts
+        counts = Hash.new(0)
+        @transitions.each do |t|
+          counts[t[:transition_id]] += 1
+        end
+        counts
+      end
+
+      # Get visited markings (unique states)
+      def visited_markings
+        @markings.uniq { |m| m.to_h.sort.to_s }
+      end
+
+      # Get firing sequence (just transition IDs)
+      def firing_sequence
+        @transitions.map { |t| t[:transition_id] }
+      end
+
+      # Get firing sequence with names
+      def firing_sequence_names
+        @transitions.map { |t| t[:transition_name] }
+      end
+
+      # Export trace data
+      def to_h
+        {
+          initial_marking: @initial_marking&.to_h,
+          steps: steps,
+          transitions: @transitions,
+          markings: @markings.map(&:to_h),
+          firing_sequence: firing_sequence,
+          unique_states: visited_markings.size
+        }
+      end
+
+      # Pretty print trace
+      def to_s
+        lines = []
+        lines << "Trace (#{steps} steps)"
+        lines << "Initial: #{@initial_marking&.to_h}"
+        lines << ""
+
+        @transitions.each_with_index do |transition, idx|
+          lines << "Step #{transition[:step]}: #{transition[:transition_name]} (#{transition[:transition_id]})"
+          lines << "  Before: #{transition[:marking_before].to_h}"
+          lines << "  After:  #{transition[:marking_after].to_h}"
+        end
+
+        lines.join("\n")
+      end
+
+      # Clear trace
+      def clear
+        @transitions.clear
+        @markings.clear
+        @initial_marking = nil
+      end
+
+      # Statistics about the trace
+      def stats
+        {
+          steps: steps,
+          unique_states: visited_markings.size,
+          unique_transitions: transition_firing_counts.size,
+          most_fired_transition: transition_firing_counts.max_by { |_, c| c }&.first,
+          firing_counts: transition_firing_counts
+        }
+      end
+    end
+  end
+end

data/lib/petri_flow/tasks/petri_flow.rake

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# PetriFlow Verification Tasks
+#
+# These tasks are automatically loaded in Rails apps that include the petri_flow gem.
+# Workflows are discovered in app/workflows/*_workflow.rb
+#
+# Usage:
+#   rake petri_flow:verify                    # Verify all workflows
+#   rake petri_flow:verify:list               # List registered workflows
+#   rake petri_flow:verify:workflow[Name]     # Verify specific workflow
+#   rake petri_flow:generate:from_state_machine[Model,attr]  # Generate from state machine
+#   rake petri_flow:generate:scan             # Scan for models with state machines
+#
+#   rake workflows:verify                     # Alias for petri_flow:verify
+#   rake workflows:list                       # Alias for petri_flow:verify:list
+
+namespace :petri_flow do
+  desc "Verify all registered workflows and generate reports"
+  task verify: :environment do
+    ensure_workflows_loaded
+
+    if PetriFlow::Registry.count.zero?
+      puts "No workflows registered."
+      puts "Create workflows in #{workflows_path}/*_workflow.rb"
+      exit 1
+    end
+
+    runner = PetriFlow::VerificationRunner.new
+    runner.run_all
+  end
+
+  namespace :verify do
+    desc "List all registered workflows"
+    task list: :environment do
+      ensure_workflows_loaded
+
+      puts "Registered PetriFlow Workflows:"
+      puts "-" * 40
+
+      if PetriFlow::Registry.count.zero?
+        puts "  No workflows registered."
+        puts "  Create workflows in #{workflows_path}/*_workflow.rb"
+      else
+        PetriFlow::Registry.all.each do |workflow_class|
+          workflow = workflow_class.new
+          places_count = workflow_class.defined_places&.size || 0
+          terminal_count = workflow_class.defined_terminal_places&.size || 0
+          puts "  - #{workflow_class.name}"
+          puts "      Places: #{places_count}, Terminal: #{terminal_count}"
+        end
+      end
+    end
+
+    desc "Verify a specific workflow by class name"
+    task :workflow, [:name] => :environment do |_t, args|
+      ensure_workflows_loaded
+
+      name = args[:name]
+      unless name
+        puts "Usage: rake petri_flow:verify:workflow[WorkflowClassName]"
+        puts ""
+        puts "Available workflows:"
+        PetriFlow::Registry.names.each { |n| puts "  - #{n}" }
+        exit 1
+      end
+
+      unless PetriFlow::Registry.exists?(name)
+        puts "Error: Workflow '#{name}' not found."
+        puts ""
+        puts "Available workflows:"
+        PetriFlow::Registry.names.each { |n| puts "  - #{n}" }
+        exit 1
+      end
+
+      runner = PetriFlow::VerificationRunner.new
+      runner.run_by_name(name)
+    end
+  end
+
+  desc "Show PetriFlow configuration"
+  task config: :environment do
+    config = Rails.application.config.petri_flow
+
+    puts "PetriFlow Configuration:"
+    puts "-" * 40
+    puts "  Workflows path: #{config.workflows_path}"
+    puts "  Auto-discover:  #{config.auto_discover}"
+    puts "  Full path:      #{workflows_path}"
+    puts ""
+
+    ensure_workflows_loaded
+    puts "Registered workflows: #{PetriFlow::Registry.count}"
+    PetriFlow::Registry.names.each { |n| puts "  - #{n}" }
+  end
+
+  namespace :generate do
+    desc "Generate a PetriFlow workflow from a model's state machine"
+    task :from_state_machine, [:model_class, :state_attr] => :environment do |_t, args|
+      model_class_name = args[:model_class]
+      state_attr = (args[:state_attr] || :state).to_sym
+
+      unless model_class_name
+        puts "Usage: rake petri_flow:generate:from_state_machine[ModelClass,state_attribute]"
+        puts ""
+        puts "Examples:"
+        puts "  rake petri_flow:generate:from_state_machine[Order,state]"
+        puts "  rake petri_flow:generate:from_state_machine[Spree::Order,state]"
+        puts "  rake petri_flow:generate:from_state_machine[User,status]"
+        puts ""
+        puts "Supported state machine libraries:"
+        PetriFlow::Generators::WorkflowGenerator.supported_libraries.each do |lib|
+          puts "  - #{lib}"
+        end
+        exit 1
+      end
+
+      begin
+        model_class = model_class_name.constantize
+      rescue NameError
+        puts "Error: Model class '#{model_class_name}' not found"
+        exit 1
+      end
+
+      unless PetriFlow::Generators::WorkflowGenerator.supports?(model_class)
+        puts "Error: #{model_class_name} does not have a supported state machine"
+        puts ""
+        puts "Supported libraries:"
+        PetriFlow::Generators::WorkflowGenerator.supported_libraries.each do |lib|
+          puts "  - #{lib}"
+        end
+        exit 1
+      end
+
+      generator = PetriFlow::Generators::WorkflowGenerator.new(model_class, state_attr)
+      data = generator.extract
+
+      puts "=" * 60
+      puts "GENERATING WORKFLOW FROM STATE MACHINE"
+      puts "=" * 60
+      puts ""
+      puts "Model: #{model_class_name}"
+      puts "State attribute: #{state_attr}"
+      puts "Library: #{data[:library]}"
+      puts "States: #{data[:states].join(', ')}"
+      puts "Initial: #{data[:initial_state]}"
+      puts "Terminal: #{data[:terminal_states].join(', ')}"
+      puts "Transitions: #{data[:transitions].count}"
+      puts ""
+
+      filepath = generator.generate!
+      puts "Generated: #{filepath}"
+      puts ""
+
+      # Verify the generated workflow
+      puts "Verifying workflow..."
+      results = generator.verify
+
+      puts "  Reachable states: #{results[:reachability][:total_reachable_states]}"
+      puts "  Is safe (1-bounded): #{results[:boundedness][:is_safe]}"
+      puts "  Deadlock-free: #{results[:liveness][:deadlock_free]}"
+    end
+
+    desc "List models with supported state machines"
+    task scan: :environment do
+      puts "Scanning for models with state machines..."
+      puts ""
+
+      found = []
+      Rails.application.eager_load! if defined?(Rails)
+
+      ActiveRecord::Base.descendants.each do |model|
+        next if model.abstract_class?
+
+        library = PetriFlow::Generators::WorkflowGenerator.detect_library(model)
+        if library
+          found << { model: model.name, library: library }
+        end
+      end
+
+      if found.empty?
+        puts "No models with supported state machines found."
+        puts ""
+        puts "Supported libraries:"
+        PetriFlow::Generators::WorkflowGenerator.supported_libraries.each do |lib|
+          puts "  - #{lib}"
+        end
+      else
+        puts "Found #{found.count} model(s) with state machines:"
+        puts ""
+        puts "| Model | Library |"
+        puts "|-------|---------|"
+        found.each do |f|
+          puts "| #{f[:model]} | #{f[:library]} |"
+        end
+        puts ""
+        puts "Generate with:"
+        puts "  rake petri_flow:generate:from_state_machine[ModelClass,state]"
+      end
+    end
+  end
+
+  # Helper methods
+
+  def ensure_workflows_loaded
+    path = workflows_path
+    PetriFlow::Registry.discover_in(path) if Dir.exist?(path)
+  end
+
+  def workflows_path
+    config = Rails.application.config.petri_flow
+    Rails.root.join(config.workflows_path).to_s
+  end
+end
+
+# Shorthand aliases
+namespace :workflows do
+  desc "Verify all workflows (alias for petri_flow:verify)"
+  task verify: "petri_flow:verify"
+
+  desc "List all workflows (alias for petri_flow:verify:list)"
+  task list: "petri_flow:verify:list"
+
+  desc "Generate workflow from state machine (alias)"
+  task :from_state_machine, [:model_class, :state_attr] => "petri_flow:generate:from_state_machine"
+
+  desc "Scan for models with state machines (alias)"
+  task scan: "petri_flow:generate:scan"
+end