roast-ai 0.4.7 → 0.4.9

data/lib/roast/dsl/cog_execution_context.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    # Contains the cogs already executed in this run.
+    class CogExecutionContext
+      # Raises if you access a cog in an execution block that hasn't already been run.
+      class IncompleteCogExecutionAccessError < StandardError; end
+
+      def initialize(cogs, bound_names)
+        @cogs = cogs
+        bind_cog_methods(bound_names)
+      end
+
+      private
+
+      def bind_cog_methods(bound_names)
+        bound_names.map do |name|
+          define_singleton_method(name.to_sym, ->(name) do
+            @cogs[name].tap do |cog|
+              raise IncompleteCogExecutionAccessError unless cog.ran?
+            end.output
+          end)
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/cmd.rb

@@ -0,0 +1,55 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Cmd < Cog
+        class Output
+          #: String?
+          attr_reader :command_output
+
+          #: String?
+          attr_reader :err
+
+          #: Process::Status?
+          attr_reader :status
+
+          #: (
+          #|  String? output,
+          #|  String? error,
+          #|  Process::Status? status
+          #| ) -> void
+          def initialize(output, error, status)
+            @command_output = output
+            @err = error
+            @status = status
+          end
+        end
+
+        class Config < Cog::Config
+          #: () -> void
+          def print_all!
+            @values[:print_all] = true
+          end
+
+          #: () -> bool
+          def print_all?
+            !!@values[:print_all]
+          end
+
+          def display!
+            print_all!
+          end
+        end
+
+        #: (String) -> Output
+        def execute(input)
+          result = Output.new(*Roast::Helpers::CmdRunner.capture3(input))
+          puts result.command_output if @config.print_all?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/graph.rb

@@ -0,0 +1,53 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Graph < Roast::DSL::Cog
+        #: Proc
+        attr_reader :block
+
+        #: (Symbol) { (Roast::DSL::Cogs::Graph) -> void } -> void
+        def initialize(name, &block)
+          @name = name
+          @block = block
+          @graph = Roast::Graph.new
+          super(name, proc {})
+        end
+
+        #: () -> void
+        def on_invoke
+          populate!(@graph)
+        end
+
+        #: () -> Symbol
+        def store_id
+          @name.to_sym
+        end
+
+        #: (Roast::DSL::Cog) -> void
+        def update(other)
+          return unless other.is_a?(Roast::DSL::Cogs::Graph)
+
+          return if other.block.nil?
+
+          other.populate!(@graph)
+        end
+
+        # Populates the provided graph in-place, with the definition of how to populate in the block
+        #: (Roast::DSL::Cogs::Graph) -> void
+        def populate!(graph)
+          return if @block.nil?
+
+          @block.call(graph)
+        end
+
+        #: () -> void
+        def execute
+          @graph.execute
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs.rb

@@ -0,0 +1,65 @@
+# typed: false
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class << self
+        #: (String) -> void
+        def load_all_for(rube_rb_fpath)
+          rube_rb_fpath = File.expand_path(rube_rb_fpath)
+          all_cog_files(rube_rb_fpath).each do |cog_fpath|
+            require cog_fpath
+          end
+          bind_all_cog_invokers
+        end
+
+        #: () -> Array[Class]
+        def all_cog_classes
+          # rubocop:disable Sorbet/ConstantsFromStrings
+          Roast::DSL::Cogs.constants.map do |cog_class_name|
+            Roast::DSL::Cogs.const_get(cog_class_name)
+          end
+          # rubocop:enable Sorbet/ConstantsFromStrings
+        end
+
+        private
+
+        #: () -> void
+        def bind_all_cog_invokers
+          all_cog_classes.each do |cog_class|
+            # At some point we may want to tuck this all into a Roast::DSL::Binding/Scope/Context to avoid polluting toplevel.
+            TOPLEVEL_BINDING.eval(binding_string_for(cog_class))
+          end
+        end
+
+        #: (Class) -> String
+        def binding_string_for(cog_class)
+          <<~RUBY
+            def #{cog_class.method_name}(*args, **kwargs, &block)
+              #{cog_class.name}.invoke(*args, **kwargs, &block)
+            end
+          RUBY
+        end
+
+        #: (String) -> Array[String]
+        def all_cog_files(rube_rb_fpath)
+          dirs = [project_cogs_dir(rube_rb_fpath), internal_cogs_dir]
+          dirs.map do |dir|
+            Dir.glob(File.join(dir, "*.rb")) # Just toplevel .rb files
+          end.flatten
+        end
+
+        #: (String) -> String
+        def project_cogs_dir(rube_rb_fpath)
+          File.join(File.dirname(rube_rb_fpath), "cogs")
+        end
+
+        #: () -> String
+        def internal_cogs_dir
+          File.join(File.dirname(__FILE__), "cogs")
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/config_context.rb

