foobara 0.0.78 → 0.0.80

data/projects/domain/src/organization_module_extension.rb

@@ -36,7 +36,7 @@ module Foobara
           foobara_all_domain(mode: Namespace::LookupMode::DIRECT)
         end
 
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           domains = foobara_domains.map do |domain|
             to_include << domain
             domain.foobara_manifest_reference

data/projects/entity/lib/foobara/entity.rb

@@ -7,7 +7,10 @@ module Foobara
 
     class << self
       def install!
-        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendEntityTypeDeclaration.new)
+        handler = TypeDeclarations::Handlers::ExtendEntityTypeDeclaration.new
+        TypeDeclarations.register_type_declaration(handler)
+
+        TypeDeclarations.register_sensitive_type_remover(SensitiveTypeRemovers::Entity.new(handler))
 
         detached_entity = Namespace.global.foobara_lookup_type!(:detached_entity)
         BuiltinTypes.build_and_register!(:entity, detached_entity, nil)

data/projects/entity/src/sensitive_type_removers/entity.rb

@@ -0,0 +1,8 @@
+module Foobara
+  class Entity < DetachedEntity
+    module SensitiveTypeRemovers
+      class Entity < DetachedEntity::SensitiveTypeRemovers::DetachedEntity
+      end
+    end
+  end
+end

data/projects/model/lib/foobara/model.rb

@@ -6,8 +6,15 @@ module Foobara
   class Model
     class << self
       def install!
-        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendModelTypeDeclaration.new)
-        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendRegisteredModelTypeDeclaration.new)
+        model_handler = TypeDeclarations::Handlers::ExtendModelTypeDeclaration.new
+        TypeDeclarations.register_type_declaration(model_handler)
+        extended_model_handler = TypeDeclarations::Handlers::ExtendRegisteredModelTypeDeclaration.new
+        TypeDeclarations.register_type_declaration(extended_model_handler)
+
+        TypeDeclarations.register_sensitive_type_remover(SensitiveTypeRemovers::Model.new(model_handler))
+        TypeDeclarations.register_sensitive_type_remover(
+          SensitiveTypeRemovers::ExtendedModel.new(extended_model_handler)
+        )
 
         atomic_duck = Namespace.global.foobara_lookup_type!(:atomic_duck)
         BuiltinTypes.build_and_register!(:model, atomic_duck, nil)

data/projects/model/src/concerns/reflection.rb

@@ -5,9 +5,15 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def foobara_manifest(to_include: Set.new)
+          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+            attributes_declaration = foobara_attributes_type.declaration_data
+
+            if remove_sensitive
+              attributes_declaration = TypeDeclarations.remove_sensitive_types(attributes_declaration)
+            end
+
             Util.remove_blank(
-              attributes_type: foobara_attributes_type.declaration_data,
+              attributes_type: attributes_declaration,
               organization_name: foobara_type.foobara_domain.foobara_organization_name,
               domain_name: foobara_type.foobara_domain.foobara_domain_name,
               model_name: foobara_model_name,

data/projects/model/src/sensitive_type_removers/extended_model.rb

@@ -0,0 +1,10 @@
+require_relative "model"
+
+module Foobara
+  class Model
+    module SensitiveTypeRemovers
+      class ExtendedModel < SensitiveTypeRemovers::Model
+      end
+    end
+  end
+end

data/projects/model/src/sensitive_type_removers/model.rb

@@ -0,0 +1,19 @@
+module Foobara
+  class Model
+    module SensitiveTypeRemovers
+      class Model < TypeDeclarations::SensitiveTypeRemover
+        def transform(strict_type_declaration)
+          old_attributes_declaration = strict_type_declaration[:attributes_declaration]
+
+          new_attributes_declaration = remove_sensitive_types(old_attributes_declaration)
+
+          if new_attributes_declaration == old_attributes_declaration
+            strict_type_declaration
+          else
+            strict_type_declaration.merge(attributes_declaration: new_attributes_declaration)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -44,6 +44,7 @@ module Foobara
             :@foobara_lowercase_constants,
             @original_foobara_lowercase_constants || []
           )
