foobara 0.2.7 → 0.4.1

data/projects/{entity → entities/projects/entity}/src/not_found_error.rb

@@ -53,7 +53,17 @@ module Foobara
         data_path :string # TODO: we don't have a way to specify an exact value for a type
       end
 
-      foobara_delegate :primary_key_attribute, :full_entity_name, to: :entity_class
+      def primary_key_attribute
+        # :nocov:
+        entity_class.primary_key_attribute
+        # :nocov:
+      end
+
+      def full_entity_name
+        # :nocov:
+        entity_class.full_entity_name
+        # :nocov:
+      end
 
       def criteria
         context[:criteria]

data/projects/{in_memory_crud_driver → entities/projects/in_memory_crud_driver}/lib/foobara/in_memory_crud_driver.rb

@@ -1,3 +1,7 @@
+require "foobara/in_memory_crud_driver_minimal"
+
 # TODO: Why is this project basically empty? I guess so that optimizations can be added here?
 
 module Foobara::InMemoryCrudDriver; end
+
+require_relative "../../src/in_memory"

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

@@ -0,0 +1,6 @@
+require "foobara/persistence"
+
+module Foobara::InMemoryCrudDriverMinimal; end
+
+# TODO: just merge this into one file
+require_relative "../../src/in_memory_minimal"

data/projects/{in_memory_crud_driver_minimal → entities/projects/in_memory_crud_driver_minimal}/src/in_memory_minimal.rb

@@ -12,10 +12,6 @@ module Foobara
             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
@@ -76,6 +72,12 @@ module Foobara
           def hard_delete_all
             self.records = {}
           end
+
+          private
+
+          def get_id
+            @last_id += 1
+          end
         end
       end
     end

data/projects/{model → entities/projects/model}/lib/foobara/model.rb

@@ -1,3 +1,5 @@
+require "foobara/builtin_types"
+
 require "date"
 require "time"
 require "bigdecimal"
@@ -34,3 +36,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("model", project_path: "#{__dir__}/../..")

data/projects/{model → entities/projects/model}/src/concerns/classes.rb

@@ -51,7 +51,7 @@ module Foobara
               end
 
               if existing_module_to_copy_over
-                Foobara::Domain::DomainModuleExtension._copy_constants(
+                Foobara::Domain.copy_constants(
                   existing_module_to_copy_over, anonymous_model_class
                 )
               end

data/projects/{model → entities/projects/model}/src/concerns/types.rb

@@ -4,7 +4,9 @@ module Foobara
       module Types
         include Concern
 
-        foobara_delegate :attributes_type, to: :class
+        def attributes_type
+          self.class.attributes_type
+        end
 
         module ClassMethods
           attr_reader :model_type
@@ -222,7 +224,7 @@ module Foobara
             else
               method = :"#{attribute_name}="
 
-              if instance_methods.include?(method)
+              if method_defined?(method)
                 # TODO: test this code path
                 # :nocov:
                 remove_method method

data/projects/entities/projects/model/src/extensions/domain/module_extension.rb

@@ -0,0 +1,20 @@
+module Foobara
+  module Domain
+    module ModuleExtension
+      private
+
+      def foobara_set_types_mod_constant(types_mod, name, value)
+        new_value = if value.extends?(BuiltinTypes[:model])
+                      value.target_class
+                    else
+                      # TODO: test this path or delete it if unreachable
+                      # :nocov:
+                      value
+                      # :nocov:
+                    end
+
+        types_mod.const_set(name, new_value)
+      end
+    end
+  end
+end

data/projects/{model → entities/projects/model}/src/extensions/type_declarations/handlers/extend_model_type_declaration/to_type_transformer.rb

@@ -97,13 +97,13 @@ module Foobara
                   root_namespace = Namespace.current.foobara_root_namespace
                   domain = root_namespace.foobara_lookup_domain(domain_name)
 
-                  type_symbol = type.declaration_data[:name]
+                  type_symbol = type.declaration_data[:name].to_sym
 
                   if domain.foobara_type_registered?(type_symbol, mode: Namespace::LookupMode::DIRECT)
                     existing_type = domain.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::DIRECT)
 
                     if existing_type.created_in_namespace == type.created_in_namespace &&
