orfeas_petri_flow 0.6.0

data/lib/petri_flow/matrix/analyzer.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Matrix
+    # Main analyzer class that combines all matrix types
+    # Provides comprehensive analysis of Petri net execution
+    class Analyzer
+      attr_reader :crud_mapping, :correlation, :causation, :lineage, :reachability
+
+      def initialize
+        @crud_mapping = CrudEventMapping.new
+        @correlation = Correlation.new
+        @causation = Causation.new
+        @lineage = Lineage.new
+        @reachability = nil
+      end
+
+      # Analyze events and build all matrices
+      def analyze_events(events)
+        events.each do |event|
+          analyze_event(event)
+        end
+
+        self
+      end
+
+      # Analyze a single event
+      def analyze_event(event)
+        event_id = event[:event_id] || event[:id]
+
+        # CRUD mapping
+        if event[:operation] && event[:event_type]
+          @crud_mapping.record_mapping(event[:operation], event[:event_type])
+        end
+
+        # Correlation
+        if event[:correlation_id]
+          # Find other events with same correlation_id
+          # (In real usage, this would query event store)
+        end
+
+        # Causation
+        if event[:caused_by_event_id]
+          @causation.record_causation(event[:caused_by_event_id], event_id)
+        end
+
+        # Lineage
+        if event[:changes]
+          event[:changes].each do |field, (old_val, new_val)|
+            @lineage.record_modification(
+              field,
+              event_id,
+              old_value: old_val,
+              new_value: new_val,
+              timestamp: event[:timestamp]
+            )
+          end
+        end
+
+        self
+      end
+
+      # Compute reachability from a Petri net
+      def compute_reachability(net, initial_marking)
+        @reachability = Reachability.compute_from_net(net, initial_marking)
+        self
+      end
+
+      # Generate comprehensive report
+      def generate_report
+        {
+          crud_mapping: {
+            summary: @crud_mapping.to_s,
+            table: @crud_mapping.to_table,
+            stats: crud_mapping_stats
+          },
+          correlation: {
+            summary: @correlation.to_s,
+            stats: @correlation.stats
+          },
+          causation: {
+            summary: @causation.to_s,
+            stats: @causation.stats,
+            centrality: @causation.centrality_scores
+          },
+          lineage: {
+            summary: @lineage.to_s,
+            stats: @lineage.stats
+          },
+          reachability: @reachability ? {
+            summary: @reachability.to_s,
+            stats: @reachability.stats
+          } : nil
+        }.compact
+      end
+
+      # Find events in causation chain
+      def find_causation_chain(start_event, end_event)
+        @causation.causation_chain(start_event, end_event)
+      end
+
+      # Get complete field history
+      def field_history(field)
+        @lineage.field_lineage(field)
+      end
+
+      # Get events in correlation group
+      def correlation_group(event_id)
+        @correlation.correlated_events(event_id)
+      end
+
+      # Privacy impact analysis
+      def privacy_impact_analysis
+        {
+          fields_tracked: @lineage.fields.size,
+          events_with_changes: @lineage.events.size,
+          total_modifications: @lineage.stats[:total_modifications],
+          most_modified_field: @lineage.stats[:most_modified_field]
+        }
+      end
+
+      # Event flow completeness check
+      def flow_completeness
+        total_crud_ops = crud_mapping_stats[:total_mappings]
+        total_events = @causation.events.size
+
+        {
+          crud_operations: total_crud_ops,
+          events_generated: total_events,
+          mapping_ratio: total_events.to_f / [total_crud_ops, 1].max,
+          completeness: total_events >= total_crud_ops ? "✓ Complete" : "⚠ Incomplete"
+        }
+      end
+
+      def to_s
+        "MatrixAnalyzer(CRUD: #{@crud_mapping}, Correlation: #{@correlation}, " \
+          "Causation: #{@causation}, Lineage: #{@lineage})"
+      end
+
+      private
+
+      def crud_mapping_stats
+        {
+          total_mappings: @crud_mapping.crud_ops.sum { |op| @crud_mapping.total_events_for(op) },
+          operations: @crud_mapping.crud_ops.size,
+          event_types: @crud_mapping.event_types.size
+        }
+      end
+    end
+  end
+end

