foobara 0.0.142 → 0.1.2

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,11 @@ module Foobara
       end
 
       def stringified?
-        foobara_manifest_context_mode == Mode::STRINGIFIED
+        foobara_manifest_context_mode == Mode::STRINGIFIED || strict_stringified?
+      end
+
+      def include_processors?
+        foobara_manifest_context_include_processors?
       end
 
       # TODO: we should desugarize these but can't because of a bug where desugarizing entities results in creating the
@@ -105,8 +116,8 @@ module Foobara
         Thread.inheritable_thread_local_var_get("foobara_manifest_context")
       end
 
-      allowed_context_keys = [:detached, :to_include, :mode, :remove_sensitive]
-      booleans = [:detached, :remove_sensitive]
+      allowed_context_keys = [:detached, :to_include, :mode, :remove_sensitive, :include_processors]
+      booleans = [:detached, :remove_sensitive, :include_processors]
 
       booleans.each do |context_item|
         define_method "foobara_manifest_context_#{context_item}?" do
@@ -137,84 +148,3 @@ module Foobara
     end
   end
 end
-
-=begin
-how many handlers do we need??
-
-
-find registered type by symbol
-
-extend registered type (find it by symbol and use it to construct new type with additional processors)
-
-Duck
-  AtomicDuck
-    Number
-      Integer
-        BigInteger
-      Float
-        BigDecimal
-    String
-      Email
-      Phone
-    Datetime
-    Date
-    Boolean
-  Duckture
-    Array
-      Tuple
-      AssociativeArray
-        Attributes
-          Model
-            Address
-              UsAddress
-            Entity
-
-Duck (RegisteredTypeExtensionTypeDeclarationHandler)
-  AtomicDuck (N/A)
-    Number (N/A)
-      Integer (RegisteredTypeExtensionTypeDeclarationHandler)
-        BigInteger (RegisteredTypeExtensionTypeDeclarationHandler)
-      Float (RegisteredTypeExtensionTypeDeclarationHandler)
-        BigDecimal (RegisteredTypeExtensionTypeDeclarationHandler)
-    String (RegisteredTypeExtensionTypeDeclarationHandler)
-      Email (implement in terms of string extension)
-      Phone (implement in terms of string extension)
-    Datetime (RegisteredTypeExtensionTypeDeclarationHandler)
-    Date (RegisteredTypeExtensionTypeDeclarationHandler)
-    Boolean (RegisteredTypeExtensionTypeDeclarationHandler)
-  Duckture (N/A)
-    Array (hmmmm we need an element processor initialized with the element type...)
-      Tuple (hmmmm we need an element processor initialized with the elements type...)
-      AssociativeArray (hmmmm we need an element processor initialized with the key type and the value type...)
-        Attributes (we need an element processor initialized with the attribute_types)
-          Model (same as above but need to add a name attribute...)
-            Address (implement in terms of model)
-              UsAddress (implement in terms of Address)
-            Entity (same as above but with a primary key processor of some sort)
-
-
-TypeDeclarationHandler
-  RegisteredAtomTypeExtensionTypeDeclarationHandler
-  RegisteredStructuredTypeExtensionTypeDeclarationHandler
-    ExtendArrayTypeDeclarationHandler
-    ExtendTupleTypeDeclarationHandler
-    ExtendAssociativeArrayTypeDeclaration
-    ExtendAttributesTypeDeclaration
-    ExtendModelTypeDeclarationHandler
-    ExtendEntityTypeDeclarationHandler
-
-I think we need these type declarations but not necessarily Type subclasses for all of these types
-
-Maybe just one Type class??
-
-let's see...
-
-for atom could just not support element_types nor size
-for array element_types could just be applied repeating?? Kind of goofy
-For tuple element_types could be applied repeating and size validator could be added
-for associative array... element_types need to be a hash instead of an array. Is that OK?
-  Or could be an array of pairs... like Hash#to_a ? Maybe we just operate off of #each? Seems that will work, wow...
-For Attributes same as associative array but with key processor of symbol plus an attributes_processor
-For model add a name processor
-for entity add a primary key processor of some sort...
-=end

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?
@@ -310,7 +330,7 @@ module Foobara
                          end
 
         Value::Processor::Casting.new(
-          { cast_to: declaration_data },
+          { cast_to: reference_or_declaration_data },
           casters:,
           target_classes:,
           enforce_unique:
@@ -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
@@ -396,6 +416,7 @@ module Foobara
       def foobara_manifest
         to_include = TypeDeclarations.foobara_manifest_context_to_include
         remove_sensitive = TypeDeclarations.foobara_manifest_context_remove_sensitive?
+        include_processors = TypeDeclarations.include_processors?
 
         types = []
 
@@ -435,11 +456,13 @@ module Foobara
           h[:sensitive_exposed] = true
         end
 
-        h.merge!(
-          supported_processor_manifest.merge(
-            Util.remove_blank(processors: processor_manifest)
+        if include_processors
+          h.merge!(
+            supported_processor_manifest.merge(
+              Util.remove_blank(processors: processor_manifest)
+            )
           )
-        )
+        end
 
         target_classes.sort_by(&:name).each do |target_class|
           if target_class.respond_to?(:foobara_manifest)
@@ -450,6 +473,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
@@ -324,12 +322,6 @@ module Foobara
       def foobara_manifest
         to_include = TypeDeclarations.foobara_manifest_context_to_include
 
-        unless scoped_path_set?
-          if self.class.scoped_path_set?
-            self.scoped_path = self.class.scoped_path
-          end
-        end
-
         possible_errors = self.possible_errors.map do |possible_error|
           [possible_error.key.to_s, possible_error.foobara_manifest]
         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.2
 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
@@ -535,7 +538,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
 summary: A command-centric and discoverable software framework with a focus on domain
   concepts and abstracting away integration code

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

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

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

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

@@ -1,30 +0,0 @@
-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)
-            if sugary_type_declaration.is_a?(::Symbol)
-              type_registered?(sugary_type_declaration)
-            elsif sugary_type_declaration.is_a?(::String) && TypeDeclarations.stringified?
-              applicable?(sugary_type_declaration.to_sym)
-            end
-          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.to_sym }
-          end
-
-          def priority
-            Priority::FIRST
-          end
-        end
-      end
-    end
-  end
-end