-                       existing_type.type_symbol == type_symbol.to_sym &&
+                       existing_type.type_symbol == type_symbol &&
                        existing_type.declaration_data == type.declaration_data
                       # There's nothing different about this new model type. Let's just return the old one
                       # to reduce burdens on clearing caches.
@@ -111,10 +111,11 @@ module Foobara
                       return Outcome.success(existing_type)
                     end
 
+                    reregistering = true
                     domain.foobara_unregister(existing_type)
                   end
 
-                  type.type_symbol = type_symbol.to_sym
+                  type.type_symbol = type_symbol
 
                   model_class.description type.declaration_data[:description]
 
@@ -127,6 +128,10 @@ module Foobara
                   if type.declaration_data[:private]
                     model_class.private_attributes type.declaration_data[:private]
                   end
+
+                  if reregistering
+                    Model.fire_reregistered!(model_class)
+                  end
                 end
               end
             end

data/projects/{model → entities/projects/model}/src/model.rb

@@ -162,6 +162,18 @@ module Foobara
           end
         end
       end
+
+      # Why aren't we using the callbacks project for this?
+      def on_reregister(&block)
+        @on_reregister ||= []
+        @on_reregister << block
+      end
+
+      def fire_reregistered!(model_class)
+        @on_reregister&.each do |block|
+          block.call(model_class)
+        end
+      end
     end
 
     abstract
@@ -229,7 +241,19 @@ module Foobara
       validate! if validate # TODO: test this code path
     end
 
-    foobara_delegate :model_name, :valid_attribute_name?, :validate_attribute_name!, to: :class
+    def model_name
+      self.class.model_name
+    end
+
+    def valid_attribute_name?(attribute_name)
+      # :nocov:
+      self.class.valid_attribute_name?(attribute_name)
+      # :nocov:
+    end
+
+    def validate_attribute_name!(attribute_name)
+      self.class.validate_attribute_name!(attribute_name)
+    end
 
     def attributes
       @attributes ||= {}

data/projects/{model_attribute_helpers → entities/projects/model_attribute_helpers}/lib/foobara/model_attribute_helpers.rb

@@ -14,3 +14,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("model_attribute_helpers", project_path: "#{__dir__}/../..")

data/projects/{model_attribute_helpers → entities/projects/model_attribute_helpers}/src/attribute_helper_aliases.rb

@@ -1,4 +1,4 @@
-# This is currently the working file, fix this up/move it
+require "foobara/concerns"
 
 module Foobara
   module ModelAttributeHelpers

data/projects/{model_attribute_helpers → entities/projects/model_attribute_helpers}/src/attribute_helpers.rb

@@ -18,7 +18,7 @@ module Foobara
       # foobara_primary_key_type (nil if not an entity type)
       # foobara_associations
       module AttributeHelpers
-        include Foobara::Concern
+        include Concern
 
         module ClassMethods
           def foobara_has_primary_key?
@@ -46,15 +46,15 @@ module Foobara
 
             Namespace.use foobara_attributes_type.created_in_namespace do
               unless includes_primary_key
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+                declaration = TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
               end
 
               unless include_private
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
+                declaration = TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
               end
 
               unless include_delegates
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
+                declaration = TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
               end
 
               Domain.current.foobara_type_from_declaration(declaration)

data/projects/{nested_transactionable → entities/projects/nested_transactionable}/lib/foobara/nested_transactionable.rb

@@ -1,7 +1,7 @@
+require "foobara/persistence"
+
 module Foobara
   module NestedTransactionable