data/lib/petri_flow/matrix/causation.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Matrix
+    # Causation Matrix (Cau)
+    # Tracks which events cause other events (event flow)
+    class Causation
+      attr_reader :matrix, :events
+
+      def initialize
+        @matrix = Hash.new { |h, k| h[k] = Hash.new(0) }
+        @events = []
+      end
+
+      # Record that event1 causes event2
+      def record_causation(cause_event_id, effect_event_id)
+        @events << cause_event_id unless @events.include?(cause_event_id)
+        @events << effect_event_id unless @events.include?(effect_event_id)
+
+        @matrix[cause_event_id][effect_event_id] = 1
+      end
+
+      # Check if event1 directly causes event2
+      def causes?(cause_event_id, effect_event_id)
+        @matrix[cause_event_id][effect_event_id] == 1
+      end
+
+      # Get all events directly caused by an event
+      def effects_of(event_id)
+        return [] unless @matrix[event_id]
+
+        @matrix[event_id].select { |_, v| v == 1 }.keys
+      end
+
+      # Get all events that directly cause an event
+      def causes_of(event_id)
+        @matrix.select { |_, effects| effects[event_id] == 1 }.keys
+      end
+
+      # Compute transitive closure (Cau*)
+      # Returns matrix showing all reachable events (direct + indirect causation)
+      def transitive_closure
+        closure = Causation.new
+        @events.each { |e| closure.instance_variable_get(:@events) << e }
+
+        # Copy direct causations
+        @matrix.each do |cause, effects|
+          effects.each do |effect, value|
+            closure.matrix[cause][effect] = value if value == 1
+          end
+        end
+
+        # Warshall's algorithm for transitive closure
+        @events.each do |k|
+          @events.each do |i|
+            @events.each do |j|
+              if closure.matrix[i][k] == 1 && closure.matrix[k][j] == 1
+                closure.matrix[i][j] = 1
+              end
+            end
+          end
+        end
+
+        closure
+      end
+
+      # Find causation chain from event1 to event2
+      def causation_chain(start_event_id, end_event_id)
+        return [] unless @events.include?(start_event_id) && @events.include?(end_event_id)
+        return [start_event_id] if start_event_id == end_event_id
+
+        # BFS to find shortest path
+        queue = [[start_event_id]]
+        visited = Set.new([start_event_id])
+
+        while queue.any?
+          path = queue.shift
+          current = path.last
+
+          effects_of(current).each do |effect|
+            return path + [effect] if effect == end_event_id
+
+            unless visited.include?(effect)
+              visited.add(effect)
+              queue << (path + [effect])
+            end
+          end
+        end
+
+        [] # No path found
+      end
+
+      # Convert to 2D matrix representation
+      def to_matrix
+        rows = @events.map do |cause|
+          @events.map { |effect| @matrix[cause][effect] }
+        end
+        ::Matrix.rows(rows)
+      end
+
+      # Calculate centrality scores (which events are most influential)
+      def centrality_scores
+        scores = Hash.new(0)
+
+        @matrix.each do |cause, effects|
+          scores[cause] += effects.values.sum
+        end
+
+        scores
+      end
+
+      def stats
+        {
+          total_events: @events.size,
+          total_causations: @matrix.values.map { |h| h.values.sum }.sum,
+          root_events: @events.count { |e| causes_of(e).empty? },
+          leaf_events: @events.count { |e| effects_of(e).empty? }
+        }
+      end
+
+      def to_s
+        "CausationMatrix(#{@events.size} events, #{stats[:total_causations]} causations)"
+      end
+    end
+  end
+end

