foobara 0.0.1

data/projects/enumerated/src/accessors.rb

@@ -0,0 +1,61 @@
+module Foobara
+  module Enumerated
+    module Accessors
+      class ValueNotAllowed < StandardError; end
+      class CannotDetermineModuleAutomatically; end
+
+      include Concern
+
+      module ClassMethods
+        def enumerated(attribute_name, values_source = nil)
+          original_values_source = values_source
+
+          if values_source.nil?
+            module_name = Util.classify(attribute_name)
+
+            values_source = begin
+              Util.const_get_up_hierarchy(self, module_name)
+            rescue NameError
+              # :nocov:
+              raise CannotDetermineModuleAutomatically,
+                    "could not find a module for #{module_name}. Maybe consider passing it in explicitly."
+              # :nocov:
+            end
+          end
+
+          values = Values.new(values_source)
+
+          attribute_name = attribute_name.to_sym
+
+          # :nocov:
+          unless respond_to?(:enumerated_type_metadata)
+            # :nocov:
+            class << self
+              attr_accessor :enumerated_type_metadata
+            end
+
+            self.enumerated_type_metadata = {}
+          end
+
+          attr_reader attribute_name
+
+          define_method "#{attribute_name}=" do |value|
+            value = Values.normalize_value(value)
+
+            if !value.nil? && !values.all_values.include?(value)
+              raise ValueNotAllowed, "Received #{value} for #{attribute_name} but expected one of #{values.all_values}"
+            end
+
+            instance_variable_set("@#{attribute_name}", value)
+          end
+
+          enumerated_type_metadata[attribute_name] = {
+            original_values_source:,
+            values_source:,
+            values:
+          }
+        end
+      end
+    end
+  end
+end

data/projects/enumerated/src/values.rb

@@ -0,0 +1,121 @@
+module Foobara
+  module Enumerated
+    class Values
+      class BadNameType < ::StandardError; end
+      class BadValueType < ::StandardError; end
+
+      class << self
+        def valid_value_type?(value)
+          value.is_a?(String) || value.is_a?(Symbol) || value.nil?
+        end
+
+        def valid_name_type?(value)
+          value.is_a?(String) || value.is_a?(Symbol)
+        end
+
+        def normalize_value(value)
+          unless Values.valid_value_type?(value)
+            # :nocov:
+            raise BadValueType, "Expected nil, String, or Symbol, but got #{value} which is a #{value.class}"
+            # :nocov:
+          end
+
+          value&.to_sym
+        end
+
+        def module_to_symbol_map(constants_module)
+          symbol_map = {}
+
+          constants_module.constants.each do |constant_name|
+            constant_value = constants_module.const_get(constant_name)
+
+            symbol_map[constant_name] = constant_value
+          end
+
+          symbol_map
+        end
+
+        def validate_symbol_map_types(symbol_map)
+          symbol_map.each_pair do |name, value|
+            unless valid_name_type?(name)
+              # :nocov:
+              raise BadNameType, "name is #{name} which is a #{name.class} but expected String, or Symbol"
+              # :nocov:
+            end
+
+            unless valid_value_type?(value)
+              # :nocov:
+              raise BadValueType, "#{
+                name
+              } is #{value} which is a #{value.class} but expected nil, String, or Symbol"
+              # :nocov:
+            end
+          end
+        end
+
+        def normalize_symbol_map(symbol_map)
+          normalized = {}
+
+          symbol_map.each_pair do |name, value|
+            normalized[Util.constantify_sym(name)] = value&.to_sym
+          end
+
+          normalized.freeze
+        end
+      end
+
+      def initialize(*args)
+        if args.empty?
+          # :nocov:
+          raise ArgumentError, "Expected Module, Hash, or Array"
+        # :nocov:
+        elsif args.size > 1
+          initialize(args)
+        else
+          symbol_map = args.first
+
+          case symbol_map
+          when ::Hash
+            Values.validate_symbol_map_types(symbol_map)
+
+            @symbol_map = Values.normalize_symbol_map(symbol_map)
+          when ::Module
+            initialize(Values.module_to_symbol_map(symbol_map))
+          when ::Array
+            initialize(symbol_map.to_h { |name| [name, name] })
+          else
+            # :nocov:
+            raise ArgumentError, "Expected Module, Hash, or Array"
+            # :nocov:
+          end
+        end
+      end
+
+      def all
+        @symbol_map
+      end
+
+      def all_names
+        @symbol_map.keys
+      end
+
+      def all_values
+        @symbol_map.values
+      end
+
+      def method_missing(name)
+        unless respond_to_missing?(name)
+          # :nocov:
+          super
+          # :nocov:
+        end
+
+        @symbol_map[name]
+      end
+
+      def respond_to_missing?(name, _include_private = false)
+        @symbol_map.key?(name)
+      end
+    end
+  end
+end

