foobara 0.0.1

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

@@ -0,0 +1,32 @@
+module Foobara
+  class Error
+    class << self
+      def types_depended_on(*args)
+        if args.size == 1
+          context_type.types_depended_on(args.first)
+        elsif args.empty?
+          begin
+            if context_type
+              context_type.types_depended_on
+            else
+              raise Foobara::TypeDeclarations::ErrorExtension::NoContextTypeSetError
+            end
+          rescue Foobara::TypeDeclarations::ErrorExtension::NoContextTypeSetError
+            if abstract?
+              []
+            else
+              # :nocov:
+              raise
+              # :nocov:
+            end
+          end
+
+        else
+          # :nocov:
+          raise ArgumentError, "Too many arguments #{args}"
+          # :nocov:
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Foobara
+  module Types
+    class Type < Value::Processor::Pipeline
+      module Concerns
+        module Reflection
+          include Concern
+
+          # as soon as we hit a registered type, don't go further down that path
+          def types_depended_on(result = nil)
+            start = result.nil?
+            result ||= Set.new
+            return if result.include?(self)
+
+            result << self
+
+            return if !start && registered?
+
+            to_process = [*base_type, *element_type, *possible_errors.map(&:error_class)]
+
+            if element_types
+              to_process += case element_types
+                            when Type
+                              [element_types]
+                            when ::Hash
+                              element_types.values.select { |value| value.is_a?(Type) }
+                            when ::Array
+                              element_types
+                            else
+                              # :nocov:
+                              raise "Not sure how to find dependent types for #{element_types}"
+                              # :nocov:
+                            end
+            end
+
+            to_process.each do |type|
+              type.types_depended_on(result)
+            end
+
+            if start
+              result = result.select { |type| type.registered? && type != self }.to_set
+            end
+
+            result
+          end
+
+          def deep_types_depended_on
+            result = Set.new
+            to_process = types_depended_on
+
+            until to_process.empty?
+              type = to_process.first
+              to_process.delete(type)
+
+              next if result.include?(type)
+
+              result << type
+
+              to_process |= type.types_depended_on
+            end
+
+            result.select(&:registered?)
+          end
+
+          def inspect
+            # :nocov:
+            name = if scoped_path_set?
+                     scoped_full_name
+                   else
+                     "Anonymous #{base_type.type_symbol}"
+                   end
+
+            "#<Type:#{name}:0x#{object_id.to_s(16)} #{declaration_data}>"
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Foobara
+  module Types
+    class Type < Value::Processor::Pipeline
+      module Concerns
+        # What do we actually need here?
+        # we need a way to associate a type with a collection of supported processors.
+        # Type could make the most sense for this functionality.
+        # Any reason we should be decoupling the concept of validators to apply
+        # from validators that are supported and may or may not be applied?
+        # OK let's attempt doing this on Type instead.
+        module SupportedProcessorRegistration
+          class MissingProcessorError < StandardError; end
+
+          def supported_processor_classes
+            @supported_processor_classes ||= {}
+          end
+
+          def all_supported_processor_classes
+            if base_type
+              supported_processor_classes.values + base_type.all_supported_processor_classes
+            else
+              supported_processor_classes.values
+            end
+          end
+
+          def find_supported_processor_class(processor_symbol)
+            if supported_processor_classes.key?(processor_symbol)
+              supported_processor_classes[processor_symbol]
+            elsif base_type
+              base_type.find_supported_processor_class(processor_symbol)
+            else
+              # TODO: can we catch this via a type declaration validator before hitting it here?
+              raise MissingProcessorError, "No such processor for #{processor_symbol}"
+            end
+          end
+
+          def register_supported_processor_class(processor_class, symbol: processor_class.symbol)
+            unless symbol.is_a?(Symbol)
+              # :nocov:
+              raise "Invalid symbol value #{symbol.inspect}. Should instead be a symbol but was a #{symbol.class.name}"
+              # :nocov:
+            end
+
+            if supported_processor_classes.key?(symbol)
+              # :nocov:
+              raise "There's already a processor registered for #{symbol}"
+              # :nocov:
+            end
+
+            supported_processor_classes[symbol] = processor_class
+          end
+        end
+      end
+    end
+  end
+end

data/projects/types/src/type.rb

