foobara 0.0.142 → 0.1.1

data/projects/type_declarations/src/handlers/extend_attributes_type_declaration/element_type_declarations_desugarizer.rb

@@ -9,16 +9,26 @@ module Foobara
         # TODO: make a quick way to convert a couple simple procs into a transformer
         class ElementTypeDeclarationsDesugarizer < HashDesugarizer
           def desugarize(sugary_type_declaration)
-            sugary_type_declaration = sugary_type_declaration.dup
-
             sugary_type_declaration[:element_type_declarations] =
               sugary_type_declaration[:element_type_declarations].to_h do |attribute_name, element_type_declaration|
-                if attribute_name != :_desugarized
-                  handler = type_declaration_handler_for(element_type_declaration)
-                  element_type_declaration = handler.desugarize(element_type_declaration)
-                end
+                element_type_declaration = if element_type_declaration.is_a?(Types::Type)
+                                             element_type_declaration.reference_or_declaration_data
+                                           else
+                                             declaration = TypeDeclaration.new(element_type_declaration)
+
+                                             if sugary_type_declaration.deep_duped?
+                                               # TODO: probably not worth directly testing this path
+                                               # :nocov:
+                                               declaration.is_deep_duped = true
+                                               declaration.is_duped = true
+                                               # :nocov:
+                                             end
+
+                                             handler = type_declaration_handler_for(declaration)
+                                             handler.desugarize(declaration).declaration_data
+                                           end
 
-                [attribute_name, element_type_declaration]
+                [attribute_name.to_sym, element_type_declaration]
               end
 
             sugary_type_declaration

data/projects/type_declarations/src/handlers/extend_attributes_type_declaration/hash_desugarizer.rb

@@ -7,40 +7,36 @@ module Foobara
       class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class HashDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            return false unless sugary_type_declaration.is_a?(::Hash)
-            return false unless Util.all_symbolizable_keys?(sugary_type_declaration)
-
-            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
-
-            return true unless sugary_type_declaration.key?(:type)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
 
             type_symbol = sugary_type_declaration[:type]
 
-            if [:attributes, "attributes"].include?(type_symbol)
+            unless type_symbol
+              return sugary_type_declaration.all_symbolizable_keys?
+            end
+
+            if type_symbol == :attributes
               sugary_type_declaration.key?(:element_type_declarations) &&
                 Util.all_symbolizable_keys?(sugary_type_declaration[:element_type_declarations])
             elsif type_symbol.is_a?(::Symbol)
-              # Why is this done?
+              # if the type isn't registered we will assume it's an attribute named type
               !type_registered?(type_symbol)
             end
           end
 
           def desugarize(sugary_type_declaration)
