orfeas_petri_flow 0.6.0

data/lib/petri_flow/export.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative 'export/pnml_exporter'
+require_relative 'export/cpn_tools_exporter'
+require_relative 'export/json_exporter'
+require_relative 'export/yaml_exporter'
+
+module PetriFlow
+  # Export functionality for Petri nets and Colored Petri Nets
+  # Supports multiple formats: PNML, CPN Tools XML, JSON, and YAML
+  module Export
+    # Export a net to the specified format
+    # @param net [Core::Net, Colored::ColoredNet] The net to export
+    # @param format [Symbol] The export format (:pnml, :cpn, :json, :yaml)
+    # @param options [Hash] Format-specific options
+    # @return [String] The exported representation
+    def self.export(net, format:, **options)
+      exporter = exporter_for(net, format)
+
+      case format
+      when :pnml
+        exporter.to_pnml
+      when :cpn, :cpn_tools
+        exporter.to_cpn
+      when :json
+        exporter.to_json(**options)
+      when :yaml, :yml
+        exporter.to_yaml
+      else
+        raise ArgumentError, "Unknown export format: #{format}. Supported: :pnml, :cpn, :json, :yaml"
+      end
+    end
+
+    # Save a net to a file in the specified format
+    # @param net [Core::Net, Colored::ColoredNet] The net to export
+    # @param filename [String] The output filename
+    # @param format [Symbol] The export format (auto-detected from filename if not specified)
+    # @param options [Hash] Format-specific options
+    def self.save(net, filename, format: nil, **options)
+      format ||= detect_format(filename)
+
+      exporter = exporter_for(net, format)
+
+      case format
+      when :pnml
+        exporter.save_pnml(filename)
+      when :cpn, :cpn_tools
+        exporter.save_cpn(filename)
+      when :json
+        exporter.save_json(filename, **options)
+      when :yaml, :yml
+        exporter.save_yaml(filename)
+      else
+        raise ArgumentError, "Unknown export format: #{format}"
+      end
+
+      filename
+    end
+
+    # Export a net to hash (useful for JSON/YAML serialization)
+    # @param net [Core::Net, Colored::ColoredNet] The net to export
+    # @return [Hash] Hash representation of the net
+    def self.to_hash(net)
+      JsonExporter.new(net).to_hash
+    end
+
+    # Detect format from filename extension
+    # @param filename [String] The filename
+    # @return [Symbol] The detected format
+    def self.detect_format(filename)
+      ext = File.extname(filename).downcase
+      case ext
+      when '.pnml', '.xml'
+        # Check if filename suggests CPN Tools
+        if filename.downcase.include?('cpn')
+          :cpn
+        else
+          :pnml
+        end
+      when '.cpn'
+        :cpn
+      when '.json'
+        :json
+      when '.yaml', '.yml'
+        :yaml
+      else
+        raise ArgumentError, "Cannot detect format from filename: #{filename}. " \
+                             "Please specify format explicitly."
+      end
+    end
+
+    # Get the appropriate exporter for a net and format
+    # @param net [Core::Net, Colored::ColoredNet] The net
+    # @param format [Symbol] The export format
+    # @return [PnmlExporter, CpnToolsExporter, JsonExporter, YamlExporter]
+    def self.exporter_for(net, format)
+      case format
+      when :pnml
+        PnmlExporter.new(net)
+      when :cpn, :cpn_tools
+        CpnToolsExporter.new(net)
+      when :json
+        JsonExporter.new(net)
+      when :yaml, :yml
+        YamlExporter.new(net)
+      else
+        raise ArgumentError, "Unknown export format: #{format}"
+      end
+    end
+
+    # List all available export formats
+    # @return [Array<Symbol>] Available formats
+    def self.formats
+      [:pnml, :cpn, :json, :yaml]
+    end
+
+    # Get information about export formats
+    # @return [Hash] Format information
+    def self.format_info
+      {
+        pnml: {
+          name: 'PNML (Petri Net Markup Language)',
+          description: 'ISO/IEC 15909 standard format for Petri nets',
+          extension: '.pnml',
+          supports_colored: true,
+          interoperability: 'High - works with many Petri net tools'
+        },
+        cpn: {
+          name: 'CPN Tools XML',
+          description: 'Native format for CPN Tools software',
+          extension: '.cpn',
+          supports_colored: true,
+          interoperability: 'Medium - specific to CPN Tools'
+        },
+        json: {
+          name: 'JSON',
+          description: 'Human-readable, API-friendly JSON format',
+          extension: '.json',
+          supports_colored: true,
+          interoperability: 'High - universal format'
+        },
+        yaml: {
+          name: 'YAML',
+          description: 'Most human-readable format, ideal for documentation',
+          extension: '.yaml',
+          supports_colored: true,
+          interoperability: 'High - universal format'
+        }
+      }
+    end
+  end
+end
+
+# Convenience methods added to Net classes
+module PetriFlow
+  module Core
+    class Net
+      # Export this net to a string in the specified format
+      def export(format:, **options)
+        PetriFlow::Export.export(self, format: format, **options)
+      end
+
+      # Save this net to a file
+      def export_to_file(filename, format: nil, **options)
+        PetriFlow::Export.save(self, filename, format: format, **options)
+      end
+
+      # Export to hash
+      def to_export_hash
+        PetriFlow::Export.to_hash(self)
+      end
+    end
+  end
+
+  module Colored
+    class ColoredNet
+      # Export this colored net to a string in the specified format
+      def export(format:, **options)
+        PetriFlow::Export.export(self, format: format, **options)
+      end
+
+      # Save this colored net to a file
+      def export_to_file(filename, format: nil, **options)
+        PetriFlow::Export.save(self, filename, format: format, **options)
+      end
+
+      # Export to hash
+      def to_export_hash
+        PetriFlow::Export.to_hash(self)
+      end
+    end
+  end
+end