@@ -0,0 +1,375 @@
+module Foobara
+  module Types
+    # TODO: move casting interface to here?
+    class Type < Value::Processor::Pipeline
+      include Concerns::SupportedProcessorRegistration
+      include Concerns::Reflection
+      include IsManifestable
+
+      foobara_instances_are_namespaces!
+
+      class << self
+        def requires_declaration_data?
+          true
+        end
+      end
+
+      # TODO: needed/useful transformers/validators to implement:
+      #
+      # allow_empty (validation at attribute level)
+      # allow_nil (validation at attribute level)
+      # one_of (validation at attribute level)
+
+      attr_accessor :base_type,
+                    :casters,
+                    :transformers,
+                    :validators,
+                    :element_processors,
+                    :structure_count,
+                    :element_types,
+                    :element_type,
+                    :raw_declaration_data,
+                    :name,
+                    :target_classes,
+                    :description
+      attr_reader :type_symbol
+
+      def initialize(
+        *args,
+        target_classes:,
+        base_type:,
+        description: nil,
+        name: "anonymous",
+        casters: [],
+        transformers: [],
+        validators: [],
+        element_processors: nil,
+        element_type: nil,
+        element_types: nil,
+        structure_count: nil,
+        **opts
+      )
+        self.base_type = base_type
+        self.description = description
+        self.casters = [*casters, *base_type&.casters]
+        self.transformers = [*transformers, *base_type&.transformers]
+        self.validators = [*validators, *base_type&.validators]
+        self.element_processors = [*element_processors, *base_type&.element_processors]
+
+        self.structure_count = structure_count
+        # TODO: combine these maybe with the term "children_types"?
+        self.element_types = element_types
+        self.element_type = element_type
+        self.name = name
+        self.target_classes = Util.array(target_classes)
+
+        super(*args, **opts.merge(processors:, prioritize: false))
+
+        validate_processors!
+      end
+
+      def validate_processors!
+        all = [casters, transformers, validators, element_processors]
+
+        all.each do |processor_group|
+          processor_group.each.with_index do |processor, index|
+            if processor.requires_parent_declaration_data?
+              processor_group[index] = processor.dup_processor(parent_declaration_data: declaration_data)
+            end
+          end
+
+          processor_group.group_by(&:symbol).each_pair do |symbol, members|
+            if members.size > 1
+              if members.map { |m| m.class.name }.uniq.size == members.size
+                members[1..].each do |member|
+                  processor_group.delete(member)
+                end
+              else
+                # :nocov:
+                raise "Type #{name} has multiple processors with symbol #{symbol}"
+                # :nocov:
+              end
+            end
+          end
+        end
+      end
+
+      def target_class
+        if target_classes.empty?
+          # :nocov:
+          raise "No target classes"
+          # :nocov:
+        elsif target_classes.size > 1
+          # :nocov:
+          raise "Cannot use #target_class because this type has multiple target_classes"
+          # :nocov:
+        end
+
+        target_classes.first
+      end
+
+      def extends?(type)
+        case type
+        when Type
+          extends_type?(type)
+        when Symbol, String
+          concrete_type = created_in_namespace.foobara_lookup_type(type)
+          if concrete_type.nil?
+            # :nocov:
+            raise "No type found for #{type}"
+            # :nocov:
+          end
+
+          extends_type?(concrete_type)
+        else
+          # :nocov:
+          raise ArgumentError, "Expected a Type or a Symbol/String, but got #{type.inspect}"
+          # :nocov:
+        end
+      end
+
+      def extends_type?(type)
+        return true if self == type
+
+        unless type
+          # :nocov:
+          raise ArgumentError, "Expected a type but got nil"
+          # :nocov:
+        end
+
+        if registered?
+          if type.registered?
+            if type.foobara_manifest_reference == foobara_manifest_reference
+              return true
+            end
+          end
+        end
+
+        base_type&.extends_type?(type)
+      end
+
+      def type_symbol=(type_symbol)
+        @scoped_path ||= type_symbol.to_s.split("::")
+        @type_symbol = type_symbol.to_sym
+      end
+
+      def full_type_symbol
+        return @full_type_symbol if defined?(@full_type_symbol)
+
+        @full_type_symbol ||= if scoped_path_set?
+                                scoped_full_name.to_sym
+                              end
+      end
+
+      def processors
+        [
+          value_caster,
+          value_transformer,
+          value_validator,
+          element_processor
+        ].compact
+      end
+
+      def value_caster
+        # TODO: how can declaration_data be blank? That seems really strange...
+        Value::Processor::Casting.new({ cast_to: declaration_data }, casters:, target_classes:)
+      end
+
+      def applicable?(value)
+        value_caster.can_cast?(value)
+      end
+
+      foobara_delegate :needs_cast?, to: :value_caster
+
+      def cast(value)
+        value_caster.process_value(value)
+      end
+
+      def cast!(value)
+        value_caster.process_value!(value)
+      end
+
+      # TODO: an interesting thought... we have Processor and then a subclass of Processor and then an instance of
+      # processor that encapsulates the declaration_data for that processor. But then we pass `value` to every
+      # method in the instance of the processor as needed. This means it can't really memoize stuff. Should we create
+      # an instance of something from the instance of the processor and then ask it questions?? TODO: try this
+      def value_transformer
+        if transformers && !transformers.empty?
+          Value::Processor::Pipeline.new(processors: transformers)
+        end
+      end
+
+      # TODO: figure out how to safely memoize stuff so like this for performance reasons
+      # A good way, but potentially a decent amount of work, is to have a class that takes value to its initialize
+      # method.
+      def value_validator
+        if validators && !validators.empty?
+          Value::Processor::Pipeline.new(processors: validators)
+        end
+      end
+
+      def element_processor
+        if element_processors && !element_processors.empty?
+          Value::Processor::Pipeline.new(processors: element_processors)
+        end
+      end
+
+      # TODO: some way of memoizing these values? Would need to introduce a new class that takes the value to its
+      # constructor
+      def validation_errors(value)
+        value = cast!(value)
+        if value_transformer
+          value = value_transformer.process_value!(value)
+        end
+
+        if value_validator
+          value_validator.process_value(value).errors
+        else
+          []
+        end
+      end
+
+      def full_type_name
+        scoped_full_name
+      end
+
+      def reference_or_declaration_data(declaration_data = self.declaration_data)
+        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 }
+        else
+          declaration_data
+        end
+      end
+
+      # TODO: put this somewhere else
+      def foobara_manifest_reference
+        scoped_full_name
+      end
+
+      def foobara_manifest(to_include:)
+        types = []
+
+        types_depended_on.each do |dependent_type|
+          if dependent_type.registered?
+            types << dependent_type.foobara_manifest_reference
+            to_include << dependent_type
+          end
+        end
+
+        possible_errors_manifests = possible_errors.map do |possible_error|
+          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:)]
+        end.sort.to_h
+
+        h = Util.remove_blank(
+          name:,
+          target_classes: target_classes.map(&:name).sort,
+          declaration_data:,
+          types_depended_on: types.sort,
+          possible_errors: possible_errors_manifests
+        ).merge(description:, base_type: base_type&.full_type_name&.to_sym)
+
+        h.merge!(
+          supported_processor_manifest(to_include).merge(
+            Util.remove_blank(processors: processor_manifest(to_include))
+          )
+        )
+
+        target_classes.sort_by(&:name).each do |target_class|
+          if target_class.respond_to?(:foobara_manifest)
+            h.merge!(target_class.foobara_manifest(to_include:))
+          end
+        end
+
+        super.merge(h)
+      end
+
+      def supported_processor_manifest(to_include)
+        supported_casters = []
+        supported_transformers = []
+        supported_validators = []
+        supported_processors = []
+
+        all_supported_processor_classes.each do |processor_class|
+          to_include << processor_class
+
+          target = if processor_class < Value::Caster
+                     supported_casters
+                   elsif processor_class < Value::Validator
+                     supported_validators
+                   elsif processor_class < Value::Transformer
+                     supported_transformers
+                   else
+                     supported_processors
+                   end
+
+          target << processor_class.foobara_manifest_reference
+        end
+
+        Util.remove_blank(
+          supported_casters: supported_casters.sort,
+          supported_transformers: supported_transformers.sort,
+          supported_validators: supported_validators.sort,
+          supported_processors: supported_processors.sort
+        )
+      end
+
+      def processor_manifest(to_include)
+        casters_manifest = []
+        transformers_manifest = []
+        validators_manifest = []
+        caster_classes_manifest = []
+        transformer_classes_manifest = []
+        validator_classes_manifest = []
+
+        casters.each do |caster|
+          klass = caster.class
+          to_include << klass
+          caster_classes_manifest << klass.foobara_manifest_reference
+
+          if caster.scoped_path_set?
+            to_include << caster
+            casters_manifest << caster.foobara_manifest_reference
+          end
+        end
+
+        transformers.each do |transformer|
+          klass = transformer.class
+          to_include << klass
+          transformer_classes_manifest << klass.foobara_manifest_reference
+
+          if transformer.scoped_path_set?
+            to_include << transformer
+            transformers_manifest << transformer.foobara_manifest_reference
+          end
+        end
+
+        validators.each do |validator|
+          klass = validator.class
+          to_include << klass
+          validator_classes_manifest << klass.foobara_manifest_reference
+
+          if validator.scoped_path_set?
+            to_include << validator
+            validators_manifest << validator.foobara_manifest_reference
+          end
+        end
+
+        Util.remove_blank(
+          casters: casters_manifest.sort,
+          caster_classes: caster_classes_manifest.sort,
+          transformers: transformers_manifest.sort,
+          transformer_classes: transformer_classes_manifest.sort,
+          validators: validators_manifest.sort,
+          validator_classes: validator_classes_manifest.sort
+        )
+      end
+
+      def registered?
+        !!type_symbol
+      end
+    end
+  end
+
+  Type = Foobara::Types::Type
+end

