foobara 0.0.1

data/projects/state_machine/src/validations.rb

@@ -0,0 +1,69 @@
+module Foobara
+  class StateMachine
+    module Validations
+      include Concern
+
+      class UnexpectedTerminalStates < StandardError; end
+      class MissingStates < StandardError; end
+      class ExtraStates < StandardError; end
+      class MissingTransitions < StandardError; end
+      class ExtraTransitions < StandardError; end
+      class MissingTerminalStates < StandardError; end
+
+      module ClassMethods
+        def validate_terminal_states(computed_terminal_states, all_states)
+          unexpected_terminal_states = computed_terminal_states - terminal_states
+
+          unless unexpected_terminal_states.empty?
+            raise UnexpectedTerminalStates, "#{
+            unexpected_terminal_states
+          } do(es) not have transitions even though they are not in the explicit list of terminal states #{
+            terminal_states
+          }"
+          end
+
+          missing_terminal_states = terminal_states - all_states
+
+          unless missing_terminal_states.empty?
+            raise MissingTerminalStates, "#{
+            missing_terminal_states
+          } was/were included explicitly in terminal_states but didn't appear in the transition map"
+          end
+        end
+
+        def validate_states(computed_states)
+          missing_states = states - computed_states
+
+          unless missing_states.empty?
+            raise MissingStates,
+                  "#{missing_states} is/are explicitly declared as states but do(es)n't appear in the transition map"
+          end
+
+          extra_states = computed_states - states
+
+          unless extra_states.empty?
+            raise ExtraStates,
+                  "#{extra_states} appeared in the transition map but were not explicitly declared as states"
+          end
+        end
+
+        def validate_transitions(computed_transitions)
+          missing_transitions = transitions - computed_transitions
+
+          unless missing_transitions.empty?
+            raise MissingTransitions, "#{
+            missing_transitions
+          } is/are explicitly declared as transitions but do(es)n't appear in the transition map"
+          end
+
+          extra_transitions = computed_transitions - transitions
+
+          unless extra_transitions.empty?
+            raise ExtraTransitions,
+                  "#{extra_transitions} appeared in the transition map but were not explicitly declared as transitions"
+          end
+        end
+      end
+    end
+  end
+end

data/projects/thread_parent/lib/foobara/thread_parent.rb

@@ -0,0 +1 @@
+module Foobara::ThreadParent; end

data/projects/thread_parent/src/thread_parent.rb

@@ -0,0 +1,38 @@
+module Foobara
+  module ThreadParent
+    module ThreadClassExtensions
+      def new(...)
+        super.tap { |thread| thread.instance_variable_set("@foobara_parent", Thread.current) }
+      end
+    end
+  end
+end
+
+class Thread
+  class << self
+    prepend(Foobara::ThreadParent::ThreadClassExtensions)
+
+    def foobara_var_get(...)
+      Thread.current.foobara_var_get(...)
+    end
+
+    def foobara_var_set(...)
+      Thread.current.foobara_var_set(...)
+    end
+  end
+
+  attr_reader :foobara_parent
+
+  # NOTE: because there's not a way to unset a thread variable, storing nil is used as deletion.
+  # this means that a thread local variable with nil can't have any semantic meaning and should be
+  # treated the same as if #thread_variable? had returned false.
+  def foobara_var_get(...)
+    value = thread_variable_get(...)
+
+    value.nil? ? foobara_parent&.foobara_var_get(...) : value
+  end
+
+  def foobara_var_set(...)
+    thread_variable_set(...)
+  end
+end

