foobara 0.0.36 → 0.0.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796f1d29d3a7ab80b6ae136f254a80549a75ec952ec1219701960abe24bd1256
-  data.tar.gz: c99fc6d286203521a9242dbc7ed042a27161b12fb213eec3b44c02f4cca26236
+  metadata.gz: bc8a84b48b8479025a63b5ae393436a12826aa19291bf8f60d453e891e5bc433
+  data.tar.gz: 6a0b086f7b5921f2301c566f53c8bc5b2d22f59693c9349adbeb727d49323cc4
 SHA512:
-  metadata.gz: bd63e1dfe5afab9b6b29c855352d3db79a1fa4c04f912c385eeeeb187d2bedbf558fa929d021b276b510ce8d9b62aa4d41da92f8fba7aa6d12e6b752b47d80db
-  data.tar.gz: 992b76e3ba595df506570c311a93174e9745ed9e9f5af310cd3b56c1b0274b668f4f38bd3344499c11dd352b5e37ab7bf400ef4421e0b9810d774f91290505c7
+  metadata.gz: 70b1b7689b897bc3a7b7ef790fdf3b343901602948b4107e2606cc8e5a98a3b352d70f519759246127d293fa6e81fa250ba94b7d4341199b8aa70ebbff5b603b
+  data.tar.gz: 00a4a5a17cacb2aeacf6d5b03a2938f2d93c55c598b4e109d72bd57d75234e66b457e3331a17e34a342124f731bedeadbda33c7e3ac7bb5b8bf540ca51be70ed

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.0.37] - 2024-12-11
+
+- Make DomainMappers extend Command so they have possible errors and statefulness/a cleaner API
+- Fixup domain mapper lookups to give proper values/errors in various scenarios, particularly in the context
+  of running a subcommand
+
 ## [0.0.36] - 2024-12-10
 
 - Fix bug with command-named convenience functions

data/README.md

@@ -1386,25 +1386,29 @@ module FoobaraDemo
   module CapyCafe
     foobara_depends_on AnimalHouse
 
-    class AnimalToCapybara < Foobara::DomainMapper
-      from AnimalHouse::Animal
-      to CreateCapybara
+    module DomainMappers
+      class MapAnimalToCapybara < Foobara::DomainMapper
+        from AnimalHouse::Animal
+        to CreateCapybara
+
+        def map
+          {
+                  name: "#{first_name} #{last_name}",
+                  age: birthday_to_age
+          }
+        end
 
-      def map(animal)
-        age = birthday_to_age(animal.birthday)
+        alias animal from
 
-        {
-                name: "#{animal.first_name} #{animal.last_name}",
-                age:
-        }
-      end
+        foobara_delegate :first_name, :last_name, :birthday, to: :animal
 
-      def birthday_to_age(birthday)
-        today = Date.today
-        age = today.year - birthday.year
-        birthday_this_year = Date.new(birthday.year + age, birthday.month, birthday.day)
+        def birthday_to_age
+          today = Date.today
+          age = today.year - birthday.year
+          birthday_this_year = Date.new(birthday.year + age, birthday.month, birthday.day)
 
-        today < birthday_this_year ? age - 1 : age
+          today < birthday_this_year ? age - 1 : age
+        end
       end
     end
   end
@@ -1420,7 +1424,7 @@ of a command. But we can play with it directly:
 
 ```irb
 $ ./animal_house_import.rb
-> create_capybara_inputs = FoobaraDemo::CapyCafe::AnimalToCapybara.call(species: :capybara, first_name: "Barbara", last_name: "Doe", birthday: "1000-01-01")
+> create_capybara_inputs = FoobaraDemo::CapyCafe::DomainMappers::MapAnimalToCapybara.map!(species: :capybara, first_name: "Barbara", last_name: "Doe", birthday: "1000-01-01")
 ==> {:name=>"Barbara Doe", :age=>1024}
 > barbara = FoobaraDemo::CapyCafe::CreateCapybara.run!(create_capybara_inputs)
 ==> <Capybara:2>
@@ -1430,7 +1434,11 @@ $ ./animal_house_import.rb
 ==> 2
 ```
 
