foobara 0.0.1

data/projects/callback/src/set.rb

@@ -0,0 +1,56 @@
+module Foobara
+  module Callback
+    class Set
+      attr_accessor :callbacks
+
+      def initialize(callback_hash = {})
+        self.callbacks = {}
+
+        callback_hash.each do |type, blocks|
+          send("#{type}=", blocks.dup)
+        end
+      end
+
+      foobara_delegate :size, to: :callbacks
+
+      def union(set)
+        unioned = Set.new(callbacks)
+
+        set.callbacks.each_pair do |type, blocks|
+          next if blocks.empty?
+
+          unioned_blocks = unioned[type]
+          blocks.each { |block| unioned_blocks << block }
+        end
+
+        unioned
+      end
+
+      def |(other)
+        union(other)
+      end
+
+      def [](type)
+        send(type)
+      end
+
+      Block.types.each do |type|
+        define_method type do
+          callbacks[type] ||= []
+        end
+
+        define_method "#{type}=" do |blocks|
+          callbacks[type] ||= blocks
+        end
+
+        define_method "each_#{type}" do |&block|
+          send(type).each(&block)
+        end
+
+        define_method "has_#{type}_callbacks?" do
+          !send(type).empty?
+        end
+      end
+    end
+  end
+end

data/projects/command/lib/foobara/command.rb

@@ -0,0 +1,9 @@
+module Foobara
+  class Command
+    class << self
+      def install!
+        Namespace.global.foobara_add_category_for_subclass_of(:command, self)
+      end
+    end
+  end
+end

data/projects/command/src/command/entity_helpers.rb

@@ -0,0 +1,145 @@
+module Foobara
+  class Command
+    module EntityHelpers
+      module_function
+
+      def type_declaration_for_record_aggregate_update(entity_class, initial = true)
+        declaration = entity_class.attributes_type.declaration_data
+        # TODO: just slice out the element type declarations
+        declaration = Util.deep_dup(declaration)
+
+        declaration.delete(:defaults)
+        declaration.delete(:required)
+
+        if initial
+          declaration[:required] = [entity_class.primary_key_attribute]
+        end
+
+        entity_class.associations.each_pair do |data_path, type|
+          if type.extends?(BuiltinTypes[:entity])
+            target_class = type.target_class
+
+            entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
+            entry.clear
+            entry.merge!(type_declaration_for_record_aggregate_update(target_class, false))
+          end
+        end
+
+        declaration
+      end
+
+      def type_declaration_for_record_atom_update(entity_class)
+        declaration = entity_class.attributes_type.declaration_data
+        # TODO: just slice out the element type declarations
+        declaration = Util.deep_dup(declaration)
+
+        declaration.delete(:defaults)
+        declaration[:required] = [entity_class.primary_key_attribute]
+
+        # expect all associations to be expressed as primary key values
+        # TODO: should we have a special type for encapsulating primary keys types??
+        entity_class.associations.each_pair do |data_path, type|
+          if type.extends?(BuiltinTypes[:entity])
+            target_class = type.target_class
+            # TODO: do we really need declaration_data? Why cant we use the type directly?
+            # TODO: make this work with the type directly for performance reasons.
+            primary_key_type_declaration = target_class.primary_key_type.declaration_data
+            entry = type_declaration_value_at(declaration, DataPath.new(data_path).path)
+            entry.clear
+            entry.merge!(primary_key_type_declaration)
+          end
+        end
+
+        declaration
+      end
+
+      def type_declaration_for_find_by(entity_class)
+        element_type_declarations = {}
+
+        entity_class.attributes_type.element_types.each_pair do |attribute_name, attribute_type|
+          element_type_declarations[attribute_name] = attribute_type.reference_or_declaration_data
+        end
+
+        handler = Domain.global.foobara_type_builder.handler_for_class(
+          TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
+        )
+
+        handler.desugarize(
+          type: "::attributes",
+          element_type_declarations:
+        )
+      end
+
+      def update_aggregate(object, value, type = object.class.model_type)
+        return value if object.nil?
+
+        if type.extends?(BuiltinTypes[:model])
+          element_types = type.element_types.element_types
+
+          value.each_pair do |attribute_name, new_value|
+            current_value = object.read_attribute(attribute_name)
+
+            attribute_type = element_types[attribute_name]
+
+            updated_value = update_aggregate(current_value, new_value, attribute_type)
+
+            object.write_attribute(attribute_name, updated_value)
+          end
+
+          object
+        elsif type.extends?(BuiltinTypes[:attributes])
+          element_types = type.element_types
+
+          object = object.dup
+          object ||= {}
+
+          value.each_pair do |attribute_name, new_value|
+            current_value = object[attribute_name]
+            attribute_type = element_types[attribute_name]
+
+            updated_value = update_aggregate(current_value, new_value, attribute_type)
+
+            object[attribute_name] = updated_value
+          end
+
+          object
+        elsif type.extends?(BuiltinTypes[:tuple])
+          # :nocov:
+          raise "Tuple not yet supported"
+        # :nocov:
+        elsif type.extends?(BuiltinTypes[:associative_array])
+          # :nocov:
+          raise "Associated array not yet supported"
+        # :nocov:
+        elsif type.extends?(BuiltinTypes[:array])
+          element_type = type.element_type
+
+          value.map.with_index do |element, index|
+            update_aggregate(object[index], element, element_type)
+          end
+        else
+          value
+        end
+      end
+
+      def type_declaration_value_at(declaration, path_parts)
+        return declaration if path_parts.empty?
+
+        path_part, *path_parts = path_parts
+
+        declaration = case path_part
+                      when :"#"
+                        declaration[:element_type_declaration]
+                      when Symbol, Integer
+                        declaration[:element_type_declarations][path_part]
+                      else
+                        # :nocov:
+                        raise "Bad path part #{path_part}"
+                        # :nocov:
+                      end
+
+        type_declaration_value_at(declaration, path_parts)
+      end
+    end
+  end
+end