data/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -0,0 +1,131 @@
+module Foobara
+  module TypeDeclarations
+    class << self
+      def reset_all
+        # TODO: this doesn't really belong here. I think we need to maybe call reset in reverse order?
+        Foobara::Domain::DomainModuleExtension.all.each do |domain|
+          var = "@foobara_type_builder"
+
+          if domain.instance_variable_defined?(var)
+            domain.remove_instance_variable(var)
+          end
+        end
+
+        Util.descendants(Error).each do |error_class|
+          if error_class.instance_variable_defined?(:@context_type)
+            error_class.remove_instance_variable(:@context_type)
+          end
+        end
+
+        %w[
+          foobara_children
+          foobara_registry
+          foobara_type_builder
+        ].each do |var_name|
+          var_name = "@#{var_name}"
+
+          # Don't we only have to do this for Foobara and not all of these??
+          [
+            Namespace.global,
+            Foobara::GlobalOrganization,
+            Foobara::GlobalDomain,
+            Domain,
+            Command,
+            Types::Type,
+            Value::Processor,
+            Error
+          ].each do |klass|
+            klass.remove_instance_variable(var_name) if klass.instance_variable_defined?(var_name)
+          end
+        end
+
+        if GlobalDomain.const_defined?(:Types, false)
+          GlobalDomain::Types.instance_variable_set(
+            :@foobara_lowercase_constants,
+            @original_foobara_lowercase_constants || []
+          )
+        end
+
+        @original_scoped.each do |scoped|
+          Namespace.global.foobara_register(scoped)
+        end
+
+        @original_children.each do |child|
+          Namespace.global.foobara_children << child
+        end
+
+        GlobalDomain.foobara_parent_namespace = GlobalOrganization
+        GlobalOrganization.foobara_register(GlobalDomain)
+
+        register_type_declaration(Handlers::RegisteredTypeDeclaration.new)
+        register_type_declaration(Handlers::ExtendRegisteredTypeDeclaration.new)
+        register_type_declaration(Handlers::ExtendArrayTypeDeclaration.new)
+        register_type_declaration(Handlers::ExtendAssociativeArrayTypeDeclaration.new)
+        register_type_declaration(Handlers::ExtendAttributesTypeDeclaration.new)
+        register_type_declaration(Handlers::ExtendTupleTypeDeclaration.new)
+      end
+
+      def install!
+        capture_current_namespaces
+
+        reset_all
+
+        Foobara::Error.include(ErrorExtension)
+
+        Value::Processor::Casting::CannotCastError.singleton_class.define_method :context_type_declaration do
+          {
+            cast_to: :duck,
+            value: :duck,
+            attribute_name: :symbol
+          }
+        end
+
+        Value::Processor::Selection::NoApplicableProcessorError.singleton_class.define_method(
+          :context_type_declaration
+        ) do
+          {
+            processor_names: [:symbol],
+            value: :duck
+          }
+        end
+
+        Value::Processor::Selection::MoreThanOneApplicableProcessorError.singleton_class.define_method(
+          :context_type_declaration
+        ) do
+          {
+            applicable_processor_names: [:symbol],
+            processor_names: [:symbol],
+            value: :duck
+          }
+        end
+
+        Value::DataError.singleton_class.define_method :context_type_declaration do
+          {
+            attribute_name: :symbol,
+            value: :duck
+          }
+        end
+      end
+
+      def new_project_added(_project)
+        capture_current_namespaces
+      end
+
+      private
+
+      def capture_current_namespaces
+        # TODO: this feels like the wrong place to do this but doing it here for now to make sure it's done when
+        # most important
+        @original_scoped = Namespace.global.foobara_registry.all_scoped.dup
+        @original_children = Namespace.global.foobara_children.dup
+
+        if GlobalDomain.const_defined?(:Types, false)
+          # :nocov:
+          @original_foobara_lowercase_constants =
+            GlobalDomain::Types.instance_variable_get(:@foobara_lowercase_constants).dup
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/attributes.rb

@@ -0,0 +1,34 @@
+module Foobara
+  module TypeDeclarations
+    module Attributes
+      class << self
+        def merge(*type_declarations)
+          element_type_declarations = {}
+          required = []
+          defaults = {}
+
+          type_declarations.each do |declaration_data|
+            element_type_declarations.merge!(declaration_data[:element_type_declarations])
+            type_defaults = declaration_data[:defaults]
+            type_required = declaration_data[:required]
+
+            if type_defaults && !type_defaults.empty?
+              defaults.merge!(type_defaults)
+            end
+
+            if type_required && !type_required.empty?
+              required += type_required
+            end
+          end
+
+          {
+            type: "::attributes",
+            element_type_declarations:,
+            required:,
+            defaults:
+          }
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/caster.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module TypeDeclarations
+    class Caster < Value::Caster
+      include WithRegistries
+    end
+  end
+end

data/projects/type_declarations/src/desugarizer.rb

@@ -0,0 +1,25 @@
+Foobara.require_project_file("type_declarations", "with_registries")
+
+module Foobara
+  module TypeDeclarations
+    class Desugarizer < Value::Transformer
+      include WithRegistries
+
+      class << self
+        def requires_declaration_data?
+          false
+        end
+
+        def foobara_manifest(to_include:)
+          # :nocov:
+          super.merge(processor_type: :desugarizer)
+          # :nocov:
+        end
+      end
+
+      def transform(value)
+        desugarize(value)
+      end
+    end
+  end
+end

data/projects/type_declarations/src/dsl/attributes.rb