-And we can increment Barbara's age now that she has been imported into our CapyCafe:
+Now let's make use of our domain mapper in a command, which is its intended purpose:
+
+```ruby
+
+```
 
 ```irb
 > FoobaraDemo::CapyCafe::IncrementAge.run!(capybara: barbara)
@@ -1444,33 +1452,6 @@ And we can increment Barbara's age now that she has been imported into our CapyC
 Now let's create a command that makes use of our domain mapper which is the typical usage pattern:
 
 ```ruby
-#!/usr/bin/env ruby
-
-require "foobara/remote_imports"
-
-[9292, 9293].each do |port|
-  Foobara::RemoteImports::ImportCommand.run!(manifest_url: "http://localhost:#{port}/manifest")
-end
-
-module FoobaraDemo
-  module AnimalHouse
-    foobara_domain!
-  end
-end
-
-module FoobaraDemo
-  module AnimalHouse
-    class Animal < Foobara::Model
-      attributes do
-        first_name :string
-        last_name :string
-        birthday :date
-        species :symbol, one_of: %i[capybara cat tartigrade]
-      end
-    end
-  end
-end
-
 module FoobaraDemo
   module CapyCafe
     class ImportAnimal < Foobara::Command
@@ -1487,7 +1468,7 @@ module FoobaraDemo
 
       possible_input_error :animal, NotACapybara
 
-      depends_on CreateCapybara
+      depends_on CreateCapybara, DomainMappers::MapAnimalToCapybara
 
       def execute
         create_capybara
@@ -1497,14 +1478,6 @@ module FoobaraDemo
 
       attr_accessor :capybara
 
-      def validate
-        species = animal.species
-
-        unless species == :capybara
-          add_input_error :animal, NotACapybara, animal: animal, species: species
-        end
-      end
-
       def create_capybara
         self.capybara = run_mapped_subcommand!(CreateCapybara, animal)
       end
@@ -1518,8 +1491,17 @@ Note that we can automatically map `animal` to CreateCapybara inputs by calling
 Let's play with it:
 
 ```irb
-
+$ ./animal_house_import.rb 
+> basil = FoobaraDemo::CapyCafe::ImportAnimal.run!(animal: { species: :capybara, first_name: "Basil", last_name: "Doe", birthday: "1000-01-01" })
+==> <Capybara:3>
+> FoobaraDemo::CapyCafe::FindCapybara.run!(id: basil).age
+==> 1024
+> FoobaraDemo::CapyCafe::IncrementAge.run!(capybara: basil)
+==> <Capybara:3>
+> FoobaraDemo::CapyCafe::FindCapybara.run!(id: basil).age
+==> 1025
 ```
+
 TODO
 
 ### Code Generators

data/projects/command/src/concerns/domain_mappers.rb

@@ -2,34 +2,124 @@ module Foobara
   class Command
     module Concerns
       module DomainMappers
+        class ForgotToDependOnDomainMapperError < Foobara::RuntimeError
+          context { mapper_name :string, :required }
+
+          attr_accessor :mapper
+
+          def initialize(mapper)
+            self.mapper = mapper
+            super()
+          end
+
+          def context
+            { mapper_name: mapper.name }
+          end
+
+          def message
+            "Did you maybe forget to add depends_on #{mapper.name}?"
+          end
+        end
+
+        class NoDomainMapperFoundError < Foobara::RuntimeError
+          context do
+            subcommand_name :string, :required
+            to :duck
+          end
+
+          attr_accessor :subcommand, :to
+
+          def initialize(subcommand, to)
+            self.subcommand = subcommand
+            self.to = to
+
+            super()
+          end
+
+          def context
+            { subcommand_name: subcommand.name, to: }
+          end
+
+          def message
+            "No DomainMapper found that maps to #{subcommand.name} or from its result"
+          end
+        end
+
         include Concern
 
