foobara 0.0.59 → 0.0.60

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b7be87ca46efe6904e7dbda58946be00c552a293d46dc792cd58754f25cbdd1
-  data.tar.gz: '099e7378170b4855e04e09cadf67e86bf98532e752dd94b4c53bc0c394ab81bb'
+  metadata.gz: 66d592a242dce3e961e2ced3ff1a86de06c4d2a2689aa4855ad5a4ca7c5f53e9
+  data.tar.gz: c8b15ee8720b452e8e1d120372d51796ac901b733907f98b60d68dec02bf0dc7
 SHA512:
-  metadata.gz: d9aeb29f8a439ba5eeaee556aac014b9c309284232d4f729ca4c8319baf5d2a09a4859f2fb5c6abb4d8bc969ba8e0c7a1627479bf64e0bca66d63332bdeac9b8
-  data.tar.gz: d7da4a626362ccb44a79e3ac2eba674eecb467d89f2d247578bcc5f72931a451a43cd38996c7246855eb0149a18f029bbbd0ab21e251d01a8039f1328029287f
+  metadata.gz: 9993251bdfc128748b97119cafd9fd6f939c1f73617d5b5b0096d9171deaf24f8a125c653160b5576d44c1422fe63e2f044b29b235a2801668502170ea7c5c0e
+  data.tar.gz: 8fbcc20d12ff7a3dab1d0ba92c67df095ba73979d407c167816db610bc9ade966e8c6c2bfb4effebbf0ac3b9396554a420b772ec2c6a1a7603cd466602a08aec

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## [0.0.58] - 2025-02-20
+## [0.0.60] - 2025-02-22
+
+- Now including domain mappers in the .depends_on call is optional. If you include any of them, you must include all
+  of them. Otherwise, you can include none of them and then no verification of them will be performed.
+- Introduce a ranking/scoring system of domain mapper matches to help with certain ambiguous situations
+
+## [0.0.59] - 2025-02-20
 
 - DomainMapper no longer inherits from Command. Instead, both include CommandPatternImplementation mixin
 

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

@@ -45,13 +45,33 @@ module Foobara
           end
         end
 
+        module ClassMethods
+          def domain_map_criteria
+            return @domain_map_criteria if @domain_map_criteria
+
+            has_explicit_mapper_deps = depends_on.any? do |c|
+              foobara_lookup_domain_mapper(c)
+            end
+
+            @domain_map_criteria = if has_explicit_mapper_deps
+                                     ->(mapper) { depends_on?(mapper) }
+                                   end
+          end
+        end
+
         include Concern
 
         def run_mapped_subcommand!(subcommand_class, unmapped_inputs = {}, to = nil)
+          unless subcommand_class
+            # :nocov:
+            raise ArgumentError, "subcommand_class is required"
+            # :nocov:
+          end
+
           mapped_something = false
           no_mapper_found = nil
 