data/lib/petri_flow/matrix/correlation.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Matrix
+    # Correlation Matrix (C)
+    # Tracks which events share correlation IDs (belong to same user action)
+    class Correlation
+      attr_reader :matrix, :events
+
+      def initialize
+        @matrix = Hash.new { |h, k| h[k] = {} }
+        @events = []
+      end
+
+      # Record correlation between two events
+      def record_correlation(event1_id, event2_id, correlation_id)
+        @events << event1_id unless @events.include?(event1_id)
+        @events << event2_id unless @events.include?(event2_id)
+
+        @matrix[event1_id][event2_id] = correlation_id
+        @matrix[event2_id][event1_id] = correlation_id # Symmetric
+      end
+
+      # Check if two events are correlated
+      def correlated?(event1_id, event2_id)
+        !@matrix.dig(event1_id, event2_id).nil?
+      end
+
+      # Get correlation ID between two events
+      def get_correlation_id(event1_id, event2_id)
+        @matrix.dig(event1_id, event2_id)
+      end
+
+      # Get all events correlated with a given event
+      def correlated_events(event_id)
+        return [] unless @matrix[event_id]
+
+        @matrix[event_id].select { |_, corr_id| !corr_id.nil? }.keys
+      end
+
+      # Group events by correlation ID
+      def correlation_groups
+        groups = Hash.new { |h, k| h[k] = [] }
+
+        @matrix.each do |event1_id, correlations|
+          correlations.each do |event2_id, correlation_id|
+            next if correlation_id.nil?
+
+            groups[correlation_id] << event1_id unless groups[correlation_id].include?(event1_id)
+            groups[correlation_id] << event2_id unless groups[correlation_id].include?(event2_id)
+          end
+        end
+
+        groups.transform_values(&:uniq)
+      end
+
+      # Convert to 2D matrix representation
+      def to_matrix
+        size = @events.size
+        rows = @events.map do |event1|
+          @events.map { |event2| correlated?(event1, event2) ? 1 : 0 }
+        end
+        ::Matrix.rows(rows)
+      end
+
+      def stats
+        {
+          total_events: @events.size,
+          correlation_groups: correlation_groups.size,
+          average_group_size: correlation_groups.values.map(&:size).sum.to_f / [correlation_groups.size, 1].max
+        }
+      end
+
+      def to_s
+        "CorrelationMatrix(#{@events.size} events, #{correlation_groups.size} groups)"
+      end
+    end
+  end
+end

data/lib/petri_flow/matrix/crud_event_mapping.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'matrix'
+
+module PetriFlow
+  module Matrix
+    # CRUD-to-Event Mapping Matrix (M_ce)
+    # Tracks which CRUD operations generate which event types
+    class CrudEventMapping
+      CRUD_OPERATIONS = %i[create update delete].freeze
+
+      attr_reader :matrix, :crud_ops, :event_types
+
+      def initialize
+        @matrix = {}
+        @crud_ops = CRUD_OPERATIONS.dup
+        @event_types = []
+      end
+
+      # Record that a CRUD operation generates an event type
+      def record_mapping(crud_op, event_type, count = 1)
+        validate_crud_op!(crud_op)
+
+        @event_types << event_type unless @event_types.include?(event_type)
+        @matrix[crud_op] ||= Hash.new(0)
+        @matrix[crud_op][event_type] += count
+      end
+
+      # Get mapping value for specific CRUD operation and event type
+      def get(crud_op, event_type)
+        @matrix.dig(crud_op, event_type) || 0
+      end
+
+      # Get total events generated by a CRUD operation
+      def total_events_for(crud_op)
+        @matrix[crud_op]&.values&.sum || 0
+      end
+
+      # Get all event types generated by a CRUD operation
+      def events_for(crud_op)
+        @matrix[crud_op]&.keys || []
+      end
+
+      # Convert to 2D array matrix
+      def to_matrix
+        rows = @crud_ops.map do |crud_op|
+          @event_types.map { |event_type| get(crud_op, event_type) }
+        end
+        ::Matrix.rows(rows)
+      end
+
+      # Pretty print the mapping matrix
+      def to_table
+        header = ["CRUD \\ Event"] + @event_types.map(&:to_s)
+        rows = @crud_ops.map do |crud_op|
+          [crud_op.to_s.upcase] + @event_types.map { |et| get(crud_op, et) }
+        end
+        { header: header, rows: rows }
+      end
+
+      def to_s
+        "CrudEventMapping(#{@crud_ops.size} operations, #{@event_types.size} event types)"
+      end
+
+      private
+
+      def validate_crud_op!(crud_op)
+        return if CRUD_OPERATIONS.include?(crud_op.to_sym)
+
+        raise ArgumentError, "Invalid CRUD operation: #{crud_op}. Must be one of #{CRUD_OPERATIONS}"
+      end
+    end
+  end
+end

