foobara 0.0.1

data/projects/builtin_types/src/builtin_types.rb

@@ -0,0 +1,189 @@
+module Foobara
+  Foobara.require_project_file("builtin_types", "duck")
+  Foobara.require_project_file("builtin_types", "atomic_duck")
+  Foobara.require_project_file("builtin_types", "duckture")
+
+  module BuiltinTypes
+    class << self
+      foobara_delegate :global_type_declaration_handler_registry, to: TypeDeclarations
+
+      # TODO: break this up
+      def build_and_register!(
+        type_symbol,
+        base_type,
+        target_classes = const_get("::#{Util.classify(type_symbol)}"),
+        description: "Built-in #{type_symbol} type"
+      )
+        declaration_data = { type: type_symbol.to_sym }
+
+        module_symbol = Util.classify(type_symbol).to_sym
+
+        builtin_type_module = const_get(module_symbol, false)
+
+        casters_module = Util.constant_value(builtin_type_module, :Casters)
+        caster_classes = if casters_module
+                           Util.constant_values(casters_module, extends: Value::Processor)
+                         end
+        casters = caster_classes&.map do |caster_class|
+          caster_class.new_with_agnostic_args(parent_declaration_data: declaration_data)
+        end
+
+        transformers_module = Util.constant_value(builtin_type_module, :Transformers)
+        transformer_classes = if transformers_module
+                                Util.constant_values(transformers_module, extends: Value::Processor)
+                              end
+        transformers = transformer_classes&.map do |transformer_class|
+          transformer_class.new_with_agnostic_args(parent_declaration_data: declaration_data)
+        end || []
+
+        validators_module = Util.constant_value(builtin_type_module, :Validators)
+        validator_classes = if validators_module
+                              Util.constant_values(validators_module, extends: Value::Processor)
+                            end
+        validators = validator_classes&.map do |validator_class|
+          validator_class.new_with_agnostic_args(parent_declaration_data: declaration_data)
+        end || []
+
+        type = Foobara::Types::Type.new(
+          declaration_data,
+          base_type:,
+          name: type_symbol,
+          casters:,
+          transformers:,
+          validators:,
+          # TODO: this is for controlling casting or not casting but could give the wrong information from a
+          # reflection point of view...
+          target_classes:,
+          description:
+        )
+
+        builtin_types << type
+
+        # TODO: is this necessary?
+        Foobara::Namespace::NamespaceHelpers.foobara_namespace!(type)
+
+        # TODO: really need to encapsulate this somehow...
+        type.type_symbol = type_symbol
+        type.foobara_parent_namespace ||= GlobalDomain
+        type.foobara_parent_namespace.foobara_register(type)
+
+        supported_casters_module = Util.constant_value(builtin_type_module, :SupportedCasters)
+        supported_caster_classes = if supported_casters_module
+                                     Util.constant_values(supported_casters_module, extends: Value::Processor)
+                                   end
+        supported_transformers_module = Util.constant_value(builtin_type_module, :SupportedTransformers)
+        supported_transformer_classes = if supported_transformers_module
+                                          Util.constant_values(supported_transformers_module, extends: Value::Processor)
+                                        end
+        supported_validators_module = Util.constant_value(builtin_type_module, :SupportedValidators)
+        supported_validator_classes = if supported_validators_module
+                                        Util.constant_values(supported_validators_module, extends: Value::Processor)
+                                      end
+        supported_processors_module = Util.constant_value(builtin_type_module, :SupportedProcessors)
+        supported_processor_classes = if supported_processors_module
+                                        Util.constant_values(supported_processors_module, extends: Value::Processor)
+                                      end
+
+        processor_classes = [*transformers, *validators].map(&:class)
+
+        [
+          *supported_caster_classes,
+          *supported_transformer_classes,
+          *supported_validator_classes,
+          *supported_processor_classes
+        ].each do |processor_class|
+          type.register_supported_processor_class(processor_class)
+          processor_classes << processor_class
+        end
+
+        processor_classes.each do |processor_class|
+          install_type_declaration_extensions_for(processor_class)
+        end
+
+        [
+          [casters_module, caster_classes, casters],
+          [transformers_module, transformer_classes, transformers],
+          [validators_module, validator_classes, validators],
+          [supported_casters_module, supported_caster_classes],
+          [supported_processors_module, supported_processor_classes],
+          [supported_transformers_module, supported_transformer_classes],
+          [supported_validators_module, supported_validator_classes]
+        ].each do |(mod, klasses, instances)|
+          next unless mod
+
+          prefix = Util.non_full_name(mod)
+
+          [*klasses, *instances].each do |scoped|
+            if !scoped.scoped_path_set? || scoped.scoped_path_autoset?
+              # TODO: Do we actually need this?
+              short_name = Util.non_full_name(scoped)
+              short_name = Util.underscore(short_name) unless scoped.is_a?(::Class)
+
+              scoped.scoped_path = [prefix, short_name]
+            end
+
+            parent = scoped.scoped_namespace
+
+            if parent.nil? || parent == Foobara || parent == Namespace.global || parent == GlobalDomain
+              scoped.foobara_parent_namespace = type
+              type.foobara_register(scoped)
+            end
+          end
+        end
+
+        type
+      end
+
+      def install_type_declaration_extensions_for(processor_class)
+        extension_module = Util.constant_value(processor_class, :TypeDeclarationExtension)
+
+        return unless extension_module
+
+        Util.constant_values(extension_module, is_a: ::Module).each do |handler_module|
+          handler_name = Util.non_full_name(handler_module)
+          handler_class_to_extend = TypeDeclarations::Handlers.const_get(handler_name)
+
+          unless handler_class_to_extend
+            # :nocov:
+            raise "Couldn't find handler class for #{handler_name}"
+            # :nocov:
+          end
+
+          handler_to_extend = global_type_declaration_handler_registry.type_declaration_handler_for_handler_class(
+            handler_class_to_extend
+          )
+
+          unless handler_to_extend
+            # :nocov:
+            raise "Could not find a handler for #{handler_class_to_extend}"
+            # :nocov:
+          end
+
+          desugarizer_module = Util.constant_value(handler_module, :Desugarizers)
+
+          if desugarizer_module
+            desugarizer_classes = Util.constant_values(desugarizer_module, is_a: ::Class)
+
+            desugarizer_classes.each do |desugarizer_class|
+              desugarizer = desugarizer_class.instance
+
+              handler_to_extend.desugarizers << desugarizer
+            end
+          end
+
+          validator_module = Util.constant_value(handler_module, :TypeDeclarationValidators)
+
+          if validator_module
+            validator_classes = Util.constant_values(validator_module, is_a: Class)
+
+            validator_classes.each do |validator_class|
+              validator = validator_class.instance
+
+              handler_to_extend.type_declaration_validators << validator
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/date/casters/hash.rb