+          GlobalDomain.send(:remove_const, :Types)
         end
 
         @original_scoped.each do |scoped|
@@ -59,10 +60,17 @@ module Foobara
 
         register_type_declaration(Handlers::RegisteredTypeDeclaration.new)
         register_type_declaration(Handlers::ExtendRegisteredTypeDeclaration.new)
-        register_type_declaration(Handlers::ExtendArrayTypeDeclaration.new)
+        array_handler = Handlers::ExtendArrayTypeDeclaration.new
+        register_type_declaration(array_handler)
         register_type_declaration(Handlers::ExtendAssociativeArrayTypeDeclaration.new)
-        register_type_declaration(Handlers::ExtendAttributesTypeDeclaration.new)
+        attributes_handler = Handlers::ExtendAttributesTypeDeclaration.new
+        register_type_declaration(attributes_handler)
         register_type_declaration(Handlers::ExtendTupleTypeDeclaration.new)
+
+        @sensitive_type_removers = nil
+
+        register_sensitive_type_remover(SensitiveTypeRemovers::Attributes.new(attributes_handler))
+        register_sensitive_type_remover(SensitiveTypeRemovers::Array.new(array_handler))
       end
 
       def install!

data/projects/type_declarations/src/attributes.rb

@@ -34,6 +34,7 @@ module Foobara
         end
 
         def reject(declaration, *keys)
+          # TODO: do we really need a deep dup?
           declaration = Util.deep_dup(declaration)
 
           element_type_declarations = declaration[:element_type_declarations]

data/projects/type_declarations/src/desugarizer.rb

@@ -10,7 +10,7 @@ module Foobara
           false
         end
 
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           # :nocov:
           super.merge(processor_type: :desugarizer)
           # :nocov:

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

@@ -8,7 +8,7 @@ module Foobara
         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]
+              extra_keys = sugary_type_declaration.keys - %i[type description sensitive sensitive_exposed]
 
               return false if extra_keys.any?
 
@@ -27,6 +27,14 @@ module Foobara
               strict_type_declaration[:description] = sugary_type_declaration[:description]
             end
 
+            if sugary_type_declaration.key?(:sensitive)
+              strict_type_declaration[:sensitive] = sugary_type_declaration[:sensitive]
+            end
+
+            if sugary_type_declaration.key?(:sensitive_exposed)
+              strict_type_declaration[:sensitive_exposed] = sugary_type_declaration[:sensitive_exposed]
+            end
+
             strict_type_declaration
           end
         end

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

@@ -45,10 +45,12 @@ module Foobara
               category << processor
             end
 
+            sensitive = strict_type_declaration[:sensitive]
+            sensitive_exposed = strict_type_declaration[:sensitive_exposed]
+
             type_class.new(
               strict_type_declaration,
               base_type:,
-              # description: strict_type_declaration.is_a?(::Hash) && strict_type_declaration[:description],
               description: strict_type_declaration[:description],
               casters:,
               transformers:,
@@ -56,7 +58,9 @@ module Foobara
               element_processors:,
               # TODO: can't we just set this to [] here??
               target_classes: target_classes(strict_type_declaration),
-              name: type_name(strict_type_declaration)
+              name: type_name(strict_type_declaration),
+              sensitive:,
+              sensitive_exposed:
             )
           end
 
@@ -70,7 +74,7 @@ module Foobara
           end
 
           def non_processor_keys
-            %i[type _desugarized description]
+            %i[type _desugarized description sensitive sensitive_exposed]
           end
         end
       end

data/projects/type_declarations/src/sensitive_type_remover.rb

@@ -0,0 +1,17 @@
+module Foobara
+  module TypeDeclarations
+    class SensitiveTypeRemover < Value::Transformer
+      def applicable?(strict_type_declaration)
+        handler.applicable?(strict_type_declaration)
+      end
+
+      def handler
+        declaration_data
+      end
+
+      def remove_sensitive_types(strict_type_declaration)
+        TypeDeclarations.remove_sensitive_types(strict_type_declaration)
+      end
+    end
+  end
+end

data/projects/type_declarations/src/sensitive_type_removers/array.rb