@@ -0,0 +1,199 @@
+module Foobara
+  module TypeDeclarations
+    module Dsl
+      class NoTypeGivenError < StandardError; end
+
+      class BadAttributeError < StandardError
+        attr_accessor :attribute_name, :method_name
+
+        def initialize(attribute_name, method_name)
+          self.attribute_name = attribute_name
+          self.method_name = method_name
+
+          super("You probably did not mean to declare an attribute named \"#{attribute_name}\" " \
+                "but you tried to access .\"#{method_name}\" method on it. " \
+                "Return values of attribute declarations do not return anything meaningful.")
+        end
+      end
+
+      # Using this class as a proxy to explode if somebody accidentally tries to use the return value of an
+      # attribute declaration
+      # NOTE: when debugging stuff, it's helpful to comment out the inheritance from BasicObject
+      class AttributeCreated < BasicObject
+        def initialize(name)
+          @_name = name
+        end
+
+        def method_missing(method_name, ...)
+          ::Kernel.raise BadAttributeError.new(@_name, method_name)
+        end
+
+        def respond_to_missing?(...)
+          # :nocov:
+          false
+          # :nocov:
+        end
+      end
+
+      # NOTE: when debugging stuff, it's helpful to comment out the inheritance from BasicObject
+      class Attributes < BasicObject
+        class << self
+          def to_declaration(&)
+            new._to_declaration(&)
+          end
+        end
+
+        attr_accessor :_method_missing_disabled
+
+        def _to_declaration(&)
+          instance_eval(&)
+          _prune_type_declaration
+          _type_declaration
+        end
+
+        def method_missing(attribute_name, *processor_symbols, **declaration, &block)
+          unless respond_to_missing?(attribute_name)
+            # :nocov:
+            return super
+            # :nocov:
+          end
+
+          _disable_method_missing do
+            declaration = declaration.dup
+
+            if block
+              # TODO: technically, current namespace might have an overridden :array type so instead we
+              # should lookup :array he to see if we get BuiltinTypes[:array] or not (or "::array" or not)
+              if processor_symbols.first == :array
+                type, *processor_symbols = processor_symbols
+              end
+            else
+              type, *processor_symbols = processor_symbols
+
+              unless type
+                if processor_symbols.empty? && !declaration.empty?
+                  type = :attributes
+                  declaration = { element_type_declarations: declaration }
+                else
+                  ::Kernel.raise NoTypeGivenError, "Expected a type but attribute #{attribute_name} was declared " \
+                                                   "without a type. (Perhaps you didn't mean for #{attribute_name} " \
+                                                   "to be an attribute?)"
+                end
+              end
+            end
+
+            processor_symbols.each do |processor_symbol|
+              case processor_symbol
+              when ::String
+                description = processor_symbol
+
+                if declaration.key?(:description)
+                  # :nocov:
+                  ::Kernel.raise ArgumentError, "Expected only one description but " \
+                                                "got #{description.inspect} and #{declaration[:description].inspect}"
+                  # :nocov:
+                end
+
+                declaration[:description] = description
+              when ::Symbol
+                declaration[processor_symbol] = true
+              else
+                # :nocov:
+                ::Kernel.raise ArgumentError, "expected a Symbol, got #{processor_symbol.inspect}"
+                # :nocov:
+              end
+            end
+
+            if declaration.delete(:required)
+              _add_to_required(attribute_name)
+            end
+
+            default = declaration.delete(:default)
+
+            if default
+              _add_to_defaults(attribute_name, default)
+            end
+
+            if declaration.empty? && !block
+              _add_attribute(attribute_name, type)
+            else
+              declaration = if block
+                              attributes_declaration = Attributes.to_declaration(&block).merge(declaration)
+
+                              if type == :array
+                                {
+                                  type: :array,
+                                  element_type_declaration: attributes_declaration
+                                }
+                              else
+                                attributes_declaration
+                              end
+                            else
+                              declaration.merge(type:)
+                            end
+
+              _add_attribute(attribute_name, declaration)
+            end
+
+            _type_declaration
+
+            AttributeCreated.new(attribute_name)
+          end
+        end
+
+        def respond_to_missing?(method_name, private = false)
+          !_method_missing_disabled || super
+        end
+
+        private
+
+        def _disable_method_missing
+          old = _method_missing_disabled
+
+          begin
+            self._method_missing_disabled = true
+            yield
+          ensure
+            self._method_missing_disabled = old
+          end
+        end
+
+        def _add_attribute(attribute_name, declaration)
+          _type_declaration[:element_type_declarations][attribute_name.to_sym] = declaration
+        end
+
+        def _add_to_required(attribute_name)
+          _type_declaration[:required] << attribute_name.to_sym
+        end
+
+        def _add_to_defaults(attribute_name, value)
+          _type_declaration[:defaults][attribute_name.to_sym] = value
+        end
+
+        def _prune_type_declaration
+          if _type_declaration[:required].empty?
+            _type_declaration.delete(:required)
+          end
+
+          if _type_declaration[:defaults].empty?
+            _type_declaration.delete(:defaults)
+          end
+        end
+
+        def _type_declaration
+          @_type_declaration ||= begin
+            sugar = {
+              type: "::attributes",
+              element_type_declarations: {},
+              required: [],
+              defaults: {}
+            }
+
+            handler = Domain.current.foobara_type_builder.handler_for_class(Handlers::ExtendAttributesTypeDeclaration)
+            handler.desugarize(sugar)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/element_processor.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module TypeDeclarations
+    class ElementProcessor < Types::ElementProcessor
+      include WithRegistries
+    end
+  end
+end

