foobara 0.0.1

data/projects/command/src/concerns/errors_type.rb

@@ -0,0 +1,124 @@
+module Foobara
+  class Command
+    module Concerns
+      module ErrorsType
+        include Concern
+
+        module ClassMethods
+          def process_error_constants
+            return if @error_constants_processed
+
+            @error_constants_processed = true
+
+            Util.constant_values(self, extends: Foobara::RuntimeError).each do |error_class|
+              key = PossibleError.new(error_class).key.to_s
+
+              unless error_context_type_map.key?(key)
+                possible_error error_class
+              end
+            end
+          end
+
+          def possible_errors
+            error_context_type_map.values
+          end
+
+          def possible_error(*args)
+            possible_error = case args.size
+                             when 1
+                               arg = args.first
+
+                               if arg.is_a?(PossibleError)
+                                 # TODO: test this code path
+                                 # :nocov:
+                                 arg
+                                 # :nocov:
+                               elsif arg.is_a?(::Class) && arg < Foobara::Error
+                                 PossibleError.new(arg)
+                               else
+                                 # :nocov:
+                                 raise ArgumentError, "Expected a PossibleError or an Error but got #{arg}"
+                                 # :nocov:
+                               end
+                             when 2
+                               symbol, error_class_or_context_type_declaration, data = args
+                               error_class = to_runtime_error_class(symbol, error_class_or_context_type_declaration)
+                               PossibleError.new(error_class, symbol:, data:)
+                             else
+                               # :nocov:
+                               raise ArgumentError, "Expected an error or a symbol and error context type declaration"
+                               # :nocov:
+                             end
+
+            register_possible_error_class(possible_error)
+          end
+
+          def possible_input_error(
+            path,
+            symbol_or_error_class,
+            error_class_or_context_type_declaration = {},
+            data = nil
+          )
+            error_class, symbol = if symbol_or_error_class.is_a?(Class)
+                                    [symbol_or_error_class, symbol_or_error_class.symbol]
+                                  else
+                                    [
+                                      to_input_error_class(
+                                        symbol_or_error_class,
+                                        error_class_or_context_type_declaration
+                                      ),
+                                      symbol_or_error_class
+                                    ]
+                                  end
+
+            possible_error = PossibleError.new(error_class, symbol:, data:)
+            possible_error.prepend_path!(path)
+
+            possible_error.manually_added = true
+            register_possible_error_class(possible_error)
+          end
+
+          def manually_added_possible_input_errors
+            @manually_added_possible_input_errors ||= []
+          end
+
+          # TODO: kill this method in favor of possible_errors
+          def error_context_type_map
+            process_error_constants
+            @error_context_type_map ||= if superclass < Foobara::Command
+                                          superclass.error_context_type_map.dup
+                                        end || {}
+          end
+
+          def register_possible_error_class(possible_error)
+            if possible_error.manually_added
+              manually_added_possible_input_errors << possible_error
+            end
+
+            error_context_type_map[possible_error.key.to_s] = possible_error
+          end
+
+          def unregister_possible_error_if_registered(possible_error)
+            key = possible_error.key.to_s
+            error_context_type_map.delete(key)
+          end
+
+          # TODO: should we cache these???
+          def to_input_error_class(symbol, context_type_declaration)
+            Foobara::Value::DataError.subclass(
+              symbol:,
+              context_type_declaration:
+            )
+          end
+
+          def to_runtime_error_class(symbol, context_type_declaration)
+            Foobara::RuntimeError.subclass(
+              symbol:,
+              context_type_declaration:
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command/src/concerns/inputs.rb

@@ -0,0 +1,59 @@
+module Foobara
+  class Command
+    module Concerns
+      module Inputs
+        include Concern
+
+        attr_reader :inputs
+
+        def method_missing(method_name, *args, &)
+          if respond_to_missing_for_inputs?(method_name)
+            inputs[method_name]
+          else
+            # :nocov:
+            super
+            # :nocov:
+          end
+        end
+
+        def respond_to_missing?(method_name, private = false)
+          respond_to_missing_for_inputs?(method_name, private) || super
+        end
+
+        def respond_to_missing_for_inputs?(method_name, _private = false)
+          inputs_type&.element_types&.key?(method_name)
+        end
+
+        foobara_delegate :inputs_type, to: :class
+
+        def cast_and_validate_inputs
+          if inputs_type.nil? && (raw_inputs.nil? || raw_inputs.empty?)
+            @inputs = {}
+            return
+          end
+
+          outcome = inputs_type.runner(raw_inputs).process_value
+
+          if outcome.success?
+            @inputs = outcome.result
+          else
+            outcome.errors.each do |error|
+              if error.is_a?(Value::DataError)
+                add_input_error(error)
+              else
+                # TODO: raise a real error
+                # :nocov:
+                raise "wtf"
+                # :nocov:
+              end
+            end
+          end
+
+          if outcome.success?
+            @inputs = outcome.result
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command/src/concerns/inputs_type.rb

@@ -0,0 +1,58 @@
+module Foobara
+  class Command
+    module Concerns
+      module InputsType
+        include Concern
+
+        module ClassMethods
+          def inputs(...)
+            old_inputs_type = inputs_type
+
+            old_inputs_type&.possible_errors&.each do |possible_error|
+              unregister_possible_error_if_registered(possible_error)
+            end
+
+            type = type_for_declaration(...)
+
+            if type.extends?(BuiltinTypes[:model]) && !type.extends?(BuiltinTypes[:entity])
+              type = type.element_types
+            end
+
+            @inputs_type = type
+
+            register_possible_input_errors
+
+            @inputs_type
+          end
+
+          def inputs_type
+            return @inputs_type if defined?(@inputs_type)
+
+            @inputs_type = if superclass < Foobara::Command
+                             superclass.inputs_type
+                           end
+          end
+
+          def raw_inputs_type_declaration
+            inputs_type.raw_declaration_data
+          end
+
+          def inputs_type_declaration
+            inputs_type.declaration_data
+          end
+
+          private
+
+          def register_possible_input_errors
+            # TODO: let's derive these at runtime and memoize...
+            inputs_type.possible_errors.each do |possible_error|
+              register_possible_error_class(possible_error)
+            end
+          end
+        end
+
+        foobara_delegate :inputs_type, :raw_inputs_type_declaration, to: :class
+      end
+    end
+  end
+end

data/projects/command/src/concerns/namespace.rb

@@ -0,0 +1,49 @@
+module Foobara
+  class Command
+    module Concerns
+      module Namespace
+        include Concern
+
+        on_include do
+          foobara_subclasses_are_namespaces!(default_parent: Foobara::GlobalDomain, autoregister: true)
+        end
+
+        module ClassMethods
+          def type_for_declaration(...)
+            domain.foobara_type_from_declaration(...)
+          end
+
+          def domain
+            namespace = foobara_parent_namespace
+
+            while namespace
+              if namespace.is_a?(Module) && namespace.foobara_domain?
+                d = namespace
+                break
+              end
+
+              namespace = namespace.foobara_parent_namespace
+            end
+
+            d || GlobalDomain
+          end
+
+          # TODO: prefix these...
+          def organization
+            domain.foobara_organization
+          end
+
+          def full_command_name
+            scoped_full_name
+          end
+
+          def full_command_symbol
+            @full_command_symbol ||= Util.underscore_sym(full_command_name)
+          end
+        end
+
+        foobara_delegate :type_for_declaration, to: :class
+      end
+    end
+  end
+end

data/projects/command/src/concerns/reflection.rb

@@ -0,0 +1,137 @@
+module Foobara
+  class Command
+    module Concerns
+      module Reflection
+        include Concern
+        include Manifestable
+
+        def initialize(...)
+          self.class.all << self
+          super(...)
+        end
+
+        module ClassMethods
+          def all
+            @all ||= []
+          end
+
+          def reset_all
+            remove_instance_variable("@all") if instance_variable_defined?("@all")
+          end
+
+          def foobara_manifest(to_include:)
+            depends_on = self.depends_on.map do |command_name|
+              other_command = Foobara::Namespace.global.foobara_lookup!(command_name,
+                                                                        mode: Foobara::Namespace::LookupMode::ABSOLUTE)
+              to_include << other_command
+              other_command.foobara_manifest_reference
+            end.sort
+
+            types = types_depended_on.map do |t|
+              to_include << t
+              t.foobara_manifest_reference
+            end.sort
+
+            inputs_types_depended_on = self.inputs_types_depended_on.map do |t|
+              to_include << t
+              t.foobara_manifest_reference
+            end.sort
+
+            result_types_depended_on = self.result_types_depended_on.map do |t|
+              to_include << t
+              t.foobara_manifest_reference
+            end.sort
+
+            errors_types_depended_on = self.errors_types_depended_on.map do |t|
+              to_include << t
+              t.foobara_manifest_reference
+            end.sort
+
+            possible_errors = self.possible_errors.map do |possible_error|
+              [possible_error.key.to_s, possible_error.foobara_manifest(to_include:)]
+            end.sort.to_h
+
+            h = Util.remove_blank(
+              types_depended_on: types,
+              inputs_types_depended_on:,
+              result_types_depended_on:,
+              errors_types_depended_on:,
+              possible_errors:,
+              depends_on:,
+              # TODO: allow inputs type to be nil or really any type?
+              inputs_type: inputs_type&.reference_or_declaration_data || {
+                type: "::attributes",
+                element_type_declarations: {},
+                required: []
+              }
+            ).merge(description:)
+
+            if result_type
+              # TODO: find a way to represent literal types like "nil"
+              h[:result_type] = result_type.reference_or_declaration_data
+            end
+
+            super.merge(h)
+          end
+
+          def command_name
+            Util.non_full_name(self)
+          end
+
+          def types_depended_on
+            # TODO: is there a simpler way to wrap these methods in this namespace?
+            # something aspect-oriented-ish?
+            @types_depended_on ||= begin
+              types = inputs_types_depended_on | result_types_depended_on | errors_types_depended_on
+
+              unless depends_on_entities.empty?
+                entity_types = depends_on_entities.map(&:entity_type)
+                types |= entity_types
+                types |= entity_types.map(&:types_depended_on).inject(:|)
+              end
+
+              types
+            end
+          end
+
+          def inputs_types_depended_on
+            @inputs_types_depended_on ||= if inputs_type
+                                            if inputs_type.registered?
+                                              # TODO: if we ever change from attributes-only inputs type
+                                              # then this will be handy
+                                              # :nocov:
+                                              Set[inputs_type]
+                                              # :nocov:
+                                            else
+                                              inputs_type.types_depended_on
+                                            end
+                                          else
+                                            Set.new
+                                          end
+          end
+
+          def result_types_depended_on
+            @result_types_depended_on ||= if result_type
+                                            if result_type.registered?
+                                              Set[result_type]
+                                            else
+                                              result_type.types_depended_on
+                                            end
+                                          else
+                                            Set.new
+                                          end
+          end
+
+          def errors_types_depended_on
+            @errors_types_depended_on ||= begin
+              error_classes = possible_errors.map(&:error_class)
+              error_classes.map(&:types_depended_on).inject(:|) || Set.new
+            end
+          end
+        end
+
+        foobara_delegate :type_for_declaration, to: :class
+      end
+    end
+  end
+end

data/projects/command/src/concerns/result.rb

@@ -0,0 +1,25 @@
+module Foobara
+  class Command
+    module Concerns
+      module Result
+        include Concern
+
+        class CouldNotProcessResult < Outcome::UnsuccessfulOutcomeError; end
+
+        private
+
+        def process_result_using_result_type(result)
+          return result unless result_type
+
+          outcome = result_type.process_value(result)
+
+          if outcome.success?
+            outcome.result
+          else
+            raise CouldNotProcessResult, outcome.errors
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command/src/concerns/result_type.rb

@@ -0,0 +1,29 @@
+module Foobara
+  class Command
+    module Concerns
+      module ResultType
+        include Concern
+
+        module ClassMethods
+          def result(...)
+            @result_type = type_for_declaration(...)
+          end
+
+          def result_type
+            return @result_type if defined?(@result_type)
+
+            @result_type = if superclass < Foobara::Command
+                             superclass.result_type
+                           end
+          end
+
+          def raw_result_type_declaration
+            result_type.raw_declaration_data
+          end
+        end
+
+        foobara_delegate :result_type, :raw_result_type_declaration, to: :class
+      end
+    end
+  end
+end

data/projects/command/src/concerns/runtime.rb

@@ -0,0 +1,119 @@
+module Foobara
+  class Command
+    module Concerns
+      module Runtime
+        include Concern
+
+        class CannotHaltWithoutAddingErrors < StandardError; end
+        class Halt < StandardError; end
+
+        module ClassMethods
+          def run(...)
+            new(...).run
+          end
+
+          def run!(...)
+            new(...).run!
+          end
+        end
+
+        attr_reader :outcome, :exception
+
+        def run!
+          run.result!
+        end
+
+        def run
+          Foobara::Namespace.use self.class do
+            invoke_with_callbacks_and_transition(:open_transaction)
+
+            invoke_with_callbacks_and_transition_in_transaction(%i[
+                                                                  cast_and_validate_inputs
+                                                                  load_records
+                                                                  validate_records
+                                                                  validate
+                                                                  run_execute
+                                                                  commit_transaction
+                                                                ])
+
+            invoke_with_callbacks_and_transition(:succeed)
+          end
+
+          @outcome
+        rescue Halt
+          rollback_transaction
+
+          return outcome if state_machine.currently_errored?
+
+          if error_collection.empty?
+            # :nocov:
+            raise CannotHaltWithoutAddingErrors, "Cannot halt without adding errors first. " \
+                                                 "Either add errors or use error! transition instead."
+            # :nocov:
+          end
+
+          state_machine.fail!
+
+          @outcome = Outcome.errors(error_collection)
+        rescue => e
+          @exception = e
+          rollback_transaction
+          state_machine.error!
+          raise
+        end
+
+        def success?
+          outcome&.success?
+        end
+
+        def run_execute
+          result = process_result_using_result_type(execute)
+          @outcome = Outcome.success(result)
+        end
+
+        def succeed
+          # noop but for now helpful for carrying out state transition
+        end
+
+        def validate_records
+          # noop
+        end
+
+        def validate
+          # can override if desired, default is a no-op
+        end
+
+        def halt!
+          raise Halt
+        end
+
+        private
+
+        def invoke_with_callbacks_and_transition_in_transaction(transition_or_transitions)
+          Persistence::EntityBase.using_transactions(transactions) do
+            invoke_with_callbacks_and_transition(transition_or_transitions)
+          end
+        end
+
+        def invoke_with_callbacks_and_transition(transition_or_transitions)
+          result = nil
+
+          if transition_or_transitions.is_a?(Array)
+            transition_or_transitions.each do |transition|
+              result = invoke_with_callbacks_and_transition(transition)
+            end
+          else
+            transition = transition_or_transitions
+
+            state_machine.perform_transition!(transition) do
+              result = send(transition)
+              halt! if has_errors?
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/projects/command/src/concerns/state_machine.rb

@@ -0,0 +1,12 @@
+module Foobara
+  class Command
+    module Concerns
+      module StateMachine
+        def state_machine
+          # It makes me nervous to pass self around. Seems like a design smell.
+          @state_machine ||= Foobara::Command::StateMachine.new(owner: self)
+        end
+      end
+    end
+  end
+end