foobara 0.0.1

data/projects/persistence/src/entity_base.rb

@@ -0,0 +1,114 @@
+module Foobara
+  module Persistence
+    class EntityBase
+      attr_accessor :tables, :name, :entity_attributes_crud_driver
+
+      class << self
+        def using_transactions(existing_transactions, &block)
+          if existing_transactions.empty?
+            block.call
+          elsif existing_transactions.size == 1
+            existing_transaction = existing_transactions.first
+
+            existing_transaction.entity_base.using_transaction(existing_transaction, &block)
+          else
+            existing_transactions.inject(block) do |nested_proc, existing_transaction|
+              proc do
+                existing_transaction.entity_base.using_transaction(existing_transaction, &nested_proc)
+              end
+            end.call
+          end
+        end
+      end
+
+      def initialize(name, entity_attributes_crud_driver:)
+        self.entity_attributes_crud_driver = entity_attributes_crud_driver
+        self.tables = {}
+        self.name = name
+        # TODO: a smell?
+      end
+
+      def register_entity_class(entity_class, table_name: entity_class.full_entity_name)
+        table = EntityBase::Table.new(table_name, self)
+
+        register_table(table)
+      end
+
+      def register_table(table)
+        tables[table.table_name] = table
+      end
+
+      def transaction_key
+        @transaction_key ||= "foobara:tx:#{name}"
+      end
+
+      def current_transaction
+        Thread.foobara_var_get(transaction_key)
+      end
+
+      def set_current_transaction(transaction)
+        Thread.foobara_var_set(transaction_key, transaction)
+      end
+
+      VALID_MODES = [:use_existing, :open_nested, :open_new, nil].freeze
+
+      def using_transaction(existing_transaction, &)
+        transaction(existing_transaction:, &)
+      end
+
+      def transaction(mode = nil, existing_transaction: nil)
+        unless VALID_MODES.include?(mode)
+          # :nocov:
+          raise ArgumentError, "Mode was #{mode} but expected one of #{VALID_MODES}"
+          # :nocov:
+        end
+
+        old_transaction = current_transaction
+
+        if old_transaction&.closed?
+          old_transaction = nil
+        end
+
+        if old_transaction&.currently_open?
+          if mode == :use_existing || existing_transaction == old_transaction
+            if block_given?
+              return yield old_transaction
+            else
+              return old_transaction
+            end
+          elsif mode != :open_nested && mode != :open_new
+            # :nocov:
+            raise "Transaction already open. " \
+                  "Use mode :use_existing if you want to make use of the existing transaction. " \
+                  "Use mode :open_nested if you are actually trying to nest transactions."
+            # :nocov:
+          end
+        end
+
+        unless block_given?
+          return existing_transaction || Transaction.new(self)
+        end
+
+        begin
+          if existing_transaction
+            tx = existing_transaction
+          else
+            tx = Transaction.new(self)
+            tx.open!
+          end
+
+          set_current_transaction(tx)
+          result = yield tx
+          tx.commit! if tx.currently_open? && !existing_transaction
+          result
+        rescue Foobara::Persistence::EntityBase::Transaction::RolledBack # rubocop:disable Lint/SuppressedException
+        rescue => e
+          tx.rollback!(e) if tx.currently_open?
+          raise
+        ensure
+          set_current_transaction(old_transaction)
+        end
+      end
+    end
+  end
+end

data/projects/persistence/src/persistence.rb