data/lib/petri_flow/generators/adapters/aasm_adapter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Generators
+    module Adapters
+      # Adapter for AASM (acts_as_state_machine) gem
+      # @see https://github.com/aasm/aasm
+      class AasmAdapter < StateMachineAdapter
+        def self.library_name
+          "aasm"
+        end
+
+        def self.supports?(model_class)
+          model_class.respond_to?(:aasm)
+        end
+
+        def extract
+          aasm = model_class.aasm(state_attribute)
+          raise ArgumentError, "No AASM state machine for :#{state_attribute} on #{model_class}" unless aasm
+
+          states = extract_states(aasm)
+          initial = extract_initial_state(aasm)
+          transitions = extract_transitions(aasm)
+          terminal = find_terminal_states(states, transitions)
+
+          {
+            states: states,
+            initial_state: initial,
+            terminal_states: terminal,
+            transitions: transitions,
+            library: self.class.library_name
+          }
+        end
+
+        private
+
+        def extract_states(aasm)
+          aasm.states.map(&:name)
+        end
+
+        def extract_initial_state(aasm)
+          aasm.initial_state
+        end
+
+        def extract_transitions(aasm)
+          transitions = []
+
+          aasm.events.each do |event|
+            event.transitions.each do |transition|
+              from_states = Array(transition.from)
+              to_state = transition.to
+
+              from_states.each do |from|
+                transitions << {
+                  name: "#{event.name}_from_#{from}".to_sym,
+                  event: event.name,
+                  from: from,
+                  to: to_state
+                }
+              end
+            end
+          end
+
+          transitions
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/generators/adapters/state_machines_adapter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Generators
+    module Adapters
+      # Adapter for state_machines-activerecord gem
+      # @see https://github.com/state-machines/state_machines-activerecord
+      class StateMachinesAdapter < StateMachineAdapter
+        def self.library_name
+          "state_machines-activerecord"
+        end
+
+        def self.supports?(model_class)
+          model_class.respond_to?(:state_machines)
+        end
+
+        def extract
+          sm = model_class.state_machines[state_attribute]
+          raise ArgumentError, "No state machine for :#{state_attribute} on #{model_class}" unless sm
+
+          states = extract_states(sm)
+          initial = extract_initial_state(sm)
+          transitions = extract_transitions(sm)
+          terminal = find_terminal_states(states, transitions)
+
+          {
+            states: states,
+            initial_state: initial,
+            terminal_states: terminal,
+            transitions: transitions,
+            library: self.class.library_name
+          }
+        end
+
+        private
+
+        def extract_states(sm)
+          sm.states.map(&:name).compact
+        end
+
+        def extract_initial_state(sm)
+          # Try to get initial state from a new instance
+          initial = sm.initial_state(model_class.new)
+          initial.try(:name) || extract_states(sm).first
+        end
+
+        def extract_transitions(sm)
+          transitions = []
+
+          sm.events.each do |event|
+            event.branches.each do |branch|
+              branch.state_requirements.each do |req|
+                from_states = extract_state_values(req[:from])
+                to_states = extract_state_values(req[:to])
+
+                from_states.each do |from|
+                  to_states.each do |to|
+                    transitions << {
+                      name: "#{event.name}_from_#{from}".to_sym,
+                      event: event.name,
+                      from: from,
+                      to: to
+                    }
+                  end
+                end
+              end
+            end
+          end
+
+          transitions
+        end
+
+        def extract_state_values(state_matcher)
+          if state_matcher.respond_to?(:values)
+            state_matcher.values
+          else
+            [state_matcher]
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/generators/state_machine_adapter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Generators
+    # Base class for state machine adapters.
+    # Subclasses extract states and transitions from different state machine libraries.
+    #
+    # @abstract Subclass and implement {#extract}
+    class StateMachineAdapter
+      attr_reader :model_class, :state_attribute
+
+      # @param model_class [Class] ActiveRecord model class
+      # @param state_attribute [Symbol] The state attribute name (default: :state)
+      def initialize(model_class, state_attribute = :state)
+        @model_class = model_class
+        @state_attribute = state_attribute.to_sym
+      end
+
+      # Check if this adapter can handle the given model
+      # @return [Boolean]
+      def self.supports?(model_class)
+        raise NotImplementedError, "Subclasses must implement .supports?"
+      end
+
+      # Extract state machine definition
+      # @return [Hash] with :states, :initial_state, :terminal_states, :transitions
+      def extract
+        raise NotImplementedError, "Subclasses must implement #extract"
+      end
+
+      # Human-readable name of the state machine library
+      # @return [String]
+      def self.library_name
+        raise NotImplementedError, "Subclasses must implement .library_name"
+      end
+
+      protected
+
+      # Find terminal states (states with no outgoing transitions)
+      def find_terminal_states(states, transitions)
+        states_with_outgoing = Set.new(transitions.map { |t| t[:from] })
+        terminal = states.reject { |s| states_with_outgoing.include?(s) }
+        terminal.empty? ? [states.last] : terminal
+      end
+    end
+  end
+end

