foobara 0.0.1

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

@@ -0,0 +1,69 @@
+module Foobara
+  class << self
+    # TODO: come up with a way to change a type's manifest... Or maybe treat Model very differently?
+    # ok... new manifest will be of this form...
+    # { <orgs|commands|types, etc, letś call this a type category...> => full_scoped_name => manifest }
+    #
+    # The manifest itself will only contain full scoped names. This is kind of analogous to a store serializer
+    # in the http connector.
+    def manifest
+      to_include = Namespace.global.foobara_all_organization.to_set
+      included = {}
+
+      h = {}
+
+      until to_include.empty?
+        object = to_include.first
+        to_include.delete(object)
+
+        unless object.scoped_path_set?
+          # :nocov:
+          raise "no scoped path set for #{object}"
+          # :nocov:
+        end
+
+        manifest_reference = object.foobara_manifest_reference.to_sym
+        category_symbol = Namespace.global.foobara_category_symbol_for(object)
+
+        unless category_symbol
+          # :nocov:
+          raise "no category symbol for #{object}"
+          # :nocov:
+        end
+
+        if included.key?(manifest_reference)
+          if included[manifest_reference] == category_symbol
+            next
+          else
+            # :nocov:
+            raise "Collision for #{manifest_reference}: #{included[manifest_reference]} and #{category_symbol}"
+            # :nocov:
+          end
+        end
+
+        cat = h[category_symbol] ||= {}
+        cat[manifest_reference] = object.foobara_manifest(to_include:)
+
+        included[manifest_reference] = category_symbol
+      end
+
+      h.sort.to_h
+    end
+
+    def all_organizations
+      Namespace.global.foobara_all_organization
+    end
+
+    def all_domains
+      Namespace.global.foobara_all_domain
+    end
+
+    def all_commands
+      Namespace.global.foobara_all_command
+    end
+
+    def all_types
+      Namespace.global.foobara_all_type
+    end
+  end
+end

data/projects/domain/src/global_domain.rb

@@ -0,0 +1,14 @@
+require_relative "global_organization"
+
+module Foobara
+  module GlobalDomain
+    foobara_namespace!(scoped_path: [])
+    self.foobara_parent_namespace = GlobalOrganization
+    GlobalOrganization.foobara_register(self)
+
+    foobara_domain!
+    self.foobara_domain_name = "global_domain"
+    self.foobara_full_domain_name = "#{GlobalOrganization.foobara_organization_name}::#{foobara_domain_name}"
+    self.foobara_manifest_reference = foobara_full_domain_name
+  end
+end

data/projects/domain/src/global_organization.rb

@@ -0,0 +1,12 @@
+require_relative "module_extension"
+
+module Foobara
+  module GlobalOrganization
+    foobara_namespace!(scoped_path: [])
+    self.foobara_parent_namespace = Namespace.global
+    foobara_parent_namespace.foobara_register(self)
+
+    foobara_organization!
+    self.foobara_manifest_reference = self.foobara_organization_name = "global_organization"
+  end
+end

data/projects/domain/src/is_manifestable.rb

@@ -0,0 +1,68 @@
+module Foobara
+  module IsManifestable
+    def scoped_clear_caches
+      [
+        # TODO: what about this one??
+        # "@created_in_namespace",
+        "@foobara_domain"
+      ].each do |variable|
+        remove_instance_variable(variable) if instance_variable_defined?(variable)
+      end
+      super
+    end
+
+    def foobara_domain
+      return @foobara_domain if defined?(@foobara_domain)
+
+      scoped = self
+
+      while scoped
+        if scoped.is_a?(::Module)
+          if scoped.foobara_domain?
+            return @foobara_domain = scoped
+          end
+        end
+
+        scoped = scoped.scoped_namespace
+      end
+
+      @foobara_domain = GlobalDomain
+    end
+
+    def foobara_organization
+      if is_a?(::Module) && foobara_organization?
+        self
+      else
+        foobara_domain.foobara_organization
+      end
+    end
+
+    def foobara_manifest(to_include: Set.new)
+      h = {
+        scoped_path:,
+        scoped_name:,
+        scoped_short_name:,
+        scoped_prefix:,
+        scoped_full_path:,
+        scoped_full_name:,
+        scoped_category:,
+        reference: foobara_manifest_reference,
+        domain: foobara_domain&.foobara_manifest_reference,
+        organization: foobara_organization&.foobara_manifest_reference
+      }
+
+      parent = scoped_namespace
+
+      if parent
+        parent_category = Namespace.global.foobara_category_symbol_for(parent)
+
+        if parent_category
+          to_include << parent
+          h[:parent] = [parent_category, parent.foobara_manifest_reference]
+        end
+      end
+
+      h
+    end
+  end
+end

data/projects/domain/src/manifestable.rb