@@ -0,0 +1,172 @@
+module Foobara
+  module Persistence
+    class NoTableOrCrudDriverError < StandardError; end
+    class NoTransactionOpenError < StandardError; end
+
+    class << self
+      attr_reader :default_crud_driver
+
+      def default_crud_driver=(crud_driver)
+        if default_crud_driver
+          # :nocov:
+          raise "Default crud driver already set."
+          # :nocov:
+        end
+
+        @default_crud_driver = crud_driver
+      end
+
+      def default_base
+        @default_base ||= if default_crud_driver
+                            base = EntityBase.new(
+                              "default_entity_base",
+                              entity_attributes_crud_driver: default_crud_driver
+                            )
+                            register_base(base)
+                          end
+      end
+
+      # TODO: automatically order these by dependency...
+      # TODO: also, consider automatically opening transactions for dependent entities automatically...
+      def transaction(*objects, mode: nil, &block)
+        # def transaction(mode = nil, existing_transaction: nil)
+        bases = objects_to_bases(objects)
+
+        if bases.empty?
+          # :nocov:
+          raise "No bases found for #{objects}"
+          # :nocov:
+        end
+
+        if bases.size == 1
+          bases.first.transaction(mode, &block)
+        else
+          bases.inject(block) do |nested_proc, base|
+            proc do
+              base.transaction(mode, &nested_proc)
+            end
+          end.call
+        end
+      end
+
+      # TODO: support transactions across multiple bases
+      def current_transaction(object)
+        base = to_base(object)
+        base.current_transaction
+      end
+
+      def current_transaction!(object)
+        base = to_base(object)
+        tx = base.current_transaction
+
+        unless tx
+          # :nocov:
+          raise NoTransactionOpenError
+          # :nocov:
+        end
+
+        tx
+      end
+
+      def current_transaction_table!(object)
+        current_transaction!(object).table_for(object)
+      end
+
+      def current_transaction_table(object)
+        current_transaction(object).table_for(object)
+      end
+
+      def to_base(object)
+        bases = to_bases(object)
+
+        if bases.empty?
+          # :nocov:
+          raise "Could not find a base for #{object}"
+          # :nocov:
+        end
+
+        if bases.size > 1
+          # :nocov:
+          raise "Expected to only find 1 base for #{object} but found #{bases.size}"
+          # :nocov:
+        end
+
+        bases.first
+      end
+
+      def to_bases(object)
+        objects_to_bases(Util.array(object))
+      end
+
+      def objects_to_bases(objects)
+        objects.map do |object|
+          object_to_base(object)
+        end.uniq
+      end
+
+      def object_to_base(object)
+        case object
+        when EntityBase
+          object
+        when ::String
+          bases[object]
+        when ::Symbol
+          bases[object.to_s]
+        when Class
+          base_for_entity_class(object)
+        when Entity
+          base_for_entity_class(object.class)
+        else
+          # :nocov:
+          raise ArgumentError, "Not able to convert #{object} to an entity base"
+          # :nocov:
+        end
+      end
+
+      def bases
+        @bases ||= {}
+      end
+
+      def base_for_entity_class_name(entity_class_name)
+        table_for_entity_class_name(entity_class_name).entity_base
+      end
+
+      def base_for_entity_class(entity_class)
+        table_for_entity_class_name(entity_class.full_entity_name).entity_base
+      end
+
+      def table_for_entity_class_name(entity_class_name)
+        table = tables_for_entity_class_name[entity_class_name]
+
+        return table if table
+
+        if default_base
+          table = EntityBase::Table.new(entity_class_name, default_base)
+          default_base.register_table(table)
+          tables_for_entity_class_name[entity_class_name] = table
+        else
+          # :nocov:
+          raise NoTableOrCrudDriverError,
+                "Can't find table for #{entity_class_name} and can't dynamically build one without default crud driver."
+          # :nocov:
+        end
+      end
+
+      def register_base(base)
+        # TODO: add some validations here
+        bases[base.name] = base
+      end
+
+      def register_entity(base, entity_class, table_name: entity_class.full_entity_name)
+        base = to_base(base)
+
+        table = base.register_entity_class(entity_class, table_name:)
+        tables_for_entity_class_name[entity_class.full_entity_name] = table
+      end
+
+      def tables_for_entity_class_name
+        @tables_for_entity_class_name ||= {}
+      end
+    end
+  end
+end

data/projects/state_machine/lib/foobara/state_machine.rb

@@ -0,0 +1 @@
+class Foobara::StateMachine; end

data/projects/state_machine/src/callbacks.rb

