fractor 0.1.6 → 0.1.8

data/lib/fractor/workflow/visualizer.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Fractor
+  class Workflow
+    # Generates visual representations of workflows.
+    # Supports Mermaid, DOT/Graphviz, and ASCII art formats.
+    class Visualizer
+      def initialize(workflow_class)
+        @workflow_class = workflow_class
+        @jobs = workflow_class.jobs
+      end
+
+      # Generate Mermaid flowchart diagram
+      #
+      # @return [String] Mermaid diagram syntax
+      def to_mermaid
+        lines = ["flowchart TD"]
+        lines << "    Start([Start: #{@workflow_class.workflow_name}])"
+
+        # Add job nodes
+        @jobs.each do |name, job|
+          label = escape_mermaid(name)
+          worker = escape_mermaid(job.worker_class.name.split("::").last)
+
+          # Different shapes based on job type
+          lines << if job.terminates
+                     "    #{node_id(name)}[/#{label}<br/>#{worker}/]"
+                   else
+                     "    #{node_id(name)}[#{label}<br/>#{worker}]"
+                   end
+        end
+
+        lines << "    End([End])"
+
+        # Add edges
+        @jobs.each do |name, job|
+          if job.dependencies.empty?
+            # Start job
+            lines << "    Start --> #{node_id(name)}"
+          else
+            # Dependencies
+            job.dependencies.each do |dep|
+              edge_label = ""
+              if job.condition_proc
+                edge_label = "|conditional|"
+              end
+              lines << "    #{node_id(dep)} -->#{edge_label} #{node_id(name)}"
+            end
+          end
+
+          # Terminating jobs
+          if job.terminates
+            lines << "    #{node_id(name)} --> End"
+          end
+        end
+
+        # Add styling
+        lines << ""
+        lines << "    classDef terminating fill:#f9f,stroke:#333,stroke-width:2px"
+        @jobs.each do |name, job|
+          lines << "    class #{node_id(name)} terminating" if job.terminates
+        end
+
+        lines.join("\n")
+      end
+
+      # Generate DOT/Graphviz diagram
+      #
+      # @return [String] DOT syntax
+      def to_dot
+        lines = ["digraph #{dot_id(@workflow_class.workflow_name)} {"]
+        lines << "  rankdir=TD;"
+        lines << "  node [shape=box, style=rounded];"
+        lines << ""
+
+        # Start node
+        lines << '  start [label="Start", shape=ellipse];'
+
+        # Job nodes
+        @jobs.each do |name, job|
+          worker = job.worker_class.name
+          label = "#{name}\\n(#{worker})"
+
+          lines << if job.terminates
+                     "  #{dot_id(name)} [label=\"#{label}\", " \
+                              "style=\"rounded,filled\", fillcolor=lightpink];"
+                   else
+                     "  #{dot_id(name)} [label=\"#{label}\"];"
+                   end
+        end
+
+        # End node
+        lines << '  end [label="End", shape=ellipse];'
+        lines << ""
+
+        # Edges
+        @jobs.each do |name, job|
+          if job.dependencies.empty?
+            lines << "  start -> #{dot_id(name)};"
+          else
+            job.dependencies.each do |dep|
+              lines << if job.condition_proc
+                         "  #{dot_id(dep)} -> #{dot_id(name)} " \
+                                  "[label=\"conditional\", style=dashed];"
+                       else
+                         "  #{dot_id(dep)} -> #{dot_id(name)};"
+                       end
+            end
+          end
+
+          if job.terminates
+            lines << "  #{dot_id(name)} -> end;"
+          end
+        end
+
+        lines << "}"
+        lines.join("\n")
+      end
+
+      # Generate ASCII art diagram
+      #
+      # @return [String] ASCII art representation
+      def to_ascii
+        lines = []
+        lines << "┌─────────────────────────────────────────┐"
+        lines << "│ Workflow: #{@workflow_class.workflow_name.ljust(27)} │"
+        lines << "└─────────────────────────────────────────┘"
+        lines << ""
+
+        # Compute execution order
+        order = compute_execution_order
+
+        order.each_with_index do |job_group, index|
+          if job_group.size == 1
+            # Single job
+            job = @jobs[job_group.first]
+            lines << "    ┌─────────────────────────┐"
+            lines << "    │ #{job_group.first.ljust(23)} │"
+            lines << "    │ (#{job.worker_class.name.split('::').last.ljust(21)}) │"
+            lines << "    └─────────────────────────┘"
+          else
+            # Parallel jobs
+            lines << "    ╔═════════════════════════╗"
+            lines << "    ║ PARALLEL EXECUTION      ║"
+            lines << "    ╚═════════════════════════╝"
+            job_group.each do |job_name|
+              job = @jobs[job_name]
+              lines << "        ├─ #{job_name}"
+              lines << "        │  (#{job.worker_class.name.split('::').last})"
+            end
+          end
+
+          # Arrow to next group
+          if index < order.size - 1
+            lines << "           │"
+            lines << "           ▼"
+          end
+        end
+
+        lines << ""
+        lines << "Legend: Regular jobs │ Parallel jobs ╔═══╗"
+
+        lines.join("\n")
+      end
+
+      # Print ASCII diagram to stdout
+      def print
+        puts to_ascii
+      end
+
+      private
+
+      def node_id(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      end
+
+      def dot_id(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      end
+
+      def escape_mermaid(text)
+        text.to_s.gsub(/["\[\]()]/, "")
+      end
+
+      def compute_execution_order
+        # Topological sort
+        jobs = @jobs
+        order = []
+        remaining = jobs.keys.to_set
+        processed = Set.new
+
+        until remaining.empty?
+          ready = remaining.select do |job_name|
+            job = jobs[job_name]
+            job.dependencies.all? { |dep| processed.include?(dep) }
+          end
+
+          break if ready.empty?
+
+          order << ready
+          ready.each do |job_name|
+            processed.add(job_name)
+            remaining.delete(job_name)
+          end
+        end
+
+        order
+      end
+    end
+  end
+end

data/lib/fractor/workflow/workflow_context.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Fractor
+  class Workflow
+    # Manages data flow and state during workflow execution.
+    # Stores workflow inputs, job outputs, and provides resolution of data dependencies.
+    class WorkflowContext
+      attr_reader :workflow_input, :job_outputs, :correlation_id, :logger
+
+      def initialize(workflow_input, correlation_id: nil, logger: nil)
+        @workflow_input = workflow_input
+        @job_outputs = {}
+        @correlation_id = correlation_id || generate_correlation_id
+        @logger = logger || WorkflowLogger.new(correlation_id: @correlation_id)
+      end
+
+      # Store the output of a completed job.
+      #
+      # @param job_name [String] The job name
+      # @param output [Lutaml::Model::Serializable] The job's output
+      def store_job_output(job_name, output)
+        @job_outputs[job_name] = output
+      end
+
+      # Get the output of a completed job.
+      #
+      # @param job_name [String] The job name
+      # @return [Lutaml::Model::Serializable, nil] The job's output
+      def job_output(job_name)
+        @job_outputs[job_name]
+      end
+
+      # Build input for a job based on its input mappings.
+      #
+      # @param job [Job] The job to build input for
+      # @return [Lutaml::Model::Serializable] The constructed input
+      def build_job_input(job)
+        return @workflow_input if job.input_mappings[:workflow]
+
+        input_type = job.input_type
+        unless input_type
+          raise "Job '#{job.name}' has no input_type defined in its worker"
+        end
+
+        # Collect attributes from all mapped sources
+        input_attrs = {}
+
+        job.input_mappings.each do |source_job_name, attr_mappings|
+          source_output = job_output(source_job_name)
+          unless source_output
+            raise "Job '#{job.name}' depends on '#{source_job_name}' but its output is not available"
+          end
+
+          if attr_mappings == :all
+            # Map all attributes from source to input
+            copy_all_attributes(source_output, input_attrs, input_type)
+          else
+            # Map specific attributes
+            attr_mappings.each do |target_attr, source_attr|
+              target_attr = target_attr.to_sym
+              source_attr = source_attr.to_sym
+
+              # Get value from source output
+              value = if source_output.respond_to?(source_attr)
+                        source_output.send(source_attr)
+                      elsif source_output.respond_to?(:[])
+                        source_output[source_attr]
+                      else
+                        raise "Source output from '#{source_job_name}' does not have attribute '#{source_attr}'"
+                      end
+
+              input_attrs[target_attr] = value
+            end
+          end
+        end
+
+        # Create input instance
+        input_type.new(**input_attrs)
+      end
+
+      # Check if a job's output is available.
+      #
+      # @param job_name [String] The job name
+      # @return [Boolean] Whether the output is available
+      def job_completed?(job_name)
+        @job_outputs.key?(job_name)
+      end
+
+      # Convert context to hash for debugging/logging
+      def to_h
+        {
+          correlation_id: @correlation_id,
+          workflow_input: @workflow_input.class.name,
+          completed_jobs: @job_outputs.keys,
+        }
+      end
+
+      private
+
+      def generate_correlation_id
+        require "securerandom"
+        "wf-#{SecureRandom.hex(8)}"
+      end
+
+      def copy_all_attributes(source, target_hash, input_type)
+        # Copy all compatible attributes from source to target
+        if defined?(Lutaml::Model::Serializable) &&
+            source.is_a?(Lutaml::Model::Serializable) &&
+            input_type.respond_to?(:attributes)
+          # Lutaml::Model path
+          source.class.attributes.each_key do |attr_name|
+            if input_type.attributes.key?(attr_name)
+              target_hash[attr_name] = source.send(attr_name)
+            end
+          end
+        else
+          # Fallback for plain Ruby classes
+          # Copy all instance variables from source that exist in target
+          source.instance_variables.each do |var|
+            attr_name = var.to_s.delete("@").to_sym
+
+            # Check if target class has this attribute (via attr_accessor/reader)
+            if input_type.instance_methods.include?(attr_name) ||
+                input_type.instance_methods.include?("#{attr_name}=".to_sym)
+              target_hash[attr_name] = source.instance_variable_get(var)
+            end
+          end
+        end
+      end
+    end
+  end
+end