data/lib/petri_flow/matrix/lineage.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Matrix
+    # Data Lineage Matrix (L)
+    # Tracks which events modified which fields (data lineage)
+    class Lineage
+      attr_reader :matrix, :fields, :events
+
+      def initialize
+        @matrix = Hash.new { |h, k| h[k] = Hash.new(0) }
+        @fields = []
+        @events = []
+      end
+
+      # Record that an event modified a field
+      def record_modification(field, event_id, old_value: nil, new_value: nil, timestamp: nil)
+        @fields << field unless @fields.include?(field)
+        @events << event_id unless @events.include?(event_id)
+
+        @matrix[field][event_id] = {
+          modified: 1,
+          old_value: old_value,
+          new_value: new_value,
+          timestamp: timestamp || Time.current
+        }
+      end
+
+      # Check if an event modified a field
+      def modified?(field, event_id)
+        value = @matrix.dig(field, event_id)
+        value.is_a?(Hash) && value[:modified] == 1
+      end
+
+      # Get all events that modified a field
+      def events_for_field(field)
+        return [] unless @matrix[field]
+
+        @matrix[field].select { |_, v| v.is_a?(Hash) && v[:modified] == 1 }.keys
+      end
+
+      # Get all fields modified by an event
+      def fields_for_event(event_id)
+        @fields.select { |field| modified?(field, event_id) }
+      end
+
+      # Get complete lineage for a field (temporal history)
+      def field_lineage(field)
+        return [] unless @matrix[field]
+
+        modifications = @matrix[field]
+                        .select { |_, v| v.is_a?(Hash) && v[:modified] == 1 }
+                        .map do |event_id, data|
+          {
+            event_id: event_id,
+            old_value: data[:old_value],
+            new_value: data[:new_value],
+            timestamp: data[:timestamp]
+          }
+        end
+
+        modifications.sort_by { |m| m[:timestamp] }
+      end
+
+      # Reconstruct field value at a specific point in time
+      def reconstruct_value(field, at_time)
+        lineage = field_lineage(field)
+        return nil if lineage.empty?
+
+        # Find last modification before at_time
+        applicable_mods = lineage.select { |m| m[:timestamp] <= at_time }
+        return nil if applicable_mods.empty?
+
+        applicable_mods.last[:new_value]
+      end
+
+      # Get field value chain (how value evolved)
+      def value_chain(field)
+        lineage = field_lineage(field)
+        return [] if lineage.empty?
+
+        chain = []
+        lineage.each do |mod|
+          chain << mod[:old_value] if chain.empty? && !mod[:old_value].nil?
+          chain << mod[:new_value] unless mod[:new_value].nil?
+        end
+
+        chain.uniq
+      end
+
+      # Convert to 2D matrix representation
+      def to_matrix
+        rows = @fields.map do |field|
+          @events.map { |event| modified?(field, event) ? 1 : 0 }
+        end
+        ::Matrix.rows(rows)
+      end
+
+      def stats
+        {
+          total_fields: @fields.size,
+          total_events: @events.size,
+          total_modifications: @matrix.values.map { |h| h.values.count { |v| v.is_a?(Hash) && v[:modified] == 1 } }.sum,
+          most_modified_field: @fields.max_by { |f| events_for_field(f).size }
+        }
+      end
+
+      def to_s
+        "LineageMatrix(#{@fields.size} fields, #{@events.size} events)"
+      end
+    end
+  end
+end