data/projects/foobara/lib/foobara/all.rb

@@ -0,0 +1,44 @@
+require "foobara/util"
+require "foobara/monorepo"
+
+module Foobara
+  module All
+    # just makes Rubocop happy
+    # TODO: delete this and make Rubocop exception in .rubocop.yml
+  end
+
+  module Monorepo
+    # universal
+    project "version"
+
+    # could be independent projects
+    projects "delegate",
+             "concerns",
+             "thread_parent",
+             "weak_object_set",
+             "enumerated",
+             "callback",
+             "state_machine",
+             "namespace"
+
+    project "domain"
+
+    # various components of the foobara framework that have some level of coupling.
+    # for example, Error in common knows about (or could be implemented to know about)
+    # type declarations to expose its context type.
+    projects "common",
+             "value",
+             "types",
+             "type_declarations",
+             "builtin_types",
+             "model",
+             "entity",
+             "command",
+             "persistence",
+             "in_memory_crud_driver_minimal",
+             "in_memory_crud_driver",
+             "manifest"
+
+    install!
+  end
+end

data/projects/in_memory_crud_driver/lib/foobara/in_memory_crud_driver.rb

@@ -0,0 +1,3 @@
+# TODO: Why is this project basically empty? I guess so that optimizations can be added here?
+
+module Foobara::InMemoryCrudDriver; end

data/projects/in_memory_crud_driver/src/in_memory.rb

@@ -0,0 +1,10 @@
+module Foobara
+  module Persistence
+    module CrudDrivers
+      class InMemory < InMemoryMinimal
+        class Table < InMemoryMinimal::Table
+        end
+      end
+    end
+  end
+end

data/projects/in_memory_crud_driver_minimal/lib/foobara/in_memory_crud_driver_minimal.rb

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

data/projects/in_memory_crud_driver_minimal/src/in_memory_minimal.rb

@@ -0,0 +1,113 @@
+module Foobara
+  module Persistence
+    module CrudDrivers
+      class InMemoryMinimal < EntityAttributesCrudDriver
+        # TODO: delete
+        def open_connection(_connection_or_credentials)
+          # TODO: figure out what we expect here when there is no connection necessary
+          Object.new
+        end
+
+        def open_transaction
+          # TODO: figure out what we expect here when there is no native transaction support
+          Object.new
+        end
+
+        def close_transaction(_raw_tx)
+          # can't fail since there's no native transaction support...
+        end
+
+        def rollback_transaction(_raw_tx)
+          # nothing to do... except maybe enter a state where we don't flush anything else
+          # but can just rely on higher-up plumbing for that
+        end
+
+        class Table < EntityAttributesCrudDriver::Table
+          attr_accessor :records
+
+          def initialize(...)
+            @last_id = 0
+            self.records = {}
+
+            super
+          end
+
+          def get_id
+            @last_id += 1
+          end
+
+          # CRUD
+          # TODO: all multiple record methods should return enumerators and code further up should only use
+          # the lazy enumerator interface... to encourage that/catch bugs we will return lazy enumerators in these
+          # built-in crud drivers
+          def all
+            records.each_value.lazy
+          end
+
+          def count
+            records.count
+          end
+
+          def find(record_id)
+            Util.deep_dup(records[record_id])
+          end
+
+          def find!(record_id)
+            attributes = find(record_id)
+
+            unless attributes
+              raise CannotFindError.new(record_id, "does not exist")
+            end
+
+            attributes
+          end
+
+          def insert(attributes)
+            attributes = Util.deep_dup(attributes)
+
+            record_id = record_id_for(attributes)
+
+            if record_id
+              if exists?(record_id)
+                raise CannotInsertError.new(record_id, "already exists")
+              end
+            else
+              record_id = get_id
+              attributes.merge!(primary_key_attribute => record_id)
+            end
+
+            records[record_id] = attributes
+            find(record_id)
+          end
+
+          def update(attributes)
+            record_id = record_id_for(attributes)
+
+            unless exists?(record_id)
+              # :nocov:
+              raise CannotUpdateError.new(record_id, "does not exist")
+              # :nocov:
+            end
+
+            records[record_id] = Util.deep_dup(attributes)
+            find(record_id)
+          end
+
+          def hard_delete(record_id)
+            unless exists?(record_id)
+              # :nocov:
+              raise CannotUpdateError.new(record_id, "does not exist")
+              # :nocov:
+            end
+
+            records.delete(record_id)
+          end
+
+          def hard_delete_all
+            self.records = {}
+          end
+        end
+      end
+    end
+  end
+end

