foobara 0.0.142 → 0.1.2

data/projects/type_declarations/src/attributes.rb

@@ -25,12 +25,16 @@ module Foobara
             TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
           )
 
-          handler.desugarize(
-            type: "::attributes",
+          declaration = TypeDeclaration.new(
+            type: :attributes,
             element_type_declarations:,
             required:,
             defaults:
           )
+          declaration.is_absolutified = true
+          declaration.is_duped = true
+
+          handler.desugarize(declaration).declaration_data
         end
 
         def only(declaration, *keys)
@@ -49,9 +53,8 @@ module Foobara
           reject(declaration, keys_to_reject)
         end
 
-        def reject(declaration, *keys)
-          # TODO: do we really need a deep dup?
-          declaration = Util.deep_dup(declaration)
+        def reject(declaration_data, *keys)
+          declaration = TypeDeclaration.new(declaration_data)
 
           element_type_declarations = declaration[:element_type_declarations]
           required = declaration[:required]
@@ -64,17 +67,20 @@ module Foobara
 
             if element_type_declarations.key?(key)
               changed = true
-              element_type_declarations.delete(key)
+              declaration[:element_type_declarations] = declaration[:element_type_declarations].except(key)
             end
 
             if required&.include?(key)
               changed = true
+              required = required.dup
               required.delete(key)
+              declaration[:required] = required
             end
 
             if defaults&.key?(key)
               changed = true
-              defaults.delete(key)
+              defaults = defaults.except(key)
+              declaration[:defaults] = defaults
             end
           end
 
@@ -83,9 +89,9 @@ module Foobara
               TypeDeclarations::Handlers::ExtendAttributesTypeDeclaration
             )
 
-            handler.desugarize(declaration)
+            handler.desugarize(declaration).declaration_data
           else
-            declaration
+            declaration_data
           end
         end
       end

data/projects/type_declarations/src/attributes_transformers/from_yaml.rb

@@ -48,7 +48,7 @@ module Foobara
 
         declaration[:element_type_declarations].each_pair do |attribute_name, declaration_data|
           element_type_declarations[attribute_name] = if from_yaml.include?(attribute_name)
-                                                        { type: :string }
+                                                        :string
                                                       else
                                                         declaration_data
                                                       end

data/projects/type_declarations/src/desugarizer_pipeline.rb

@@ -0,0 +1,9 @@
+module Foobara
+  module TypeDeclarations
+    class DesugarizerPipeline < Value::Processor::Pipeline
+      def applicable?(type_declaration)
+        !type_declaration.strict? && super
+      end
+    end
+  end
+end

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

@@ -117,7 +117,8 @@ module Foobara
               _add_attribute(attribute_name, type)
             else
               declaration = if block