data/projects/types/src/types.rb

@@ -0,0 +1,4 @@
+module Foobara
+  module Types
+  end
+end

data/projects/value/lib/foobara/value.rb

@@ -0,0 +1,7 @@
+module Foobara
+  module Value
+    foobara_domain!
+  end
+
+  Foobara.require_project_file("value", "processor")
+end

data/projects/value/src/caster.rb

@@ -0,0 +1,84 @@
+module Foobara
+  module Value
+    # TODO: do we really need these??  Can't just use a transformer?
+    class Caster < Transformer
+      class << self
+        def foobara_manifest(to_include:)
+          super.merge(processor_type: :caster)
+        end
+
+        def requires_declaration_data?
+          false
+        end
+
+        def create(options)
+          subclass(**options).instance
+        end
+
+        def subclass(name: nil, **options)
+          arity_zero = %i[name applies_message]
+          arity_one = %i[applicable? cast]
+          allowed = arity_zero + arity_one
+
+          invalid_options = options.keys - allowed
+
+          unless invalid_options.empty?
+            # :nocov:
+            raise ArgumentError, "Invalid options #{invalid_options} expected only #{allowed}"
+            # :nocov:
+          end
+
+          name ||= "#{self.name}::Anon#{SecureRandom.hex}"
+
+          unless name.include?(":")
+            name = "#{self.name}::#{name}"
+          end
+
+          Util.make_class name, self do
+            arity_one.each do |method_name|
+              if options.key?(method_name)
+                method = options[method_name]
+
+                define_method method_name do |value|
+                  method.call(value)
+                end
+              end
+            end
+
+            arity_zero.each do |method_name|
+              if options.key?(method_name)
+                value = options[method_name]
+
+                define_method method_name do
+                  value
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def applicable?(_value)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def applies_message
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def transform(value)
+        cast(value)
+      end
+
+      def cast(_value)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+    end
+  end
+end

data/projects/value/src/data_error.rb

@@ -0,0 +1,27 @@
+module Foobara
+  module Value
+    class DataError < Error
+      class << self
+        def category
+          :data
+        end
+      end
+
+      def initialize(message: nil, symbol: nil, context: nil, path: nil)
+        args = { message:, symbol:, context:, path: }.compact
+        super(**args.merge(category: self.class.category))
+      end
+
+      def attribute_name
+        # TODO: feels awkward... something is not right
+        # how is path actually set?
+        path.last || context[:attribute_name]
+      end
+
+      def eql?(other)
+        # TODO: this doesn't feel right at all...
+        super && other.is_a?(DataError) && path == other.path
+      end
+    end
+  end
+end