@@ -0,0 +1,54 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    class ConfigContext
+      def initialize(cogs, config_proc)
+        @cogs = cogs
+        @executor_scoped_configs = {}
+        @cog_scoped_configs = {}
+        @config_proc = config_proc
+      end
+
+      def fetch_merged_config(cog_class, name = nil)
+        # All configs have an entry, even if it's empty.
+        configs = fetch_execution_scope(cog_class)
+        instance_configs = fetch_cog_config(cog_class, name) unless name.nil?
+        configs = configs.merge(instance_configs) if instance_configs
+        configs
+      end
+
+      def prepare!
+        bind_default_cogs
+        instance_eval(&@config_proc)
+      end
+
+      #: () -> void
+      def bind_default_cogs
+        bind_cog(Cogs::Cmd, :cmd)
+      end
+
+      def fetch_cog_config(cog_class, name)
+        @cog_scoped_configs[cog_class][name]
+      end
+
+      def fetch_or_create_cog_config(cog_class, name)
+        @cog_scoped_configs[cog_class][name] = cog_class.config_class.new unless @cog_scoped_configs.key?(name)
+        @cog_scoped_configs[cog_class][name]
+      end
+
+      def fetch_execution_scope(cog_class)
+        @executor_scoped_configs[cog_class]
+      end
+
+      def bind_cog(cog_class, method_name)
+        @cog_scoped_configs[cog_class] = {}
+        @executor_scoped_configs[cog_class] = cog_class.config_class.new
+        instance_eval do
+          define_singleton_method(method_name, &cog_class.on_config)
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/executor.rb

@@ -4,23 +4,78 @@
 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)
-          execute(File.read(workflow_path))
+          run!(File.read(workflow_path))
         end
 
         private
 
-        def execute(input)
-          new.instance_eval(input)
+        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
 
-      # Define methods to be used in workflows below.
+      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
 
-      def shell(command_string)
-        output, _status = Roast::Helpers::CmdRunner.capture2e(command_string)
-        puts output
+      # 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

data/lib/roast/dsl/workflow_execution_context.rb

@@ -0,0 +1,47 @@
+# 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

data/lib/roast/error.rb

@@ -0,0 +1,7 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  # Base class for all internal Roast errors.
+  class Error < StandardError; end
+end

data/lib/roast/errors.rb

@@ -4,12 +4,12 @@
 module Roast
   module Errors
     # Custom error for API resource not found (404) responses
-    class ResourceNotFoundError < StandardError; end
+    class ResourceNotFoundError < Roast::Error; end
 
     # Custom error for when API authentication fails
-    class AuthenticationError < StandardError; end
+    class AuthenticationError < Roast::Error; end
 
     # Exit the app, for instance via Ctrl-C during an InputStep
-    class ExitEarly < StandardError; end
+    class ExitEarly < Roast::Error; end
   end
 end

data/lib/roast/graph/edge.rb

@@ -0,0 +1,25 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class Edge
+      #: (Node) -> void
+      attr_writer :join_node
+
+      attr_reader :from_node, :to_node
+
+      #: (Node, Node, ?proc: Proc?) -> void
+      def initialize(from_node, to_node, proc: nil)
+        @from_node = from_node
+        @to_node = to_node
+        @proc = proc # TODO: Shadowing proc builtin here
+      end
+
+      #: () -> String
+      def to_s
+        "#{@from_node} -> #{@to_node}"
+      end
+    end
+  end
+end

data/lib/roast/graph/node.rb

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class Node
+      # class InvalidExecutableError < Roast::Error; end
+
+      attr_reader :name, :executable
+
+      #: (Symbol, ?executable: Proc | Graph | nil) -> void
+      def initialize(name, executable: nil)
+        @name = name
+        @executable = executable
+      end
+
+      #: () -> T::Boolean
+      def subgraph?
+        @executable.is_a?(Graph)
+      end
+
+      #: () -> T::Boolean
+      def done?
+        @name == :DONE
+      end
+
+      #: (Hash) -> void
+      def execute(state)
+        return if @executable.nil?
+
+        executable = @executable
+        if executable.is_a?(Proc)
+          executable.call(state)
+        elsif executable.is_a?(Graph)
+          executable.execute(state)
+        end
+      end
+    end
+  end
+end

