foobara 0.3.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1889d43f30de1d85f60a3a6245feffbed013f4a2ad2b357fd9b61209e815ccd3
-  data.tar.gz: e57dfcd26cfb93c4f96084a61e33325644bddfd2d5d592f19e9c608f285244fe
+  metadata.gz: 979ed0e27280b7f1183c77f8ca34eacaab8b232c719bf9f9ad4964ef309da64c
+  data.tar.gz: 819ad164acb49337551e91814f5faf3a78a825085c5b723d76fff701d4c1adcd
 SHA512:
-  metadata.gz: cd88755c0131cab9ee13fc46b38cafc779e5799aae3c33a8289198a809af9f9a021565ccaadc41d05b5a2c02aed22aad4e9ca0b3b664c0447e488ab8993c939e
-  data.tar.gz: b9c4090428c31817a87498f261a50a986594d90e8395dfd2250bd56c963373c44d10a8faa27ec0de7500c764ebfd90b6b0ee04d523d4cd7f061041727305e903
+  metadata.gz: 488905b81c1b660af40b374cef9f34ebaf5548cae9202afdb2a90680abd78be9673a7b51de2431f1ce836b7815cf82ff1be245757e86da1ea0d4bcb4eed74294
+  data.tar.gz: 4a1d3377183c75ceea13be7d1501c686c97f9b6b29f76a01e9a9b9fa0e1addd18a0fdbef4bf6879e21f383aa3dc304d6ed2c1f9d1a3ac788be3db41ecc1793eb

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [0.4.2] - 2026-01-15
+
+- Fix relaxed lookup bug for a symbol starting with a prefix
+- Allow registered types to be looked up by string and in relaxed mode
+- Create entities_plumbing project and implement auth mapping for entities
+- Implement auth mappers concept
+- Change authenticator to be a TypedTransformer
+- Allow passing a block to a connector to simplify connecting stuff a bit
+- Remove likely-unused automatic creation of Types module constants
+- Support official ruby debug
+
+# [0.4.1] - 2025-12-19
+
+- Add a model_plumbing project and use it to fix up commands when models are reregistered
+- Fix a .to_domain bug where we might grab the wrong global domain
+- Allow running Describe without a full_command_name input
+- Rename BaseManifest#path to BaseManifest#manifest_path (#61)
+- Remove attributes_type from model manifest (#60)
+- Big reorganization of this monorepo into 3 submonorepos: the top-level, typesystem, and entities
+- Make more stuff private that can be private
+
 # [0.3.0] - 2025-11-23
 
 - Fix bug caused by exposing errors with organizations as parents

data/README.md

@@ -1578,7 +1578,9 @@ module FoobaraDemo
 
         alias animal from
 
-        foobara_delegate :first_name, :last_name, :birthday, to: :animal
+        def first_name = animal.first_name
+        def last_name = animal.last_name
+        def birthday = animal.birthday
 
         def birthday_to_age
           today = Date.today
@@ -2116,128 +2118,24 @@ TODO: give some code examples
   * https://foobara.org/videos
   * https://www.youtube.com/@FoobaraFlix
 * YARD Docs
-  * All docs combined: https://docs.foobara.com/all/
+  * All docs combined: https://docs.foobara.org/all/
   * Per-repository docs: https://foobara.org/docs
 
 # Help
 
-Are you actually trying to build something with Foobara? Happy to help! miles@foobara.com
+Are you actually trying to build something with Foobara? Happy to help! miles@foobara.org
 
 # Contributing
 
 There are many ways you could help! There are tasks in the codebase for all skill levels including absolute beginner.
 There's also much need for improved documentation. If you're interested in helping but don't know how, then
-please reach out! miles@foobara.com
+please reach out! miles@foobara.org
 
 You are welcome to also contribute via a github pull request or open issues for bugs. 
 Make sure the test suite and linter pass locally before opening a pull request as 
 the build will fail if test coverage is below 100%.
 
-## Developing locally
-
-You should be able to do the typical stuff:
-
-### 1. Cloning repository:
-Fork the repository and run this(Only for SSH):
-
-```
-git clone git@github.com:${your_github_username}/foobara.git
-```
-
-Create a new branch for you to push into
-
-```
-git checkout -b <branch-name>
-```
-
-Now navigate to project directory
-
-```
-cd foobara
-```
-
-### 2. Installing mise (LINUX/WSL)
-Mise is a package manager and helps with managing different versions of ruby. It allows you to switch different versions of ruby.
-
-The installation docs might be updated by mise so here's the reference to that: [Installation Docs](https://mise.jdx.dev/installing-mise.html)
-
-***If you already installed by following mise's docs then, you can skip this section***
-
-Else to setup mise follow the script given below:
-
-```
-sudo apt update -y && sudo apt install -y gpg wget \
-build-essential \
-  libssl-dev zlib1g-dev libreadline-dev libyaml-dev libxml2-dev \
-  libxslt1-dev libffi-dev libgdbm-dev autoconf bison
-wget -qO - https://mise.jdx.dev/gpg-key.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/mise-archive-keyring.gpg 1> /dev/null
-echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=amd64] https://mise.jdx.dev/deb stable main" | sudo tee /etc/apt/sources.list.d/mise.list
-sudo apt update
-sudo apt install -y mise
-```
-
-Verify if it's installed or not by running:
-
-```
-mise -v
-```
-
-It should print out an ascii-art saying "mise-en-place"
-
-### 3. Install required ruby version
-In this project, currently we require ruby version >=3.4 so we can install it manually using the command below
-
-```
-mise use -g ruby@3.4
-```
-
-In case, you want to automatically activate the ruby version whenever you navigate to the directory containing .ruby-version file
-
-This helps a lot when you have lot of ruby projects with different versions and don't want to switch ruby versions each time manually
-
-```
-mise settings add idiomatic_version_file_enable_tools ruby
-```
-
-### 4. Activating mise
-We can activate mise so that it will update the environment variables such that we will use the correct version of ruby.
-
-```
-echo 'eval "$(mise activate bash)"' >> ~/.bashrc
-```
-
-Restart the terminal
-
-Now environment variables are updated and you can verify it by running:
-
-```
-ruby -v
-```
-
-It will print out the ruby version, which is mentioned in .ruby-version file
-
-You can list out your mise tools and its versions by running:
-
-```
-mise list
-```
-
-### 5. Running tests
-Before running test-suite, we need to install all the dependencies
-
-Run this to install all the dependencies:
-
-```
-bundle
-```
-
-Run the tests now:
-
-```
-rake
-```
-
-And if the tests/linter pass then you could dive into modifying the code
+For detailed information regarding contributing, please see [Contributing guide](./CONTRIBUTING.md)
 
 ## Monorepo Structure
 
@@ -2245,8 +2143,16 @@ Foobara is split up into many, many projects
 
 Many are in separate repositories which you can see at: https://github.com/orgs/foobara/repositories
 
-This repository, however, is a monorepo. Sometimes projects are extracted from here
-into their own repositories. Each project in this repository has its own directory in the projects/ directory.
+This repository, however, is a monorepo which in turn contains two submonorepos! You can
+see the projects in this repository in projects/ and `projects/typesystem` and `projects/entities`
+are their own submonorepos with their own `projects/` directories.
+
+These two submonorepos are in the process of being decoupled for removal into their own
+repositories/gems so that Foobara can require `typesystem` but not the less stable `entities`
+in preparation for a 1.0 release.
+
+Sometimes projects are extracted from this repository
+into their own repositories.
 
 # Licensing
 

data/lib/foobara/all.rb

@@ -0,0 +1,22 @@
+require "foobara/delegate"
+# TODO: Weird to have both of these requiring each other...
+require "foobara"
+
+module Foobara
+  # TODO: delete this but deprecate it for now to not break other projects
+  Monorepo = Foobara
+
+  module All
+    # just makes Rubocop happy
+    # TODO: delete this and make Rubocop exception in .rubocop.yml
+  end
+
+  require "foobara/model_attribute_helpers"
+  require "foobara/model_plumbing"
+  # Shouldn't this be optional? Maybe use autoload feature somehow?
+  require "foobara/in_memory_crud_driver"
+  require "foobara/domain_mapper"
+  require "foobara/manifest"
+
+  install!
+end

data/projects/command/lib/foobara/command.rb

@@ -1,12 +1,15 @@
 module Foobara
-  # TODO: Make some kind of module to house these methods instead of the Command class
-  class Service; end
-
   class Command
     class << self
       def install!
         Namespace.global.foobara_add_category_for_subclass_of(:command, self)
+
+        Domain::DomainModuleExtension::ClassMethods.prepend(
+          DomainModuleExtensionExtension::ClassMethods
+        )
       end
     end
   end
 end
+
+Foobara.project("command", project_path: "#{__dir__}/../..")

data/projects/command/src/command_pattern_implementation/concerns/subcommands.rb

@@ -10,7 +10,9 @@ module Foobara
 
         attr_accessor :is_subcommand
 
-        foobara_delegate :verify_depends_on!, to: :class
+        def verify_depends_on!(subcommand_class)
+          self.class.verify_depends_on!(subcommand_class)
+        end
 
         def subcommand?
           is_subcommand

data/projects/command/src/command_pattern_implementation/concerns/transactions.rb

@@ -1,3 +1,5 @@
+require "foobara/nested_transactionable"
+
 module Foobara
   module CommandPatternImplementation
     module Concerns
@@ -5,6 +7,7 @@ module Foobara
         include Concern
         include NestedTransactionable
 
+        # TODO: move this out of here!
         def relevant_entity_classes
           return @relevant_entity_classes if defined?(@relevant_entity_classes)
 

data/projects/command/src/extensions/domain/domain_module_extension.rb

@@ -0,0 +1,16 @@
+module Foobara
+  module Domain
+    module DomainModuleExtension
+      module ClassMethods
+        def foobara_command_classes
+          foobara_all_command(mode: Namespace::LookupMode::DIRECT)
+        end
+
+        def foobara_can_call_subcommands_from?(other_domain)
+          other_domain = Domain.to_domain(other_domain)
+          other_domain == self || self == GlobalDomain || foobara_depends_on?(other_domain)
+        end
+      end
+    end
+  end
+end

data/projects/command/src/extensions/domain/domain_module_extension_extension.rb

@@ -0,0 +1,22 @@
+# rubocop:disable Naming/FileName
+module Foobara
+  class Command
+    module DomainModuleExtensionExtension
+      module ClassMethods
+        def foobara_manifest
+          to_include = TypeDeclarations.foobara_manifest_context_to_include
+
+          commands = foobara_all_command(mode: Namespace::LookupMode::DIRECT).map do |command_class|
+            if to_include
+              to_include << command_class
+            end
+            command_class.foobara_manifest_reference
+          end.sort
+
+          super.merge(commands:)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Naming/FileName

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

@@ -0,0 +1,7 @@
+module Foobara
+  class << self
+    def all_commands
+      Namespace.global.foobara_all_command
+    end
+  end
+end

data/projects/command_connectors/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, all_after_pass: false, all_on_start: true, cmd: "bundle exec rspec", failed_mode: :focus do
+  watch(%r{^spec/(.+)_spec\.rb$})
+  watch(%r{^src/(.+)\.rb$}) { "spec/" }
+  watch(%r{^lib/(.+)\.rb$}) { "spec/" }
+  watch(%r{^spec/spec_helper.rb$}) { "spec/" }
+end

data/projects/command_connectors/lib/foobara/command_connectors.rb

@@ -32,5 +32,5 @@ module Foobara
     end
   end
 
-  project "command_connectors"
+  project "command_connectors", project_path: "#{__dir__}/../../"
 end

data/projects/command_connectors/spec/ambiguous_lookups_spec.rb

@@ -0,0 +1,143 @@
+RSpec.describe Foobara::CommandConnector do
+  after do
+    Foobara.reset_alls
+  end
+
+  before do
+    Foobara::Persistence.default_crud_driver = Foobara::Persistence::CrudDrivers::InMemory.new
+
+    stub_module :DomainA do
+      foobara_domain!
+    end
+
+    stub_module :DomainB do
+      foobara_domain!
+    end
+
+    stub_class(:User, Foobara::Entity) do
+      attributes id: :integer, name: :string
+      primary_key :id
+    end
+
+    stub_class("DomainA::User", Foobara::Entity) do
+      attributes id: :integer, name: :string
+      primary_key :id
+    end
+
+    stub_class("DomainB::User", Foobara::Entity) do
+      attributes id: :integer, name: :string
+      primary_key :id
+    end
+
+    stub_class(:SomeCommand, Foobara::Command) do
+      depends_on_entities(User)
+    end
+
+    stub_class("DomainA::SomeCommand", Foobara::Command) do
+      description "Some Command Description"
+
+      depends_on_entities(User, DomainA::User)
+    end
+
+    stub_class("DomainB::SomeCommand", Foobara::Command) do
+      depends_on_entities(User, DomainB::User)
+    end
+
+    command_connector.connect(SomeCommand)
+    command_connector.connect(DomainA::SomeCommand)
+    command_connector.connect(DomainB::SomeCommand)
+  end
+
+  let(:command_connector) { described_class.new }
+
+  describe "#transformed_command_from_name" do
+    it "can find the correct command or type despite ambiguities" do
+      expect(command_connector.lookup_command("SomeCommand").command_class).to eq(SomeCommand)
+      expect(command_connector.lookup_command(:SomeCommand).command_class).to eq(SomeCommand)
+      expect(
+        command_connector.lookup_command("DomainA::SomeCommand").command_class
+      ).to eq(DomainA::SomeCommand)
+      expect(
+        command_connector.lookup_command(:"DomainA::SomeCommand").command_class
+      ).to eq(DomainA::SomeCommand)
+      expect(
+        command_connector.lookup_command("DomainB::SomeCommand").command_class
+      ).to eq(DomainB::SomeCommand)
+      expect(
+        command_connector.lookup_command(:"DomainB::SomeCommand").command_class
+      ).to eq(DomainB::SomeCommand)
+
+      expect(command_connector.type_from_name("User").target_class).to eq(User)
+      expect(command_connector.type_from_name(:User).target_class).to eq(User)
+      expect(command_connector.type_from_name("DomainA::User").target_class).to eq(DomainA::User)
+      expect(command_connector.type_from_name(:"DomainA::User").target_class).to eq(DomainA::User)
+      expect(command_connector.type_from_name("DomainB::User").target_class).to eq(DomainB::User)
+      expect(command_connector.type_from_name(:"DomainB::User").target_class).to eq(DomainB::User)
+    end
+  end
+
+  describe "when connecting a command twice but with a suffix" do
+    before do
+      command_connector.connect(DomainA::SomeCommand, suffix: "Again")
+    end
+
+    it "registers it again but with the new name" do
+      some_command = command_connector.lookup_command("DomainA::SomeCommand")
+      some_command_again = command_connector.lookup_command("DomainA::SomeCommandAgain")
+
+      expect(some_command.command_class).to eq(DomainA::SomeCommand)
+      expect(some_command_again.command_class).to eq(DomainA::SomeCommand)
+      expect(some_command.command_name).to eq("SomeCommand")
+      expect(some_command_again.command_name).to eq("SomeCommandAgain")
+      expect(some_command_again.command_class.command_name).to eq("SomeCommand")
+
+      manifest = some_command_again.foobara_manifest
+
+      expect(manifest[:scoped_path]).to eq(["SomeCommandAgain"])
+      expect(manifest[:scoped_name]).to eq("SomeCommandAgain")
+      expect(manifest[:scoped_short_name]).to eq("SomeCommandAgain")
+      expect(manifest[:scoped_prefix]).to be_nil
+      expect(manifest[:scoped_full_path]).to eq(["DomainA", "SomeCommandAgain"])
+      expect(manifest[:scoped_full_name]).to eq("DomainA::SomeCommandAgain")
+      expect(manifest[:scoped_category]).to eq(:command)
+      expect(manifest[:reference]).to eq("DomainA::SomeCommandAgain")
+      expect(manifest[:domain]).to eq("DomainA")
+      expect(manifest[:organization]).to eq("global_organization")
+      expect(manifest[:parent]).to eq([:domain, "DomainA"])
+      expect(manifest[:types_depended_on]).to be_an(Array)
+      expect(manifest[:inputs_type]).to be_a(Hash)
+      expect(manifest[:description]).to eq("Some Command Description")
+      expect(manifest[:errors_transformers]).to be_nil
+    end
+
+    it "includes the suffixed commands in the manifest" do
+      manifest = command_connector.foobara_manifest
+
+      domain_manifest = manifest[:domain][:DomainA]
+      commands_list = domain_manifest[:commands]
+
+      expect(commands_list).to eq([
+                                    "DomainA::SomeCommand",
+                                    "DomainA::SomeCommandAgain"
+                                  ])
+    end
+  end
+
+  describe "#foobara_manifest" do
+    context "when detached" do
+      around do |example|
+        Foobara::TypeDeclarations.with_manifest_context(detached: true) do
+          example.run
+        end
+      end
+
+      it "converts entities to detached entities" do
+        manifest = command_connector.foobara_manifest
+
+        declaration_data = manifest[:type][:"DomainA::User"][:declaration_data]
+        expect(declaration_data[:type]).to eq(:detached_entity)
+        expect(declaration_data[:model_base_class]).to eq("Foobara::DetachedEntity")
+      end
+    end
+  end
+end

data/projects/command_connectors/spec/auth_mappers_spec.rb

@@ -0,0 +1,201 @@
+RSpec.describe Foobara::CommandConnector do
+  after do
+    Foobara.reset_alls
+  end
+
+  let(:command_class) do
+    stub_class(:ComputeExponent, Foobara::Command) do
+      inputs exponent: :integer, base: :integer
+      result :integer
+
+      def execute = base ** exponent
+    end
+  end
+
+  let(:command_connector) do
+    described_class.new(authenticator:, current_user: current_user_mapper)
+  end
+
+  let(:authenticator) do
+    proc { "some_user" }
+  end
+
+  let(:base) { 2 }
+  let(:exponent) { 3 }
+
+  let(:response) { command_connector.run(full_command_name:, action:, inputs:) }
+  let(:errors_hash) { response.body.errors_hash }
+
+  let(:action) { "run" }
+  let(:full_command_name) { "ComputeExponent" }
+  let(:inputs) do
+    { base:, exponent: }
+  end
+
+  describe "#run_command" do
+    class << self
+      def with_current_user_allowed_rule
+        let(:allowed_rule) do
+          -> { current_user == "current_user is some_user" }
+        end
+      end
+
+      def with_current_user_not_allowed_rule
+        let(:allowed_rule) do
+          -> { current_user == "asfdasdf" }
+        end
+      end
+
+      def with_authenticated_user_allowed_rule
+        let(:allowed_rule) do
+          -> { authenticated_user == "some_user" }
+        end
+      end
+
+      def with_authenticated_user_not_allowed_rule
+        let(:allowed_rule) do
+          -> { authenticated_user == "asfdasdf" }
+        end
+      end
+    end
+
+    shared_examples "a connector with auth mappers" do
+      before do
+        command_connector.connect(command_class, allowed_rule:)
+      end
+
+      context "when using current_user in the allowed rule" do
+        context "when allowed" do
+          with_current_user_allowed_rule
+
+          it "runs the command" do
+            expect(response.status).to be(0)
+            expect(response.body).to eq(8)
+          end
+        end
+
+        context "when not allowed" do
+          with_current_user_not_allowed_rule
+
+          it "fails with a relevant error" do
+            expect(response.status).to be(1)
+            expect(errors_hash.key?("runtime.not_allowed")).to be true
+          end
+        end
+
+        context "when calling current_user multiple times" do
+          let(:allowed_rule) do
+            -> { current_user && current_user == "current_user is some_user" }
+          end
+
+          it "runs the command" do
+            expect(response.status).to be(0)
+            expect(response.body).to eq(8)
+          end
+        end
+      end
+
+      context "when using authenticated_user in the allowed rule" do
+        context "when allowed" do
+          with_authenticated_user_allowed_rule
+
+          it "runs the command" do
+            expect(response.status).to be(0)
+            expect(response.body).to eq(8)
+          end
+        end
+
+        context "when not allowed" do
+          with_authenticated_user_not_allowed_rule
+
+          it "fails with a relevant error" do
+            expect(response.status).to be(1)
+            expect(errors_hash.key?("runtime.not_allowed")).to be true
+          end
+        end
+      end
+    end
+
+    context "when auth user mapper is a hash" do
+      let(:current_user_mapper) do
+        {
+          to: :string,
+          map: ->(authenticated_user) { "current_user is #{authenticated_user}" }
+        }
+      end
+
+      it_behaves_like "a connector with auth mappers"
+    end
+
+    context "when auth user mapper is an array" do
+      let(:current_user_mapper) { [:string, ->(authenticated_user) { "current_user is #{authenticated_user}" }] }
+
+      it_behaves_like "a connector with auth mappers"
+    end
+
+    context "when auth user mapper is a typed transformer class" do
+      let(:current_user_mapper) do
+        stub_class("SomeTypedTransformer", Foobara::TypeDeclarations::TypedTransformer) do
+          to :string
+
+          def transform(authenticated_user)
+            "current_user is #{authenticated_user}"
+          end
+        end
+      end
+
+      it_behaves_like "a connector with auth mappers"
+
+      context "when it is an instance" do
+        let(:current_user_mapper) { super().instance }
+
+        it_behaves_like "a connector with auth mappers"
+      end
+    end
+
+    context "when auth user mapper is a domain mapper" do
+      let(:current_user_mapper) do
+        stub_class("SomeDomainMapper", Foobara::DomainMapper) do
+          from :string
+          to :string
+
+          def map = "current_user is #{from}"
+        end
+      end
+
+      it_behaves_like "a connector with auth mappers"
+    end
+
+    context "when auth user mapper is a command" do
+      context "with only one input" do
+        let(:current_user_mapper) do
+          stub_class("SomeCommand", Foobara::Command) do
+            inputs auth_user: :string
+            result :string
+
+            def execute = "current_user is #{auth_user}"
+          end
+        end
+
+        it_behaves_like "a connector with auth mappers"
+      end
+
+      context "with multiple inputs but only one required input" do
+        let(:current_user_mapper) do
+          stub_class("SomeCommand", Foobara::Command) do
+            inputs do
+              foo :string
+              bar :string
+              auth_user :string, :required
+            end
+            result :string
+
+            def execute = "current_user is #{auth_user}"
+          end
+        end
+
+        it_behaves_like "a connector with auth mappers"
+      end
+    end
+  end
+end