data/projects/manifest/lib/foobara/manifest.rb

@@ -0,0 +1,4 @@
+module Foobara
+  module Manifest
+  end
+end

data/projects/manifest/src/foobara/manifest/array.rb

@@ -0,0 +1,13 @@
+require_relative "type_declaration"
+
+module Foobara
+  module Manifest
+    class Array < TypeDeclaration
+      alias array_manifest relevant_manifest
+
+      def element_type
+        @element_type ||= TypeDeclaration.new(root_manifest, [*path, :element_type_declaration])
+      end
+    end
+  end
+end

data/projects/manifest/src/foobara/manifest/attributes.rb

@@ -0,0 +1,40 @@
+require_relative "type_declaration"
+
+module Foobara
+  module Manifest
+    class Attributes < TypeDeclaration
+      optional_keys :required, :defaults
+
+      alias attributes_manifest relevant_manifest
+
+      def required?(attribute_name)
+        required = DataPath.value_at(:required, attributes_manifest)
+
+        if required
+          required.include?(attribute_name.to_sym) || required.include?(attribute_name.to_s)
+        end
+      end
+
+      def default_for(attribute_name)
+        DataPath.value_at([:defaults, attribute_name], attributes_manifest)
+      end
+
+      def attribute_declarations
+        element_type_declarations.keys.to_h do |attribute_name|
+          [
+            attribute_name.to_sym,
+            TypeDeclaration.new(root_manifest, [*path, :element_type_declarations, attribute_name])
+          ]
+        end
+      end
+
+      def empty?
+        attribute_declarations.empty?
+      end
+
+      def attribute_names
+        attribute_declarations.keys.map(&:to_s)
+      end
+    end
+  end
+end

data/projects/manifest/src/foobara/manifest/base_manifest.rb

@@ -0,0 +1,161 @@
+module Foobara
+  module Manifest
+    class InvalidPath < StandardError; end
+
+    class BaseManifest
+      include TruncatedInspect
+
+      attr_accessor :root_manifest, :path
+
+      class << self
+        attr_accessor :category_symbol
+
+        def optional_keys(*values, default: nil)
+          if values.empty?
+            @optional_keys ||= if superclass == Object
+                                 Set.new
+                               else
+                                 superclass.optional_keys.dup
+                               end
+          else
+            if default
+              default = default.freeze
+            end
+
+            values.each do |value|
+              value = value.to_sym
+              optional_keys << value
+              if default
+                optional_key_defaults[value] = default
+              end
+            end
+          end
+        end
+
+        def optional_key_defaults
+          @optional_key_defaults ||= {}
+        end
+
+        def optional_key(value, default: nil)
+          optional_keys(value, default:)
+        end
+
+        def category_to_manifest_class(category_symbol)
+          category_symbol = category_symbol.to_sym
+
+          Util.descendants(BaseManifest).find do |manifest_class|
+            manifest_class.category_symbol == category_symbol
+          end
+        end
+      end
+
+      def initialize(root_manifest, path)
+        self.root_manifest = root_manifest
+        self.path = path
+
+        if relevant_manifest.nil?
+          # :nocov:
+          raise InvalidPath, "invalid path #{path}"
+          # :nocov:
+        end
+      end
+
+      def domain
+        domain_reference = self[:domain]
+
+        Domain.new(root_manifest, [:domain, domain_reference])
+      end
+
+      def organization
+        organization_reference = self[:organization]
+
+        Organization.new(root_manifest, [:organization, organization_reference])
+      end
+
+      def parent
+        if parent_category
+          parent_class = self.class.category_to_manifest_class(parent_category)
+
+          parent_class&.new(root_manifest, self[:parent])
+        end
+      end
+
+      def parent_category
+        self[:parent]&.first
+      end
+
+      def parent_name
+        self[:parent]&.last
+      end
+
+      def scoped_category
+        self[:scoped_category]
+      end
+
+      def relevant_manifest
+        @relevant_manifest ||= Foobara::DataPath.values_at(path, root_manifest).first
+      end
+
+      def find_type(type_declaration)
+        type_symbol = type_declaration.type
+
+        Type.new(root_manifest, [:type, type_symbol])
+      end
+
+      def global_domain
+        Domain.new(root_manifest, %i[domain global_organization::global_domain])
+      end
+
+      def global_organization
+        Organization.new(root_manifest, %i[organization global_organization])
+      end
+
+      def method_missing(method_name, *, &)
+        if key?(method_name)
+          self[method_name]
+        elsif optional_key?(method_name)
+          self.class.optional_key_defaults[method_name.to_sym]
+        else
+          # :nocov:
+          super
+          # :nocov:
+        end
+      end
+
+      def [](method_name)
+        if relevant_manifest.key?(method_name.to_sym)
+          relevant_manifest[method_name.to_sym]
+        elsif relevant_manifest.key?(method_name.to_s)
+          relevant_manifest[method_name.to_s]
+        end
+      end
+
+      def key?(method_name)
+        relevant_manifest.key?(method_name.to_sym) || relevant_manifest.key?(method_name.to_s)
+      end
+
+      def optional_key?(key)
+        if key.is_a?(::Symbol) || key.is_a?(::String)
+          self.class.optional_keys.include?(key.to_sym)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        relevant_manifest.key?(method_name.to_sym) || relevant_manifest.key?(method_name.to_s) ||
+          optional_key?(method_name) || super
+      end
+
+      def ==(other)
+        other.class == self.class && other.path.map(&:to_sym) == path.map(&:to_sym)
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        [root_manifest, path.map(&:to_sym)].hash
+      end
+    end
+  end
+end