-            sugary_type_declaration = Util.deep_dup(sugary_type_declaration)
-
-            Util.symbolize_keys!(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
 
             unless strictish_type_declaration?(sugary_type_declaration)
-              sugary_type_declaration = {
+              sugary_type_declaration.declaration_data = {
                 type: :attributes,
-                _desugarized: { type_absolutified: true },
-                element_type_declarations: sugary_type_declaration
+                element_type_declarations: sugary_type_declaration.declaration_data
               }
-
+              sugary_type_declaration.is_absolutified = true
+              sugary_type_declaration.is_duped = true
             end
 
-            Util.symbolize_keys!(sugary_type_declaration[:element_type_declarations])
-
             sugary_type_declaration
           end
 
@@ -51,8 +47,9 @@ module Foobara
           private
 
           def strictish_type_declaration?(hash)
-            keys = hash.keys.map(&:to_sym)
-            keys.include?(:type) && keys.include?(:element_type_declarations)
+            if hash.key?(:type) || hash.key?("type")
+              hash.key?(:element_type_declarations) || hash.key?("element_type_declarations")
+            end
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_attributes_type_declaration/to_type_transformer.rb

@@ -7,12 +7,9 @@ module Foobara
       class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
-            super.tap do |type|
-              type_declarations = type.declaration_data[:element_type_declarations]
-              type.element_types = type_declarations&.transform_values do |attribute_declaration|
-                type_for_declaration(attribute_declaration)
-              end
-            end
+            type = super
+            type.element_types = :Attributes
+            type
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_attributes_type_declaration.rb

@@ -3,8 +3,19 @@ module Foobara
     module Handlers
       class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         def applicable?(sugary_type_declaration)
-          strictish_type_declaration = desugarize(sugary_type_declaration)
-          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :attributes
+          strictish_type_declaration = if sugary_type_declaration.strict?
+                                         sugary_type_declaration
+                                       else
+                                         desugarize(sugary_type_declaration.clone)
+                                       end
+
+          if strictish_type_declaration.hash? && strictish_type_declaration[:type] == :attributes
+            unless strictish_type_declaration.equal?(sugary_type_declaration)
+              sugary_type_declaration.assign(strictish_type_declaration)
+            end
+
+            true
+          end
         end
 
         def priority

data/projects/type_declarations/src/handlers/extend_registered_type_declaration/to_type_transformer.rb

@@ -16,7 +16,7 @@ module Foobara
             validators = []
             element_processors = []
 
-            additional_processors_to_apply = strict_type_declaration.except(*non_processor_keys)
+            additional_processors_to_apply = strict_type_declaration.declaration_data.except(*non_processor_keys)
 
             # TODO: validate the name
             additional_processors_to_apply.each_pair do |processor_symbol, declaration_data|
@@ -49,7 +49,7 @@ module Foobara
             sensitive_exposed = strict_type_declaration[:sensitive_exposed]
 
             type_class.new(
-              strict_type_declaration,
+              strict_type_declaration.declaration_data,
               base_type:,
               description: strict_type_declaration[:description],
               casters:,
@@ -74,7 +74,7 @@ module Foobara
           end
 
           def non_processor_keys
-            [:type, :_desugarized, :description, :sensitive, :sensitive_exposed]
+            [:type, :description, :sensitive, :sensitive_exposed]
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_registered_type_declaration.rb

@@ -5,13 +5,25 @@ module Foobara
     module Handlers
       class ExtendRegisteredTypeDeclaration < RegisteredTypeDeclaration
         def applicable?(sugary_type_declaration)
-          strict_type_declaration = desugarize(sugary_type_declaration)
+          strict_type_declaration = if sugary_type_declaration.strict?
+                                      # :nocov:
+                                      sugary_type_declaration
+                                      # :nocov:
+                                    else
+                                      desugarize(sugary_type_declaration.clone)
+                                    end
 
-          return false unless strict_type_declaration.is_a?(::Hash)
+          return false unless strict_type_declaration.hash?
           # if there's no processors to extend the existing type with, then we don't handle that here
-          return false if strict_type_declaration.keys == [:type]
+          return false if strict_type_declaration.declaration_data.keys == [:type]
 
-          super(strict_type_declaration.slice(:type))
+          applicable = super(strict_type_declaration.slice(:type))
+
+          if applicable && !sugary_type_declaration.equal?(strict_type_declaration)
+            sugary_type_declaration.assign(strict_type_declaration)
+          end
+
+          applicable
         end
 
         def priority

data/projects/type_declarations/src/handlers/extend_tuple_type_declaration/array_desugarizer.rb

@@ -8,20 +8,34 @@ module Foobara
         # TODO: make a quick way to convert a couple simple procs into a transformer
         class ArrayDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            sugary_type_declaration.is_a?(::Array) && sugary_type_declaration.size > 1
+            sugary_type_declaration.array? && sugary_type_declaration.size > 1
           end
 
           def desugarize(sugary_type_declaration)
-            element_type_declarations = sugary_type_declaration.map do |element_type_declaration|
-              handler = type_declaration_handler_for(element_type_declaration)
-
-              handler.desugarize(element_type_declaration)
+            element_type_declarations = sugary_type_declaration.declaration_data.map do |element_type_declaration|
+              if element_type_declaration.is_a?(Types::Type)
+                element_type_declaration.reference_or_declaration_data
+              else
+                declaration = TypeDeclaration.new(element_type_declaration)
+                if sugary_type_declaration.deep_duped?
+                  # TODO: probably not worth directly testing this path
+                  # :nocov:
+                  declaration.is_deep_duped = true
+                  declaration.is_duped = true
+                  # :nocov:
+                end
+                handler = type_declaration_handler_for(declaration)
+                handler.desugarize(declaration).declaration_data
+              end
             end
 
-            {
+            sugary_type_declaration.declaration_data = {
               type: :tuple,
               element_type_declarations:
             }
+            sugary_type_declaration.is_strict = true
+
+            sugary_type_declaration
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_tuple_type_declaration/to_type_transformer.rb

@@ -7,15 +7,9 @@ module Foobara
       class ExtendTupleTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
-            super.tap do |type|
-              element_type_declarations = type.declaration_data[:element_type_declarations]
-
-              if element_type_declarations && !element_type_declarations.empty?
-                type.element_types = element_type_declarations.map do |element_type_declaration|
-                  type_for_declaration(element_type_declaration)
-                end
-              end
-            end
+            type = super
+            type.element_types = :Tuple
+            type
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_tuple_type_declaration.rb

@@ -3,9 +3,19 @@ module Foobara
     module Handlers
       class ExtendTupleTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         def applicable?(sugary_type_declaration)
-          strictish_type_declaration = desugarize(sugary_type_declaration)
+          strictish_type_declaration = if sugary_type_declaration.strict?
+                                         sugary_type_declaration
+                                       else
+                                         desugarize(sugary_type_declaration.clone)
+                                       end
 
-          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :tuple
+          if strictish_type_declaration.hash? && strictish_type_declaration[:type] == :tuple
+            unless strictish_type_declaration.equal?(sugary_type_declaration)
+              sugary_type_declaration.assign(strictish_type_declaration)
+            end
+
+            true
+          end
         end
       end
     end

data/projects/type_declarations/src/handlers/registered_type_declaration/to_type_transformer.rb

@@ -10,16 +10,14 @@ module Foobara
             registered_type(strict_type_declaration)
           end
 
-          def type_symbol(strict_type_declaration)
-            strict_type_declaration[:type]
-          end
-
           def registered_type(strict_type_declaration)
-            symbol = type_symbol(strict_type_declaration)
-            if TypeDeclarations.strict? || TypeDeclarations.strict_stringified?
-              symbol = "::#{symbol}"
-            end
-            lookup_type!(symbol)
+            type = strict_type_declaration.type || strict_type_declaration.base_type
+
+            return type if type
+
+            type = lookup_type!(strict_type_declaration[:type], mode: Namespace::LookupMode::ABSOLUTE)
+
+            strict_type_declaration.base_type = type
           end
 
           def target_classes(strict_type_declaration)

data/projects/type_declarations/src/handlers/registered_type_declaration.rb

@@ -6,16 +6,31 @@ module Foobara
       # TODO: we should just use the symbol instead of {type: symbol} to save space and simplify some stuff...
       class RegisteredTypeDeclaration < TypeDeclarationHandler
         def applicable?(sugary_type_declaration)
-          strict_type_declaration = desugarize(sugary_type_declaration)
+          return true if sugary_type_declaration.type
 
-          return false unless strict_type_declaration.is_a?(::Hash)
+          unless sugary_type_declaration.reference_checked?
+            sugary_type_declaration.handle_symbolic_declaration
+            return true if sugary_type_declaration.type
+          end
+
+          strict_type_declaration = if sugary_type_declaration.strict?
+                                      sugary_type_declaration
+                                    else
+                                      desugarize(sugary_type_declaration.clone)
+                                    end
 
-          # we only handle case where it's a builtin type not an extension of one
-          if strict_type_declaration.keys == [:type]
-            type_symbol = strict_type_declaration[:type]
-            if type_symbol.is_a?(::Symbol) || type_symbol.is_a?(::String)
-              type_registered?(type_symbol)
+          if strict_type_declaration.reference?
+            unless strict_type_declaration.type
+              # :nocov:
+              strict_type_declaration.handle_symbolic_declaration
+              # :nocov:
             end
+
+            unless sugary_type_declaration.equal?(strict_type_declaration)
+              sugary_type_declaration.assign(strict_type_declaration)
+            end
+
+            true
           end
         end
 

data/projects/type_declarations/src/lazy_element_types/array.rb

@@ -0,0 +1,19 @@
+module Foobara
+  module TypeDeclarations
+    module LazyElementTypes
+      module Array
+        module_function
+
+        def resolve(type)
+          element_type_declaration = type.declaration_data[:element_type_declaration]
+
+          type.element_type = if element_type_declaration
+                                TypeDeclarations.strict do
+                                  Domain.current.foobara_type_from_declaration(element_type_declaration)
+                                end
+                              end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/lazy_element_types/attributes.rb

@@ -0,0 +1,27 @@
+module Foobara
+  module TypeDeclarations
+    module LazyElementTypes
+      module Attributes
+        module_function
+
+        def resolve(type)
+          type_declarations = type.declaration_data[:element_type_declarations]
+
+          type.element_types = if type_declarations
+                                 if type_declarations.empty?
+                                   {}
+                                 else
+                                   TypeDeclarations.strict do
+                                     domain = Domain.current
+
+                                     type_declarations.transform_values do |attribute_declaration|
+                                       domain.foobara_type_from_declaration(attribute_declaration)
+                                     end
+                                   end
+                                 end
+                               end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/lazy_element_types/hash.rb

@@ -0,0 +1,38 @@
+module Foobara
+  module TypeDeclarations
+    module LazyElementTypes
+      # Using Hash instead of AssociativeArray to avoid making a symbol for it
+      # (probably doesn't really matter)
+      module Hash
+        module_function
+
+        def resolve(type)
+          declaration_data = type.declaration_data
+
+          key_type_declaration = declaration_data[:key_type_declaration]
+          value_type_declaration = declaration_data[:value_type_declaration]
+
+          type.element_types = if key_type_declaration || value_type_declaration
+                                 TypeDeclarations.strict do
+                                   domain = Domain.current
+
+                                   key_declaration = if key_type_declaration
+                                                       domain.foobara_type_from_declaration(key_type_declaration)
+                                                     else
+                                                       BuiltinTypes[:duck]
+                                                     end
+
+                                   value_declaration = if value_type_declaration
+                                                         domain.foobara_type_from_declaration(value_type_declaration)
+                                                       else
+                                                         BuiltinTypes[:duck]
+                                                       end
+
+                                   [key_declaration, value_declaration]
+                                 end
+                               end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/lazy_element_types/tuple.rb

@@ -0,0 +1,23 @@
+module Foobara
+  module TypeDeclarations
+    module LazyElementTypes
+      module Tuple
+        module_function
+
+        def resolve(type)
+          element_type_declarations = type.declaration_data[:element_type_declarations]
+
+          type.element_types = if element_type_declarations
+                                 TypeDeclarations.strict do
+                                   domain = Domain.current
+
+                                   element_type_declarations.map do |element_type_declaration|
+                                     domain.foobara_type_from_declaration(element_type_declaration)
+                                   end
+                                 end
+                               end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/sensitive_type_remover.rb

@@ -2,7 +2,12 @@ module Foobara
   module TypeDeclarations
     class SensitiveTypeRemover < Value::Transformer
       def applicable?(strict_type_declaration)
-        handler.applicable?(strict_type_declaration)
+        declaration = TypeDeclaration.new(strict_type_declaration)
+
+        declaration.is_strict = true
+        declaration.is_absolutified = true
+
+        handler.applicable?(declaration)
       end
 
       def handler

data/projects/type_declarations/src/sensitive_type_removers/attributes.rb

@@ -16,6 +16,8 @@ module Foobara
           to_remove = []
 
           strict_type_declaration[:element_type_declarations].each_pair do |attribute_name, attribute_declaration|
+            next if attribute_declaration.is_a?(::Symbol)
+
             if attribute_declaration[:sensitive]
               to_remove << attribute_name
             else

data/projects/type_declarations/src/type_builder.rb

@@ -7,9 +7,13 @@ module Foobara
       def args_to_type_declaration(*args, &block)
         if block
           if args.empty? || args == [:attributes]
-            block
+            TypeDeclaration.new(block)
           elsif args == [:array]
-            { type: :array, element_type_declaration: block }
+            type_declaration = TypeDeclaration.new(type: :array, element_type_declaration: block)
+            type_declaration.is_absolutified = true
+            type_declaration.is_duped = true
+            type_declaration.is_deep_duped = true
+            type_declaration
           else
             # :nocov:
             raise ArgumentError, "Cannot provide both block and declaration of #{args}"
@@ -22,23 +26,39 @@ module Foobara
             raise ArgumentError, "expected 1 argument or a block but got 0 arguments and no block"
             # :nocov:
           when 1
-            args.first
+            arg = args.first
+
+            if arg.is_a?(TypeDeclaration)
+              arg
+            else
+              TypeDeclaration.new(arg)
+            end
           else
             type, *symbolic_processors, processor_data = args
 
-            if !symbolic_processors.empty?
-              symbolic_processors = symbolic_processors.to_h { |symbol| [symbol, true] }
-
-              if processor_data.is_a?(::Hash) && !processor_data.empty?
-                processor_data.merge(symbolic_processors)
-              else
-                symbolic_processors
-              end
-            elsif processor_data.is_a?(::Hash)
-              processor_data
-            else
-              { processor_data.to_sym => true }
-            end.merge(type:)
+            type_declaration = if !symbolic_processors.empty?
+                                 symbolic_processors = symbolic_processors.to_h { |symbol| [symbol, true] }
+
+                                 if processor_data.is_a?(::Hash) && !processor_data.empty?
+                                   h = processor_data.merge(symbolic_processors)
+                                   h[:type] = type
+                                   TypeDeclaration.new(h)
+                                 else
+                                   type_declaration = TypeDeclaration.new(symbolic_processors.merge(type:))
+                                   type_declaration.is_deep_duped = true
+                                   type_declaration
+                                 end
+                               elsif processor_data.is_a?(::Hash)
+                                 TypeDeclaration.new(processor_data.merge(type:))
+                               else
+                                 h = { type:, processor_data.to_sym => true }
+                                 type_declaration = TypeDeclaration.new(h)
+                                 type_declaration.is_deep_duped = true
+                                 type_declaration
+                               end
+
+            type_declaration.is_duped = true
+            type_declaration
           end
         end
       end
@@ -81,7 +101,7 @@ module Foobara
         end
 
         raise NoTypeDeclarationHandlerFoundError,
-              "No type declaration handler found for #{type_declaration}"
+              "No type declaration handler found for #{type_declaration.declaration_data}"
       end
 
       def handlers
@@ -94,15 +114,17 @@ module Foobara
 
       def type_for_strict_stringified_declaration(type_declaration)
         TypeDeclarations.strict_stringified do
-          handler = type_declaration_handler_for(type_declaration)
-          handler.process_value!(type_declaration)
+          declaration = TypeDeclaration.new(type_declaration)
+          handler = type_declaration_handler_for(declaration)
+          handler.process_value!(declaration)
         end
       end
 
       def type_for_strict_declaration(type_declaration)
         TypeDeclarations.strict do
-          handler = type_declaration_handler_for(type_declaration)
-          handler.process_value!(type_declaration)
+          declaration = TypeDeclaration.new(type_declaration)
+          handler = type_declaration_handler_for(declaration)
+          handler.process_value!(declaration)
         end
       end
 
@@ -123,6 +145,9 @@ module Foobara
       def type_for_declaration_without_cache(*type_declaration_bits, &)
         type_declaration = TypeDeclarations.args_to_type_declaration(*type_declaration_bits, &)
 
+        type = type_declaration.type
+        return type if type
+
         handler = type_declaration_handler_for(type_declaration)
         handler.process_value!(type_declaration)
       end