@@ -0,0 +1,21 @@
+require_relative "../sensitive_type_remover"
+
+module Foobara
+  module TypeDeclarations
+    module SensitiveTypeRemovers
+      class Array < SensitiveTypeRemover
+        def transform(strict_type_declaration)
+          old_element_declaration = strict_type_declaration[:element_type_declaration]
+
+          new_element_declaration = remove_sensitive_types(old_element_declaration)
+
+          if new_element_declaration == old_element_declaration
+            strict_type_declaration
+          else
+            strict_type_declaration.merge(element_type_declaration: new_element_declaration)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_relative "../sensitive_type_remover"
+
+module Foobara
+  module TypeDeclarations
+    module SensitiveTypeRemovers
+      class Attributes < SensitiveTypeRemover
+        def transform(strict_type_declaration)
+          to_change = {}
+          to_remove = []
+
+          strict_type_declaration[:element_type_declarations].each_pair do |attribute_name, attribute_declaration|
+            if attribute_declaration[:sensitive]
+              to_remove << attribute_name
+            else
+              new_declaration = remove_sensitive_types(attribute_declaration)
+
+              if new_declaration != attribute_declaration
+                to_change[attribute_name] = new_declaration
+              end
+            end
+          end
+
+          if to_change.empty? && to_remove.empty?
+            strict_type_declaration
+          else
+            new_declaration = if to_remove.empty?
+                                strict_type_declaration
+                              else
+                                TypeDeclarations::Attributes.reject(strict_type_declaration, *to_remove)
+                              end
+
+            unless to_change.empty?
+              new_elements = new_declaration[:element_type_declarations].merge(to_change)
+              new_declaration = new_declaration.merge(element_type_declarations: new_elements)
+            end
+
+            new_declaration
+          end
+        end
+      end
+    end
+  end
+end

data/projects/type_declarations/src/type_declaration_handler.rb

@@ -4,7 +4,7 @@ module Foobara
   module TypeDeclarations
     class TypeDeclarationHandler < Value::Processor::Pipeline
       class << self
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           # :nocov:
           super.merge(processor_type: :type_declaration_handler)
           # :nocov:

data/projects/type_declarations/src/type_declaration_handler_registry.rb

@@ -2,7 +2,7 @@ module Foobara
   module TypeDeclarations
     class TypeDeclarationHandlerRegistry < Value::Processor::Selection
       class << self
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           # :nocov:
           super.merge(processor_type: :type_declaration_handler_registry)
           # :nocov:

data/projects/type_declarations/src/type_declaration_validator.rb

@@ -4,7 +4,7 @@ module Foobara
       include WithRegistries
 
       class << self
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           # :nocov:
           super.merge(processor_type: :type_declaration_validator)
           # :nocov:

data/projects/type_declarations/src/type_declarations.rb

@@ -17,6 +17,27 @@ module Foobara
         global_type_declaration_handler_registry.register(type_declaration_handler)
       end
 
+      def register_sensitive_type_remover(sensitive_type_remover)
+        handler = sensitive_type_remover.handler
+        sensitive_type_removers[handler.class.name] = sensitive_type_remover
+      end
+
+      def sensitive_type_removers
+        @sensitive_type_removers ||= {}
+      end
+
+      def remove_sensitive_types(strict_type_declaration)
+        handler = GlobalDomain.foobara_type_builder.type_declaration_handler_for(strict_type_declaration)
+
+        sensitive_type_remover = sensitive_type_removers[handler.class.name]
+
+        if sensitive_type_remover
+          sensitive_type_remover.process_value!(strict_type_declaration)
+        else
+          strict_type_declaration
+        end
+      end
+
       def strict(&)
         using_mode(Mode::STRICT, &)
       end

data/projects/types/src/extensions/error.rb

@@ -1,13 +1,13 @@
 module Foobara
   class Error
     class << self
-      def types_depended_on(*args)
+      def types_depended_on(*args, remove_sensitive: false)
         if args.size == 1
-          context_type.types_depended_on(args.first)
+          context_type.types_depended_on(args.first, remove_sensitive:)
         elsif args.empty?
           begin
             if context_type