-          criteria = ->(mapper) { self.class.depends_on?(mapper) }
+          criteria = self.class.domain_map_criteria
 
           inputs_mapper = self.class.domain.lookup_matching_domain_mapper(
             from: unmapped_inputs,
@@ -88,7 +108,7 @@ module Foobara
             result_mapper = self.class.domain.lookup_matching_domain_mapper(
               from: result,
               to:,
-              criteria: ->(domain_mapper) { self.class.depends_on?(domain_mapper) },
+              criteria:,
               strict: true
             )
           end
@@ -99,24 +119,26 @@ module Foobara
           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
+            if criteria
+              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
             end
 
             raise NoDomainMapperFoundError.new(subcommand_class, to)
@@ -125,12 +147,12 @@ module Foobara
           result
         end
 
-        def domain_map(...)
-          self.class.domain.foobara_domain_map(...)
+        def domain_map(*, **, &)
+          self.class.domain.foobara_domain_map(*, criteria: self.class.domain_map_criteria, strict: true, **, &)
         end
 
-        def domain_map!(...)
-          self.class.domain.foobara_domain_map!(...)
+        def domain_map!(*, **, &)
+          self.class.domain.foobara_domain_map!(*, criteria: self.class.domain_map_criteria, strict: true, **, &)
         end
       end
     end

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

@@ -79,6 +79,10 @@ module Foobara
           end
 
           def verify_depends_on!(subcommand_class)
+            unless domain_map_criteria
+              return if subcommand_class < DomainMapper
+            end
+
             unless depends_on?(subcommand_class)
               # :nocov:
               raise SubcommandNotRegistered, "Need to declare #{subcommand_class} on #{self} with .depends_on"

data/projects/domain/src/domain_module_extension.rb

@@ -133,7 +133,7 @@ module Foobara
           super
         end
 
-        def foobara_domain_map(value, to: nil, strict: false, **opts)
+        def foobara_domain_map(value, to: nil, strict: false, criteria: nil, should_raise: false, **opts)
           invalid_keys = opts.keys - [:from]
 
           if invalid_keys.any?
@@ -144,23 +144,27 @@ module Foobara
 
           from = if opts.key?(:from)
                    opts[:from]
-                 elsif !strict
+                 else
+                   try_nil = true
                    value
                  end
 
-          mapper = lookup_matching_domain_mapper(from:, to:, strict:)
-
-          mapper&.map!(value)
-        end
+          mapper = lookup_matching_domain_mapper(from:, to:, criteria:, strict:)
 
-        def foobara_domain_map!(value, from: value, to: nil, strict: false)
-          mapper = lookup_matching_domain_mapper(from:, to:, strict:)
+          if try_nil
+            from = nil
+            mapper = lookup_matching_domain_mapper(from:, to:, criteria:, strict:)
+          end
 
-          unless mapper
+          if mapper
+            mapper.map!(value)
+          elsif should_raise
             raise Foobara::DomainMapperLookups::NoDomainMapperFoundError.new(from, to, value:)
           end
+        end
 
-          mapper.map!(value)
+        def foobara_domain_map!(value, from: nil, to: nil, criteria: nil, strict: false)
+          foobara_domain_map(value, from:, to:, criteria:, strict:, should_raise: true)
         end
 
         def foobara_domain_name

data/projects/domain_mapper/src/domain_mapper.rb

@@ -1,4 +1,7 @@
 module Foobara
+  # NOTE: If you depend_on a domain mapper in a command, then you need to depend on all domain mappers
+  # that that command uses. Or you can just exclude all of them in which case Foobara won't enforce
+  # explicit depends_on of domain mappers.
   class DomainMapper
     include CommandPatternImplementation
 
@@ -38,22 +41,37 @@ module Foobara
       end
 
       def matches?(type_indicator, value)
-        return true if type_indicator.nil? || value.nil? || type_indicator == value
+        match_score(type_indicator, value)&.>(0)
+      end
+
+      def applicable_score(from_value, to_value)
+        [*match_score(from_type, from_value), *match_score(to_type, to_value)].sum
+      end
+
+      def match_score(type_indicator, value)
+        return 1 if type_indicator.nil? || value.nil?
+        return 20 if 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?
+        return 1 if type.nil?
+        return 9 if type == value
+
+        return 5 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
+            if value.declaration_data == type.declaration_data
+              8
+            end
           end
         else
           value_type = object_to_type(value)
 
           if value_type
-            matches?(type, value_type)
+            if matches?(type, value_type)
+              6
+            end
           end
         end
       end

data/projects/domain_mapper/src/domain_mapper_lookups.rb

@@ -56,7 +56,25 @@ module Foobara
         end
 
         if candidates.size > 1
-          raise AmbiguousDomainMapperError.new(from, to, candidates)
+          best = []
+          best_score = 0
+
+          candidates.each do |mapper|
+            score = mapper.applicable_score(from, to)
+
+            if score > best_score
+              best = [mapper]
+              best_score = score
+            elsif score == best_score
+              best << mapper
+            end
+          end
+
+          if best.size > 1
+            raise AmbiguousDomainMapperError.new(from, to, candidates)
+          else
+            candidates = best
+          end
         end
 
         value = candidates.first

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.59
+  version: 0.0.60
 platform: ruby
 authors:
 - Miles Georgi
 bindir: bin
 cert_chain: []
-date: 2025-02-20 00:00:00.000000000 Z
+date: 2025-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal