foobara 0.0.142 → 0.1.1

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

data/projects/type_declarations/src/type_declaration_handler.rb

@@ -92,25 +92,24 @@ module Foobara
         [desugarizer, type_declaration_validator, to_type_transformer]
       end
 
-      def process_value(raw_type_declaration)
-        # TODO: deep_dup this again??
-        super.tap do |type_outcome|
-          if type_outcome.success?
-            type_outcome.result.raw_declaration_data = raw_type_declaration
-          end
-        end
-      end
-
       def desugarizer
         # TODO: memoize this?
-        Value::Processor::Pipeline.new(processors: desugarizers)
+        DesugarizerPipeline.new(processors: desugarizers)
       end
 
       def desugarize(value)
-        desugarizer.process_value!(value)
+        unless value.strict?
+          if desugarizer.applicable?(value)
+            value = desugarizer.process_value!(value)
+            value.is_strict = true
+          end
+        end
+
+        value
       end
 
       def type_declaration_validator
+        # TODO: memoize this
         Value::Processor::Pipeline.new(processors: type_declaration_validators)
       end
 

data/projects/type_declarations/src/type_declarations.rb

@@ -30,11 +30,14 @@ module Foobara
       end
 
       def remove_sensitive_types(strict_type_declaration)
-        handler = GlobalDomain.foobara_type_builder.type_declaration_handler_for(strict_type_declaration)
+        declaration = TypeDeclaration.new(strict_type_declaration)
+        declaration.is_strict = true
+
+        handler = GlobalDomain.foobara_type_builder.type_declaration_handler_for(declaration)
 
         sensitive_type_remover = sensitive_type_removers[handler.class.name]
 
-        if sensitive_type_remover
+        if sensitive_type_remover&.applicable?(strict_type_declaration)
           sensitive_type_remover.process_value!(strict_type_declaration)
         else
           strict_type_declaration
@@ -51,12 +54,16 @@ module Foobara
       end
 
       def sensitive_value_remover_class_for_type(type)
-        handler = GlobalDomain.foobara_type_builder.type_declaration_handler_for(type.declaration_data)
+        declaration_data = type.declaration_data
+        declaration = TypeDeclaration.new(declaration_data)
+        declaration.is_strict = true
+
+        handler = GlobalDomain.foobara_type_builder.type_declaration_handler_for(declaration)
         remover_class = sensitive_value_removers[handler.class.name]
 
         unless remover_class
           # :nocov:
-          raise "No sensitive value remover found for #{type.declaration_data}"
+          raise "No sensitive value remover found for #{declaration_data}"
           # :nocov:
         end
 
@@ -89,7 +96,7 @@ module Foobara
       end
 
       def stringified?
-        foobara_manifest_context_mode == Mode::STRINGIFIED
+        foobara_manifest_context_mode == Mode::STRINGIFIED || strict_stringified?
       end
 
       # TODO: we should desugarize these but can't because of a bug where desugarizing entities results in creating the

data/projects/types/src/type.rb

@@ -21,7 +21,6 @@ module Foobara
                     :element_processors,
                     :structure_count,
                     :is_builtin,
-                    :raw_declaration_data,
                     :name,
                     :target_classes,
                     :description,
@@ -77,6 +76,15 @@ module Foobara
         validate_processors!
       end
 
+      # TODO: replace the concept of builtin? with primitive?
+      def primitive?
+        declaration_data.is_a?(::Symbol)
+      end
+
+      def derived?
+        declaration_data.is_a?(::Hash)
+      end
+
       def sensitive?
         sensitive
       end
@@ -86,11 +94,23 @@ module Foobara
       end
 
       def element_type
-        @element_type || base_type&.element_type
+        type = @element_type || base_type&.element_type
+
+        if type.is_a?(::Symbol)
+          type = @element_type = TypeDeclarations::LazyElementTypes.const_get(type).resolve(self)
+        end
+
+        type
       end
 
       def element_types
-        @element_types || base_type&.element_types
+        types = @element_types || base_type&.element_types
+
+        if types.is_a?(::Symbol)
+          types = @element_types = TypeDeclarations::LazyElementTypes.const_get(types).resolve(self)
+        end
+
+        types
       end
 
       def has_sensitive_types?
