orfeas_petri_flow 0.6.0

data/Rakefile

@@ -0,0 +1,28 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+task default: :test
+
+desc "Run console with gem loaded"
+task :console do
+  require "irb"
+  require "petri_flow"
+  ARGV.clear
+  IRB.start
+end
+
+desc "Generate example outputs"
+task :examples do
+  Dir.glob("examples/**/*.rb").each do |example|
+    puts "Running #{example}..."
+    load example
+    puts ""
+  end
+end

data/lib/petri_flow/colored/arc_expression.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Colored
+    # Represents an arc expression for colored Petri nets
+    # Arc expressions transform token data as it passes through the arc
+    class ArcExpression
+      attr_reader :name, :transformation
+
+      def initialize(name: nil, &transformation)
+        @name = name
+        @transformation = transformation
+      end
+
+      # Execute the arc expression on token data
+      # @param token_data [Hash] The token's data
+      # @param context [Hash] Additional context (metadata, state, etc.)
+      # @return [Hash] Transformed token data
+      def execute(token_data, context = {})
+        return token_data unless @transformation
+
+        @transformation.call(token_data, context)
+      end
+
+      # Compose arc expressions (chain transformations)
+      def then(other_expression)
+        ArcExpression.new(name: "#{@name} then #{other_expression.name}") do |data, context|
+          intermediate = execute(data, context)
+          other_expression.execute(intermediate, context)
+        end
+      end
+
+      def to_s
+        "ArcExpression(#{@name || 'anonymous'})"
+      end
+
+      def inspect
+        "#<PetriFlow::Colored::ArcExpression name=#{@name}>"
+      end
+    end
+
+    # Common arc expression factories
+    module ArcExpressions
+      # Identity expression (pass-through)
+      def self.identity
+        ArcExpression.new(name: "identity") { |data, _| data }
+      end
+
+      # Map specific fields
+      def self.map_fields(field_mappings)
+        ArcExpression.new(name: "map_fields") do |data, _|
+          result = data.dup
+          field_mappings.each do |old_field, new_field|
+            result[new_field] = result.delete(old_field) if result.key?(old_field)
+          end
+          result
+        end
+      end
+
+      # Add metadata
+      def self.add_metadata(metadata)
+        ArcExpression.new(name: "add_metadata") do |data, _|
+          data.merge(metadata: metadata)
+        end
+      end
+
+      # Transform CRUD to Event (for Lyra integration)
+      def self.crud_to_event(operation)
+        ArcExpression.new(name: "crud_to_event(#{operation})") do |data, context|
+          {
+            event_type: "#{data[:model_class]}#{operation.to_s.capitalize}",
+            event_id: SecureRandom.uuid,
+            data: data[:attributes] || {},
+            changes: data[:changes] || {},
+            metadata: {
+              correlation_id: data[:correlation_id],
+              action_id: data[:action_id],
+              user_id: data[:user_id],
+              timestamp: Time.current
+            }
+          }
+        end
+      end
+
+      # Detect PII in data
+      def self.detect_pii(pii_detector = nil)
+        ArcExpression.new(name: "detect_pii") do |data, context|
+          pii_detected = if pii_detector
+                          pii_detector.call(data)
+                        else
+                          # Simple pattern-based detection
+                          detect_pii_patterns(data)
+                        end
+
+          data.merge(pii_detected: pii_detected)
+        end
+      end
+
+      # Apply privacy policy transformations
+      def self.apply_privacy_policy(policy)
+        ArcExpression.new(name: "apply_policy(#{policy})") do |data, context|
+          # Mask sensitive fields based on policy
+          masked_data = data.dup
+          policy_rules = context.dig(:policies, policy) || {}
+
+          policy_rules.each do |field, rule|
+            if masked_data[field] && rule[:mask]
+              masked_data[field] = mask_value(masked_data[field], rule[:mask])
+            end
+          end
+
+          masked_data
+        end
+      end
+
+      # Extract specific fields
+      def self.extract_fields(*fields)
+        ArcExpression.new(name: "extract_fields(#{fields.join(',')})") do |data, _|
+          data.slice(*fields)
+        end
+      end
+
+      # Merge with context data
+      def self.merge_context(*keys)
+        ArcExpression.new(name: "merge_context") do |data, context|
+          additional_data = keys.each_with_object({}) do |key, hash|
+            hash[key] = context[key] if context.key?(key)
+          end
+          data.merge(additional_data)
+        end
+      end
+
+      private
+
+      def self.detect_pii_patterns(data)
+        pii = {}
+        data.each do |key, value|
+          next unless value.is_a?(String)
+
+          pii[key] = :email if key.to_s.match?(/email/i) || value.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+          pii[key] = :phone if key.to_s.match?(/phone/i) || value.match?(/\A\d{10,}\z/)
+          pii[key] = :ssn if key.to_s.match?(/ssn|social/i)
+          pii[key] = :credit_card if value.match?(/\A\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\z/)
+        end
+        pii
+      end
+
+      def self.mask_value(value, mask_type)
+        case mask_type
+        when :full
+          "***MASKED***"
+        when :partial
+          return value if value.length < 4
+          value[0..1] + "*" * (value.length - 4) + value[-2..-1]
+        when :hash
+          Digest::SHA256.hexdigest(value.to_s)[0..15]
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/colored/color.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Colored
+    # Represents a color (data type) for tokens in a colored Petri net
+    class Color
+      attr_reader :name, :attributes, :validator
+
+      def initialize(name:, attributes: {}, validator: nil)
+        @name = name
+        @attributes = attributes
+        @validator = validator
+      end
+
+      # Validate data conforms to this color definition
+      def valid?(data)
+        return true unless @validator
+
+        @validator.call(data)
+      end
+
+      # Create a token of this color
+      def create_token(data = {})
+        raise ColorValidationError, "Invalid data for color #{@name}" unless valid?(data)
+
+        Core::Token.new(color: @name, data: data)
+      end
+
+      def to_s
+        "Color(#{@name})"
+      end
+
+      def inspect
+        "#<PetriFlow::Colored::Color name=#{@name} attributes=#{@attributes.keys}>"
+      end
+    end
+
+    class ColorValidationError < StandardError; end
+  end
+end

