foobara 0.0.1

data/projects/callback/src/block/around.rb

@@ -0,0 +1,10 @@
+module Foobara
+  module Callback
+    class Block
+      class Around < Block
+        include Concerns::KeywordArgumentableBlock
+        include Concerns::BlockParameterRequired
+      end
+    end
+  end
+end

data/projects/callback/src/block/before.rb

@@ -0,0 +1,10 @@
+module Foobara
+  module Callback
+    class Block
+      class Before < Block
+        include Concerns::KeywordArgumentableBlock
+        include Concerns::BlockParameterNotAllowed
+      end
+    end
+  end
+end

data/projects/callback/src/block/concerns/block_parameter_not_allowed.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module Callback
+    class Block
+      module Concerns
+        module BlockParameterNotAllowed
+          private
+
+          def validate_original_block!
+            super
+
+            if takes_block?
+              # :nocov:
+              raise ArgumentError, "#{type} callback is not allowed to accept a block"
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/block/concerns/block_parameter_required.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module Callback
+    class Block
+      module Concerns
+        module BlockParameterRequired
+          private
+
+          def validate_original_block!
+            super
+
+            unless takes_block?
+              # :nocov:
+              raise ArgumentError, "#{type} callback must take a block argument"
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/block/concerns/keyword_argumentable_block.rb

@@ -0,0 +1,31 @@
+module Foobara
+  module Callback
+    class Block
+      module Concerns
+        module KeywordArgumentableBlock
+          def to_proc
+            @to_proc ||= if has_keyword_args?
+                           proc do |*args, &block|
+                             keyword_args = args.reduce(:merge) || {}
+                             original_block.call(**keyword_args, &block)
+                           end
+                         else
+                           original_block
+                         end
+          end
+
+          def validate_original_block!
+            super
+
+            if has_keyword_args? && has_positional_args?
+              # TODO: raise a real error
+              # :nocov:
+              raise "Expect #{type} block to either take a positional arg or keyword args but not both"
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/block/concerns/single_argument_block.rb

@@ -0,0 +1,22 @@
+module Foobara
+  module Callback
+    class Block
+      module Concerns
+        module SingleArgumentBlock
+          private
+
+          def validate_original_block!
+            super
+
+            if has_keyword_args?
+              # :nocov:
+              raise ArgumentError,
+                    "Expect #{type} block to only receive one or zero arguments. It cannot take keyword arguments."
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/block/concerns/type.rb

@@ -0,0 +1,17 @@
+module Foobara
+  module Callback
+    class Block
+      module Concerns
+        module Type
+          include Concern
+
+          module ClassMethods
+            def type
+              @type ||= Util.non_full_name_underscore(self)&.gsub(/_block$/, "")&.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/block/error.rb

@@ -0,0 +1,10 @@
+module Foobara
+  module Callback
+    class Block
+      class Error < Block
+        include Concerns::SingleArgumentBlock
+        include Concerns::BlockParameterNotAllowed
+      end
+    end
+  end
+end

data/projects/callback/src/block.rb

@@ -0,0 +1,83 @@
+Foobara::Util.require_directory("#{__dir__}/block")
+
+module Foobara
+  module Callback
+    class Block
+      include Concerns::Type
+
+      class << self
+        def types_to_subclasses
+          @types_to_subclasses ||= subclasses.to_h { |klass| [klass.type, klass] }
+        end
+
+        def types
+          @types ||= types_to_subclasses.keys
+        end
+
+        def for(type, callback)
+          const_get(Util.classify(type)).new(callback)
+        end
+      end
+
+      attr_accessor :original_block
+
+      def initialize(original_block)
+        self.original_block = original_block
+        validate_original_block!
+      end
+
+      foobara_delegate :type, to: :class
+
+      def call(...)
+        to_proc.call(...)
+      end
+
+      def to_proc
+        @to_proc ||= original_block
+      end
+
+      private
+
+      def validate_original_block!
+        unless has_one_or_zero_positional_args?
+          # TODO: raise a real error
+          # :nocov:
+          raise "Can't pass multiple arguments to a callback. Only 1 or 0 arguments."
+          # :nocov:
+        end
+      end
+
+      def takes_block?
+        @takes_block ||= original_block.parameters.last&.first&.==(:block)
+      end
+
+      def has_one_or_zero_positional_args?
+        @has_one_or_zero_positional_args ||= positional_args_count <= 1
+      end
+
+      def has_keyword_args?
+        @has_keyword_args ||= param_types.any? { |type| %i[keyreq keyrest].include?(type) }
+      end
+
+      def has_positional_args?
+        @has_positional_args ||= positional_args_count > 0
+      end
+
+      def param_types
+        @param_types ||= original_block.parameters.map(&:first)
+      end
+
+      def optional_positional_args_count
+        @optional_positional_args_count ||= original_block.parameters.map(&:first).count { |type| type == :opt }
+      end
+
+      def required_positional_args_count
+        @required_positional_args_count ||= original_block.parameters.map(&:first).count { |type| type == :req }
+      end
+
+      def positional_args_count
+        @positional_args_count ||= optional_positional_args_count + required_positional_args_count
+      end
+    end
+  end
+end