@@ -0,0 +1,12 @@
+require_relative "is_manifestable"
+
+module Foobara
+  # Weird that this concept lives here instead of in its own project...
+  module Manifestable
+    include Concern
+
+    module ClassMethods
+      include IsManifestable
+    end
+  end
+end

data/projects/domain/src/module_extension.rb

@@ -0,0 +1,122 @@
+require_relative "organization_module_extension"
+require_relative "domain_module_extension"
+
+module Foobara
+  module Domain
+    # TODO: should we just couple domain project and commands project to simplify this connection?
+    # TODO: move this stuff to extensions/ directory
+    module ModuleExtension
+      class CannotBeOrganizationAndDomainAtSameTime < StandardError; end
+
+      def foobara_domain!
+        if foobara_organization?
+          # :nocov:
+          raise CannotBeOrganizationAndDomainAtSameTime
+          # :nocov:
+        end
+
+        include(DomainModuleExtension)
+
+        unless is_a?(Namespace::IsNamespace)
+          foobara_namespace!
+          foobara_autoset_namespace!(default_namespace: Foobara::GlobalOrganization)
+          foobara_autoset_scoped_path!
+
+          # TODO: wow this is awkward. We should find a cleaner way to set children on namespaces.
+          parent = foobara_parent_namespace
+          parent.foobara_register(self)
+          self.foobara_parent_namespace = parent
+        end
+
+        children = foobara_children
+        children = children.sort_by { |child| child.scoped_path.size }
+
+        # see if we are upgrading from prefix to domain and copy over types to Types module
+        children.each do |child|
+          next unless child.is_a?(Types::Type)
+
+          types_mod_path = scoped_full_path.dup
+          unless child.scoped_path.first == "Types"
+            types_mod_path << "Types"
+          end
+
+          types_mod_path += child.scoped_path[..-2]
+          types_mod = Util.make_module_p(types_mod_path.join("::"))
+
+          # TODO: dry this up
+          # TODO: this doesn't handle a type nested under a lower-case type for now
+          if child.scoped_short_name =~ /^[a-z]/
+            unless types_mod.respond_to?(child.scoped_short_name)
+              types_mod.singleton_class.define_method child.scoped_short_name do
+                child
+              end
+
+              unless types_mod.instance_variable_defined?(:@foobara_lowercase_constants)
+                # TODO: test this path or delete it if unreachable
+                # :nocov:
+                types_mod.instance_variable_set(:@foobara_lowercase_constants, [])
+                # :nocov:
+              end
+
+              types_mod.instance_variable_get(:@foobara_lowercase_constants) << child.scoped_short_name
+            end
+          else
+            value = if types_mod.const_defined?(child.scoped_short_name, false)
+                      # TODO: test this path or delete it if unreachable
+                      # :nocov:
+                      types_mod.const_get(child.scoped_short_name, false)
+                      # :nocov:
+                    end
+
+            if value != child
+              types_mod.send(:remove_const, child.scoped_short_name) if value
+              # TODO: can we decouple this from the model project?
+              new_value = if child.extends?("::model")
+                            child.target_class
+                          else
+                            # TODO: test this path or delete it if unreachable
+                            # :nocov:
+                            child
+                            # :nocov:
+                          end
+              types_mod.const_set(child.scoped_short_name, new_value)
+            end
+          end
+        end
+      end
+
+      def foobara_organization!
+        if foobara_domain?
+          # :nocov:
+          raise CannotBeOrganizationAndDomainAtSameTime
+          # :nocov:
+        end
+
+        include(OrganizationModuleExtension)
+
+        unless is_a?(Namespace::IsNamespace)
+          foobara_namespace!
+          self.scoped_namespace = Namespace.global
+          foobara_autoset_scoped_path!(make_top_level: true)
+
+          # TODO: wow this is awkward. We should find a cleaner way to set children on namespaces.
+          parent = foobara_parent_namespace
+          parent.foobara_register(self)
+          self.foobara_parent_namespace = parent
+        end
+      end
+
+      def foobara_domain?
+        false
+      end
+
+      def foobara_organization?
+        false
+      end
+    end
+  end
+end
+
+Module.include(Foobara::Domain::ModuleExtension)
+
+Foobara.foobara_organization!

data/projects/domain/src/organization.rb