@@ -0,0 +1,23 @@
+module Foobara
+  module BuiltinTypes
+    module Date
+      module Casters
+        class Hash < Value::Caster
+          def applicable?(hash)
+            hash.is_a?(::Hash) && hash.keys.size == 3 && (hash.keys.map(&:to_s).sort == %w[day month year])
+          end
+
+          def applies_message
+            "be a Hash with :year, :month, and :day keys"
+          end
+
+          def cast(hash)
+            hash = Util.symbolize_keys(hash)
+
+            ::Date.new(hash[:year], hash[:month], hash[:day])
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/date/casters/string.rb

@@ -0,0 +1,40 @@
+module Foobara
+  module BuiltinTypes
+    module Date
+      module Casters
+        class String < Value::Caster
+          def applicable?(value)
+            value.is_a?(::String) && parse(value)
+          end
+
+          def applies_message
+            "be a valid date string with year-month-day order"
+          end
+
+          def cast(string)
+            parse(string)
+          end
+
+          private
+
+          NOT_DELIMITED_REGEX = /\A(?<year>\d{4})(?<month>\d{2})(?<day>\d{2})\z/
+          DELIMITED_REGEX = /\A(?<year>\d{4,})(?<delimiter>[\/\\.|_:;-])(?<month>\d{1,2})\k<delimiter>(?<day>\d{1,2})\z/
+
+          def parse(string)
+            match = NOT_DELIMITED_REGEX.match(string) || DELIMITED_REGEX.match(string)
+
+            if match
+              year = match[:year].to_i
+              month = match[:month].to_i
+              day = match[:day].to_i
+
+              if ::Date.valid_date?(year, month, day)
+                ::Date.new(year, month, day)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/datetime/casters/date.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module Datetime
+      module Casters
+        class Date < Value::Caster
+          def applicable?(value)
+            value.is_a?(::Date)
+          end
+
+          def applies_message
+            "be a Date"
+          end
+
+          def cast(date)
+            date.to_time
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/datetime/casters/hash.rb