-        def run_mapped_subcommand!(subcommand_class, *args)
-          unmapped_inputs, has_result_type, result_type =
-            case args.size
-            when 1
-              [args.first]
-            when 2
-              [args[1], true, args[0]]
-            else
-              # :nocov:
-              raise ArgumentError,
-                    "Wrong number of arguments: (#{args.size}. Expected 2 or 3 argument."
-              # :nocov:
-            end
+        def run_mapped_subcommand!(subcommand_class, unmapped_inputs = {}, to = nil)
+          mapped_something = false
+          no_mapper_found = nil
+
+          criteria = ->(mapper) { self.class.depends_on?(mapper) }
+
+          inputs_mapper = self.class.domain.lookup_matching_domain_mapper(
+            from: unmapped_inputs,
+            to: subcommand_class,
+            criteria:,
+            strict: true
+          )
+
+          inputs = if inputs_mapper
+                     mapped_something = true
+                     run_subcommand!(inputs_mapper, from: unmapped_inputs)
+                   else
+                     unmapped_inputs
+                   end
+
+          result_mapper = if subcommand_class.result_type
+                            mapper = self.class.domain.lookup_matching_domain_mapper(
+                              from: subcommand_class.result_type,
+                              to:,
+                              criteria:,
+                              strict: true
+                            )
 
-          inputs = domain_map!(unmapped_inputs, to: subcommand_class, strict: true)
+                            no_mapper_found = mapper.nil? && inputs_mapper.nil?
 
-          result = run_subcommand!(subcommand_class, inputs)
+                            mapper
+                          end
 