@@ -0,0 +1,52 @@
+module Foobara
+  module Organization
+    class OrganizationAlreadyExistsError < StandardError; end
+    class NoSuchOrganization < StandardError; end
+
+    class << self
+      # TODO: move this to organization.rb
+      def to_organization(object)
+        case object
+        when nil
+          GlobalOrganization
+        when ::String, ::Symbol
+          organization = Namespace.global.foobara_lookup_organization(object)
+
+          unless organization
+            # :nocov:
+            raise NoSuchOrganization, "Couldn't determine organization for #{object}"
+            # :nocov:
+          end
+
+          organization
+        when Foobara::Scoped
+          if object.is_a?(Module) && object.foobara_organization?
+            object
+          else
+            parent = object.scoped_namespace
+
+            if parent
+              to_organization(parent)
+            else
+              GlobalOrganization
+            end
+          end
+        else
+          # :nocov:
+          raise NoSuchOrganization, "Couldn't determine organization for #{object}"
+          # :nocov:
+        end
+      end
+
+      def create(full_organization_name)
+        if Organization.to_organization(full_organization_name)
+          # :nocov:
+          raise OrganizationAlreadyExistsError, "Organization #{full_organization_name} already exists"
+          # :nocov:
+        end
+      rescue Organization::NoSuchOrganization
+        Util.make_module_p(full_organization_name) { foobara_organization! }
+      end
+    end
+  end
+end

data/projects/domain/src/organization_module_extension.rb

@@ -0,0 +1,50 @@
+require_relative "manifestable"
+
+module Foobara
+  module Domain
+    module OrganizationModuleExtension
+      # Does this really need to be a Concern?
+      include Concern
+      include Manifestable
+
+      module ClassMethods
+        attr_writer :foobara_organization_name, :foobara_full_organization_name
+
+        def foobara_organization_name
+          @foobara_organization_name || scoped_name
+        end
+
+        def foobara_full_organization_name
+          @foobara_full_organization_name || scoped_full_name
+        end
+
+        def foobara_organization?
+          true
+        end
+
+        def foobara_owns_domain?(domain)
+          foobara_each_domain(mode: Namespace::LookupMode::DIRECT) do |d|
+            if d == domain || (d == domain.mod if domain.respond_to?(:mod))
+              return true
+            end
+          end
+
+          false
+        end
+
+        def foobara_domains
+          foobara_all_domain(mode: Namespace::LookupMode::DIRECT)
+        end
+
+        def foobara_manifest(to_include:)
+          domains = foobara_domains.map do |domain|
+            to_include << domain
+            domain.foobara_manifest_reference
+          end.sort
+
+          super.merge(domains:)
+        end
+      end
+    end
+  end
+end

data/projects/entity/lib/foobara/entity.rb

@@ -0,0 +1,27 @@
+require "date"
+require "time"
+require "bigdecimal"
+
+module Foobara
+  # TODO: I think we should have a configuration that indicates if created records can have primary keys past to them
+  # or not. That is, do primary keys get issued by the database upon insertion? Or are they generated externally
+  # and passed in? Would be nice to have programmatic clarification via explicit configuration.
+  class Entity < Model
+    abstract
+
+    class << self
+      def install!
+        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendEntityTypeDeclaration.new)
+
+        model = Namespace.global.foobara_lookup_type!(:model)
+        BuiltinTypes.build_and_register!(:entity, model, nil)
+      end
+
+      def reset_all
+        Entity::Concerns::Callbacks.reset_all
+
+        install!
+      end
+    end
+  end
+end

data/projects/entity/src/concerns/associations.rb