data/projects/callback/src/registry/base.rb

@@ -0,0 +1,90 @@
+module Foobara
+  module Callback
+    module Registry
+      class Base
+        def runner(*, **)
+          Runner.new(unioned_callback_set_for(*, **))
+        end
+
+        def register_callback(type, *, **, &callback_block)
+          unless block_given?
+            # :nocov:
+            raise ArgumentError, "Must provide a callback block to register"
+            # :nocov:
+          end
+
+          validate_type!(type)
+
+          set = specific_callback_set_for(*, **)
+
+          set[type] << Block.for(type, callback_block)
+        end
+
+        def specific_callback_set_for(*_args, **_opts)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def unioned_callback_set_for(*_args, **_opts)
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def before(...)
+          register_callback(:before, ...)
+        end
+
+        def after(...)
+          register_callback(:after, ...)
+        end
+
+        def around(...)
+          register_callback(:around, ...)
+        end
+
+        def error(...)
+          register_callback(:error, ...)
+        end
+
+        def has_callbacks?(type, *, **)
+          !unioned_callback_set_for(*, **)[type].empty?
+        end
+
+        def has_before_callbacks?(*, **)
+          has_callbacks?(:before, *, **)
+        end
+
+        def has_after_callbacks?(*, **)
+          has_callbacks?(:after, *, **)
+        end
+
+        def has_around_callbacks?(*, **)
+          has_callbacks?(:around, *, **)
+        end
+
+        def has_error_callbacks?(*, **)
+          has_callbacks?(:error, *, **)
+        end
+
+        attr_writer :allowed_types
+
+        def allowed_types
+          @allowed_types = Block.types
+        end
+
+        private
+
+        def validate_type!(type)
+          unless allowed_types.include?(type)
+            # TODO: raise a real error
+            # :nocov:
+            raise "bad type #{type} expected one of #{allowed_types}"
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/registry/chained_conditioned.rb

@@ -0,0 +1,24 @@
+Foobara.require_project_file("callback", "registry/conditioned")
+
+module Foobara
+  module Callback
+    module Registry
+      class ChainedConditioned < Conditioned
+        attr_accessor :other_conditions_registry
+
+        class InvalidConditions < StandardError; end
+
+        foobara_delegate :possible_conditions, :possible_condition_keys, to: :other_conditions_registry
+
+        def initialize(other_conditions_registry)
+          self.other_conditions_registry = other_conditions_registry
+          super(possible_conditions)
+        end
+
+        def unioned_callback_set_for(...)
+          super.union(other_conditions_registry.unioned_callback_set_for(...))
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/registry/chained_multiple_action.rb

@@ -0,0 +1,24 @@
+Foobara.require_project_file("callback", "registry/multiple_action")
+
+module Foobara
+  module Callback
+    module Registry
+      class ChainedMultipleAction < MultipleAction
+        attr_accessor :other_multiple_actions_registry
+
+        class InvalidConditions < StandardError; end
+
+        foobara_delegate :possible_actions, :allowed_types, to: :other_multiple_actions_registry
+
+        def initialize(other_multiple_actions_registry)
+          self.other_multiple_actions_registry = other_multiple_actions_registry
+          super(possible_actions)
+        end
+
+        def unioned_callback_set_for(...)
+          super.union(other_multiple_actions_registry.unioned_callback_set_for(...))
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/registry/conditioned.rb

@@ -0,0 +1,101 @@
+Foobara.require_project_file("callback", "registry/base")
+
+module Foobara
+  module Callback
+    module Registry
+      class Conditioned < Base
+        attr_accessor :possible_conditions, :possible_condition_keys, :callback_sets
+
+        class InvalidConditions < StandardError; end
+
+        def initialize(possible_conditions)
+          super()
+
+          self.callback_sets = {}
+          self.possible_conditions = possible_conditions
+          self.possible_condition_keys = possible_conditions.keys.map(&:to_s).sort.map(&:to_sym)
+        end
+
+        def specific_callback_set_for(*args, **opts)
+          conditions = Util.args_and_opts_to_opts(args, opts)
+          validate_conditions!(**conditions) # TODO: don't always have to validate this...
+          key = condition_hash_to_callback_key(conditions)
+          callback_sets[key] ||= Callback::Set.new
+        end
+
+        def unioned_callback_set_for(**conditions)
+          return specific_callback_set_for if conditions.empty?
+
+          full_callback_key = condition_hash_to_callback_key(conditions)
+          all_sets = callback_key_permutations(full_callback_key).map do |callback_key|
+            callback_sets[callback_key]
+          end.compact
+
+          all_sets.inject { |unioned, set| unioned.union(set) } || Callback::Set.new
+        end
+
+        private
+
+        def validate_conditions!(**conditions)
+          unless conditions.is_a?(Hash)
+            # :nocov:
+            raise InvalidConditions, "Expected a hash"
+            # :nocov:
+          end
+
+          conditions.each_pair do |condition_name, condition_value|
+            unless possible_condition_keys.include?(condition_name)
+              raise InvalidConditions,
+                    "Invalid condition name #{condition_name} expected one of #{possible_condition_keys}"
+            end
+
+            next if condition_value.nil?
+
+            possible_values = possible_conditions[condition_name]
+
+            unless possible_values.include?(condition_value)
+              raise InvalidConditions,
+                    "Invalid condition value #{
+                      condition_value
+                    }: expected nil or one of #{possible_values} but got #{condition_value}"
+
+            end
+          end
+        end
+
+        def condition_hash_to_callback_key(hash)
+          possible_condition_keys.map do |condition|
+            hash[condition]
+          end
+        end
+
+        # we need to fetch callbacks for every possible way a specified condition could be omitted
+        # so for example...
+        # let's say possible conditions are :a, :b, :c
+        # and we are given callbacks_for(:before, a: 1, c: 2)
+        # well then b is always nil meaning b can be anything.
+        # so we need the callbacks that were registered for the following keys...
+        # [1, nil, 2] (conditions that were passed in, the most specific callbacks)
+        # [1, nil, nil]
+        # [nil, nil, 2]
+        # [nil, nil, nil] (all :before callbacks for any conditions)
+        # So what is the logic that generates this behavior?
+        # What we could do is take the indexes of non-nil values and then create the powerset of those.
+        # This would then create a list of which indexes to keep and which to nil out.
+        def callback_key_permutations(full_callback_key)
+          non_nil_indices = []
+
+          full_callback_key.each.with_index do |condition_value, index|
+            non_nil_indices << index if condition_value
+          end
+
+          Util.power_set(non_nil_indices).map do |indices_to_exclude|
+            indices_to_exclude.each_with_object(full_callback_key.dup) do |index, condition_key|
+              condition_key[index] = nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/registry/multiple_action.rb

@@ -0,0 +1,110 @@
+Foobara.require_project_file("callback", "registry/base")
+
+module Foobara
+  module Callback
+    module Registry
+      class MultipleAction < Base
+        attr_accessor :callback_sets, :possible_actions
+
+        class InvalidAction < StandardError; end
+
+        def initialize(*possible_actions)
+          super()
+
+          self.callback_sets = {}
+
+          possible_actions = normalize_actions(possible_actions, false)
+
+          self.possible_actions = possible_actions.map(&:to_s).sort.map(&:to_sym)
+        end
+
+        def runner(*actions)
+          super(*normalize_actions(actions))
+        end
+
+        def before(*actions, &)
+          super(*normalize_actions(actions), &)
+        end
+
+        def after(*actions, &)
+          super(*normalize_actions(actions), &)
+        end
+
+        def around(*actions, &)
+          super(*normalize_actions(actions), &)
+        end
+
+        def error(*actions, &)
+          super(*normalize_actions(actions), &)
+        end
+
+        def specific_callback_set_for(*actions)
+          action = normalize_action(actions)
+
+          validate_action!(action)
+          callback_sets[action] ||= Callback::Set.new
+        end
+
+        def unioned_callback_set_for(*actions)
+          action = normalize_action(actions)
+
+          if action.nil?
+            callback_sets.values.reduce(:|) || Callback::Set.new
+          else
+            specific_callback_set_for(nil) | specific_callback_set_for(action)
+          end
+        end
+
+        private
+
+        def validate_action!(action)
+          if !action.nil? && !possible_actions.include?(action)
+            raise InvalidAction,
+                  "Invalid action #{action.inspect} expected nil or one of #{possible_actions}"
+          end
+        end
+
+        def validate_actions!(actions)
+          actions.each { |action| validate_action!(action) }
+        end
+
+        def normalize_action(actions)
+          case actions.size
+          when 0
+            nil
+          when 1
+            action = actions.first
+            validate_action!(action)
+            action
+          else
+            # :nocov:
+            raise ArgumentError, "Can either pass an action or not but can't pass multiple"
+            # :nocov:
+          end
+        end
+
+        def normalize_actions(actions, validate = true)
+          first = actions.first
+
+          if first.is_a?(Array)
+            if actions.size == 1
+              normalize_actions(first, validate)
+            else
+              # :nocov:
+              raise ArgumentError, "Not expecting an array of arrays, expected an array of actions"
+              # :nocov:
+            end
+          elsif actions.empty?
+            [nil]
+          else
+            if validate
+              validate_actions!(actions)
+            end
+
+            actions
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/registry/single_action.rb

@@ -0,0 +1,15 @@
+module Foobara
+  module Callback
+    module Registry
+      class SingleAction < Base
+        def specific_callback_set_for
+          @specific_callback_set_for ||= Callback::Set.new
+        end
+
+        def unioned_callback_set_for
+          specific_callback_set_for
+        end
+      end
+    end
+  end
+end

data/projects/callback/src/runner.rb

@@ -0,0 +1,89 @@
+module Foobara
+  module Callback
+    class Runner
+      class UnexpectedErrorWhileRunningCallback < StandardError
+        attr_accessor :callback_data
+
+        def initialize(callback_data, error)
+          super(error.message)
+
+          self.callback_data = callback_data
+        end
+      end
+
+      attr_accessor :callback_set, :error
+      attr_writer :callback_data
+
+      def initialize(callback_set)
+        self.callback_set = callback_set
+      end
+
+      def has_callback_data?
+        defined?(@callback_data)
+      end
+
+      def callback_data(*args, **opts)
+        return @callback_data if args.empty? && opts.empty?
+
+        self.callback_data = Util.args_and_opts_to_opts(args, opts)
+
+        self
+      end
+
+      def run(&do_it)
+        if block_given?
+          callback_set.each_before do |callback|
+            run_callback(callback)
+          end
+
+          around_callback = callback_set.around.inject(do_it) do |nested_proc, callback|
+            proc do
+              run_callback(callback, &nested_proc)
+            end
+          end
+
+          run_callback(around_callback)
+        else
+          # TODO: raise better errors
+          if callback_set.has_before_callbacks?
+            # :nocov:
+            raise
+            # :nocov:
+          end
+          if callback_set.has_around_callbacks?
+            # :nocov:
+            raise
+            # :nocov:
+          end
+        end
+
+        callback_set.each_after do |callback|
+          run_callback(callback)
+        end
+      rescue => real_error
+        begin
+          raise UnexpectedErrorWhileRunningCallback.new(callback_data, real_error)
+          # this non-sense is just to set the Error#cause properly
+        rescue UnexpectedErrorWhileRunningCallback => e
+          self.error = e
+
+          callback_set.each_error do |callback|
+            run_callback(callback)
+          end
+        end
+
+        raise
+      end
+
+      def run_callback(callback, &)
+        if error
+          callback.call(error)
+        elsif has_callback_data?
+          callback.call(callback_data, &)
+        else
+          callback.call(&)
+        end
+      end
+    end
+  end
+end