-    include Concern
-
     class << self
       def relevant_entity_classes_for_type(type)
         entity_classes = []

data/projects/{persistence → entities/projects/persistence}/lib/foobara/persistence.rb

@@ -1,3 +1,5 @@
+require "foobara/entity"
+
 module Foobara
   module Persistence
     class << self
@@ -21,3 +23,5 @@ module Foobara
     end
   end
 end
+
+Foobara.project("persistence", project_path: "#{__dir__}/../..")

data/projects/{persistence → entities/projects/persistence}/src/entity_base/transaction/concerns/transaction_tracking.rb

@@ -1,3 +1,5 @@
+require "foobara/concerns"
+
 module Foobara
   module Persistence
     class EntityBase

data/projects/{persistence → entities/projects/persistence}/src/entity_base/transaction/state_machine.rb

@@ -1,3 +1,5 @@
+require "foobara/state_machine"
+
 module Foobara
   module Persistence
     class EntityBase

data/projects/{persistence → entities/projects/persistence}/src/entity_base/transaction_table/concerns/record_tracking.rb

@@ -1,3 +1,5 @@
+require "foobara/weak_object_set"
+
 module Foobara
   module Persistence
     class EntityBase

data/projects/{persistence → entities/projects/persistence}/src/entity_base/transaction_table.rb

@@ -418,7 +418,7 @@ module Foobara
 
         def find_all_by_attribute_containing_any_of(attribute_name, values)
           values = Util.array(values)
-          return [] if values.empty?
+          return EMPTY_ARRAY if values.empty?
 
           value_type = entity_class.attributes_type.element_types[attribute_name].element_type
 
@@ -486,7 +486,7 @@ module Foobara
 
         def find_all_by_attribute_any_of(attribute_name, values)
           values = Util.array(values)
-          return [] if values.empty?
+          return EMPTY_ARRAY if values.empty?
 
           value_type = entity_class.attributes_type.element_types[attribute_name]
 

data/projects/entities/projects/weak_object_set/lib/foobara/weak_object_set.rb

@@ -0,0 +1,6 @@
+require "weakref"
+
+class Foobara::WeakObjectSet; end
+
+# TODO: just merge this into one file
+require_relative "../../src/weak_object_set"

data/projects/entities/spec/builtin_types/detached_entity_spec.rb