data/lib/petri_flow/matrix/reachability.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Matrix
+    # Reachability Matrix (R)
+    # Tracks which markings (states) are reachable from other markings
+    class Reachability
+      attr_reader :matrix, :markings
+
+      def initialize
+        @matrix = Hash.new { |h, k| h[k] = Hash.new(0) }
+        @markings = []
+      end
+
+      # Record that marking_j is reachable from marking_i
+      def record_reachability(marking_i, marking_j)
+        marking_i_key = marking_key(marking_i)
+        marking_j_key = marking_key(marking_j)
+
+        @markings << marking_i_key unless @markings.include?(marking_i_key)
+        @markings << marking_j_key unless @markings.include?(marking_j_key)
+
+        @matrix[marking_i_key][marking_j_key] = 1
+      end
+
+      # Check if marking_j is reachable from marking_i
+      def reachable?(marking_i, marking_j)
+        marking_i_key = marking_key(marking_i)
+        marking_j_key = marking_key(marking_j)
+
+        @matrix[marking_i_key][marking_j_key] == 1
+      end
+
+      # Get all markings reachable from a given marking
+      def reachable_from(marking)
+        marking_key_val = marking_key(marking)
+        return [] unless @matrix[marking_key_val]
+
+        @matrix[marking_key_val].select { |_, v| v == 1 }.keys
+      end
+
+      # Compute reachability graph from a Petri net and initial marking
+      def self.compute_from_net(net, initial_marking)
+        reachability = new
+        visited = Set.new
+        queue = [initial_marking.dup]
+
+        reachability.record_reachability(initial_marking, initial_marking)
+
+        while queue.any?
+          current_marking = queue.shift
+          current_key = reachability.send(:marking_key, current_marking)
+
+          next if visited.include?(current_key)
+          visited.add(current_key)
+
+          # Set net to current marking
+          net.set_marking(current_marking)
+
+          # Try firing each enabled transition
+          net.enabled_transitions.each do |transition|
+            # Save current state
+            saved_marking = net.current_marking.dup
+
+            # Fire transition
+            begin
+              transition.fire!
+              new_marking = net.current_marking
+
+              # Record reachability
+              reachability.record_reachability(initial_marking, new_marking)
+              reachability.record_reachability(current_marking, new_marking)
+
+              # Add to queue if not visited
+              new_key = reachability.send(:marking_key, new_marking)
+              queue << new_marking.dup unless visited.include?(new_key)
+            ensure
+              # Restore marking for next iteration
+              net.set_marking(saved_marking)
+            end
+          end
+        end
+
+        reachability
+      end
+
+      # Convert to 2D matrix representation
+      def to_matrix
+        rows = @markings.map do |marking_i|
+          @markings.map { |marking_j| @matrix[marking_i][marking_j] }
+        end
+        ::Matrix.rows(rows)
+      end
+
+      # Check for deadlock states (markings with no successors)
+      def deadlock_states
+        @markings.select do |marking|
+          reachable_from(marking).empty?
+        end
+      end
+
+      def stats
+        {
+          total_markings: @markings.size,
+          total_transitions: @matrix.values.map { |h| h.values.sum }.sum,
+          deadlock_states: deadlock_states.size
+        }
+      end
+
+      def to_s
+        "ReachabilityMatrix(#{@markings.size} markings, #{stats[:total_transitions]} transitions)"
+      end
+
+      private
+
+      def marking_key(marking)
+        case marking
+        when Core::Marking
+          marking.to_h.sort.to_s
+        when Hash
+          marking.sort.to_s
+        else
+          marking.to_s
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/railtie.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module PetriFlow
+  # Rails integration for PetriFlow.
+  # Automatically loads rake tasks and discovers workflows in app/workflows/.
+  #
+  # @example Configure in config/application.rb or an initializer
+  #   Rails.application.configure do
+  #     config.petri_flow.workflows_path = "app/workflows"
+  #     config.petri_flow.auto_discover = true
+  #   end
+  #
+  class Railtie < Rails::Railtie
+    railtie_name :petri_flow
+
+    # Load rake tasks
+    rake_tasks do
+      load File.expand_path("tasks/petri_flow.rake", __dir__)
+    end
+
+    # Configuration defaults
+    config.petri_flow = ActiveSupport::OrderedOptions.new
+    config.petri_flow.workflows_path = "app/workflows"
+    config.petri_flow.auto_discover = true
+
+    # Store configuration reference
+    initializer "petri_flow.configuration" do |app|
+      PetriFlow.rails_config = app.config.petri_flow
+    end
+
+    # Auto-discover workflows after initialization
+    config.after_initialize do |app|
+      if app.config.petri_flow.auto_discover
+        workflows_dir = app.root.join(app.config.petri_flow.workflows_path)
+        Registry.discover_in(workflows_dir.to_s)
+      end
+    end
+  end
+end