data/projects/command/src/command.rb

@@ -0,0 +1,36 @@
+module Foobara
+  class Command
+    include TruncatedInspect
+
+    include Concerns::Description
+    include Concerns::Namespace
+
+    include Concerns::InputsType
+    include Concerns::ErrorsType
+    include Concerns::ResultType
+
+    include Concerns::Inputs
+    include Concerns::Errors
+    include Concerns::Result
+
+    include Concerns::Runtime
+    include Concerns::Callbacks
+    include Concerns::StateMachine
+    include Concerns::Transactions
+    include Concerns::Entities
+    include Concerns::Subcommands
+    include Concerns::DomainMappers
+    include Concerns::Reflection
+
+    attr_reader :raw_inputs
+
+    def initialize(inputs = {})
+      @raw_inputs = inputs
+      super()
+    end
+  end
+
+  Command.after_subclass_defined do |subclass|
+    Command.all << subclass
+  end
+end

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

@@ -0,0 +1,93 @@
+module Foobara
+  class Command
+    module Concerns
+      module Callbacks
+        include Concern
+
+        module ClassMethods
+          def subclass_defined_callbacks
+            @subclass_defined_callbacks ||= Foobara::Callback::Registry::SingleAction.new
+          end
+
+          def inherited(subclass)
+            super
+
+            subclass_defined_callbacks.runner.callback_data(subclass).run
+          end
+
+          def after_subclass_defined(&)
+            subclass_defined_callbacks.register_callback(:after, &)
+          end
+
+          def callback_state_machine_target
+            Foobara::Command::StateMachine
+          end
+
+          foobara_delegate :remove_all_callbacks, to: :callback_state_machine_target
+        end
+
+        on_include do
+          [self, singleton_class].each do |target|
+            %i[before after].each do |type|
+              target.define_method "#{type}_any_transition" do |&block|
+                callback_state_machine_target.register_transition_callback(type) do |state_machine:, **args|
+                  block.call(command: state_machine.owner, **args)
+                end
+              end
+            end
+
+            target.define_method "around_any_transition" do |&block|
+              callback_state_machine_target.register_transition_callback(
+                :around
+              ) do |state_machine:, **args, &do_transition_block|
+                block.call(command: state_machine.owner, **args, &do_transition_block)
+              end
+            end
+
+            target.define_method :error_any_transition do |&block|
+              callback_state_machine_target.register_transition_callback(:error) do |error|
+                callback_data = error.callback_data
+
+                state_machine = callback_data[:state_machine]
+                command = state_machine.owner
+                from = callback_data[:from]
+                transition = callback_data[:transition]
+                to = callback_data[:to]
+
+                block.call(error:, command:, state_machine:, from:, to:, transition:)
+              end
+            end
+          end
+
+          Foobara::Command::StateMachine.transitions.each do |transition|
+            [self, singleton_class].each do |target|
+              %i[before after].each do |type|
+                target.define_method "#{type}_#{transition}" do |&block|
+                  callback_state_machine_target.register_transition_callback(
+                    type, transition:
+                  ) do |state_machine:, **args|
+                    block.call(command: state_machine.owner, **args)
+                  end
+                end
+              end
+
+              target.define_method "around_#{transition}" do |&block|
+                callback_state_machine_target.register_transition_callback(
+                  :around, transition:
+                ) do |state_machine:, **args, &do_transition_block|
+                  block.call(command: state_machine.owner, **args, &do_transition_block)
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def callback_state_machine_target
+          state_machine
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Foobara
+  class Command
+    module Concerns
+      module Description
+        include Concern
+
+        module ClassMethods
+          def description(*args)
+            if args.empty?
+              @description
+            elsif args.size == 1
+              @description = args.first
+            else
+              # :nocov:
+              raise ArgumentError, "wrong number of arguments (#{args.size} for 0 or 1)"
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Foobara
+  class Command
+    module Concerns
+      module DomainMappers
+        include Concern
+
+        def run_mapped_subcommand!(subcommand_class, unmapped_inputs)
+          inputs = domain_map!(unmapped_inputs, to: subcommand_class, strict: true)
+
+          result = run_subcommand!(subcommand_class, inputs)
+
+          result_mapper = self.class.domain.foobara_domain_mapper_registry.lookup(
+            from: result,
+            to: result_type,
+            strict: true
+          )
+
+          if result_mapper
+            result_mapper.map(result)
+          else
+            result
+          end
+        end
+
+        def domain_map(...)
+          self.class.domain.foobara_domain_map(...)
+        end
+
+        def domain_map!(...)
+          self.class.domain.foobara_domain_map!(...)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Foobara
+  class Command
+    module Concerns
+      module Entities
+        include Concern
+
+        module ClassMethods
+          # Only needed for entities not discoverable through the inputs
+          def depends_on_entities(*entities_to_add)
+            if entities_to_add.empty?
+              @depends_on_entities ||= Set.new
+            else
+              entities_to_add.each do |entity_class|
+                depends_on_entity(entity_class)
+              end
+            end
+          end
+
+          def depends_on_entity(entity_class)
+            depends_on_entities << entity_class
+          end
+
+          def entity_class_paths
+            # TODO: bust this cache when changing inputs_type??
+            @entity_class_paths ||= Entity.construct_associations(
+              inputs_type
+            ).transform_values(&:target_class)
+          end
+
+          # TODO: move to better concern!
+          # TODO: make work with inheritance
+          def to_load(*paths)
+            h = @to_load_paths_and_error_classes || {}
+
+            paths.each do |path|
+              path = DataPath.new(path)
+              entity_class = entity_class_paths[path.to_s]
+              error_class = Entity::NotFoundError.subclass(self, entity_class, path)
+              h[path.to_s] = error_class
+              possible_error(error_class)
+            end
+
+            @to_load_paths_and_error_classes = h.sort_by do |path, _error_class|
+              [DataPath.new(path).path.size, path]
+            end.to_h
+          end
+
+          def load_all
+            to_load(*entity_class_paths.keys)
+          end
+
+          def to_load_paths_and_error_classes
+            @to_load_paths_and_error_classes
+          end
+        end
+
+        def load_entities(data_path)
+          error_class = self.class.to_load_paths_and_error_classes[data_path.to_s]
+          entity_class = error_class.entity_class
+
+          thunks = DataPath.values_at(data_path, inputs)
+
+          thunks_to_load = thunks.reject(&:created?)
+
+          begin
+            # here... filter out created entities...
+            if thunks_to_load.size == 1
+              entity_class.load(thunks_to_load.first)
+            else
+              entity_class.load_many(thunks_to_load)
+            end
+
+            thunks_to_load
+          rescue Entity::NotFoundError => e
+            add_runtime_error(error_class.new(e.criteria))
+          end
+        end
+
+        # TODO: make this work with collections...
+        def load_records
+          self.class.to_load.each_key do |data_path|
+            load_entities(data_path)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+module Foobara
+  class Command
+    module Concerns
+      module Errors
+        include Concern
+
+        module ClassMethods
+          def lookup_input_error_class(symbol, path)
+            key = ErrorKey.new(symbol:, path:, category: :data)
+            key = key.to_s_type
+
+            unless error_context_type_map.key?(key)
+              # :nocov:
+              raise "No error class was registered for #{key}"
+              # :nocov:
+            end
+
+            error_context_type_map[key].error_class
+          end
+
+          def lookup_runtime_error_class(symbol)
+            key = ErrorKey.new(symbol:, category: :runtime)
+            key = key.to_s_type
+
+            unless error_context_type_map.key?(key)
+              # :nocov:
+              raise "No error class was registered for #{key}"
+              # :nocov:
+            end
+
+            error_context_type_map[key].error_class
+          end
+
+          def lookup_error_class(key)
+            key = ErrorKey.to_s_type(key)
+
+            unless error_context_type_map.key?(key)
+              # :nocov:
+              raise "No error class was registered for #{key}"
+              # :nocov:
+            end
+
+            error_context_type_map[key].error_class
+          end
+        end
+
+        attr_reader :error_collection
+
+        def initialize
+          @error_collection = ErrorCollection.new
+        end
+
+        foobara_delegate :has_errors?, to: :error_collection
+
+        private
+
+        def add_error(error)
+          error = process_error(error)
+          error_collection.add_error(error)
+        end
+
+        def add_input_error(*args, **opts)
+          error = if args.size == 1 && opts.empty?
+                    error = args.first
+
+                    unless error.is_a?(Value::DataError)
+                      # :nocov:
+                      raise ArgumentError, "expected an DataError or keyword arguments to construct one"
+                      # :nocov:
+                    end
+
+                    error
+                  elsif args.empty? || (args.size == 1 && args.first.is_a?(Hash))
+                    error_args = opts.merge(args.first || {})
+                    symbol = error_args[:symbol]
+                    path = Util.array(error_args[:input] || error_args[:path])
+
+                    error_args = error_args.except(:input)
+
+                    unless symbol
+                      # :nocov:
+                      raise ArgumentError, "missing error symbol"
+                      # :nocov:
+                    end
+
+                    unless path
+                      # :nocov:
+                      raise ArgumentError, "missing input"
+                      # :nocov:
+                    end
+
+                    error_class = self.class.lookup_input_error_class(symbol, path)
+                    error_class.new(**error_args.merge(path:))
+                  elsif args.size == 2 || args.size == 3
+                    input, symbol, message = args
+                    context = opts
+
+                    error_class = self.class.lookup_input_error_class(symbol, input)
+                    error_class.new(path: Util.array(input), symbol:, context:, message:)
+                  else
+                    # :nocov:
+                    raise ArgumentError,
+                          "Invalid arguments given. Expected an error or args for an error"
+                    # :nocov:
+                  end
+
+          add_error(error)
+        end
+
+        def add_subcommand_error(subcommand, error)
+          error.runtime_path = [subcommand.class.full_command_symbol, *Util.array(error.runtime_path)]
+          add_error(error)
+          halt!
+        end
+
+        def add_runtime_error(*args, halt: true, **opts)
+          error = if args.size == 1 && opts.empty? && (
+            args.first.is_a?(::Class) || args.first.is_a?(Foobara::RuntimeError)
+          )
+                    error = args.first
+
+                    if error.is_a?(::Class) && error < Foobara::RuntimeError
+                      error = error.new
+                    end
+
+                    unless error.is_a?(Foobara::RuntimeError)
+                      # :nocov:
+                      raise ArgumentError,
+                            "expected a Foobara::RuntimeError or keyword arguments to construct one"
+                      # :nocov:
+                    end
+
+                    error
+                  elsif args.empty? || (args.size == 1 && args.first.is_a?(Hash))
+                    error_args = opts.merge(args.first || {})
+                    symbol = error_args[:symbol]
+
+                    unless symbol
+                      # :nocov:
+                      raise ArgumentError, "missing error symbol"
+                      # :nocov:
+                    end
+
+                    error_class = self.class.lookup_runtime_error_class(symbol)
+                    error_class.new(**error_args)
+                  elsif args.is_a?(::Array) && (args.size == 1 || args.size == 2)
+                    symbol, message = args
+                    context = opts
+
+                    error_class = self.class.lookup_runtime_error_class(symbol)
+                    error_class.new(symbol:, context:, message:)
+                  else
+                    # :nocov:
+                    raise ArgumentError, "Invalid arguments given. Expected an error or args/opts to build error"
+                    # :nocov:
+                  end
+
+          add_error(error)
+          if halt
+            halt!
+          else
+            error
+          end
+        end
+
+        def process_error(error)
+          return error unless error.runtime_path.empty?
+
+          context = error.context
+
+          error_class = self.class.lookup_error_class(error.key)
+          context_type = error_class.context_type
+
+          error.context = context_type.process_value!(context || {})
+
+          error
+        end
+      end
+    end
+  end
+end