@@ -0,0 +1,300 @@
+RSpec.describe ":detached_entity" do
+  after do
+    Foobara.reset_alls
+    [
+      :SomeModel,
+      :SomeEntity,
+      :SomeOrg,
+      :SomeDomain
+    ].each do |const|
+      Object.send(:remove_const, const) if Object.const_defined?(const)
+    end
+  end
+
+  let(:type) do
+    Foobara::Domain.current.foobara_type_from_declaration(type_declaration)
+  end
+
+  let(:type_declaration) do
+    {
+      type: :detached_entity,
+      name: model_name,
+      attributes_declaration:,
+      primary_key:,
+      mutable:
+    }
+  end
+  let(:mutable) { false }
+  let(:primary_key) { :pk }
+  let(:model_name) { "SomeEntity" }
+  let(:attributes_declaration) do
+    {
+      foo: { type: :integer, max: 10 },
+      pk: { type: :integer, required: true },
+      # TODO: aren't we supposed to be doing required: false instead??
+      bar: { type: :string, required: true }
+    }
+  end
+
+  let(:constructed_model) { type.target_class }
+
+  describe "#read_attribute!" do
+    let(:record) { constructed_model.new }
+
+    context "when bad attribute" do
+      it "explodes" do
+        expect {
+          record.read_attribute!("asdfasdf")
+        }.to raise_error(Foobara::Model::NoSuchAttributeError)
+      end
+    end
+
+    context "when good attribute" do
+      it "doesn't explode" do
+        expect(record.read_attribute!("foo")).to be_nil
+      end
+    end
+  end
+
+  describe "#validate!" do
+    let(:record) { constructed_model.new(pk: 1) }
+
+    it "raises validation errors" do
+      expect {
+        record.validate!
+      }.to raise_error(
+        Foobara::BuiltinTypes::Attributes::SupportedValidators::Required::MissingRequiredAttributeError
+      )
+    end
+  end
+
+  it "sets model_class and model_base_class" do
+    expect(type.declaration_data[:model_class]).to eq("SomeEntity")
+    expect(type.declaration_data[:model_base_class]).to eq("Foobara::DetachedEntity")
+  end
+
+  context "when primary key doesn't point at a real attribute" do
+    let(:primary_key) { :not_a_valid_attribute }
+
+    it "explodes" do
+      expect {
+        type
+      }.to raise_error(
+        Foobara::TypeDeclarations::Handlers::ExtendEntityTypeDeclaration::
+          ValidatePrimaryKeyReferencesAttribute::InvalidPrimaryKeyError
+      )
+    end
+  end
+
+  context "when primary key isn't a symbol or a string" do
+    let(:primary_key) { Object.new }
+
+    it "explodes" do
+      expect {
+        type
+      }.to raise_error(
+        Foobara::TypeDeclarations::Handlers::ExtendEntityTypeDeclaration::ValidatePrimaryKeyIsSymbol::
+            PrimaryKeyNotSymbolError
+      )
+    end
+  end
+
+  context "when primary key is a string" do
+    let(:primary_key) { "foo" }
+
+    it "can still create the type" do
+      expect(type.declaration_data[:primary_key]).to eq(:foo)
+    end
+  end
+
+  context "when primary key is missing" do
+    let(:type_declaration) do
+      {
+        type: :detached_entity,
+        name: model_name,
+        attributes_declaration:,
+        mutable: true
+      }
+    end
+
+    it "explodes" do
+      expect {
+        type
+      }.to raise_error(
+        Foobara::TypeDeclarations::Handlers::ExtendEntityTypeDeclaration::ValidatePrimaryKeyPresent::
+            MissingPrimaryKeyError
+      )
+    end
+  end
+
+  describe "#process_value!" do
+    let(:value) { type.process_value!(value_to_process) }
+
+    context "when instantiating via type declaration instead of class" do
+      context "when constructed from attributes hash" do
+        let(:value_to_process) do
+          { "foo" => 10, "bar" => :baz, pk: 100 }
+        end
+
+        it "constructs detached value" do
+          expect(value).to be_a(constructed_model)
+          expect(value.foo).to eq(10)
+          expect(value.bar).to eq("baz")
+        end
+      end
+    end
+
+    context "when instantiating via model instance" do
+      let(:value_to_process) do
+        constructed_model.new(attributes)
+      end
+
+      let(:attributes) do
+        { "foo" => 10, "bar" => :baz, pk: 100 }
+      end
+
+      it "constructs value" do
+        expect(value).to be_a(constructed_model)
+        expect(value).to be(value_to_process)
+        expect(value).to be_valid
+      end
+    end
+  end
+
+  describe "#possible_errors" do
+    let(:mutable) { true }
+
+    it "gives expected possible errors" do
+      expect(type.possible_errors.to_h { |p| [p.key.to_sym, p.error_class] }).to eq(
+        "data.bar.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
+        "data.bar.missing_required_attribute":
+          Foobara::BuiltinTypes::Attributes::SupportedValidators::Required::MissingRequiredAttributeError,
+        "data.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
+        "data.foo.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
+        "data.foo.max_exceeded": Foobara::BuiltinTypes::Number::SupportedValidators::Max::MaxExceededError,
+        "data.missing_required_attribute":
+          Foobara::BuiltinTypes::Attributes::SupportedValidators::Required::MissingRequiredAttributeError,
+        "data.pk.cannot_cast": Foobara::Value::Processor::Casting::CannotCastError,
+        "data.pk.missing_required_attribute":
+          Foobara::BuiltinTypes::Attributes::SupportedValidators::Required::MissingRequiredAttributeError,
+        "data.unexpected_attributes":
+          Foobara::BuiltinTypes::Attributes::SupportedProcessors::ElementTypeDeclarations::UnexpectedAttributesError
+      )
+    end
+  end
+
+  describe "registering model on a domain" do
+    let(:domain) do
+      Foobara::GlobalDomain
+    end
+
+    around do |example|
+      Foobara::Namespace.use domain do
+        example.run
+      end
+    end
+
+    it "can be used by symbol" do
+      Foobara::Model.deanonymize_class(type.target_class)
+      expect(type.target_class).to eq(SomeEntity)
+      expect(domain.foobara_lookup_type!(:SomeEntity).target_class).to eq(SomeEntity)
+    end
+
+    context "when used as attribute type" do
+      let(:new_type) do
+        type
+        domain.foobara_type_from_declaration(
+          first_name: :string,
+          some_model: :SomeEntity
+        )
+      end
+      let(:record) { constructed_model.new(pk: 500, foo: 3, bar: "whatasdfsever") }
+      let(:actual_value) do
+        new_type.process_value!(
+          first_name: "SomeFirstName",
+          some_model: record
+        )
+      end
+      let(:expected_value) do
+        {
+          first_name: "SomeFirstName",
+          some_model: record
+        }
+      end
+
+      it "can process a value" do
+        expect(actual_value).to eq(expected_value)
+        expect(actual_value).to_not be(expected_value)
+        expect(actual_value.hash).to eq(expected_value.hash)
+        expect(actual_value.eql?(expected_value)).to be(true)
+      end
+
+      describe "Foobara.manifest" do
+        it "contains the type for the model" do
+          type
+          expect(Foobara.manifest[:type][:SomeEntity][:declaration_data][:name]).to eq("SomeEntity")
+        end
+      end
+    end
+  end
+
+  describe "using model_module to specify domain" do
+    let(:domain_module) {
+      stub_module "SomeDomain" do
+        foobara_domain!
+      end
+    }
+    let(:type_declaration) do
+      {
+        type: :detached_entity,
+        name: model_name,
+        attributes_declaration:,
+        model_module:,
+        primary_key:
+      }
+    end
+    let(:model_module) { domain_module }
+    let(:type) do
+      domain_module.foobara_type_from_declaration(type_declaration)
+    end
+
+    let(:constructed_model) do
+      type.target_class
+    end
+
+    it "can be used by symbol" do
+      expect(type.name).to eq("SomeEntity")
+      expect(domain_module.foobara_type_from_declaration(:SomeEntity)).to be(type)
+      expect(constructed_model.domain.foobara_type_registered?("SomeEntity")).to be(true)
+    end
+
+    it "is registered where expected" do
+      expect(type.full_type_name).to eq("SomeDomain::SomeEntity")
+      expect(constructed_model.domain.foobara_domain_name).to eq("SomeDomain")
+      expect(constructed_model.domain).to be(domain_module)
+    end
+
+    context "when using domain name instead" do
+      let(:model_module) { "SomeDomain" }
+
+      it "still works" do
+        expect(type.full_type_name).to eq("SomeDomain::SomeEntity")
+        expect(constructed_model.domain.foobara_domain_name).to eq("SomeDomain")
+      end
+    end
+  end
+
+  describe "#to_json" do
+    subject { instance.to_json }
+
+    let(:instance) { constructed_model.new(pk: 100, foo: 1, bar: "adf") }
+
+    it { is_expected.to eq("100") }
+
+    context "with no primary key" do
+      let(:instance) { constructed_model.new(foo: 1, bar: "adf") }
+
+      it { is_expected_to_raise(Foobara::Entity::CannotConvertRecordWithoutPrimaryKeyToJsonError) }
+    end
+  end
+end