foobara 0.0.1

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

@@ -0,0 +1,36 @@
+require_relative "array_desugarizer"
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        # 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 - %i[type description]
+
+              return false if extra_keys.any?
+
+              type = sugary_type_declaration[:type]
+
+              if type.is_a?(::Array)
+                super(type)
+              end
+            end
+          end
+
+          def desugarize(sugary_type_declaration)
+            strict_type_declaration = super(sugary_type_declaration[:type])
+
+            if sugary_type_declaration.key?(:description)
+              strict_type_declaration[:description] = sugary_type_declaration[:description]
+            end
+
+            strict_type_declaration
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      # Hmmmm... this inheritance feels backwards
+      class ExtendArrayTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        def applicable?(sugary_type_declaration)
+          strictish_type_declaration = desugarize(sugary_type_declaration)
+
+          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :array
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+Foobara.require_project_file(
+  "type_declarations",
+  "handlers/extend_registered_type_declaration/to_type_transformer"
+)
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+Foobara.require_project_file("type_declarations", "handlers/extend_registered_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAssociativeArrayTypeDeclaration < ExtendRegisteredTypeDeclaration
+        def applicable?(sugary_type_declaration)
+          strictish_type_declaration = desugarize(sugary_type_declaration)
+
+          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :associative_array
+        end
+
+        # TODO: do we really need this? Isn't this the default?
+        def priority
+          Priority::LOW
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+Foobara.require_project_file("type_declarations", "handlers/extend_attributes_type_declaration/hash_desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        class DslDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration.is_a?(::Proc)
+          end
+
+          def desugarize(block)
+            Foobara::TypeDeclarations::Dsl::Attributes.to_declaration(&block)
+          end
+
+          def priority
+            # TODO: need a way to express that we must run after/before other processors so that we could just say
+            # we are higher priority than the HashDesugarizer...
+            Priority::HIGH - 1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+Foobara.require_project_file("type_declarations", "handlers/extend_attributes_type_declaration/hash_desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendAttributesTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        # 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
+
+                [attribute_name, element_type_declaration]
+              end
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::LOW
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      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)
+
+            type_symbol = sugary_type_declaration[:type]
+
+            if [:attributes, "attributes"].include?(type_symbol)
+              Util.all_symbolizable_keys?(sugary_type_declaration[:element_type_declarations])
+            elsif type_symbol.is_a?(::Symbol)
+              # Why is this done?
+              !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)
+
+            unless strictish_type_declaration?(sugary_type_declaration)
+              sugary_type_declaration = {
+                type: :attributes,
+                _desugarized: { type_absolutified: true },
+                element_type_declarations: sugary_type_declaration
+              }
+
+            end
+
+            Util.symbolize_keys!(sugary_type_declaration[:element_type_declarations])
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::HIGH
+          end
+
+          private
+
+          def strictish_type_declaration?(hash)
+            keys = hash.keys.map(&:to_sym)
+            keys.include?(:type) && keys.include?(:element_type_declarations)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+Foobara.require_project_file("type_declarations", "handlers/registered_type_declaration/to_type_transformer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Foobara
+  module TypeDeclarations
+    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
+        end
+
+        def priority
+          Priority::LOW
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+Foobara.require_project_file("type_declarations", "handlers/registered_type_declaration/to_type_transformer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredTypeDeclaration < RegisteredTypeDeclaration
+        # TODO: make a quick way to convert a couple simple procs into a transformer
+        class ToTypeTransformer < RegisteredTypeDeclaration::ToTypeTransformer
+          def transform(strict_type_declaration)
+            # TODO: maybe cache this stuff??
+            base_type = super
+
+            casters = []
+            transformers = []
+            validators = []
+            element_processors = []
+
+            additional_processors_to_apply = strict_type_declaration.except(*non_processor_keys)
+
+            # TODO: validate the name
+            additional_processors_to_apply.each_pair do |processor_symbol, declaration_data|
+              processor_class = base_type.find_supported_processor_class(processor_symbol)
+              processor = processor_class.new_with_agnostic_args(
+                declaration_data:,
+                parent_declaration_data: strict_type_declaration
+              )
+
+              category = case processor
+                         when Value::Caster
+                           casters
+                         when Value::Validator
+                           validators
+                         when Value::Transformer
+                           transformers
+                         when Types::ElementProcessor
+                           element_processors
+                         else
+                           # TODO: add validator that these are all fine so we don't have to bother here...
+                           # :nocov:
+                           raise "Not sure where to put #{processor}"
+                           # :nocov:
+                         end
+
+              category << processor
+            end
+
+            Types::Type.new(
+              strict_type_declaration,
+              base_type:,
+              # description: strict_type_declaration.is_a?(::Hash) && strict_type_declaration[:description],
+              description: strict_type_declaration[:description],
+              casters:,
+              transformers:,
+              validators:,
+              element_processors:,
+              # TODO: can't we just set this to [] here??
+              target_classes: target_classes(strict_type_declaration),
+              name: type_name(strict_type_declaration)
+            )
+          end
+
+          # TODO: test that registering a custom type sets its name
+          def type_name(strict_type_declaration)
+            "Anonymous #{strict_type_declaration[:type]} extension"
+          end
+
+          def non_processor_keys
+            %i[type _desugarized description]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+Foobara.require_project_file("type_declarations", "handlers/registered_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendRegisteredTypeDeclaration < RegisteredTypeDeclaration
+        def applicable?(sugary_type_declaration)
+          strict_type_declaration = desugarize(sugary_type_declaration)
+
+          return false unless strict_type_declaration.is_a?(::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]
+
+          super(strict_type_declaration.slice(:type))
+        end
+
+        def priority
+          Priority::LOWEST
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendTupleTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        # 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
+          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)
+            end
+
+            {
+              type: :tuple,
+              element_type_declarations:
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+Foobara.require_project_file("type_declarations", "handlers/registered_type_declaration/to_type_transformer")
+Foobara.require_project_file("type_declarations", "handlers/extend_associative_array_type_declaration")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class ExtendTupleTypeDeclaration < ExtendAssociativeArrayTypeDeclaration
+        def applicable?(sugary_type_declaration)
+          strictish_type_declaration = desugarize(sugary_type_declaration)
+
+          strictish_type_declaration.is_a?(::Hash) && strictish_type_declaration[:type] == :tuple
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # type_symbol is basically just a flag that lets us know that type is fully qualified.
+        # rather hacky but other potential workarounds seemed gnarlier
+        class DesugarizerMetadataCleanupDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(strict_type_declaration)
+            strict_type_declaration.is_a?(::Hash)
+          end
+
+          def desugarize(strict_type_declaration)
+            strict_type_declaration = strict_type_declaration.dup
+
+            strict_type_declaration.delete(:_desugarized)
+
+            strict_type_declaration
+          end
+
+          def priority
+            Priority::LOWEST + 100
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # type_symbol is basically just a flag that lets us know that type is fully qualified.
+        # rather hacky but other potential workarounds seemed gnarlier
+        class ShortTypeNameDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            return false if TypeDeclarations.strict_stringified? || TypeDeclarations.strict?
+
+            sugary_type_declaration = sugary_type_declaration.dup
+
+            return false unless sugary_type_declaration.is_a?(::Hash)
+
+            sugary_type_declaration = normalize_type(sugary_type_declaration)
+
+            if sugary_type_declaration.key?(:type) &&
+               !sugary_type_declaration.dig(:_desugarized, :type_absolutified)
+              type_symbol = sugary_type_declaration[:type]
+
+              (type_symbol.is_a?(::Symbol) || type_symbol.is_a?(::String)) && type_registered?(type_symbol)
+            end
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugary_type_declaration = normalize_type(sugary_type_declaration)
+
+            type_symbol = sugary_type_declaration[:type]
+            type = lookup_type!(type_symbol)
+
+            desugarized = sugary_type_declaration[:_desugarized] || {}
+            desugarized[:type_absolutified] = true
+            # TODO: just use the symbol and nothing else??
+            # maybe confusing in languages with no distinction between symbol and string?
+            sugary_type_declaration.merge(type: type.full_type_symbol, _desugarized: desugarized)
+          end
+
+          # TODO: clean this up in a different desugarizer so we don't have to think about it here
+          def normalize_type(sugary_type_declaration)
+            if sugary_type_declaration.key?("type") && !sugary_type_declaration.key?(:type)
+              if Util.all_symbolizable_keys?(sugary_type_declaration)
+                sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
+                type_symbol = sugary_type_declaration[:type]
+
+                if type_symbol.is_a?(::String)
+                  sugary_type_declaration[:type] = type_symbol.to_sym
+                end
+              end
+            else
+              sugary_type_declaration = sugary_type_declaration.dup
+            end
+
+            sugary_type_declaration
+          end
+
+          def priority
+            Priority::FIRST + 2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # type_symbol is basically just a flag that lets us know that type is fully qualified.
+        # rather hacky but other potential workarounds seemed gnarlier
+        class StrictDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(strict_type_declaration)
+            # TODO: we shouldn't have to check if this is a hash. This means some other desugarizer is unnecessarily
+            # processing a type declaration as if it were sugary. Find and fix that to speed this up a tiny bit.
+            return false unless strict_type_declaration.is_a?(::Hash) && TypeDeclarations.strict?
+
+            !strict_type_declaration.dig(:_desugarized, :type_absolutified)
+          end
+
+          def desugarize(strict_type_declaration)
+            strict_type_declaration = Util.symbolize_keys(strict_type_declaration)
+            desugarized = strict_type_declaration[:_desugarized] || {}
+            desugarized[:type_absolutified] = true
+            strict_type_declaration.merge(_desugarized: desugarized)
+          end
+
+          def priority
+            Priority::FIRST
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # type_symbol is basically just a flag that lets us know that type is fully qualified.
+        # rather hacky but other potential workarounds seemed gnarlier
+        class StrictStringifiedDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            # TODO: we shouldn't have to check if this is a hash. This means some other desugarizer is unnecessarily
+            # processing a type declaration as if it were sugary. Find and fix that to speed this up a tiny bit.
+            return false unless sugary_type_declaration.is_a?(::Hash) && TypeDeclarations.strict_stringified?
+
+            !sugary_type_declaration.dig(:_desugarized, :type_absolutified)
+          end
+
+          def desugarize(sugary_type_declaration)
+            sugary_type_declaration = Util.symbolize_keys(sugary_type_declaration)
+            type_symbol = sugary_type_declaration[:type]
+
+            type = Foobara.foobara_root_namespace.foobara_lookup_type!(type_symbol,
+                                                                       mode: Namespace::LookupMode::ABSOLUTE)
+
+            type_symbol = type.full_type_symbol
+
+            desugarized = sugary_type_declaration[:_desugarized] || {}
+            desugarized[:type_absolutified] = true
+            sugary_type_declaration.merge(_desugarized: desugarized, type: type_symbol)
+          end
+
+          def priority
+            Priority::FIRST
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+Foobara.require_project_file("type_declarations", "desugarizer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # TODO: make a quick way to convert a couple simple procs into a transformer
+        class SymbolDesugarizer < TypeDeclarations::Desugarizer
+          def applicable?(sugary_type_declaration)
+            sugary_type_declaration.is_a?(Symbol) && type_registered?(sugary_type_declaration)
+          end
+
+          def desugarize(symbol)
+            # TODO: just use the symbol and nothing else??
+            # maybe confusing in languages with no distinction between symbol and string?
+            { type: symbol }
+          end
+
+          def priority
+            Priority::FIRST
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+Foobara.require_project_file("type_declarations", "to_type_transformer")
+
+module Foobara
+  module TypeDeclarations
+    module Handlers
+      class RegisteredTypeDeclaration < TypeDeclarationHandler
+        # TODO: seems like we have more base classes than we need
+        class ToTypeTransformer < TypeDeclarations::ToTypeTransformer
+          def transform(strict_type_declaration)
+            registered_type(strict_type_declaration)
+          end
+
+          def type_symbol(strict_type_declaration)
+            strict_type_declaration[:type]
+          end
+
+          def registered_type(strict_type_declaration)
+            lookup_absolute_type!(type_symbol(strict_type_declaration), mode: Namespace::LookupMode::ABSOLUTE)
+          end
+
+          def target_classes(strict_type_declaration)
+            registered_type(strict_type_declaration).target_classes
+          end
+        end
+      end
+    end
+  end
+end