@@ -0,0 +1,77 @@
+module Foobara
+  module BuiltinTypes
+    module Datetime
+      module Casters
+        # TODO: there seems to be an issue with the design here. We cast first and casters are
+        # transformers (don't return errors.)  However, it would probably give a better error if we could
+        # indicate exactly what was wrong with this hash instead of a catch-all error mixed with all the other
+        # casters errors. The obvious solution is to inherit Value::Processor instead. Maybe that would just work
+        # without any other changes needed.
+        # TODO: try that
+        class Hash < TypeDeclarations::Caster
+          def applicable?(hash)
+            hash.is_a?(::Hash) && valid_hash?(hash)
+          end
+
+          def applies_message
+            "be a Hash with :year, :month, :day, :hours, :minutes, :seconds, :milliseconds, and :zone keys"
+          end
+
+          def cast(hash)
+            hash = datetime_attributes_type.process_value!(hash)
+
+            year = hash[:year]
+            month = hash[:month]
+            day = hash[:day]
+            hours = hash[:hours]
+            minutes = hash[:minutes]
+            seconds = hash[:seconds]
+            milliseconds = hash[:milliseconds]
+            zone = hash[:zone]
+
+            if milliseconds
+              seconds = seconds.to_r + (milliseconds.to_r / 1000)
+            end
+
+            ::Time.new(year, month, day, hours, minutes, seconds, zone)
+          end
+
+          def datetime_attributes_type
+            @datetime_attributes_type ||= type_for_declaration(
+              year: :integer,
+              month: { type: :integer, min: 1, max: 12 },
+              day: { type: :integer, min: 1, max: 31 },
+              hours: { type: :integer, min: 0, max: 23, required: false, default: 0 },
+              minutes: { type: :integer, min: 0, max: 59, required: false, default: 0 },
+              seconds: { type: :big_decimal, min: 0, max: 59, required: false, default: 0 },
+              milliseconds: { type: :integer, min: 0, max: 1000, required: false },
+              zone: { type: :string, required: false }
+            )
+          end
+
+          private
+
+          def valid_hash?(hash)
+            # TODO: use a #runner to memoize this?
+            outcome = datetime_attributes_type.process_value(hash)
+
+            if outcome.success?
+              hash = outcome.result
+
+              year = hash[:year]
+              month = hash[:month]
+              day = hash[:day]
+              zone = hash[:zone]
+
+              ::Date.valid_date?(year, month, day) && (zone.nil? || valid_zone?(zone))
+            end
+          end
+
+          def valid_zone?(zone)
+            !!Time.zone_offset(zone)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/datetime/casters/seconds_since_epoch.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module Datetime
+      module Casters
+        class SecondsSinceEpoch < Value::Caster
+          def applicable?(value)
+            value.is_a?(::Integer)
+          end
+
+          def applies_message
+            "be a an integer representing seconds since epoch"
+          end
+
+          def cast(seconds_since_epoch)
+            Time.at(seconds_since_epoch)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/datetime/casters/string.rb

@@ -0,0 +1,31 @@
+module Foobara
+  module BuiltinTypes
+    module Datetime
+      module Casters
+        class String < Value::Caster
+          def applicable?(value)
+            value.is_a?(::String) && parse(value)
+          end
+
+          def applies_message
+            "be a valid date string"
+          end
+
+          def cast(string)
+            parse(string)
+          end
+
+          private
+
+          def parse(string)
+            # would be nice to do this some other way where we can verify against a regex independent of casting
+            # to a Time especially since ArgumentError is way too generic. But might have to just stick with this
+            ::Time.parse(string)
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_casters/allow_nil.rb

@@ -0,0 +1,38 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedCasters
+        class AllowNil < TypeDeclarations::Caster
+          class << self
+            def requires_declaration_data?
+              true
+            end
+
+            def default_declaration_data
+              false
+            end
+          end
+          def applicable?(value)
+            value.nil? && allow_nil?
+          end
+
+          def allow_nil?
+            declaration_data
+          end
+
+          def cast(value)
+            value
+          end
+
+          def applies_message
+            "be nil"
+          end
+
+          def priority
+            Priority::HIGH
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/class_desugarizer.rb