@@ -0,0 +1,241 @@
+module Foobara
+  class Entity < Model
+    module Concerns
+      module Associations
+        include Concern
+
+        module ClassMethods
+          def associations
+            @associations ||= construct_associations
+          end
+
+          def deep_associations
+            @deep_associations ||= begin
+              deep = {}
+
+              associations.each_pair do |data_path, type|
+                deep[data_path] = type
+
+                entity_class = type.target_class
+
+                entity_class.deep_associations.each_pair do |sub_data_path, sub_type|
+                  deep["#{data_path}.#{sub_data_path}"] = sub_type
+                end
+              end
+
+              deep
+            end
+          end
+
+          # TODO: stamp this metadata out somewhere, preferably on deep_associations hash somehow
+          def association(name, *association_identifiers)
+            target_association_key = association_for(association_identifiers)
+
+            is_many = target_association_key.include?("#")
+
+            define_method name do
+              # TODO: memoize but with some smart cache busting
+              values = Foobara::DataPath.values_at(target_association_key, self)
+
+              if is_many
+                values
+              else
+                if values.size > 1
+                  # :nocov:
+                  raise "Multiple records found for #{name} association but only expected 0 or 1."
+                  # :nocov:
+                end
+
+                unless values.empty?
+                  values.first
+                end
+              end
+            end
+          end
+
+          def association_for(association_filters)
+            if association_filters.size == 1
+              data_path = association_filters.first.to_s
+
+              if deep_associations.key?(data_path)
+                return data_path
+              end
+            end
+
+            result = association_filters.inject(deep_associations.keys) do |filtered, filter|
+              filtered_associations(filter, filtered)
+            end
+
+            if result.empty?
+              # :nocov:
+              raise "Could not find association matching #{association_filters}"
+              # :nocov:
+            elsif result.size > 1
+              # :nocov:
+              raise "Multiple associations matched by #{association_filters}"
+              # :nocov:
+            else
+              result.first
+            end
+          end
+
+          def filtered_associations(filter, association_keys = deep_associations.keys)
+            if filter.is_a?(::Symbol)
+              filter = filter.to_s
+            end
+
+            if filter.is_a?(::String)
+              if filter =~ /[A-Z]/
+                association_keys.select do |key|
+                  type = deep_associations[key]
+                  entity_class = type.target_class
+                  entity_class.full_entity_name.include?(filter)
+                end
+              else
+                association_keys.select do |key|
+                  key.include?(filter)
+                end
+              end
+            elsif filter.is_a?(::Class) && filter < Entity
+              association_keys.select do |key|
+                type = deep_associations[key]
+                entity_class = type.target_class
+                entity_class == filter || entity_class < filter
+              end
+            else
+              # :nocov:
+              raise "Not sure how to apply filter #{filter}"
+              # :nocov:
+            end
+          end
+
+          def construct_associations(
+            type = attributes_type,
+            path = DataPath.new,
+            result = {}
+          )
+            if type.extends?(BuiltinTypes[:entity])
+              result[path.to_s] = type
+            elsif type.extends?(BuiltinTypes[:tuple])
+              element_types = type.element_types
+
+              element_types&.each&.with_index do |element_type, index|
+                construct_associations(element_type, path.append(index), result)
+              end
+            elsif type.extends?(BuiltinTypes[:array])
+              # TODO: what to do about an associative array type?? Unclear how to make a key from that...
+              # TODO: raise if associative array contains a non-persisted record to handle this edge case for now.
+              element_type = type.element_type
+
+              if element_type
+                construct_associations(element_type, path.append(:"#"), result)
+              end
+            elsif type.extends?(BuiltinTypes[:attributes])
+              type.element_types.each_pair do |attribute_name, element_type|
+                construct_associations(element_type, path.append(attribute_name), result)
+              end
+            elsif type.extends?(BuiltinTypes[:model])
+              construct_associations(type.target_class.attributes_type, path, result)
+            elsif type.extends?(BuiltinTypes[:associative_array])
+              # not going to bother testing this for now
+              # :nocov:
+              if contains_associations?(type)
+                raise "Associative array types with associations in them are not currently supported. " \
+                      "Use attributes type if you can or set the key_type and/or value_type to duck type"
+              end
+              # :nocov:
+            end
+
+            result
+          end
+
+          def contains_associations?(type = entity_type, initial = true)
+            if type.extends?(BuiltinTypes[:entity])
+              if initial
+                contains_associations?(type.element_types, false)
+              else
+                true
+              end
+            elsif type.extends?(BuiltinTypes[:array])
+              # TODO: what to do about an associative array type?? Unclear how to make a key from that...
+              # TODO: raise if associative array contains a non-persisted record to handle this edge case for now.
+              element_type = type.element_type
+
+              if element_type
+                contains_associations?(element_type, false)
+              end
+            elsif type.extends?(BuiltinTypes[:attributes])
+              type.element_types.values.any? do |element_type|
+                contains_associations?(element_type, false)
+              end
+            elsif type.extends?(BuiltinTypes[:associative_array])
+              element_types = type.element_types
+
+              if element_types
+                key_type, value_type = element_types
+
+                contains_associations?(key_type, false) ||
+                  contains_associations?(value_type, false)
+              end
+            end
+          end
+
+          def that_owns(record, filters = [])
+            containing_records = that_own(record, filters)
+
+            unless containing_records.empty?
+              if containing_records.size == 1
+                containing_records.first
+              else
+                # :nocov:
+                raise "Expected only one record to own #{record} but found #{containing_records.size}"
+                # :nocov:
+              end
+            end
+          end
+
+          def that_own(record, filters = [])
+            association_key = association_for([record.class, *filters])
+
+            data_path = DataPath.new(association_key)
+
+            done = false
+
+            containing_records = Util.array(record)
+
+            until done
+              last = data_path.path.last
+
+              if last == :"#"
+                method = :find_all_by_attribute_containing_any_of
+                attribute_name = data_path.path[-2]
+                data_path = DataPath.new(data_path.path[0..-3])
+              else
+                method = :find_all_by_attribute_any_of
+                attribute_name = last
+                data_path = DataPath.new(data_path.path[0..-2])
+              end
+
+              containing_entity_class_path = data_path.to_s
+
+              entity_class = if containing_entity_class_path.empty?
+                               done = true
+                               self
+                             else
+                               deep_associations[
+                                 containing_entity_class_path
+                               ].target_class
+                             end
+
+              containing_records = entity_class.send(method, attribute_name, containing_records).to_a
+
+              done = true unless containing_records
+            end
+
+            containing_records
+          end
+        end
+      end
+    end
+  end
+end