roast-ai 0.4.9 → 0.5.0

data/lib/roast/dsl/executor.rb

@@ -1,82 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Roast
-  module DSL
-    class Executor
-      class ExecutorError < Roast::Error; end
-      class ExecutorAlreadyPreparedError < ExecutorError; end
-      class ExecutorAlreadyCompletedError < ExecutorError; end
-
-      class << self
-        def from_file(workflow_path)
-          run!(File.read(workflow_path))
-        end
-
-        private
-
-        def run!(workflow_definition)
-          executor = new
-          executor.prepare!(workflow_definition)
-          executor.start!
-        end
-      end
-
-      def prepare!(input)
-        # You can only initialize an executor once.
-        raise ExecutorAlreadyPreparedError if @prepared
-
-        extract_dsl_procs(input)
-        @cogs = Cog::Store.new
-        @cog_stack = Cog::Stack.new
-
-        @config_context = ConfigContext.new(@cogs, @config_proc)
-        @config_context.prepare!
-        @execution_context = WorkflowExecutionContext.new(@cogs, @cog_stack, @execution_proc)
-        @execution_context.prepare!
-
-        @prepared = true
-      end
-
-      def start!
-        # Now we run the cogs!
-        # You can only do this once, executors are not reusable to avoid state pollution
-        raise ExecutorAlreadyCompletedError if @completed
-
-        @cog_stack.map do |name, cog|
-          cog.run!(
-            @config_context.fetch_merged_config(cog.class, name.to_sym),
-            @execution_context.cog_execution_context,
-          )
-        end
-
-        @completed = true
-      end
-
-      def prepared?
-        @prepared ||= false
-      end
-
-      def completed?
-        @completed ||= false
-      end
-
-      #: { () [self: ConfigContext] -> void} -> void
-      def config(&block)
-        @config_proc = block
-      end
-
-      #: { () [self: WorkflowExecutionContext] -> void} -> void
-      def execute(&block)
-        @execution_proc = block
-      end
-
-      # Separating the instance evals ensures that we can reuse the same cog method
-      # names between config and execute, while have the backing objects be completely
-      # different. This means we have an enforced separation between configuring and running.
-      def extract_dsl_procs(input)
-        instance_eval(input)
-      end
-    end
-  end
-end

data/lib/roast/dsl/workflow_execution_context.rb

@@ -1,47 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Roast
-  module DSL
-    class WorkflowExecutionContext
-      def initialize(cogs, cog_stack, execution_proc)
-        @cogs = cogs
-        @cog_stack = cog_stack
-        @execution_proc = execution_proc
-        @bound_names = []
-      end
-
-      def prepare!
-        bind_default_cogs
-        instance_eval(&@execution_proc)
-      end
-
-      def cog_execution_context
-        @cog_execution_context ||= CogExecutionContext.new(@cogs, @bound_names)
-      end
-
-      private
-
-      def add_cog_instance(name, cog)
-        @cogs.insert(name, cog)
-        @cog_stack.push([name, cog])
-      end
-
-      def output(name)
-        @cogs[name].output
-      end
-
-      #: () -> void
-      def bind_default_cogs
-        bind_cog(Cogs::Cmd, :cmd)
-      end
-
-      def bind_cog(cog_class, name)
-        @bound_names << name
-        instance_eval do
-          define_singleton_method(name, &cog_class.on_create)
-        end
-      end
-    end
-  end
-end