data/lib/petri_flow/colored/colored_net.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Colored
+    # Represents a Colored Petri Net (CPN)
+    # Extends basic Petri net with colored tokens, guards, and arc expressions
+    class ColoredNet < Core::Net
+      attr_reader :colors, :colored_places, :token_pools
+
+      def initialize(name: "ColoredPetriNet")
+        super(name: name)
+        @colors = {}
+        @colored_places = {}
+        @token_pools = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register a color (token type)
+      def add_color(name, attributes: {}, validator: nil)
+        color = Color.new(name: name, attributes: attributes, validator: validator)
+        @colors[name] = color
+        color
+      end
+
+      # Add a colored place
+      def add_colored_place(id:, name: nil, color: nil, initial_tokens: [])
+        place = add_place(id: id, name: name, initial_tokens: 0)
+        @colored_places[id] = {
+          color: color,
+          tokens: initial_tokens
+        }
+        @token_pools[id] = initial_tokens.dup
+        place
+      end
+
+      # Add a colored transition with guard
+      def add_colored_transition(id:, name: nil, guard: nil)
+        guard_obj = case guard
+                    when Guard
+                      guard
+                    when Proc
+                      Guard.new(&guard)
+                    else
+                      nil
+                    end
+
+        add_transition(id: id, name: name, guard: guard_obj)
+      end
+
+      # Add an arc with expression
+      def add_colored_arc(source_id:, target_id:, weight: 1, expression: nil)
+        expr_obj = case expression
+                   when ArcExpression
+                     expression
+                   when Proc
+                     ArcExpression.new(&expression)
+                   else
+                     nil
+                   end
+
+        add_arc(
+          source_id: source_id,
+          target_id: target_id,
+          weight: weight,
+          expression: expr_obj
+        )
+      end
+
+      # Get tokens from a colored place
+      def tokens_at_place(place_id)
+        @token_pools[place_id] || []
+      end
+
+      # Add a token to a colored place
+      def add_token_to_place(place_id, token)
+        raise "Place #{place_id} not found" unless @places[place_id]
+
+        @token_pools[place_id] << token
+        @places[place_id].add_tokens(1)
+      end
+
+      # Remove a token from a colored place
+      def remove_token_from_place(place_id, token = nil)
+        raise "Place #{place_id} not found" unless @places[place_id]
+
+        token_to_remove = token || @token_pools[place_id].first
+        @token_pools[place_id].delete(token_to_remove)
+        @places[place_id].remove_tokens(1)
+        token_to_remove
+      end
+
+      # Fire a colored transition
+      def fire_colored_transition(transition_id, token_bindings = {}, context = {})
+        transition = @transitions[transition_id]
+        raise "Transition #{transition_id} not found" unless transition
+
+        # Check guard with token data
+        guard_context = context.merge(tokens: token_bindings)
+        return false unless transition.enabled?(guard_context)
+
+        # Process input arcs (consume tokens with expressions)
+        input_tokens = {}
+        transition.input_arcs.each do |arc|
+          token = remove_token_from_place(arc.source.id, token_bindings[arc.source.id])
+          input_tokens[arc.source.id] = token
+        end
+
+        # Process output arcs (produce tokens with expressions)
+        transition.output_arcs.each do |arc|
+          # Get token data from corresponding input
+          input_token = input_tokens.values.first
+          output_data = if arc.expression
+                         arc.expression.execute(input_token&.data || {}, context)
+                       else
+                         input_token&.data || {}
+                       end
+
+          output_token = Core::Token.new(
+            color: @colored_places.dig(arc.target.id, :color) || :default,
+            data: output_data
+          )
+
+          add_token_to_place(arc.target.id, output_token)
+        end
+
+        true
+      end
+
+      # Get colored marking (with token data)
+      def colored_marking
+        marking = {}
+        @token_pools.each do |place_id, tokens|
+          marking[place_id] = tokens.map(&:to_h)
+        end
+        marking
+      end
+
+      def to_s
+        "ColoredNet(#{@name}, P=#{@places.size}, T=#{@transitions.size}, Colors=#{@colors.size})"
+      end
+
+      def inspect
+        "#<PetriFlow::Colored::ColoredNet name=#{@name} colors=#{@colors.keys} #{stats}>"
+      end
+    end
+  end
+end