-          if has_result_type
-            result_mapper = self.class.domain.foobara_domain_mapper_registry.lookup!(
+          result = unless no_mapper_found
+                     run_subcommand!(subcommand_class, inputs)
+                   end
+
+          unless subcommand_class.result_type
+            result_mapper = self.class.domain.lookup_matching_domain_mapper(
               from: result,
-              to: result_type,
+              to:,
+              criteria: ->(domain_mapper) { self.class.depends_on?(domain_mapper) },
               strict: true
             )
+          end
+
+          if result_mapper
+            mapped_something = true
+            result = run_subcommand!(result_mapper, from: result)
+          end
+
+          unless mapped_something
+            mapper = self.class.domain.lookup_matching_domain_mapper(
+              from: unmapped_inputs,
+              to: subcommand_class,
+              strict: true
+            )
+
+            if mapper
+              raise ForgotToDependOnDomainMapperError, mapper
+            end
+
+            mapper = self.class.domain.lookup_matching_domain_mapper(
+              from: subcommand_class.result_type,
+              to:,
+              strict: true
+            )
+
+            if mapper
+              raise ForgotToDependOnDomainMapperError, mapper
+            end
 
-            result = result_mapper.map(result)
+            raise NoDomainMapperFoundError.new(subcommand_class, to)
           end
 
           result

data/projects/common/src/error.rb

@@ -67,7 +67,10 @@ module Foobara
         end
       end
 
-      def context(*args)
+      def context(*args, &block)
+        if block_given?
+          args = [*args, block]
+        end
         args_size = args.size
 
         case args_size

data/projects/domain/lib/foobara/domain.rb

@@ -14,12 +14,6 @@ module Foobara
         Namespace.global.foobara_add_category(:organization) { is_a?(Module) && foobara_organization? }
         Namespace.global.foobara_add_category(:domain) { is_a?(Module) && foobara_domain? }
       end
-
-      def reset_all
-        if Foobara::DomainMapper.instance_variable_defined?(:@foobara_domain_mappers_to_process)
-          Foobara::DomainMapper.remove_instance_variable(:@foobara_domain_mappers_to_process)
-        end
-      end
     end
   end
 end

data/projects/domain/src/domain_module_extension.rb

@@ -148,27 +148,19 @@ module Foobara
                    value
                  end
 
-          mapper = foobara_domain_mapper_registry.lookup(from:, to:, strict:)
+          mapper = lookup_matching_domain_mapper(from:, to:, strict:)
 
-          mapper&.call(value)
+          mapper&.map!(value)
         end
 
         def foobara_domain_map!(value, from: value, to: nil, strict: false)
-          mapper = foobara_domain_mapper_registry.lookup(from:, to:, strict:)
+          mapper = lookup_matching_domain_mapper(from:, to:, strict:)
+
           unless mapper
-            raise Foobara::DomainMapper::NoDomainMapperFoundError.new(from, to, value:)
+            raise Foobara::DomainMapperLookups::NoDomainMapperFoundError.new(from, to, value:)
           end
 
-          mapper.call(value)
-        end
-
-        def foobara_domain_mapper(mapper)
-          foobara_domain_mapper_registry(skip_check: true).register(mapper)
-        end
-
-        def foobara_domain_mapper_registry(skip_check: false)
-          Foobara::DomainMapper.foobara_process_domain_mappers unless skip_check
-          @foobara_domain_mapper_registry ||= DomainMapper::Registry.new
+          mapper.map!(value)
         end
 
         def foobara_domain_name

data/projects/domain_mapper/lib/foobara/domain_mapper.rb

@@ -0,0 +1,10 @@
+module Foobara
+  class DomainMapper < Foobara::Command
+    class << self
+      def install!
+        Namespace.global.foobara_add_category_for_subclass_of(:domain_mapper, self)
+        Domain::DomainModuleExtension.include Foobara::DomainMapperLookups
+      end
+    end
+  end
+end

data/projects/domain_mapper/src/domain_mapper.rb

@@ -0,0 +1,106 @@
+module Foobara
+  # TODO: would be nice to inherit from something other than Command. Can we hoist a bunch of common behavior up
+  # out of Command into some other class maybe called Service or Runnable or something?
+  class DomainMapper < Foobara::Command
+    class << self
+      def map(value)
+        new(from: value).run
+      end
+
+      def map!(value)
+        new(from: value).run!
+      end
+
+      # A bit hacky because Command only supports attributes inputs at the moment, ugg.
+      def from(...)
+        from_type = args_to_type(...)
+
+        inputs do
+          from from_type, :required
+        end
+      end
+
+      def to(...)
+        result_type = args_to_type(...)
+        result(result_type)
+      end
+
+      def from_type
+        inputs_type.element_types[:from]
+      end
+
+      def to_type
+        result_type
+      end
+
+      def applicable?(from_value, to_value)
+        matches?(from_type, from_value) && matches?(to_type, to_value)
+      end
+
+      def matches?(type_indicator, value)
+        return true if type_indicator.nil? || value.nil? || type_indicator == value
+
+        type = object_to_type(type_indicator)
+
+        return true if type.nil? || type == value
+        return true if type.applicable?(value) && type.process_value(value).success?
+
+        if value.is_a?(Types::Type)
+          if !value.registered? && !type.registered?
+            value.declaration_data == type.declaration_data
+          end
+        else
+          value_type = object_to_type(value)
+
+          if value_type
+            matches?(type, value_type)
+          end
+        end
+      end
+
+      # TODO: should this be somewhere more general-purpose?
+      def args_to_type(*args, **opts, &block)
+        if args.size == 1 && opts.empty? && block.nil?
+          object_to_type(args.first)
+        else
+          domain.foobara_type_from_declaration(*args, **opts, &block)
+        end
+      end
+
+      def object_to_type(object)
+        if object
+          if object.is_a?(::Class)
+            if object < Foobara::Model
+              object.model_type
+            elsif object < Foobara::Command
+              object.inputs_type
+            else
+              domain.foobara_type_from_declaration(object)
+            end
+          else
+            case object
+            when Types::Type
+              object
+            when ::Symbol
+              domain.foobara_lookup_type!(object)
+            end
+          end
+        end
+      end
+    end
+
+    def execute
+      map
+    end
+
+    def from
+      inputs[:from]
+    end
+
+    def map
+      # :nocov:
+      raise "subclass responsibility"
+      # :nocov:
+    end
+  end
+end

data/projects/{domain/src/domain_mapper/registry.rb → domain_mapper/src/domain_mapper_lookups.rb}

@@ -1,5 +1,5 @@
 module Foobara
-  class DomainMapper
+  module DomainMapperLookups
     class NoDomainMapperFoundError < StandardError
       attr_accessor :value, :from, :to, :has_value
 
@@ -25,31 +25,33 @@ module Foobara
       end
     end
 
-    class Registry
-      class AmbiguousDomainMapperError < StandardError
-        attr_accessor :candidates, :from, :to
+    class AmbiguousDomainMapperError < StandardError
+      attr_accessor :candidates, :from, :to
 
-        def initialize(from, to, candidates)
-          self.to = to
-          self.from = from
-          self.candidates = [*candidates].flatten
+      def initialize(from, to, candidates)
+        self.to = to
+        self.from = from
+        self.candidates = [*candidates].flatten
 
-          super("#{candidates.size} ambiguous candidates found.")
-        end
+        super("#{candidates.size} ambiguous candidates found.")
       end
+    end
 
-      def register(mapper)
-        mappers << mapper
-      end
+    include Concern
 
-      def lookup!(from: nil, to: nil, strict: false)
-        result = lookup(from:, to:, strict:)
+    module ClassMethods
+      def lookup_matching_domain_mapper!(from: nil, to: nil, strict: false, criteria: nil)
+        result = lookup_matching_domain_mapper(from:, to:, strict:, criteria:)
 
         result || raise(NoDomainMapperFoundError.new(from, to))
       end
 
-      def lookup(from: nil, to: nil, strict: false)
+      def lookup_matching_domain_mapper(from: nil, to: nil, strict: false, criteria: nil)
         candidates = mappers.select do |mapper|
+          if criteria
+            next unless criteria.call(mapper)
+          end
+
           mapper.applicable?(from, to)
         end
 
@@ -63,15 +65,15 @@ module Foobara
 
         unless strict
           if from
-            lookup(from: nil, to:)
+            lookup_matching_domain_mapper(from: nil, to:)
           elsif to
-            lookup(from:, to: nil)
+            lookup_matching_domain_mapper(from:, to: nil)
           end
         end
       end
 
       def mappers
-        @mappers ||= []
+        @mappers ||= foobara_all_domain_mapper
       end
     end
   end

data/projects/foobara/lib/foobara/all.rb

@@ -18,12 +18,11 @@ module Foobara
              "state_machine",
              "namespace"
 
-    project "domain"
-
     # various components of the foobara framework that have some level of coupling.
     # for example, Error in common knows about (or could be implemented to know about)
     # type declarations to expose its context type.
-    projects "common",
+    projects "domain",
+             "common",
              "value",
              "types",
              "type_declarations",
@@ -32,6 +31,7 @@ module Foobara
              "detached_entity",
              "entity",
              "command",
+             "domain_mapper",
              "persistence",
              "in_memory_crud_driver_minimal",
              "in_memory_crud_driver",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.36
+  version: 0.0.38
 platform: ruby
 authors:
 - Miles Georgi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-10 00:00:00.000000000 Z
+date: 2024-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foobara-util
@@ -193,8 +193,6 @@ files:
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_references_attribute.rb
 - projects/domain/lib/foobara/domain.rb
 - projects/domain/src/domain.rb
-- projects/domain/src/domain_mapper.rb
-- projects/domain/src/domain_mapper/registry.rb
 - projects/domain/src/domain_module_extension.rb
 - projects/domain/src/extensions/foobara.rb
 - projects/domain/src/global_domain.rb
@@ -204,6 +202,9 @@ files:
 - projects/domain/src/module_extension.rb
 - projects/domain/src/organization.rb
 - projects/domain/src/organization_module_extension.rb
+- projects/domain_mapper/lib/foobara/domain_mapper.rb
+- projects/domain_mapper/src/domain_mapper.rb
+- projects/domain_mapper/src/domain_mapper_lookups.rb
 - projects/entity/lib/foobara/entity.rb
 - projects/entity/src/concerns/attribute_helpers.rb
 - projects/entity/src/concerns/attributes.rb
@@ -393,6 +394,7 @@ require_paths:
 - "./projects/delegate/lib"
 - "./projects/detached_entity/lib"
 - "./projects/domain/lib"
+- "./projects/domain_mapper/lib"
 - "./projects/entity/lib"
 - "./projects/enumerated/lib"
 - "./projects/foobara/lib"

data/projects/domain/src/domain_mapper.rb

@@ -1,166 +0,0 @@
-module Foobara
-  class DomainMapper
-    class << self
-      def call(value)
-        instance.call(value)
-      end
-
-      def from(*args)
-        if args.empty?
-          @from
-        else
-          if args.size > 1
-            # :nocov:
-            raise ArgumentError, "only one argument allowed"
-            # :nocov:
-          end
-
-          @from = args.first
-        end
-      end
-
-      def to(*args)
-        if args.empty?
-          @to
-        else
-          if args.size > 1
-            # :nocov:
-            raise ArgumentError, "only one argument allowed"
-            # :nocov:
-          end
-
-          @to = args.first
-        end
-      end
-
-      def from_type
-        return @from_type if defined?(@from_type)
-
-        @from_type = object_to_type(from)
-      end
-
-      def to_type
-        return @to_type if defined?(@to_type)
-
-        @to_type = object_to_type(to)
-      end
-
-      def instance
-        @instance ||= new
-      end
-
-      def inherited(subclass)
-        foobara_domain_mapper_to_process(subclass.instance)
-
-        super
-      end
-
-      def foobara_domain_mapper_to_process(mapper)
-        foobara_domain_mappers_to_process << mapper
-      end
-
-      def foobara_domain_mappers_to_process
-        @foobara_domain_mappers_to_process ||= []
-      end
-
-      def foobara_process_domain_mappers
-        if defined?(@foobara_domain_mappers_to_process)
-          @foobara_domain_mappers_to_process.each do |mapper|
-            mapper.domain.foobara_domain_mapper(mapper)
-          end
-          remove_instance_variable(:@foobara_domain_mappers_to_process)
-        end
-      end
-
-      def domain
-        candidate = self
-
-        loop do
-          candidate = Util.module_for(candidate)
-
-          if candidate.nil?
-            # :nocov:
-            raise "Domain mapper must be scoped within a domain but #{self.class.name} is not in a domain"
-            # :nocov:
-          elsif candidate.foobara_domain?
-            return candidate
-          end
-        end
-      end
-
-      def matches?(type_indicator, value)
-        return true if type_indicator.nil? || value.nil? || type_indicator == value
-
-        type = object_to_type(type_indicator)
-
-        return true if type.nil? || type == value
-        return true if type.applicable?(value) && type.process_value(value).success?
-
-        if value.is_a?(Types::Type)
-          if !value.registered? && !type.registered?
-            value.declaration_data == type.declaration_data
-          end
-        else
-          value_type = object_to_type(value)
-
-          if value_type
-            matches?(type, value_type)
-          end
-        end
-      end
-
-      def object_to_type(object)
-        if object
-          if object.is_a?(::Class)
-            if object < Foobara::Model
-              object.model_type
-            elsif object < Foobara::Command
-              object.inputs_type
-            else
-              domain.foobara_type_from_declaration(object)
-            end
-          else
-            case object
-            when Types::Type
-              object
-            when ::Symbol
-              domain.foobara_lookup_type!(object)
-            end
-          end
-        end
-      end
-    end
-
-    def from_type
-      self.class.from_type
-    end
-
-    def to_type
-      self.class.to_type
-    end
-
-    def call(from_value)
-      from_value = from_type.process_value!(from_value)
-
-      mapped_value = map(from_value)
-
-      to_type.process_value!(mapped_value)
-    end
-
-    # TODO: can we make _from_value passed to #initialize instead? That way it doesn't have to be passed around
-    # between various helper methods
-    def map(_from_value)
-      # :nocov:
-      raise "subclass repsonsibility"
-      # :nocov:
-    end
-
-    def applicable?(from_value, to_value)
-      self.class.matches?(from_type, from_value) && self.class.matches?(to_type, to_value)
-    end
-
-    def domain
-      self.class.domain
-    end
-  end
-end