@@ -0,0 +1,29 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class InstanceOf < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendRegisteredTypeDeclaration
+              module Desugarizers
+                class ClassDesugarizer < TypeDeclarations::Desugarizer
+                  def applicable?(rawish_type_declaration)
+                    rawish_type_declaration.is_a?(::Class)
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    { type: :duck, instance_of: rawish_type_declaration.name }
+                  end
+
+                  def priority
+                    Priority::LOWEST + 1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/instance_of_class_desugarizer.rb

@@ -0,0 +1,31 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class InstanceOf < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendRegisteredTypeDeclaration
+              module Desugarizers
+                class InstanceOfClassDesugarizer < TypeDeclarations::Desugarizer
+                  def applicable?(rawish_type_declaration)
+                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:instance_of].is_a?(::Class)
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    instance_of = rawish_type_declaration[:instance_of]
+                    instance_of = instance_of.name
+                    rawish_type_declaration.merge(instance_of:)
+                  end
+
+                  def priority
+                    Priority::LOWEST + 1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/instance_of_symbol_desugarizer.rb

@@ -0,0 +1,31 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class InstanceOf < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendRegisteredTypeDeclaration
+              module Desugarizers
+                class InstanceOfSymbolDesugarizer < TypeDeclarations::Desugarizer
+                  def applicable?(rawish_type_declaration)
+                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:instance_of].is_a?(::Symbol)
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    instance_of = rawish_type_declaration[:instance_of]
+                    instance_of = instance_of.to_s
+                    rawish_type_declaration.merge(instance_of:)
+                  end
+
+                  def priority
+                    Priority::LOWEST + 1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_validators/instance_of/type_declaration_extension/extend_registered_type_declaration/type_declaration_validators/is_valid_class.rb

@@ -0,0 +1,43 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class InstanceOf < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendRegisteredTypeDeclaration
+              module TypeDeclarationValidators
+                class IsValidClass < TypeDeclarations::TypeDeclarationValidator
+                  class InvalidInstanceOfValueGivenError < Value::DataError
+                    class << self
+                      def message
+                        "instance_of: should be a class or the name of an existing class"
+                      end
+                    end
+                  end
+
+                  def applicable?(strict_type_declaration)
+                    strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:instance_of)
+                  end
+
+                  def validation_errors(strict_type_declaration)
+                    instance_of = strict_type_declaration[:instance_of]
+
+                    return if instance_of.is_a?(::Class)
+
+                    if instance_of.is_a?(::String) || instance_of.is_a?(::Symbol)
+                      unless Object.const_defined?(instance_of)
+                        build_error(context: { attribute_name: :instance_of, value: instance_of })
+                      end
+                    else
+                      build_error(context: { attribute_name: :instance_of, value: instance_of })
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_validators/instance_of.rb

@@ -0,0 +1,42 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class InstanceOf < TypeDeclarations::Validator
+          class NotInstanceOfError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  value: :duck,
+                  expected_class_name: :string
+                }
+              end
+            end
+          end
+
+          def expected_class_name
+            declaration_data
+          end
+
+          def validation_errors(value)
+            klass = Object.const_get(expected_class_name)
+            unless value.is_a?(klass)
+              build_error(value)
+            end
+          end
+
+          def error_message(value)
+            "#{value} is not an instance of #{expected_class_name}"
+          end
+
+          def error_context(value)
+            {
+              value:,
+              expected_class_name:
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck/supported_validators/one_of/type_declaration_extension/extend_registered_type_declaration/desugarizers/cast_one_of.rb

@@ -0,0 +1,37 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class OneOf < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendRegisteredTypeDeclaration
+              module Desugarizers
+                class CastOneOf < TypeDeclarations::Desugarizer
+                  def applicable?(rawish_type_declaration)
+                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:one_of].is_a?(::Array)
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    one_of = rawish_type_declaration[:one_of]
+
+                    type = type_for_declaration(rawish_type_declaration.except(:one_of))
+
+                    one_of = one_of.map do |value|
+                      type.process_value!(value)
+                    end
+
+                    rawish_type_declaration.merge(one_of:)
+                  end
+
+                  def priority
+                    Priority::LOW + 1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end