data/projects/type_declarations/src/error_extension.rb

@@ -0,0 +1,73 @@
+module Foobara
+  module TypeDeclarations
+    class << self
+      attr_accessor :validate_error_context_enabled
+
+      def validate_error_context_enabled?
+        validate_error_context_enabled
+      end
+
+      def with_validate_error_context_disabled
+        old_enabled = validate_error_context_enabled
+
+        begin
+          self.validate_error_context_enabled = false
+          yield
+        ensure
+          self.validate_error_context_enabled = old_enabled
+        end
+      end
+    end
+
+    self.validate_error_context_enabled = true
+
+    module ErrorExtension
+      class NoContextTypeSetError < StandardError
+        def initialize
+          super("No context type declaration set. Either set it or mark the error as abstract")
+        end
+      end
+
+      include Concern
+      # TODO: replace this with some kind of Foobara::TypeBuilder version
+      include WithRegistries
+
+      module ClassMethods
+        def context_type
+          @context_type ||= begin
+            Foobara::Domain.foobara_type_from_declaration(self, context_type_declaration)
+          rescue NoContextTypeSetError
+            if abstract?
+              nil
+            else
+              # :nocov:
+              raise
+              # :nocov:
+            end
+          end
+        end
+
+        def context_type_declaration
+          # :nocov:
+          raise NoContextTypeSetError
+          # :nocov:
+        end
+      end
+
+      def initialize(...)
+        super
+
+        validate_context!
+      end
+
+      def validate_context!
+        if TypeDeclarations.validate_error_context_enabled?
+          # TODO: we need to wrap this in a new error here to communicate what's going on a bit better
+          context_type.process_value!(context)
+        end
+      end
+
+      foobara_delegate :context_type, :context_type_declaration, to: :class
+    end
+  end
+end

data/projects/type_declarations/src/handlers/extend_array_type_declaration/array_desugarizer.rb

@@ -0,0 +1,31 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        # TODO: make a quick way to convert a couple simple procs into a transformer
+        class ArrayDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration.is_a?(::Array) && sugary_type_declaration.size <= 1
+          end
+
+          def desugarize(sugary_type_declaration)
+            strict_type_declaration = { type: :array, _desugarized: { type_absolutified: true } }
+
+            unless sugary_type_declaration.empty?
+              element_type_declaration = sugary_type_declaration.first
+
+              handler = type_declaration_handler_for(element_type_declaration)
+
+              strict_type_declaration[:element_type_declaration] = handler.desugarize(element_type_declaration)
+            end
+
+            strict_type_declaration
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/handlers/extend_array_type_declaration/element_type_declaration_desugarizer.rb

@@ -0,0 +1,37 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        class ElementTypeDeclarationDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false unless sugary_type_declaration.is_a?(::Hash)
+            return false unless Util.all_symbolizable_keys?(sugary_type_declaration)
+
+            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
+
+            return false unless sugary_type_declaration.key?(:type)
+
+            type_symbol = sugary_type_declaration[:type]
+
+            type_symbol == :array && sugary_type_declaration.key?(:element_type_declaration)
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugar = sugary_type_declaration[:element_type_declaration]
+
+            handler = type_declaration_handler_for(sugar)
+            strict = handler.desugarize(sugar)
+
+            sugary_type_declaration[:element_type_declaration] = strict
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/handlers/extend_array_type_declaration/to_type_transformer.rb

@@ -0,0 +1,22 @@
+Foobara.require_project_file("type_declarations", "handlers/registered_type_declaration/to_type_transformer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
+          def transform(strict_type_declaration)
+            super.tap do |type|
+              element_type_declaration = type.declaration_data[:element_type_declaration]
+
+              if element_type_declaration
+                type.element_type = type_for_declaration(element_type_declaration)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end