@@ -380,7 +400,7 @@ module Foobara
 
         if registered?
           # TODO: we should just use the symbol and nothing else in this context instead of a hash with 1 element.
-          { type: foobara_manifest_reference.to_sym }
+          foobara_manifest_reference.to_sym
         elsif remove_sensitive
           TypeDeclarations.remove_sensitive_types(declaration_data)
         else
@@ -450,6 +470,8 @@ module Foobara
         super.merge(h)
       end
 
+      # TODO: replace the concept of builtin? with primitive? and delete this method since
+      # primitive? already exists.
       def builtin?
         is_builtin
       end

data/projects/value/src/mutator.rb

@@ -18,10 +18,7 @@ module Foobara
       end
 
       def process_value(value)
-        if applicable?(value)
-          mutate(value)
-        end
-
+        mutate(value)
         Outcome.success(value)
       end
     end

data/projects/value/src/processor/casting.rb

@@ -89,8 +89,13 @@ module Foobara
         end
 
         def error_message(value)
-          type = declaration_data[:cast_to][:type].to_s
-          article = type =~ /^[aeiouy]/i ? "an" : "a"
+          type = declaration_data[:cast_to]
+
+          if type.is_a?(::Hash)
+            type = type[:type]
+          end
+
+          article = type.to_s =~ /^[aeiouy]/i ? "an" : "a"
 
           "Cannot cast #{value.inspect} to #{article} #{type}. Expected it to #{applies_message}"
         end

data/projects/value/src/processor/pipeline.rb

@@ -14,7 +14,15 @@ module Foobara
 
         def process_outcome(old_outcome)
           processors.inject(old_outcome) do |outcome, processor|
-            processor.process_outcome(outcome)
+            return outcome if outcome.fatal?
+
+            value = outcome.result
+
+            if processor.applicable?(value)
+              processor.process_outcome(outcome)
+            else
+              outcome
+            end
           end
         end
 

data/projects/value/src/processor.rb

@@ -232,8 +232,6 @@ module Foobara
 
         value = old_outcome.result
 
-        return old_outcome unless applicable?(value)
-
         process_value(value).tap do |outcome|
           outcome.add_errors(old_outcome.error_collection)
         end

data/projects/value/src/transformer.rb

@@ -73,9 +73,7 @@ module Foobara
       end
 
       def process_value(value)
-        if applicable?(value)
-          value = transform(value)
-        end
+        value = transform(value)
 
         Outcome.success(value)
       end

data/projects/value/src/validator.rb

@@ -19,8 +19,6 @@ module Foobara
       end
 
       def process_value(value)
-        return Outcome.success(value) unless applicable?(value)
-
         errors = Util.array(validation_errors(value))
 
         if errors.empty?

data/projects/weak_object_set/src/weak_object_set.rb

@@ -95,6 +95,7 @@ module Foobara
       monitor.synchronize do
         ref = ref_for(object_or_object_id)
 
+        # TODO: is this necessary? Why not check weakref_alive? now that we're in a mutex?
         object = begin
           ref&.__getobj__
         rescue WeakRef::RefError
@@ -122,6 +123,7 @@ module Foobara
     def each
       monitor.synchronize do
         objects.each_value do |ref|
+          # Is this still necessary now that we're in a mutex?
           object = begin
             ref.__getobj__
           rescue WeakRef::RefError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.0.142
+  version: 0.1.1
 platform: ruby
 authors:
 - Miles Georgi
@@ -373,6 +373,7 @@ files:
 - projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/normalize_mutable_attributes_desugarizer.rb
 - projects/model/src/extensions/type_declarations/handlers/extend_registered_model_type_declaration/to_type_transformer.rb
 - projects/model/src/extensions/type_declarations/handlers/registered_type_declaration/model_class_desugarizer.rb
+- projects/model/src/extensions/type_declarations/lazy_element_types/model.rb
 - projects/model/src/model.rb
 - projects/model/src/sensitive_type_removers/extended_model.rb
 - projects/model/src/sensitive_type_removers/model.rb