data/lib/petri_flow/colored/guard.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Colored
+    # Represents a guard condition for colored Petri net transitions
+    # Guards determine if a transition can fire based on token data
+    class Guard
+      attr_reader :name, :condition
+
+      def initialize(name: nil, &condition)
+        @name = name
+        @condition = condition
+      end
+
+      # Evaluate the guard condition
+      # @param context [Hash] Context including token data, event data, etc.
+      # @return [Boolean] true if guard is satisfied
+      def satisfied?(context = {})
+        return true unless @condition
+
+        @condition.call(context)
+      end
+
+      # Combine guards with AND logic
+      def and(other_guard)
+        Guard.new(name: "#{@name} AND #{other_guard.name}") do |context|
+          satisfied?(context) && other_guard.satisfied?(context)
+        end
+      end
+
+      # Combine guards with OR logic
+      def or(other_guard)
+        Guard.new(name: "#{@name} OR #{other_guard.name}") do |context|
+          satisfied?(context) || other_guard.satisfied?(context)
+        end
+      end
+
+      # Negate guard
+      def not
+        Guard.new(name: "NOT #{@name}") do |context|
+          !satisfied?(context)
+        end
+      end
+
+      def to_s
+        "Guard(#{@name || 'anonymous'})"
+      end
+
+      def inspect
+        "#<PetriFlow::Colored::Guard name=#{@name}>"
+      end
+    end
+
+    # Common guard factories
+    module Guards
+      # Guard that checks if a field equals a value
+      def self.field_equals(field, value)
+        Guard.new(name: "#{field}==#{value}") do |context|
+          context.dig(:token, :data, field) == value
+        end
+      end
+
+      # Guard that checks if a field matches a pattern
+      def self.field_matches(field, pattern)
+        Guard.new(name: "#{field}=~/#{pattern}/") do |context|
+          context.dig(:token, :data, field)&.match?(pattern)
+        end
+      end
+
+      # Guard that checks if a condition is met
+      def self.condition(name, &block)
+        Guard.new(name: name, &block)
+      end
+
+      # Guard that always passes (true)
+      def self.always_true
+        Guard.new(name: "always_true") { |_| true }
+      end
+
+      # Guard that never passes (false)
+      def self.always_false
+        Guard.new(name: "always_false") { |_| false }
+      end
+
+      # Guard for privacy policy checks (PAM integration)
+      def self.has_consent(purpose)
+        Guard.new(name: "has_consent(#{purpose})") do |context|
+          user_id = context.dig(:token, :data, :user_id)
+          # In real implementation, check consent registry
+          context[:consent_granted]&.include?([user_id, purpose])
+        end
+      end
+
+      # Guard for retention policy checks
+      def self.within_retention(model_class)
+        Guard.new(name: "within_retention(#{model_class})") do |context|
+          timestamp = context.dig(:token, :timestamp)
+          retention_period = context.dig(:retention_policies, model_class) || 7.years
+          timestamp && (Time.current - timestamp) < retention_period
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/core/arc.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Core
+    # Represents an arc in a Petri net
+    # Arcs connect places to transitions or transitions to places
+    class Arc
+      attr_reader :source, :target, :weight
+      attr_accessor :expression
+
+      # Create a new arc
+      # @param source [Place, Transition] The source node
+      # @param target [Transition, Place] The target node
+      # @param weight [Integer] Number of tokens consumed/produced (default: 1)
+      # @param expression [Proc] Arc expression for colored nets (optional)
+      def initialize(source:, target:, weight: 1, expression: nil)
+        validate_arc!(source, target)
+
+        @source = source
+        @target = target
+        @weight = weight
+        @expression = expression
+      end
+
+      # Check if this is an input arc (place -> transition)
+      def input_arc?
+        @source.is_a?(Place) && @target.is_a?(Transition)
+      end
+
+      # Check if this is an output arc (transition -> place)
+      def output_arc?
+        @source.is_a?(Transition) && @target.is_a?(Place)
+      end
+
+      # Execute arc expression (for colored Petri nets)
+      def execute_expression(token_data)
+        return token_data unless @expression
+
+        @expression.call(token_data)
+      end
+
+      def to_s
+        "Arc(#{@source.name} -> #{@target.name}, weight: #{@weight})"
+      end
+
+      def inspect
+        "#<PetriFlow::Core::Arc #{@source.class.name}(#{@source.name}) -> " \
+          "#{@target.class.name}(#{@target.name}) weight=#{@weight}>"
+      end
+
+      private
+
+      def validate_arc!(source, target)
+        valid = (source.is_a?(Place) && target.is_a?(Transition)) ||
+                (source.is_a?(Transition) && target.is_a?(Place))
+
+        raise ArcValidationError, "Arc must connect Place<->Transition or Transition<->Place" unless valid
+      end
+    end
+
+    class ArcValidationError < StandardError; end
+  end
+end