data/lib/roast/graph/quantum_edge.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class QuantumEdge
+      #: (Roast::Graph::Node, Proc) -> void
+      def initialize(from_node, to_proc)
+        @from_node = from_node
+        @to_proc = to_proc
+      end
+
+      #: (Hash[untyped, untyped], Hash[Symbol, Roast::Graph::Node]) -> Array[Roast::Graph::Edge]
+      def collapse(state, nodes)
+        to_node_names = @to_proc.call(state)
+        to_node_names = to_node_names.is_a?(Array) ? to_node_names : [to_node_names]
+
+        to_node_names.map do |to_node_name|
+          to_node = nodes[to_node_name]
+          raise Error, "No node found with name #{to_node_name.inspect}" if to_node.nil?
+
+          Edge.new(@from_node, to_node)
+        end
+      end
+    end
+  end
+end

data/lib/roast/graph/threaded_exec.rb

@@ -0,0 +1,93 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  class Graph
+    class StateConflictError < Error; end
+
+    class ThreadedExec
+      def initialize(nodes, og_state)
+        @nodes = nodes
+        @og_state = og_state
+      end
+
+      #: () -> Hash[untyped, untyped]
+      def async_execute
+        states = threaded_execute(@nodes, @og_state)
+        merge_states!(@og_state, states)
+        @og_state
+      end
+
+      # Returns a hash of the new states for each node.
+      #: (Array[Node], Hash[untyped, untyped]) -> Hash[Symbol, Hash[untyped, untyped]]
+      def threaded_execute(nodes, og_state)
+        states = {}
+        threads = nodes.map do |current_node|
+          states[current_node.name] = og_state.dup
+          Thread.new do
+            current_node.execute(states[current_node.name])
+          end
+        end
+
+        threads.map(&:value)
+
+        states
+      end
+
+      #: (Hash, Hash) -> void
+      def merge_states!(orig_state, new_states)
+        orig_state.merge!(merge_new_states(orig_state, new_states))
+      end
+
+      # We merge all the new states together first so we can catch any keys that were modified by multiple threads.
+      #: (Hash[untyped, untyped], Hash[Symbol, Hash[untyped, untyped]]) -> Hash[untyped, untyped]
+      def merge_new_states(orig_state, new_states)
+        # We only care about what the threads have changes from the original state.
+        changed_states = changed_states(orig_state, new_states)
+
+        return {} if changed_states.empty?
+
+        # Grab some entry to be the one we merge all the other changes into.
+        base_node_name, base_changed_state = T.must(changed_states.shift)
+        base_node_name = T.cast(base_node_name, Symbol)
+        base_changed_state = T.cast(base_changed_state, T::Hash[T.untyped, T.untyped])
+
+        changed_states.each do |node_name, changed_state|
+          base_changed_state.merge!(changed_state) do |key, old_value, new_value|
+            raise_state_conflict(key, old_value, new_value, [base_node_name, node_name])
+          end
+        end
+
+        base_changed_state
+      end
+
+      #: (Hash, Hash[Symbol, Hash]) -> Hash[Symbol, Hash]
+      def changed_states(orig_state, new_states)
+        new_states.transform_values do |new_state|
+          changed_state_entries(orig_state, new_state)
+        end
+      end
+
+      # Filter new states content to only include keys that were modified by the new states.
+      #: (Hash, Hash) -> Hash
+      def changed_state_entries(orig_state, new_state)
+        new_state.reject do |key, value|
+          orig_state[key] == value
+        end
+      end
+
+      #: (Symbol, untyped, untyped, Array[Symbol]) -> void
+      def raise_state_conflict(key, old_value, new_value, conflicting_nodes)
+        raise StateConflictError, <<~CONFLICT.chomp
+          Parallel nodes modified the same state key.
+          Conflicting nodes: #{conflicting_nodes.join(", ")}
+          Key: :#{key}
+          Old value:
+          #{old_value.inspect}
+          New value:
+          #{new_value.inspect}
+        CONFLICT
+      end
+    end
+  end
+end