@@ -421,6 +422,7 @@ files:
 - projects/type_declarations/src/attributes_transformers/reject.rb
 - projects/type_declarations/src/caster.rb
 - projects/type_declarations/src/desugarizer.rb
+- projects/type_declarations/src/desugarizer_pipeline.rb
 - projects/type_declarations/src/dsl/attributes.rb
 - projects/type_declarations/src/element_processor.rb
 - projects/type_declarations/src/error_extension.rb
@@ -430,7 +432,9 @@ files:
 - projects/type_declarations/src/handlers/extend_array_type_declaration/to_type_transformer.rb
 - projects/type_declarations/src/handlers/extend_array_type_declaration/type_set_to_array_desugarizer.rb
 - projects/type_declarations/src/handlers/extend_associative_array_type_declaration.rb
+- projects/type_declarations/src/handlers/extend_associative_array_type_declaration/key_type_declaration_desugarizer.rb
 - projects/type_declarations/src/handlers/extend_associative_array_type_declaration/to_type_transformer.rb
+- projects/type_declarations/src/handlers/extend_associative_array_type_declaration/value_type_declaration_desugarizer.rb
 - projects/type_declarations/src/handlers/extend_attributes_type_declaration.rb
 - projects/type_declarations/src/handlers/extend_attributes_type_declaration/dsl_desugarizer.rb
 - projects/type_declarations/src/handlers/extend_attributes_type_declaration/element_type_declarations_desugarizer.rb
@@ -442,13 +446,11 @@ files:
 - projects/type_declarations/src/handlers/extend_tuple_type_declaration/array_desugarizer.rb
 - projects/type_declarations/src/handlers/extend_tuple_type_declaration/to_type_transformer.rb
 - projects/type_declarations/src/handlers/registered_type_declaration.rb
-- projects/type_declarations/src/handlers/registered_type_declaration/desugarizer_metadata_cleanup_desugarizer.rb
-- projects/type_declarations/src/handlers/registered_type_declaration/short_type_name_desugarizer.rb
-- projects/type_declarations/src/handlers/registered_type_declaration/strict_desugarizer.rb
-- projects/type_declarations/src/handlers/registered_type_declaration/strict_stringified_desugarizer.rb
-- projects/type_declarations/src/handlers/registered_type_declaration/symbol_desugarizer.rb
 - projects/type_declarations/src/handlers/registered_type_declaration/to_type_transformer.rb
-- projects/type_declarations/src/handlers/registered_type_declaration/type_desugarizer.rb
+- projects/type_declarations/src/lazy_element_types/array.rb
+- projects/type_declarations/src/lazy_element_types/attributes.rb
+- projects/type_declarations/src/lazy_element_types/hash.rb
+- projects/type_declarations/src/lazy_element_types/tuple.rb
 - projects/type_declarations/src/processor.rb
 - projects/type_declarations/src/remove_sensitive_values_transformer.rb
 - projects/type_declarations/src/sensitive_type_remover.rb
@@ -459,6 +461,7 @@ files:
 - projects/type_declarations/src/to_type_transformer.rb
 - projects/type_declarations/src/transformer.rb
 - projects/type_declarations/src/type_builder.rb
+- projects/type_declarations/src/type_declaration.rb
 - projects/type_declarations/src/type_declaration_error.rb
 - projects/type_declarations/src/type_declaration_handler.rb
 - projects/type_declarations/src/type_declaration_handler_registry.rb

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

@@ -1,29 +0,0 @@
-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

@@ -1,62 +0,0 @@
-Foobara.require_project_file("type_declarations", "desugarizer")
-
-module Foobara
-  module TypeDeclarations
-    module Handlers
-      class RegisteredTypeDeclaration < TypeDeclarationHandler
-        class ShortTypeNameDesugarizer < TypeDeclarations::Desugarizer
-          def applicable?(sugary_type_declaration)
-            return false if TypeDeclarations.strict_stringified? || TypeDeclarations.strict?
-            return false unless sugary_type_declaration.is_a?(::Hash)
-
-            sugary_type_declaration = sugary_type_declaration.dup
-
-            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