foobara 0.0.1

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

@@ -0,0 +1,35 @@
+require_relative "model"
+
+module Foobara
+  module Manifest
+    class Entity < Model
+      self.category_symbol = :type
+
+      optional_key(:associations, default: {})
+
+      alias entity_manifest model_manifest
+
+      def has_associations?
+        associations && !associations.empty?
+      end
+
+      def primary_key_name
+        primary_key_attribute.to_s
+      end
+
+      def primary_key_type
+        @primary_key_type ||= TypeDeclaration.new(root_manifest, [*path, :primary_key_type])
+      end
+
+      def attribute_names
+        super - [primary_key_name]
+      end
+
+      def associations
+        @associations ||= self[:associations].to_h do |path_key, type_name|
+          [path_key.to_sym, Type.new(root_manifest, [:type, type_name])]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Foobara
+  module Manifest
+    class Error < BaseManifest
+      self.category_symbol = :error
+
+      def error_manifest
+        relevant_manifest
+      end
+
+      def symbol
+        super.to_sym
+      end
+
+      def error_name
+        scoped_name
+      end
+
+      def full_error_name
+        scoped_full_name
+      end
+
+      def abstract
+        self[:abstract]
+      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
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_relative "type"
+
+module Foobara
+  module Manifest
+    class Model < Type
+      self.category_symbol = :type
+
+      alias model_manifest relevant_manifest
+
+      def attributes_type
+        Attributes.new(root_manifest, [*path, :attributes_type])
+      end
+
+      def attribute_names
+        attributes_type.attribute_names
+      end
+
+      # TODO: rename
+      def has_associations?(type = attributes_type)
+        case type
+        when Entity
+          true
+        when Model
+          has_associations?(type.attributes_type)
+        when Attributes
+          type.attribute_declarations.values.any? do |attribute_declaration|
+            has_associations?(attribute_declaration)
+          end
+        when Array
+          has_associations?(type.element_type)
+        when TypeDeclaration
+          has_associations?(type.to_type)
+        when Type
+          type.entity?
+        else
+          # :nocov:
+          raise "not sure how to proceed with #{type}"
+          # :nocov:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Foobara
+  module Manifest
+    class Organization < BaseManifest
+      self.category_symbol = :organization
+
+      def organization_manifest
+        relevant_manifest
+      end
+
+      def domains
+        @domains ||= DataPath.value_at(:domains, organization_manifest).map do |key|
+          Domain.new(root_manifest, [:domain, key])
+        end
+      end
+
+      def commands
+        domains.map(&:commands).flatten
+      end
+
+      def types
+        domains.map(&:types).flatten
+      end
+
+      def entities
+        domains.map(&:entities).flatten
+      end
+
+      def models
+        domains.map(&:models).flatten
+      end
+
+      def global?
+        reference == "global_organization"
+      end
+
+      def organization_name
+        scoped_name
+      end
+
+      def full_organization_name
+        scoped_full_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Foobara
+  module Manifest
+    class PossibleError < BaseManifest
+      optional_key(:path, default: [])
+
+      def possible_error_manifest
+        relevant_manifest
+      end
+
+      def error
+        Error.new(root_manifest, [:error, DataPath.value_at([:error], possible_error_manifest)])
+      end
+
+      def processor_manifest_data
+        self[:processor_manifest_data]
+      end
+
+      def manually_added
+        self[:manually_added]
+      end
+
+      # TODO: this has to die
+
+      # oops, shadowed the convenience method
+      def _path
+        method_missing(:path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Foobara
+  module Manifest
+    class Processor < BaseManifest
+      self.category_symbol = :processor
+
+      def full_processor_name
+        scoped_full_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Foobara
+  module Manifest
+    class ProcessorClass < BaseManifest
+      self.category_symbol = :processor_class
+
+      def full_processor_class_name
+        scoped_full_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Foobara
+  module Manifest
+    class RootManifest < BaseManifest
+      include TruncatedInspect
+
+      attr_accessor :root_manifest
+
+      def initialize(root_manifest)
+        super(root_manifest, [])
+      end
+
+      def organizations
+        @organizations ||= DataPath.value_at(:organization, root_manifest).keys.map do |reference|
+          Organization.new(root_manifest, [:organization, reference])
+        end
+      end
+
+      def domains
+        @domains ||= DataPath.value_at(:domain, root_manifest).keys.map do |reference|
+          Domain.new(root_manifest, [:domain, reference])
+        end
+      end
+
+      def commands
+        organizations.map(&:commands).flatten
+      end
+
+      def types
+        @types ||= DataPath.value_at(:type, root_manifest).keys.map do |reference|
+          Type.new(root_manifest, [:type, reference])
+        end
+      end
+
+      def entities
+        organizations.map(&:entities).flatten
+      end
+
+      def models
+        organizations.map(&:models).flatten
+      end
+
+      def errors
+        @errors ||= DataPath.value_at(:error, root_manifest).keys.map do |reference|
+          Error.new(root_manifest, [:error, reference])
+        end
+      end
+
+      def entity_by_name(name)
+        type = type_by_name(name)
+
+        raise "#{name} is not an entity" unless type.entity?
+
+        type
+      end
+
+      def model_by_name(name)
+        type = type_by_name(name)
+
+        raise "#{name} is not a model" unless type.model?
+
+        type
+      end
+
+      def type_by_name(name)
+        Type.new(root_manifest, [:type, name])
+      end
+
+      def command_by_name(name)
+        Command.new(root_manifest, [:command, name])
+      end
+
+      def domain_by_name(name)
+        Domain.new(root_manifest, [:domain, name])
+      end
+
+      def organization_by_name(name)
+        Organization.new(root_manifest, [:organization, name])
+      end
+
+      # TODO: this isn't quite right. If the thing is there but is nil or false, this should be truthy.
+      def contains?(reference, category)
+        DataPath.value_at([category, reference], root_manifest)
+      end
+
+      def lookup_path(category, reference)
+        path = [category, reference]
+        raw_manifest = DataPath.value_at(path, root_manifest)
+
+        if raw_manifest
+          return self.class.category_to_manifest_class(category).new(root_manifest, path)
+        end
+
+        nil
+      end
+
+      def lookup(reference)
+        prioritized_categories = %i[command type error domain organization processor processor_class]
+
+        prioritized_categories.each do |category|
+          path = [category, reference]
+          raw_manifest = DataPath.value_at(path, root_manifest)
+
+          if raw_manifest
+            return self.class.category_to_manifest_class(category).new(root_manifest, path)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Foobara
+  module Manifest
+    # TODO: override new to return Entity when it's an entity
+    class Type < BaseManifest
+      self.category_symbol = :type
+
+      class << self
+        def new(root_manifest, path)
+          type = super(root_manifest, path)
+
+          if self == Type
+            if type.entity?
+              type = Entity.new(type.root_manifest, type.path)
+            elsif type.model?
+              type = Model.new(type.root_manifest, type.path)
+            end
+          end
+
+          type
+        end
+      end
+
+      def type_manifest
+        relevant_manifest
+      end
+
+      def entity?
+        type = base_type
+
+        while type
+          return true if type.reference.to_sym == :entity
+
+          type = type.base_type
+        end
+
+        false
+      end
+
+      def model?
+        return false if reference == "entity"
+
+        type = base_type
+
+        while type
+          return true if type.reference.to_sym == :model
+
+          type = type.base_type
+        end
+
+        false
+      end
+
+      def base_type
+        base_type_symbol = self[:base_type]
+
+        if base_type_symbol
+          Type.new(root_manifest, [:type, self[:base_type]])
+        end
+      end
+
+      def target_class
+        if target_classes.size != 1
+          # :nocov:
+          raise "Can only use #target_class for types with one target class but #{name} has #{target_classes.size}"
+          # :nocov:
+        end
+
+        target_classes.first
+      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 type_name
+        scoped_name
+      end
+
+      def full_type_name
+        scoped_full_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+require_relative "base_manifest"
+
+module Foobara
+  module Manifest
+    class TypeDeclaration < BaseManifest
+      optional_keys(:allow_nil, :one_of)
+
+      class << self
+        def new(root_manifest, path)
+          type_declaration = super(root_manifest, path)
+
+          if self == TypeDeclaration
+            case type_declaration.type.to_sym
+            when :attributes
+              Attributes.new(type_declaration.root_manifest, type_declaration.path)
+            when :array
+              Array.new(type_declaration.root_manifest, type_declaration.path)
+            else
+              type_declaration
+            end
+          else
+            type_declaration
+          end
+        end
+      end
+
+      # rubocop:disable Naming/MemoizedInstanceVariableName
+      # TODO: create an Attribute class to encapsulate this situation
+      def attribute?
+        return @is_attribute if defined?(@is_attribute)
+
+        parent_path_atom = path[2..][-2]
+        @is_attribute = [:element_type_declarations, "element_type_declarations"].include?(parent_path_atom)
+      end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
+
+      def parent_attributes
+        return @parent_attributes if defined?(@parent_attributes)
+
+        raise "Not an attribute" unless attribute?
+
+        @parent_attributes = Attributes.new(root_manifest, path[0..-3])
+      end
+
+      def attribute_name
+        return @attribute_name if defined?(@attribute_name)
+
+        raise "Not an attribute" unless attribute?
+
+        @attribute_name = path[-1]
+      end
+
+      def required?
+        parent_attributes.required?(attribute_name)
+      end
+
+      def default
+        parent_attributes.default_for(attribute_name)
+      end
+
+      def allows_nil?
+        allow_nil
+      end
+
+      def type_declaration_manifest
+        relevant_manifest
+      end
+
+      def attributes?
+        type.to_sym == :attributes
+      end
+
+      def array?
+        type.to_sym == :array
+      end
+
+      def model?
+        return @model if defined?(@model)
+
+        @model = to_type.model?
+      end
+
+      def to_model
+        raise "not an model" unless model?
+        raise "model extension instead of an model" unless relevant_manifest.size == 1
+
+        type = to_type
+
+        raise "not an model" unless type.model?
+
+        type
+      end
+
+      def entity?
+        return @entity if defined?(@entity)
+
+        @entity = to_type.entity?
+      end
+
+      def to_entity
+        raise "not an entity" unless entity?
+        raise "entity extension instead of an entity" unless relevant_manifest.size == 1
+
+        type = to_type
+
+        raise "not an entity" unless type.entity?
+
+        type
+      end
+
+      def to_type
+        # awkward??
+        @to_type ||= find_type(self)
+      end
+    end
+  end
+end

data/projects/model/lib/foobara/model.rb

@@ -0,0 +1,23 @@
+require "date"
+require "time"
+require "bigdecimal"
+
+module Foobara
+  class Model
+    class << self
+      def install!
+        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendModelTypeDeclaration.new)
+        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendRegisteredModelTypeDeclaration.new)
+
+        atomic_duck = Namespace.global.foobara_lookup_type!(:atomic_duck)
+        BuiltinTypes.build_and_register!(:model, atomic_duck, nil)
+        # address = build_and_register!(:address, model)
+        # us_address = build_and_register!(:us_address, model)
+      end
+
+      def reset_all
+        install!
+      end
+    end
+  end
+end

