foobara 0.0.142 → 0.1.2

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

data/projects/type_declarations/src/type_declaration.rb

@@ -0,0 +1,295 @@
+module Foobara
+  # Inheriting from ::Hash for now but we should remove this once all of the handlers are updated
+  class TypeDeclaration
+    attr_reader :is_strict
+
+    attr_accessor :is_duped,
+                  :declaration_data,
+                  :is_deep_duped,
+                  :is_absolutified,
+                  :reference_checked,
+                  :type,
+                  :base_type
+
+    # TODO: we should be able to delete absolutified opt once strict declarations
+    # use `:ref` instead of `{type: :ref}` format.
+    def initialize(declaration_data, absolutified = false, skip_reference_check = false)
+      if TypeDeclarations.strict?
+        self.is_strict = true
+      elsif absolutified || TypeDeclarations.strict_stringified?
+        self.is_absolutified = true
+      end
+
+      self.declaration_data = declaration_data
+
+      unless strict? || skip_reference_check
+        handle_symbolic_declaration
+      end
+    end
+
+    def is_strict=(value)
+      if value
+        self.is_absolutified = true
+      end
+
+      @is_strict = value
+    end
+
+    def handle_symbolic_declaration
+      self.reference_checked = true
+
+      if declaration_data.is_a?(::Symbol)
+        symbol = declaration_data
+      elsif declaration_data.is_a?(::String) && TypeDeclarations.stringified?
+        symbol = declaration_data.to_sym
+      end
+
+      if symbol
+        type = if absolutified?
+                 Domain.current.foobara_lookup_type(symbol, mode: Namespace::LookupMode::ABSOLUTE)
+               else
+                 Domain.current.foobara_lookup_type(symbol)
+               end
+
+        if type
+          unless strict?
+            self.declaration_data = type.full_type_symbol
+          end
+
+          self.type = type
+
+          self.is_strict = true
+          self.is_deep_duped = true
+          self.is_duped = true
+
+        else
+          if declaration_data.is_a?(::Symbol)
+            self.is_duped = true
+            self.is_deep_duped = true
+          end
+
+          self.declaration_data = declaration_data
+        end
+      elsif TypeDeclarations.strict_stringified?
+        symbolize_keys!
+        type_symbol = self[:type].to_sym
+        self[:type] = type_symbol
+
+        type = Domain.current.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+
+        if type
+          if declaration_data.keys.size == 1
+            self.type = type
+            self.is_strict = true
+            self.is_deep_duped = true
+            self.is_duped = true
+            self.declaration_data = type.full_type_symbol
+          else
+            self.base_type = type
+          end
+        end
+      elsif declaration_data.is_a?(::Hash)
+        type_symbol = self[:type] || self["type"]
+
+        if type_symbol
+          if type_symbol.is_a?(::Symbol) || type_symbol.is_a?(::String)
+            type = if absolutified?
+                     Domain.current.foobara_lookup_type(type_symbol, mode: Namespace::LookupMode::ABSOLUTE)
+                   else
+                     Domain.current.foobara_lookup_type(type_symbol)
+                   end
+
+            if type
+              symbolize_keys!
+              self[:type] = type.full_type_symbol
+              self.is_absolutified = true
+
+              if declaration_data.keys.size == 1
+                self.declaration_data = type.full_type_symbol
+
+                self.type = type
+                self.is_strict = true
+                self.is_deep_duped = true
+              else
+                self.base_type = type
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def hash?
+      declaration_data.is_a?(::Hash)
+    end
+
+    def key?(key)
+      declaration_data.key?(key)
+    end
+
+    def [](key)
+      declaration_data[key]
+    end
+
+    def array?
+      declaration_data.is_a?(::Array)
+    end
+
+    def proc?
+      declaration_data.is_a?(::Proc)
+    end
+
+    def to_proc
+      declaration_data
+    end
+
+    def size
+      declaration_data.size
+    end
+
+    def delete(key)
+      return unless declaration_data.key?(key)
+
+      if duped?
+        declaration_data.delete(key)
+      else
+        self.declaration_data = declaration_data.except(key)
+        self.is_duped = true
+      end
+
+      if strict?
+        self.is_strict = false
+      end
+
+      if absolutified? && key == :type
+        self.is_absolutified = false
+      end
+    end
+
+    def class?
+      declaration_data.is_a?(::Class)
+    end
+
+    def []=(key, value)
+      if strict?
+        self.is_strict = false
+      end
+
+      unless duped?
+        self.declaration_data = declaration_data.dup
+        self.is_duped = true
+      end
+
+      declaration_data[key] = value
+    end
+
+    def all_symbolizable_keys?
+      Util.all_symbolizable_keys?(declaration_data)
+    end
+
+    def symbolize_keys!
+      if duped?
+        declaration_data.transform_keys!(&:to_sym)
+      else
+        self.declaration_data = declaration_data.transform_keys(&:to_sym)
+        self.is_duped = true
+      end
+
+      self
+    end
+
+    def except(...)
+      parts = declaration_data.except(...)
+
+      declaration = clone_from_part(parts)
+      declaration.is_duped = true
+
+      if declaration.strict?
+        declaration.is_strict = false
+      end
+
+      declaration
+    end
+
+    def slice(...)
+      parts = declaration_data.slice(...)
+
+      declaration = clone_from_part(parts)
+      declaration.is_duped = true
+
+      if declaration.strict?
+        declaration.is_strict = false
+      end
+
+      declaration
+    end
+
+    def assign(other)
+      self.declaration_data = other.declaration_data
+
+      if absolutified? != other.absolutified?
+        self.is_absolutified = other.absolutified?
+      end
+
+      if strict? != other.strict?
+        self.is_strict = other.strict?
+      end
+
+      if duped? != other.duped?
+        self.is_duped = other.duped?
+      end
+
+      if deep_duped? != other.deep_duped?
+        self.is_deep_duped = other.deep_duped?
+      end
+
+      if other.type
+        self.type = other.type
+      end
+
+      if other.base_type
+        self.base_type = other.base_type
+      end
+    end
+
+    def clone
+      declaration = TypeDeclaration.new(declaration_data, false, true)
+
+      if strict?
+        declaration.is_strict = true
+      end
+
+      if absolutified?
+        declaration.is_absolutified = true
+      end
+
+      if type
+        declaration.type = type
+      end
+
+      if base_type
+        declaration.base_type = base_type
+      end
+
+      if reference_checked?
+        declaration.reference_checked = true
+      end
+
+      declaration
+    end
+
+    def clone_from_part(part)
+      TypeDeclaration.new(part)
+    end
+
+    def reference?
+      strict? && declaration_data.is_a?(::Symbol)
+    end
+
+    alias absolutified? is_absolutified
+    alias duped? is_duped
+    alias deep_duped? is_deep_duped
+    alias strict? is_strict
+    alias reference_checked? reference_checked
+  end
+end