circuit_breaker-wf 0.1.0

data/lib/circuit_breaker/workflow_dsl.rb

@@ -0,0 +1,359 @@
+module CircuitBreaker
+  module WorkflowBuilder
+    module DSL
+      class ::Symbol
+        def >>(other)
+          StateTransition.new(self, other)
+        end
+      end
+
+      class StateTransition
+        attr_reader :from, :to
+
+        def initialize(from, to)
+          @from = from
+          @to = to
+        end
+
+        def >>(other)
+          StateTransition.new(from, other)
+        end
+
+        def to_s
+          "#{from} -> #{to}"
+        end
+      end
+
+      class ActionContext
+        attr_reader :results
+
+        def initialize
+          @results = {}
+        end
+
+        def add_result(name, result)
+          @results[name] = result if name
+        end
+
+        def get_result(name)
+          @results[name]
+        end
+
+        def method_missing(name, *args)
+          @results[name]
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          @results.key?(name) || super
+        end
+      end
+
+      class ActionBuilder
+        attr_reader :context, :actions
+
+        def initialize(workflow_builder)
+          @workflow_builder = workflow_builder
+          @context = ActionContext.new
+          @actions = []
+        end
+
+        def execute(executor, method, result_name = nil, **params)
+          @actions << [executor, method, result_name, params]
+        end
+
+        def execute_actions(token)
+          puts "Executing actions for token #{token.id}..."
+          @actions.each do |executor, method, result_name, params|
+            puts "  Executing #{method} -> #{result_name}"
+            result = executor.send(method, token, **params)
+            puts "  Result: #{result.inspect}"
+            @context.add_result(result_name, result) if result_name
+          end
+        end
+      end
+
+      class StateTransitionBuilder
+        def initialize(workflow_builder, state_transition)
+          @workflow_builder = workflow_builder
+          @from_state = state_transition.from
+          @to_state = state_transition.to
+        end
+
+        def transition(name)
+          @workflow_builder.transition(name, from: @from_state, to: @to_state)
+        end
+
+        def policy(rules)
+          @workflow_builder.policy(rules)
+        end
+
+        def actions(&block)
+          builder = ActionBuilder.new(@workflow_builder)
+          builder.instance_eval(&block)
+          @workflow_builder.set_action_context(builder.context)
+        end
+      end
+
+      class WorkflowBuilder
+        attr_reader :states, :transitions, :before_flows, :rules, :current_token
+
+        def initialize(rules = nil)
+          @states = []
+          @transitions = []
+          @before_flows = []
+          @rules = rules || Rules::DSL.define
+          @current_token = nil
+        end
+
+        def states(*states)
+          @states = states
+        end
+
+        def flow(transition_spec, name = nil, &block)
+          from_state, to_state = parse_transition_spec(transition_spec)
+          raise "Invalid transition spec" unless from_state && to_state
+
+          transition = Transition.new(name || "#{from_state}_to_#{to_state}", from_state, to_state, self)
+          transition.instance_eval(&block) if block_given?
+          @transitions << transition
+          transition
+        end
+
+        def before_flow(&block)
+          @before_flows << block
+        end
+
+        def find_transition(name, from_state = nil)
+          @transitions.find do |t|
+            t.name == name && (from_state.nil? || t.from_state == from_state)
+          end
+        end
+
+        def transition!(token, transition_name)
+          transition = @transitions.find { |t| t.name == transition_name }
+          raise "Invalid transition '#{transition_name}'" unless transition
+          raise "Invalid from state '#{token.state}' (expected #{transition.from_state})" unless token.state.to_s == transition.from_state.to_s
+
+          old_state = token.state
+          @current_token = token  # Set current token before executing actions
+
+          begin
+            # Execute actions first
+            transition.execute_actions(token)
+
+            # Then validate rules
+            transition.validate_rules(token, @rules)
+
+            # Finally update state
+            token.state = transition.to_state.to_sym
+            token.record_transition(transition_name, old_state, token.state)
+
+            token
+          ensure
+            @current_token = nil  # Clear current token after execution
+          end
+        end
+
+        def build
+          self  # Return self since we're already a workflow
+        end
+
+        def pretty_print
+          puts "States:"
+          puts "  #{@states.join(' -> ')}\n\n"
+
+          puts "Transitions:"
+          @transitions.each do |t|
+            puts "  #{t.name}: #{t.from_state} -> #{t.to_state}"
+            puts "    Rules:"
+            if t.rules.is_a?(Hash)
+              if t.rules[:all]
+                puts "      All of:"
+                t.rules[:all].each { |r| puts "        - #{r}" }
+              end
+              if t.rules[:any]
+                puts "      Any of:"
+                t.rules[:any].each { |r| puts "        - #{r}" }
+              end
+            else
+              t.rules.each { |r| puts "        - #{r}" }
+            end
+            puts "    Actions:"
+            if t.action_builder&.actions
+              t.action_builder.actions.each do |executor, method, result_name, params|
+                result = executor.send(method, @current_token, **params) if @current_token
+                puts "      #{result_name}: #{result.inspect}"
+              end
+            end
+          end
+        end
+
+        private
+
+        def parse_transition_spec(spec)
+          case spec
+          when String
+            spec.split(">>").map(&:strip)
+          when Symbol
+            [spec.to_s]
+          when StateTransition
+            [spec.from.to_s, spec.to.to_s]
+          else
+            raise "Invalid transition spec: #{spec}"
+          end
+        end
+      end
+
+      class TransitionBuilder
+        attr_accessor :name, :from_state, :to_state, :rules, :action_context
+
+        def initialize(name, from_state, to_state)
+          @name = name
+          @from_state = from_state
+          @to_state = to_state
+          @rules = []
+          @action_context = nil
+        end
+
+        def build
+          Transition.new(
+            name: @name,
+            from_state: @from_state,
+            to_state: @to_state,
+            rules: @rules,
+            action_context: @action_context
+          )
+        end
+      end
+
+      class Transition
+        attr_reader :name, :from_state, :to_state, :rules, :workflow_builder
+        attr_accessor :action_context, :action_builder
+
+        def initialize(name, from_state, to_state, workflow_builder)
+          @name = name
+          @from_state = from_state
+          @to_state = to_state
+          @rules = []
+          @action_context = nil
+          @action_builder = nil
+          @workflow_builder = workflow_builder
+        end
+
+        def actions(&block)
+          @action_builder = ActionBuilder.new(@workflow_builder)
+          @action_builder.instance_eval(&block) if block_given?
+          @action_context = @action_builder.context
+        end
+
+        def policy(rules)
+          @rules = rules
+        end
+
+        def execute_actions(token)
+          @action_builder&.execute_actions(token)
+        end
+
+        def validate_rules(token, rules_dsl)
+          return unless @rules
+          
+          rules_dsl.with_context(@action_context) do
+            # Handle :all rules
+            if @rules[:all]
+              @rules[:all].each do |rule|
+                raise "Rule '#{rule}' failed for transition '#{name}'" unless rules_dsl.evaluate(rule, token)
+              end
+            end
+
+            # Handle :any rules
+            if @rules[:any]
+              any_passed = @rules[:any].any? { |rule| rules_dsl.evaluate(rule, token) }
+              raise "None of the rules #{@rules[:any]} passed for transition '#{name}'" unless any_passed
+            end
+          end
+        end
+      end
+
+      module PrettyPrint
+        def pretty_print
+          puts "States:"
+          puts "  #{@states.join(' -> ')}"
+          puts "\nTransitions:"
+          @transitions.each do |transition|
+            puts "  #{transition.name}: #{transition.from_state} -> #{transition.to_state}"
+            if transition.rules && !transition.rules.empty?
+              puts "    Rules:"
+              if transition.rules[:all]
+                puts "      All of:"
+                transition.rules[:all].each { |rule| puts "        - #{rule}" }
+              end
+              if transition.rules[:any]
+                puts "      Any of:"
+                transition.rules[:any].each { |rule| puts "        - #{rule}" }
+              end
+            end
+            if transition.action_context && !transition.action_context.results.empty?
+              puts "    Actions:"
+              transition.action_context.results.each do |name, result|
+                puts "      #{name}: #{result}"
+              end
+            end
+          end
+        end
+      end
+
+      class Workflow
+        include PrettyPrint
+
+        attr_reader :states, :transitions, :before_flows, :rules, :tokens
+
+        def initialize(states:, transitions:, before_flows:, rules:)
+          @states = states
+          @transitions = transitions
+          @before_flows = before_flows
+          @rules = rules
+          @tokens = []
+        end
+
+        def add_token(token)
+          token.state = @states.first if token.state.nil?
+          @tokens << token
+        end
+
+        def transition!(token, transition_name)
+          transition = @transitions.find { |t| t.name == transition_name }
+          raise "Invalid transition '#{transition_name}'" unless transition
+          raise "Invalid from state '#{token.state}'" unless token.state == transition.from_state
+
+          old_state = token.state
+          @current_token = token  # Set current token
+
+          # Then validate rules
+          transition.validate_rules(token, @rules)
+
+          # Execute actions first
+          transition.execute_actions(token)
+
+          # Finally update state
+          token.state = transition.to_state
+          token.record_transition(transition_name, old_state, token.state)
+
+          @current_token = nil  # Clear current token
+          token
+        end
+
+        private
+
+        def find_transition(name, current_state)
+          @transitions.find { |t| t.name == name && t.from_state == current_state }
+        end
+      end
+
+      def self.define(rules: nil, &block)
+        builder = WorkflowBuilder.new(rules)
+        builder.instance_eval(&block)
+        builder.build
+      end
+    end
+  end
+end