data/lib/petri_flow/core/marking.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Core
+    # Represents a marking (state) of a Petri net
+    # A marking is a distribution of tokens across places
+    class Marking
+      attr_reader :tokens_by_place
+
+      def initialize(tokens_by_place = {})
+        @tokens_by_place = tokens_by_place.dup
+      end
+
+      # Get token count for a place
+      def tokens_at(place)
+        place_id = place.is_a?(Place) ? place.id : place
+        @tokens_by_place[place_id] || 0
+      end
+
+      # Set token count for a place
+      def set_tokens(place, count)
+        place_id = place.is_a?(Place) ? place.id : place
+        @tokens_by_place[place_id] = count
+      end
+
+      # Check if this marking is equal to another
+      def ==(other)
+        return false unless other.is_a?(Marking)
+
+        @tokens_by_place == other.tokens_by_place
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        @tokens_by_place.hash
+      end
+
+      # Create a copy of this marking
+      def dup
+        self.class.new(@tokens_by_place)
+      end
+
+      # Convert marking to array format for comparison
+      def to_a(places)
+        places.map { |place| tokens_at(place) }
+      end
+
+      # Convert to hash representation
+      def to_h
+        @tokens_by_place.dup
+      end
+
+      def to_s
+        place_strings = @tokens_by_place.map { |place_id, count| "#{place_id}:#{count}" }
+        "Marking(#{place_strings.join(', ')})"
+      end
+
+      def inspect
+        "#<PetriFlow::Core::Marking #{to_s}>"
+      end
+    end
+  end
+end