-                              attributes_declaration = Attributes.to_declaration(&block).merge(declaration)
+                              attributes_declaration =
+                                Attributes.to_declaration(&block).declaration_data.merge(declaration)
 
                               if type == :array
                                 {
@@ -173,13 +174,21 @@ module Foobara
 
         def _type_declaration
           @_type_declaration ||= begin
-            sugar = {
-              type: "::attributes",
+            declaration = TypeDeclaration.new(
+              type: :attributes,
               element_type_declarations: {}
-            }
+            )
+
+            declaration.is_absolutified = true
+            declaration.is_duped = true
 
             handler = Domain.current.foobara_type_builder.handler_for_class(Handlers::ExtendAttributesTypeDeclaration)
-            handler.desugarize(sugar)
+            declaration = handler.desugarize(declaration)
+
+            declaration.is_strict = false
+            declaration.is_absolutified = true
+
+            declaration
           end
         end
       end

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

@@ -8,18 +8,38 @@ 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 && !sugary_type_declaration.strict?
           end
 
           def desugarize(sugary_type_declaration)
-            strict_type_declaration = { type: :array, _desugarized: { type_absolutified: true } }
+            strict_type_declaration = sugary_type_declaration
+            sugary_type_declaration = sugary_type_declaration.declaration_data
+
+            strict_type_declaration.declaration_data = { type: :array }
+            strict_type_declaration.is_duped = true
+            strict_type_declaration.is_absolutified = true
 
             unless sugary_type_declaration.empty?
               element_type_declaration = sugary_type_declaration.first
 
-              handler = type_declaration_handler_for(element_type_declaration)
+              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 strict_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
 
-              strict_type_declaration[:element_type_declaration] = handler.desugarize(element_type_declaration)
+              strict_type_declaration[:element_type_declaration] = element_type_declaration
             end
 
             strict_type_declaration

data/projects/type_declarations/src/handlers/extend_array_type_declaration/element_type_declaration_desugarizer.rb

@@ -4,23 +4,37 @@ module Foobara
       class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class ElementTypeDeclarationDesugarizer < 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 false unless sugary_type_declaration.key?(:type)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
 
             type_symbol = sugary_type_declaration[:type]
 
-            type_symbol == :array && sugary_type_declaration.key?(:element_type_declaration)
+            type_symbol.is_a?(::Symbol) && type_symbol == :array &&
+              sugary_type_declaration.key?(:element_type_declaration)
           end
 
           def desugarize(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+
             sugar = sugary_type_declaration[:element_type_declaration]
 
-            handler = type_declaration_handler_for(sugar)
-            strict = handler.desugarize(sugar)
+            strict = if sugar.is_a?(Types::Type)
+                       sugar.reference_or_declaration_data
+                     else
+                       declaration = sugary_type_declaration.clone_from_part(sugar)
+
+                       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
 
             sugary_type_declaration[:element_type_declaration] = strict
 

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

@@ -7,13 +7,9 @@ module Foobara
       class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class ToTypeTransformer < ExtendAssociativeArrayTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
-            super.tap do |type|
-              element_type_declaration = type.declaration_data[:element_type_declaration]
-
-              if element_type_declaration
-                type.element_type = type_for_declaration(element_type_declaration)
-              end
-            end
+            type = super
+            type.element_type = :Array
+            type
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_array_type_declaration/type_set_to_array_desugarizer.rb

@@ -7,21 +7,32 @@ module Foobara
         # TODO: make a quick way to convert a couple simple procs into a transformer
         class TypeSetToArrayDesugarizer < ArrayDesugarizer
           def applicable?(sugary_type_declaration)
-            if sugary_type_declaration.is_a?(::Hash) && sugary_type_declaration.key?(:type)
-              extra_keys = sugary_type_declaration.keys - [:type, :description, :sensitive, :sensitive_exposed]
+            if sugary_type_declaration.hash? && sugary_type_declaration.key?(:type)
+              extra_keys = sugary_type_declaration.declaration_data.keys -
+                           [:type, :description, :sensitive, :sensitive_exposed]
 
               return false if extra_keys.any?
 
               type = sugary_type_declaration[:type]
 
               if type.is_a?(::Array)
-                super(type)
+                super(TypeDeclaration.new(type))
               end
             end
           end
 
           def desugarize(sugary_type_declaration)
-            strict_type_declaration = super(sugary_type_declaration[:type])
+            strict_type_declaration = TypeDeclaration.new(sugary_type_declaration[:type])
+
+            if sugary_type_declaration.deep_duped?
+              # TODO: probably not worth testing this path
+              # :nocov:
+              strict_type_declaration.is_deep_duped = true
+              strict_type_declaration.is_duped = true
+              # :nocov:
+            end
+
+            strict_type_declaration = super(strict_type_declaration)
 
             if sugary_type_declaration.key?(:description)
               strict_type_declaration[:description] = sugary_type_declaration[:description]

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

@@ -4,9 +4,19 @@ module Foobara
       # Hmmmm... this inheritance feels backwards
       class ExtendArrayTypeDeclaration < 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] == :array
+          if strictish_type_declaration.hash? && strictish_type_declaration[:type] == :array
+            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/extend_associative_array_type_declaration/key_type_declaration_desugarizer.rb

@@ -0,0 +1,48 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class KeyTypeDeclarationDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
+
+            type_symbol = sugary_type_declaration[:type]
+
+            type_symbol.is_a?(::Symbol) && type_symbol == :associative_array &&
+              sugary_type_declaration.key?(:key_type_declaration)
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+
+            sugar = sugary_type_declaration[:key_type_declaration]
+
+            strict = if sugar.is_a?(Types::Type)
+                       sugar.reference_or_declaration_data
+                     else
+                       declaration = sugary_type_declaration.clone_from_part(sugar)
+
+                       if sugary_type_declaration.deep_duped?
+                         declaration.is_deep_duped = true
+                         declaration.is_duped = true
+                       end
+
+                       handler = type_declaration_handler_for(declaration)
+                       handler.desugarize(declaration).declaration_data
+                     end
+
+            sugary_type_declaration[:key_type_declaration] = strict
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,17 +9,9 @@ module Foobara
       class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
         class ToTypeTransformer < ExtendRegisteredTypeDeclaration::ToTypeTransformer
           def transform(strict_type_declaration)
-            super.tap do |type|
-              key_type_declaration = type.declaration_data[:key_type_declaration]
-              value_type_declaration = type.declaration_data[:value_type_declaration]
-
-              if key_type_declaration || value_type_declaration
-                type.element_types = [
-                  type_for_declaration(key_type_declaration || :duck),
-                  type_for_declaration(value_type_declaration || :duck)
-                ]
-              end
-            end
+            type = super
+            type.element_types = :Hash
+            type
           end
         end
       end

data/projects/type_declarations/src/handlers/extend_associative_array_type_declaration/value_type_declaration_desugarizer.rb

@@ -0,0 +1,51 @@
+require_relative "../extend_registered_type_declaration"
+require_relative "../../desugarizer"
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
+        class ValueTypeDeclarationDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false if sugary_type_declaration.strict?
+            return false unless sugary_type_declaration.hash?
+            return false unless sugary_type_declaration.all_symbolizable_keys?
+
+            type_symbol = sugary_type_declaration[:type]
+
+            type_symbol.is_a?(::Symbol) && type_symbol == :associative_array &&
+              sugary_type_declaration.key?(:value_type_declaration)
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugary_type_declaration.symbolize_keys!
+
+            sugar = sugary_type_declaration[:value_type_declaration]
+
+            strict = if sugar.is_a?(Types::Type)
+                       sugar.reference_or_declaration_data
+                     else
+                       declaration = sugary_type_declaration.clone_from_part(sugar)
+
+                       if sugary_type_declaration.deep_duped?
+                         declaration.is_deep_duped = true
+                         declaration.is_duped = true
+                       end
+
+                       handler = type_declaration_handler_for(declaration)
+                       handler.desugarize(declaration).declaration_data
+                     end
+
+            sugary_type_declaration[:value_type_declaration] = strict
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,19 @@ module Foobara
     module Handlers
       class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
         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] == :associative_array
+          if strictish_type_declaration.hash? && strictish_type_declaration[:type] == :associative_array
+            unless strictish_type_declaration.equal?(sugary_type_declaration)
+              sugary_type_declaration.assign(strictish_type_declaration)
+            end
+
+            true
+          end
         end
 
         # TODO: do we really need this? Isn't this the default?

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

@@ -6,7 +6,7 @@ module Foobara
       class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
         class DslDesugarizer < TypeDeclarations::Desugarizer
           def applicable?(sugary_type_declaration)
-            sugary_type_declaration.is_a?(::Proc)
+            sugary_type_declaration.proc?
           end
 
           def desugarize(block)

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