data/lib/circuit_breaker.rb

@@ -0,0 +1,236 @@
+require 'concurrent'
+require 'json'
+require 'securerandom'
+require 'set'
+require_relative 'circuit_breaker/version'
+require_relative 'circuit_breaker/token'
+require_relative 'circuit_breaker/workflow_dsl'
+require_relative 'circuit_breaker/rules'
+
+# Module for implementing a Circuit Breaker pattern using a Petri net
+module CircuitBreaker
+  # Represents a place in the Petri net workflow
+  # Places can hold tokens and connect to transitions via arcs
+  class Place
+    # @!attribute [r] name
+    #   @return [Symbol] Name of the place
+    attr_reader :name
+    
+    # @!attribute [r] tokens
+    #   @return [Array<Token>] Tokens currently in this place
+    attr_reader :tokens
+    
+    # @!attribute [r] input_arcs
+    #   @return [Array<Arc>] Input arcs connected to this place
+    attr_reader :input_arcs
+    
+    # @!attribute [r] output_arcs
+    #   @return [Array<Arc>] Output arcs connected to this place
+    attr_reader :output_arcs
+    
+    # Initialize a new place with a given name
+    # @param name [Symbol] Name of the place
+    def initialize(name)
+      @name = name
+      @tokens = []
+      @input_arcs = []
+      @output_arcs = []
+      @mutex = Mutex.new
+    end
+    
+    # Add a token to this place
+    # @param token [Token] Token to add
+    def add_token(token)
+      @mutex.synchronize { @tokens << token }
+    end
+    
+    # Remove and return the most recently added token
+    # @return [Token, nil] The removed token or nil if no tokens
+    def remove_token
+      @mutex.synchronize { @tokens.pop }
+    end
+    
+    # Get the current number of tokens in this place
+    # @return [Integer] Number of tokens
+    def token_count
+      @tokens.size
+    end
+
+    # Add an input arc from a source to this place
+    # @param source [Transition] Source transition
+    # @param weight [Integer] Weight of the arc (default: 1)
+    # @return [Arc] The created arc
+    def add_input_arc(source, weight = 1)
+      arc = Arc.new(source, self, weight)
+      @input_arcs << arc
+      arc
+    end
+
+    # Add an output arc from this place to a target
+    # @param target [Transition] Target transition
+    # @param weight [Integer] Weight of the arc (default: 1)
+    # @return [Arc] The created arc
+    def add_output_arc(target, weight = 1)
+      arc = Arc.new(self, target, weight)
+      @output_arcs << arc
+      arc
+    end
+  end
+
+  # Represents an arc connecting places and transitions in the Petri net
+  # Arcs can have weights to specify how many tokens are required/produced
+  class Arc
+    # @!attribute [r] weight
+    #   @return [Integer] Weight of the arc
+    attr_reader :weight
+    
+    # @!attribute [r] source
+    #   @return [Place, Transition] Source node
+    attr_reader :source
+    
+    # @!attribute [r] target
+    #   @return [Place, Transition] Target node
+    attr_reader :target
+
+    # Initialize a new arc
+    # @param source [Place, Transition] Source node
+    # @param target [Place, Transition] Target node
+    # @param weight [Integer] Weight of the arc (default: 1)
+    def initialize(source, target, weight = 1)
+      @source = source
+      @target = target
+      @weight = weight
+    end
+
+    # Check if this arc is enabled (can fire)
+    # @return [Boolean] True if the arc can fire
+    def enabled?
+      case source
+      when Place
+        source.token_count >= weight
+      when Transition
+        true  # Transitions can always produce tokens
+      else
+        false
+      end
+    end
+  end
+
+  # Represents a transition in the Petri net workflow
+  # Transitions connect places and can have guard conditions
+  class Transition
+    attr_reader :name, :from_state, :to_state, :input_arcs, :output_arcs, :guard
+
+    def initialize(name:, from:, to:)
+      @name = name
+      @from_state = from
+      @to_state = to
+      @input_arcs = []
+      @output_arcs = []
+      @guard = nil
+    end
+
+    def add_input_arc(place, weight = 1)
+      arc = Arc.new(place, self, weight)
+      @input_arcs << arc
+      arc
+    end
+
+    def add_output_arc(place, weight = 1)
+      arc = Arc.new(self, place, weight)
+      @output_arcs << arc
+      arc
+    end
+
+    def set_guard(&block)
+      @guard = block
+    end
+
+    def enabled?
+      return false unless @guard.nil? || @guard.call
+      @input_arcs.all?(&:enabled?) && @output_arcs.all?(&:enabled?)
+    end
+
+    def can_fire?(token)
+      return true unless @guard
+      @guard.call(token)
+    end
+  end
+
+  # Main workflow class that manages the Petri net
+  # Can be created from a configuration or built programmatically
+  class Workflow
+    attr_reader :places, :transitions, :tokens, :rules
+
+    def initialize(states: [], transitions: {}, before_flows: [], rules: [])
+      @places = {}
+      @transitions = {}
+      @tokens = Set.new
+      @rules = rules
+      @before_flows = before_flows
+
+      self.states = states
+      transitions.each do |transition, data|
+        add_transition(transition, data[:from], data[:to])
+        @transitions[transition].set_guard do |token|
+          data[:rules]&.each { |rule| return false unless @rules.evaluate(rule, token) }
+          true
+        end
+      end
+    end
+
+    def states=(state_list)
+      state_list.each do |state|
+        @places[state] = Place.new(state)
+      end
+    end
+
+    def add_token(token)
+      token.state = @places.keys.first if token.state.nil?
+      @tokens.add(token)
+      @places[token.state].add_token(token)
+    end
+
+    def fire_transition(transition_name, token)
+      transition = @transitions[transition_name]
+      raise "Invalid transition: #{transition_name}" unless transition
+      raise "Invalid state: #{token.state}" unless @places[token.state]
+      raise "Token not in workflow" unless @tokens.include?(token)
+
+      # Run any before_flow blocks
+      @before_flows.each { |block| block.call(token) }
+
+      # Check if transition is valid
+      unless transition.from_state == token.state
+        raise "Cannot fire transition '#{transition_name}' from state '#{token.state}'"
+      end
+
+      # Try to fire the transition
+      unless transition.can_fire?(token)
+        raise "Transition '#{transition_name}' cannot fire"
+      end
+
+      # Move token to new state
+      @places[token.state].remove_token
+      old_state = token.state
+      token.state = transition.to_state
+      @places[token.state].add_token(token)
+
+      # Record the transition
+      token.record_transition(transition_name, old_state, token.state)
+
+      token
+    end
+
+    private
+
+    def add_transition(name, from, to)
+      transition = Transition.new(name: name, from: from, to: to)
+      @transitions[name] = transition
+
+      # Add arcs
+      @places[from].add_output_arc(transition)
+      transition.add_output_arc(@places[to])
+    end
+  end
+end

data/workflow-editor/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?