-              context_type.types_depended_on
+              context_type.types_depended_on(remove_sensitive:)
             else
               raise Foobara::TypeDeclarations::ErrorExtension::NoContextTypeSetError
             end

data/projects/types/src/type/concerns/reflection.rb

@@ -6,7 +6,7 @@ module Foobara
           include Concern
 
           # as soon as we hit a registered type, don't go further down that path
-          def types_depended_on(result = nil)
+          def types_depended_on(result = nil, remove_sensitive: false)
             start = result.nil?
             result ||= Set.new
             return if result.include?(self)
@@ -15,16 +15,31 @@ module Foobara
 
             return if !start && registered?
 
-            to_process = types_to_add_to_manifest
+            to_process = types_to_add_to_manifest(remove_sensitive:)
 
             if element_types
               to_process += case element_types
                             when Type
-                              [element_types]
+                              if remove_sensitive && element_types.sensitive?
+                                # TODO: test this code path
+                                # :nocov:
+                                []
+                                # :nocov:
+                              else
+                                [element_types]
+                              end
                             when ::Hash
-                              element_types.values.select { |value| value.is_a?(Type) }
+                              element_types.values.select do |value|
+                                if !remove_sensitive || !value.sensitive?
+                                  value.is_a?(Type)
+                                end
+                              end
                             when ::Array
-                              element_types
+                              if remove_sensitive
+                                element_types.reject(&:sensitive?)
+                              else
+                                element_types
+                              end
                             else
                               # :nocov:
                               raise "Not sure how to find dependent types for #{element_types}"
@@ -33,7 +48,7 @@ module Foobara
             end
 
             to_process.each do |type|
-              type.types_depended_on(result)
+              type.types_depended_on(result, remove_sensitive:)
             end
 
             if start
@@ -43,8 +58,14 @@ module Foobara
             result
           end
 
-          def types_to_add_to_manifest
-            [*base_type, *element_type, *possible_errors.map(&:error_class)]
+          def types_to_add_to_manifest(remove_sensitive: false)
+            types = [*base_type, *possible_errors.map(&:error_class)]
+
+            if element_type && (!remove_sensitive || !element_type.sensitive?)
+              types << element_type
+            end
+
+            types
           end
 
           def deep_types_depended_on

data/projects/types/src/type.rb

@@ -27,7 +27,10 @@ module Foobara
                     :name,
                     :target_classes,
                     :description,
+                    :sensitive,
+                    :sensitive_exposed,
                     :processor_classes_requiring_type
+
       attr_reader :type_symbol
 
       def initialize(
@@ -44,8 +47,12 @@ module Foobara
         element_types: nil,
         structure_count: nil,
         processor_classes_requiring_type: nil,
+        sensitive: nil,
+        sensitive_exposed: nil,
         **opts
       )
+        self.sensitive = sensitive
+        self.sensitive_exposed = sensitive_exposed
         self.base_type = base_type
         self.description = description
         self.casters = [*casters, *base_type&.casters]
@@ -68,6 +75,14 @@ module Foobara
         validate_processors!
       end
 
+      def sensitive?
+        sensitive
+      end
+
+      def sensitive_exposed?
+        sensitive_exposed
+      end
+
       def apply_all_processors_needing_type!
         each_processor_class_requiring_type do |processor_class|
           # TODO: is this a smell?
@@ -294,10 +309,12 @@ module Foobara
         scoped_full_name
       end
 
-      def reference_or_declaration_data(declaration_data = self.declaration_data)
+      def reference_or_declaration_data(declaration_data = self.declaration_data, remove_sensitive: false)
         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 }
+        elsif remove_sensitive
+          TypeDeclarations.remove_sensitive_types(declaration_data)
         else
           declaration_data
         end
@@ -308,10 +325,10 @@ module Foobara
         scoped_full_name
       end
 
-      def foobara_manifest(to_include: Set.new)
+      def foobara_manifest(to_include: Set.new, remove_sensitive: false)
         types = []
 