data/projects/manifest/src/foobara/manifest/command.rb

@@ -0,0 +1,59 @@
+module Foobara
+  module Manifest
+    class Command < BaseManifest
+      self.category_symbol = :command
+
+      def command_manifest
+        relevant_manifest
+      end
+
+      def command_name
+        scoped_short_name
+      end
+
+      def full_command_name
+        scoped_full_name
+      end
+
+      def inputs_type
+        Attributes.new(root_manifest, [*path, :inputs_type])
+      end
+
+      def result_type
+        TypeDeclaration.new(root_manifest, [*path, :result_type])
+      rescue Foobara::Manifest::InvalidPath
+        nil
+      end
+
+      def possible_errors
+        super.keys.to_h do |key|
+          [key, PossibleError.new(root_manifest, [*path, :possible_errors, key])]
+        end
+      end
+
+      def types_depended_on
+        @types_depended_on ||= self[:types_depended_on].map do |type_reference|
+          Type.new(root_manifest, [:type, type_reference])
+        end
+      end
+
+      def inputs_types_depended_on
+        @inputs_types_depended_on ||= self[:inputs_types_depended_on].map do |type_reference|
+          Type.new(root_manifest, [:type, type_reference])
+        end
+      end
+
+      def result_types_depended_on
+        @result_types_depended_on ||= self[:result_types_depended_on].to_set do |type_reference|
+          Type.new(root_manifest, [:type, type_reference])
+        end
+      end
+
+      def errors_types_depended_on
+        @errors_types_depended_on ||= self[:errors_types_depended_on].to_set do |type_reference|
+          Type.new(root_manifest, [:type, type_reference])
+        end
+      end
+    end
+  end
+end

data/projects/manifest/src/foobara/manifest/domain.rb

@@ -0,0 +1,43 @@
+module Foobara
+  module Manifest
+    class Domain < BaseManifest
+      self.category_symbol = :domain
+
+      def domain_manifest
+        relevant_manifest
+      end
+
+      def commands
+        @commands ||= DataPath.value_at(:commands, domain_manifest).map do |key|
+          Command.new(root_manifest, [:command, key])
+        end
+      end
+
+      def types
+        @types ||= DataPath.value_at(:types, domain_manifest).map do |key|
+          Type.new(root_manifest, [:type, key])
+        end
+      end
+
+      def entities
+        @entities ||= types.select(&:entity?)
+      end
+
+      def models
+        @models ||= types.select(&:model?)
+      end
+
+      def global?
+        reference == "global_organization::global_domain"
+      end
+
+      def domain_name
+        scoped_name
+      end
+
+      def full_domain_name
+        scoped_full_name
+      end
+    end
+  end
+end