@@ -0,0 +1,158 @@
+module Foobara
+  class StateMachine
+    module Callbacks
+      include Concern
+
+      # owner helps with determining the relevant object when running class-registered state transition callbacks
+      attr_accessor :callback_registry, :owner
+
+      def initialize(owner: nil)
+        self.owner = owner
+        self.callback_registry = Callback::Registry::ChainedConditioned.new(self.class.class_callback_registry)
+      end
+
+      foobara_delegate :callbacks_for,
+                       :has_callbacks?,
+                       :has_before_callbacks?,
+                       :has_after_callbacks?,
+                       :has_around_callbacks?,
+                       :has_error_callbacks?,
+                       :has_failure_callbacks?,
+                       to: :callback_registry
+
+      def register_transition_callback(type, **, &)
+        callback_registry.register_callback(type, **, &)
+      end
+
+      module ClassMethods
+        def class_callback_registry
+          @class_callback_registry ||= Callback::Registry::Conditioned.new(
+            from: states,
+            transition: transitions,
+            to: states
+          )
+        end
+
+        def remove_all_callbacks
+          @class_callback_registry = nil
+        end
+
+        def register_transition_callback(type, **, &)
+          class_callback_registry.register_callback(type, **, &)
+        end
+
+        attr_reader :register_callback_methods
+
+        # 0 before_any_transition
+        # 1 before_transition_to_<state>
+        # 2 before_transition_from_<state>
+        # 3 before_transition_from_<state>_to_<state>
+        # 4 before_<transition>_transition
+        # 5 before_<transition>_transition_to_<state>
+        # 6 before_<transition>_transition_from_<state>
+        def create_register_callback_methods
+          if register_callback_methods
+            # :nocov:
+            raise "Do not create register callback methods twice"
+            # :nocov:
+          end
+
+          callback_methods = @register_callback_methods = []
+
+          tos = Set.new
+          transitions = Set.new
+          froms = Set.new
+
+          froms_to_tos = Set.new
+          transitions_to_tos = Set.new
+          froms_to_transitions = Set.new
+          froms_transitions_tos = Set.new
+
+          transition_map.each_pair do |from, to_map|
+            froms << from
+            to_map.each_pair do |transition, to|
+              transitions << transition
+              tos << to
+              froms_to_tos << [from, to]
+              transitions_to_tos << [transition, to]
+              froms_to_transitions << [from, transition]
+              froms_transitions_tos << [from, transition, to]
+            end
+          end
+
+          Foobara::Callback::Block.types.each do |type|
+            method_name = "#{type}_any_transition"
+            callback_methods << method_name
+
+            define_method method_name do |&block|
+              register_transition_callback(type, &block)
+            end
+
+            froms.each do |from|
+              method_name = "#{type}_transition_from_#{from}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, from:, &block)
+              end
+            end
+
+            transitions.each do |transition|
+              method_name = "#{type}_#{transition}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, transition:, &block)
+              end
+            end
+
+            tos.each do |to|
+              method_name = "#{type}_transition_to_#{to}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, to:, &block)
+              end
+            end
+
+            froms_to_tos.each do |(from, to)|
+              method_name = "#{type}_transition_from_#{from}_to_#{to}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, to:, from:, &block)
+              end
+            end
+
+            transitions_to_tos.each do |(transition, to)|
+              method_name = "#{type}_#{transition}_to_#{to}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, transition:, to:, &block)
+              end
+            end
+
+            froms_to_transitions.each do |(from, transition)|
+              method_name = "#{type}_#{transition}_from_#{from}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, transition:, from:, &block)
+              end
+            end
+
+            froms_transitions_tos.each do |(from, transition, to)|
+              method_name = "#{type}_#{transition}_from_#{from}_to_#{to}"
+              callback_methods << method_name
+
+              define_method method_name do |&block|
+                register_transition_callback(type, transition:, from:, to:, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/state_machine/src/log_entry.rb

@@ -0,0 +1,13 @@
+module Foobara
+  class StateMachine
+    class LogEntry
+      attr_accessor :from, :transition, :to
+
+      def initialize(from:, transition:, to:)
+        self.from = from
+        self.transition = transition
+        self.to = to
+      end
+    end
+  end
+end

data/projects/state_machine/src/state_machine.rb

@@ -0,0 +1,91 @@
+module Foobara
+  require_project_file("state_machine", "sugar")
+  require_project_file("state_machine", "callbacks")
+  require_project_file("state_machine", "validations")
+
+  class StateMachine
+    include Sugar
+    include Callbacks
+    include Validations
+    include TransitionLog
+
+    class InvalidTransition < StandardError; end
+
+    class << self
+      attr_accessor :transitions, :initial_state, :states, :non_terminal_states, :terminal_states, :transition_map,
+                    :raw_transition_map, :state, :transition
+
+      def set_transition_map(transition_map, initial_state: nil, states: nil, terminal_states: nil, transitions: nil)
+        self.raw_transition_map = transition_map
+
+        self.initial_state = initial_state
+        self.states = states
+        self.terminal_states = terminal_states
+        self.transitions = transitions
+
+        desugarize_transition_map
+        determine_states_and_transitions
+
+        create_enums
+        create_state_predicate_methods
+        create_transition_methods
+        create_can_methods
+        create_register_callback_methods
+      end
+    end
+
+    attr_accessor :current_state
+
+    def initialize(*args, **options)
+      super
+
+      self.current_state = self.class.initial_state
+    end
+
+    def perform_transition!(transition, &block)
+      from = current_state
+
+      transition_map = self.class.transition_map
+
+      if in_terminal_state?
+        raise InvalidTransition,
+              "#{current_state} is a terminal state so no transitions from here are allowed."
+      end
+
+      unless transition_map[current_state].key?(transition)
+        raise InvalidTransition,
+              "Cannot perform #{transition} from #{current_state}. Expected one of #{allowed_transitions}."
+      end
+
+      to = transition_map[current_state][transition]
+
+      conditions = { from:, transition:, to: }
+
+      callback_registry.runner(**conditions).callback_data(state_machine: self, **conditions).run do
+        block.call if block_given?
+        update_current_state(**conditions)
+      end
+    end
+
+    def allowed_transitions
+      if in_terminal_state?
+        []
+      else
+        self.class.transition_map[current_state].keys
+      end
+    end
+
+    def can?(transition)
+      self.class.transition_map[current_state].key?(transition)
+    end
+
+    def update_current_state(**conditions)
+      self.current_state = conditions[:to]
+      log_transition(**conditions)
+    end
+
+    def in_terminal_state?
+      self.class.terminal_states.include?(current_state)
+    end
+  end
+end

data/projects/state_machine/src/sugar.rb

@@ -0,0 +1,125 @@
+module Foobara
+  class StateMachine
+    module Sugar
+      class TransitionAlreadyDefinedError < StandardError; end
+      class BadInitialState < StandardError; end
+
+      include Concern
+
+      module ClassMethods
+        def desugarize_transition_map
+          self.transition_map = {}
+
+          raw_transition_map.each_pair do |from_state, transitions|
+            Util.array(from_state).each do |state|
+              state = state.to_sym
+
+              transitions.each_pair do |transition, next_state|
+                transition = transition.to_sym
+                next_state = next_state.to_sym
+
+                transitions_for_state = transition_map[state] ||= {}
+
+                if transitions_for_state.key?(transition)
+                  # :nocov:
+                  raise TransitionAlreadyDefinedError, "There's already a #{transition} for #{state}"
+                  # :nocov:
+                end
+
+                transitions_for_state[transition] = next_state
+              end
+            end
+          end
+
+          transition_map.freeze
+        end
+
+        def determine_states_and_transitions
+          computed_non_terminal_states = transition_map.keys.uniq
+          computed_terminal_states = []
+          computed_transitions = []
+
+          transition_map.each_value do |transitions|
+            transitions.each_pair do |transition, to_state|
+              computed_transitions << transition unless computed_transitions.include?(transition)
+
+              if !computed_non_terminal_states.include?(to_state) && !computed_terminal_states.include?(to_state)
+                computed_terminal_states << to_state
+              end
+            end
+          end
+
+          if terminal_states
+            all_states = computed_non_terminal_states + computed_terminal_states
+            validate_terminal_states(computed_terminal_states, all_states)
+            # User has marked states as explicitly terminal even though they might have transitions
+            # This is allowed. So fix any such computations.
+            computed_non_terminal_states -= terminal_states
+            computed_terminal_states |= terminal_states
+          else
+            self.terminal_states = computed_terminal_states.freeze
+          end
+
+          self.non_terminal_states = computed_non_terminal_states.freeze
+
+          computed_states = computed_non_terminal_states + computed_terminal_states
+
+          if states
+            validate_states(computed_states)
+          else
+            self.states = computed_states.freeze
+          end
+
+          if transitions
+            validate_transitions(computed_transitions)
+          else
+            self.transitions = computed_transitions.freeze
+          end
+
+          if initial_state
+            unless states.include?(initial_state)
+              raise BadInitialState, "Initial state explicitly set to #{
+                initial_state
+              } but should have been one of #{states}"
+            end
+          else
+            self.initial_state = states.first
+          end
+        end
+
+        def create_enums
+          self.state = Enumerated::Values.new(states)
+          self.transition = Enumerated::Values.new(transitions)
+        end
+
+        def create_state_predicate_methods
+          states.each do |state|
+            define_method "currently_#{state}?" do
+              current_state == state
+            end
+
+            define_method "ever_#{state}?" do
+              current_state == state || log.any? { |log_entry| log_entry.from == state }
+            end
+          end
+        end
+
+        def create_can_methods
+          transitions.each do |transition|
+            define_method "can_#{transition}?" do
+              can?(transition)
+            end
+          end
+        end
+
+        def create_transition_methods
+          transitions.each do |transition|
+            define_method "#{transition}!" do |&block|
+              perform_transition!(transition, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/state_machine/src/transition_log.rb

@@ -0,0 +1,19 @@
+module Foobara
+  class StateMachine
+    module TransitionLog
+      include Concern
+
+      attr_accessor :log
+
+      def initialize(*args, **options)
+        super
+
+        self.log = []
+      end
+
+      def log_transition(**)
+        log << LogEntry.new(**)
+      end
+    end
+  end
+end