-        types_depended_on.each do |dependent_type|
+        types_depended_on(remove_sensitive:).each do |dependent_type|
           if dependent_type.registered?
             types << dependent_type.foobara_manifest_reference
             to_include << dependent_type
@@ -319,9 +336,15 @@ module Foobara
         end
 
         possible_errors_manifests = possible_errors.map do |possible_error|
-          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:)]
+          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:, remove_sensitive:)]
         end.sort.to_h
 
+        declaration_data = self.declaration_data
+
+        if remove_sensitive
+          declaration_data = TypeDeclarations.remove_sensitive_types(declaration_data)
+        end
+
         h = Util.remove_blank(
           name:,
           target_classes: target_classes.map(&:name).sort,
@@ -331,15 +354,23 @@ module Foobara
           builtin: builtin?
         ).merge(description:, base_type: base_type_for_manifest&.full_type_name&.to_sym)
 
+        if sensitive?
+          h[:sensitive] = true
+        end
+
+        if sensitive_exposed?
+          h[:sensitive_exposed] = true
+        end
+
         h.merge!(
-          supported_processor_manifest(to_include).merge(
-            Util.remove_blank(processors: processor_manifest(to_include))
+          supported_processor_manifest(to_include, remove_sensitive:).merge(
+            Util.remove_blank(processors: processor_manifest(to_include, remove_sensitive:))
           )
         )
 
         target_classes.sort_by(&:name).each do |target_class|
           if target_class.respond_to?(:foobara_manifest)
-            h.merge!(target_class.foobara_manifest(to_include:))
+            h.merge!(target_class.foobara_manifest(to_include:, remove_sensitive:))
           end
         end
 
@@ -354,7 +385,7 @@ module Foobara
         base_type
       end
 
-      def supported_processor_manifest(to_include)
+      def supported_processor_manifest(to_include, remove_sensitive: false)
         supported_casters = []
         supported_transformers = []
         supported_validators = []
@@ -384,7 +415,7 @@ module Foobara
         )
       end
 
-      def processor_manifest(to_include)
+      def processor_manifest(to_include, remove_sensitive: false)
         casters_manifest = []
         transformers_manifest = []
         validators_manifest = []

data/projects/value/src/caster.rb

@@ -3,7 +3,7 @@ module Foobara
     # TODO: do we really need these??  Can't just use a transformer?
     class Caster < Transformer
       class << self
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           super.merge(processor_type: :caster)
         end
 

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

@@ -22,7 +22,7 @@ module Foobara
         end
 
         class << self
-          def foobara_manifest(to_include: Set.new)
+          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
             # :nocov:
             super.merge(processor_type: :casting)
             # :nocov:

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

@@ -5,7 +5,7 @@ module Foobara
     class Processor
       class Pipeline < Multi
         class << self
-          def foobara_manifest(to_include: Set.new)
+          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
             # :nocov:
             super.merge(processor_type: :pipeline)
             # :nocov:

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

@@ -9,7 +9,7 @@ module Foobara
         class MoreThanOneApplicableProcessorError < DataError; end
 
         class << self
-          def foobara_manifest(to_include: Set.new)
+          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
             # :nocov:
             super.merge(processor_type: :selection)
             # :nocov:

data/projects/value/src/processor.rb

@@ -25,7 +25,7 @@ module Foobara
           true
         end
 
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           errors = error_classes.map do |error_class|
             to_include << error_class
             error_class.foobara_manifest_reference
@@ -317,9 +317,9 @@ module Foobara
 
       # TODO: is this in the wrong place? Should this be an extension?
 
-      def foobara_manifest(to_include: Set.new)
+      def foobara_manifest(to_include: Set.new, remove_sensitive: false)
         possible_errors = self.possible_errors.map do |possible_error|
-          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:)]
+          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:, remove_sensitive:)]
         end
 
         manifest = super.dup

data/projects/value/src/transformer.rb

@@ -10,7 +10,7 @@ module Foobara
       end
 
       class << self
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           super.merge(processor_type: :transformer)
         end
 

data/projects/value/src/validator.rb

@@ -6,7 +6,7 @@ module Foobara
       end
 
       class << self
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           super.merge(processor_type: :transformer)
         end
       end