data/projects/model/src/concerns/reflection.rb

@@ -0,0 +1,22 @@
+module Foobara
+  class Model
+    module Concerns
+      module Reflection
+        include Concern
+
+        module ClassMethods
+          def foobara_manifest(to_include:)
+            Util.remove_blank(
+              attributes_type: attributes_type.declaration_data,
+              organization_name:,
+              domain_name:,
+              model_name:,
+              model_base_class: model_type.declaration_data[:model_base_class],
+              model_class: model_type.declaration_data[:model_class]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/concerns/types.rb

@@ -0,0 +1,104 @@
+module Foobara
+  class Model
+    module Concerns
+      module Types
+        include Concern
+
+        foobara_delegate :attributes_type, to: :class
+
+        module ClassMethods
+          attr_reader :model_type
+          attr_writer :attributes_type
+
+          def attributes(*args, **opts, &)
+            new_type = domain.foobara_type_from_declaration(*args, **opts, &)
+
+            unless new_type.extends?(BuiltinTypes[:attributes])
+              # :nocov:
+              raise ArgumentError, "Expected #{args} #{opts} to extend :attributes " \
+                                   "but instead it resulted in: #{new_type.declaration_data}"
+              # :nocov:
+            end
+
+            existing_type = attributes_type
+
+            if existing_type
+              declaration = TypeDeclarations::Attributes.merge(
+                existing_type.declaration_data,
+                new_type.declaration_data
+              )
+
+              new_type = domain.foobara_type_from_declaration(declaration)
+            end
+
+            self.attributes_type = new_type
+
+            set_model_type
+          end
+
+          def set_model_type
+            return if abstract?
+
+            if attributes_type
+              declaration = type_declaration(attributes_type.declaration_data)
+
+              domain.foobara_type_from_declaration(declaration)
+
+              unless @model_type
+                # :nocov:
+                raise "Expected model type to automatically be registered"
+                # :nocov:
+              end
+            end
+          end
+
+          def type_declaration(attributes_declaration)
+            if name.start_with?(closest_namespace_module.name)
+              model_module_name = closest_namespace_module.name
+              model_name = name.gsub(/^#{closest_namespace_module.name}::/, "")
+            else
+              model_module_name = nil
+              model_name = name
+            end
+
+            Util.remove_blank(
+              type: :model,
+              name: model_name,
+              model_module: model_module_name,
+              model_class: self,
+              model_base_class: superclass,
+              attributes_declaration:,
+              description:,
+              _desugarized: { type_absolutified: true }
+            )
+          end
+
+          def attributes_type
+            return @attributes_type if @attributes_type
+
+            @attributes_type = if model_type
+                                 model_type.element_types
+                               elsif ancestors.find { |ancestor| ancestor < Model }
+                                 superclass.attributes_type
+                               end
+          end
+
+          def model_type=(model_type)
+            @model_type = model_type
+
+            attributes_type.element_types.each_key do |attribute_name|
+              define_method attribute_name do
+                read_attribute(attribute_name)
+              end
+
+              # TODO: let's cache validation_errors and clobber caches when updating this for performance reasons
+              define_method "#{attribute_name}=" do |value|
+                write_attribute(attribute_name, value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/model/src/extensions/builtin_types/model/casters/hash.rb

@@ -0,0 +1,23 @@
+module Foobara
+  module BuiltinTypes
+    module Model
+      module Casters
+        class Hash < Attributes::Casters::Hash
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def cast(attributes)
+            model_class.new(super)
+          end
+
+          def model_class
+            Object.const_get(parent_declaration_data[:model_class])
+          end
+        end
+      end
+    end
+  end
+end