foobara 0.2.7 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f5b2b0f1316a7d5530778566c64df6cffafb44dfdb99e5fd4797de2fbe3b0a2
-  data.tar.gz: 9819421a3b7dafcb39ac4d3dadb3b7a8ee2967648abf9adad4cc2fd094769bf3
+  metadata.gz: cd07a1cd0a343e918e6686086afa86cb0996b04a120a67381d4582bfdfae7171
+  data.tar.gz: cbfd94dde3fbee1846451afabac7ce3bb1b4b2f0ae7c49d2844df17486c18df4
 SHA512:
-  metadata.gz: 388210bea30291de942b1b42b80c5105c31a8f74a039e33ac42700c85f8052e7f229390eb57214a15d7cda3ba76767fa4934cf8c8bb2dae187dbce22ee72a631
-  data.tar.gz: bfb8114f0b127c60389fa83d0d6145178a6b3e6e28418ec2a7faaf645c16ff31d5075688edcd6005ea33fb67e02a76155286dc0cc4a93b5ad710787b2d93ad4d
+  metadata.gz: db7af13da7e1b0faff58350ea7953487f856cff45f92beb5edf8249dbeb041dffd1f7ef98cf405b5fd71c1cb6b4d46014256c48dd9432f84ea5b5688fa8cbfbe
+  data.tar.gz: 54563dc01bca8752b202ac61e50909d92794ea80357d4090c4741e27c6db705d498508d8cabee7c6dc40c28c51731cbee6449c8484f732dbb49adf3749c5aebd

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [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
+- Restructure code in some projects and make many more methods private
+
 # [0.2.7] - 2025-11-10
 
 - Fix CommandConnector authorization bug that can fail to close transactions

data/README.md

@@ -1,12 +1,25 @@
-Foobara is a software framework to help you encapsulate your high-level
-domain operations in commands, and automatically expose machine-readable formal metadata about those
-commands so that integration code can be decoupled and abstracted away.
+Foobara is a software framework that is command-centric and discoverable.
 
-This, as well as some other features of foobara, help manage domain complexity and produce
-more flexible systems.
+Domain operations are
+encapsulated in commands, which serve as the public interface to systems, and which automatically
+provide machine-readable formal metadata about those commands.
 
-You can watch a video that gives a good overview of what Foobara is and its goals here:
-[Introduction to the Foobara software framework](https://youtu.be/SSOmQqjNSVY)
+This metadata makes your domain discoverable and can be used to abstract away integrations,
+such as HTTP, CLI, MCP, whatever. It also makes your domain logic
+forward-compatible with integrations you didn't know you needed or that might not even have
+existed yet when you built your commands.
+
+This metadata is also used to help export commands from one system and import them into another
+as remote commands. This means you can write your domain logic and automatically get a Ruby SDK or Typescript SDK for
+free.
+
+This also helps with rearchitecting efforts since a remote command has the same interface
+as the local command. Domain logic refactors are not required to relocate domain logic
+in/out of other systems. And this also helps a system communicate and impose its mental model
+on consuming systems.
+
+You can use Foobara as a full standalone framework or you can use it with existing code
+as a service-objects layer and leverage the integration features of Foobara when/if necessary.
 
 <!-- TOC -->
 * [Overview of Features/Concepts/Goals](#overview-of-featuresconceptsgoals)
@@ -1565,7 +1578,7 @@ module FoobaraDemo
 
         alias animal from
 
-        foobara_delegate :first_name, :last_name, :birthday, to: :animal
+        foobara_delegate :first_name, :last_name, :birthday, to: :animal # Deprecated
 
         def birthday_to_age
           today = Date.today
@@ -2103,128 +2116,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
 
@@ -2232,8 +2141,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/namespace.rb

@@ -59,8 +59,6 @@ module Foobara
             end
           end
         end
-
-        foobara_delegate :type_for_declaration, to: :class
       end
     end
   end

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

@@ -167,8 +167,6 @@ module Foobara
             end
           end
         end
-
-        foobara_delegate :type_for_declaration, to: :class
       end
     end
   end

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

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: true, 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