data/lib/petri_flow/generators/workflow_generator.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Generators
+    # Generates PetriFlow workflows from ActiveRecord state machines.
+    #
+    # Supports multiple state machine libraries:
+    # - state_machines-activerecord (Solidus, many Rails apps)
+    # - AASM (acts_as_state_machine)
+    #
+    # @example Generate a workflow from a model
+    #   generator = PetriFlow::Generators::WorkflowGenerator.new(Order, :state)
+    #   generator.generate!
+    #   # => Creates app/workflows/order_workflow.rb
+    #
+    # @example Get workflow data without writing file
+    #   data = generator.extract
+    #   # => { states: [...], transitions: [...], ... }
+    #
+    class WorkflowGenerator
+      ADAPTERS = [
+        Adapters::StateMachinesAdapter,
+        Adapters::AasmAdapter
+      ].freeze
+
+      attr_reader :model_class, :state_attribute, :adapter
+
+      # @param model_class [Class] ActiveRecord model class with state machine
+      # @param state_attribute [Symbol] The state attribute name (default: :state)
+      # @raise [ArgumentError] if no supported state machine is found
+      def initialize(model_class, state_attribute = :state)
+        @model_class = model_class
+        @state_attribute = state_attribute.to_sym
+        @adapter = find_adapter
+      end
+
+      # Extract state machine data
+      # @return [Hash] extracted state machine definition
+      def extract
+        adapter.extract
+      end
+
+      # Generate workflow class code
+      # @return [String] Ruby code for the workflow class
+      def generate_code
+        data = extract
+        generate_workflow_code(data)
+      end
+
+      # Generate workflow file
+      # @param output_dir [String, Pathname] directory to write the file
+      # @return [String] path to generated file
+      def generate!(output_dir: nil)
+        output_dir ||= default_output_dir
+        FileUtils.mkdir_p(output_dir)
+
+        filepath = File.join(output_dir, filename)
+        File.write(filepath, generate_code)
+        filepath
+      end
+
+      # Build a workflow class dynamically (without writing file)
+      # @return [Class] the generated workflow class
+      def build_workflow_class
+        data = extract
+        class_name = workflow_class_name
+
+        Class.new(PetriFlow::Workflow) do
+          workflow_name data[:workflow_name] || "#{class_name} Workflow"
+          places(*data[:states])
+          initial_place data[:initial_state]
+          terminal_places(*data[:terminal_states])
+
+          data[:transitions].each do |t|
+            transition t[:name], from: t[:from], to: t[:to]
+          end
+        end
+      end
+
+      # Verify the generated workflow
+      # @return [Hash] verification results
+      def verify
+        workflow = build_workflow_class.new
+        workflow.verify!
+      end
+
+      # Class name for the generated workflow
+      # @return [String]
+      def workflow_class_name
+        "#{model_class.name.demodulize}Workflow"
+      end
+
+      # Filename for the generated workflow
+      # @return [String]
+      def filename
+        "#{model_class.name.demodulize.underscore}_workflow.rb"
+      end
+
+      # List of supported state machine libraries
+      # @return [Array<String>]
+      def self.supported_libraries
+        ADAPTERS.map(&:library_name)
+      end
+
+      # Check if a model has a supported state machine
+      # @param model_class [Class]
+      # @return [Boolean]
+      def self.supports?(model_class)
+        ADAPTERS.any? { |adapter| adapter.supports?(model_class) }
+      end
+
+      # Detect which state machine library a model uses
+      # @param model_class [Class]
+      # @return [String, nil] library name or nil
+      def self.detect_library(model_class)
+        adapter = ADAPTERS.find { |a| a.supports?(model_class) }
+        adapter&.library_name
+      end
+
+      private
+
+      def find_adapter
+        adapter_class = ADAPTERS.find { |a| a.supports?(model_class) }
+
+        unless adapter_class
+          raise ArgumentError,
+                "#{model_class} does not have a supported state machine. " \
+                "Supported: #{self.class.supported_libraries.join(', ')}"
+        end
+
+        adapter_class.new(model_class, state_attribute)
+      end
+
+      def default_output_dir
+        if defined?(Rails)
+          Rails.root.join("app", "workflows")
+        else
+          File.expand_path("app/workflows", Dir.pwd)
+        end
+      end
+
+      def generate_workflow_code(data)
+        class_name = workflow_class_name
+        workflow_name = "#{model_class.name.demodulize} State Workflow"
+
+        lines = []
+        lines << "# frozen_string_literal: true"
+        lines << "# Auto-generated from #{model_class.name} state machine (#{data[:library]})"
+        lines << "# Generated at: #{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S UTC')}"
+        lines << ""
+        lines << "# #{workflow_name}"
+        lines << "# Models the state transitions for #{model_class.name}"
+        lines << "class #{class_name} < PetriFlow::Workflow"
+        lines << "  workflow_name #{workflow_name.inspect}"
+        lines << ""
+        lines << "  # States from #{model_class.name}"
+        lines << "  places #{data[:states].map(&:inspect).join(', ')}"
+        lines << "  initial_place #{data[:initial_state].inspect}"
+        lines << "  terminal_places #{data[:terminal_states].map(&:inspect).join(', ')}"
+        lines << ""
+        lines << "  # Transitions from state machine events"
+
+        data[:transitions].each do |t|
+          lines << "  transition #{t[:name].inspect},"
+          lines << "             from: #{t[:from].inspect},"
+          lines << "             to: #{t[:to].inspect},"
+          lines << "             trigger: #{t[:event].to_s.inspect}"
+          lines << ""
+        end
+
+        lines << "end"
+        lines.join("\n")
+      end
+    end
+  end
+end