foobara 0.0.36 → 0.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796f1d29d3a7ab80b6ae136f254a80549a75ec952ec1219701960abe24bd1256
-  data.tar.gz: c99fc6d286203521a9242dbc7ed042a27161b12fb213eec3b44c02f4cca26236
+  metadata.gz: b44ab7dcd4b578702ab3f310f19a631fc804b06d46c804212b700f1cda1ef98f
+  data.tar.gz: e45e7c10ae665a2e4fd3a06c366018466ec26c7b31615ff9b9dca79dac42ea1d
 SHA512:
-  metadata.gz: bd63e1dfe5afab9b6b29c855352d3db79a1fa4c04f912c385eeeeb187d2bedbf558fa929d021b276b510ce8d9b62aa4d41da92f8fba7aa6d12e6b752b47d80db
-  data.tar.gz: 992b76e3ba595df506570c311a93174e9745ed9e9f5af310cd3b56c1b0274b668f4f38bd3344499c11dd352b5e37ab7bf400ef4421e0b9810d774f91290505c7
+  metadata.gz: c68ee020e1185a6446d4880a1b8557809a82bcb46cf2ad4309dcf965d850e9803cf2da8669a8d45a4a7cc5be2801756c581f4b9ca1c1696dd521f807c95618cc
+  data.tar.gz: 4846196d83db2d9fc9ab0b56e20092eda1abf8c4722a1f7a5dfc1c05c31981696b4f5787708252931c36f127edf745795e4386197810fbc42b55b56fd8ad3c37

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.0.37] - 2024-12-11
+
+- Make DomainMappers extend Command so they have possible errors and statefulness/a cleaner API
+
 ## [0.0.36] - 2024-12-10
 
 - Fix bug with command-named convenience functions

data/README.md

@@ -1518,8 +1518,18 @@ Note that we can automatically map `animal` to CreateCapybara inputs by calling
 Let's play with it:
 
 ```irb
-
+> basil = FoobaraDemo::CapyCafe::ImportAnimal.run!(animal: { species: :capybara, first_name: "Basil", last_name: "Doe", birthday: "1000-01-01" })
+==> <Capybara:3>
+> basil.age
+==> 1024
+> basil.id
+==> 3
+> 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

@@ -23,13 +23,13 @@ module Foobara
           result = run_subcommand!(subcommand_class, inputs)
 
           if has_result_type
-            result_mapper = self.class.domain.foobara_domain_mapper_registry.lookup!(
+            result_mapper = self.class.domain.lookup_matching_domain_mapper!(
               from: result,
               to: result_type,
               strict: true
             )
 
-            result = result_mapper.map(result)
+            result = result_mapper.map!(result)
           end
 
           result

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,30 +25,28 @@ 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)
+        result = lookup_matching_domain_mapper(from:, to:, strict:)
 
         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)
         candidates = mappers.select do |mapper|
           mapper.applicable?(from, to)
         end
@@ -63,15 +61,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.37
 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