foobara 0.0.1

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

@@ -0,0 +1,28 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module Casters
+        class Hash < Value::Caster
+          def applicable?(value)
+            value.is_a?(::Hash) && value.keys.all? { |key| key.is_a?(::Symbol) || key.is_a?(::String) }
+          end
+
+          def applies_message
+            "be a hash with symbolizable keys"
+          end
+
+          def cast(hash)
+            keys = hash.keys
+            non_symbolic_keys = keys.reject { |key| key.is_a?(::Symbol) }
+
+            if non_symbolic_keys.empty?
+              hash
+            else
+              Util.symbolize_keys(hash)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_processors/element_type_declarations.rb

@@ -0,0 +1,89 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedProcessors
+        class ElementTypeDeclarations < TypeDeclarations::ElementProcessor
+          class UnexpectedAttributesError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  unexpected_attributes: [:symbol],
+                  allowed_attributes: [:symbol]
+                }
+              end
+
+              def fatal?
+                true
+              end
+            end
+          end
+
+          def applicable?(value)
+            value.is_a?(::Hash)
+          end
+
+          def allowed_attributes
+            @allowed_attributes ||= declaration_data.keys
+          end
+
+          def process_value(attributes_hash)
+            attributes_hash = Util.deep_dup(attributes_hash)
+
+            unexpected_attributes = attributes_hash.keys - allowed_attributes
+
+            unless unexpected_attributes.empty?
+              return Outcome.error(
+                build_error(
+                  attributes_hash,
+                  message: "Unexpected attributes #{
+                  unexpected_attributes
+                }. Expected only #{allowed_attributes}",
+                  context: {
+                    unexpected_attributes:,
+                    allowed_attributes:
+                  }
+                )
+              )
+            end
+
+            errors = []
+
+            attributes_hash.each_pair do |attribute_name, attribute_value|
+              attribute_type_declaration = element_type_declarations[attribute_name]
+              attribute_type = type_for_declaration(attribute_type_declaration)
+              attribute_outcome = attribute_type.process_value(attribute_value)
+
+              if attribute_outcome.success?
+                attributes_hash[attribute_name] = attribute_outcome.result
+              else
+                attribute_outcome.each_error do |error|
+                  error.path = [attribute_name, *error.path]
+
+                  errors << error
+                end
+              end
+            end
+
+            Outcome.new(result: attributes_hash, errors:)
+          end
+
+          def possible_errors
+            possibilities = [*super]
+
+            element_type_declarations.each_pair do |attribute_name, attribute_declaration|
+              attribute_type = type_for_declaration(attribute_declaration)
+
+              attribute_type.possible_errors.each do |possible_error|
+                possible_error = possible_error.dup
+                possible_error.prepend_path!(attribute_name)
+                possibilities << possible_error
+              end
+            end
+
+            possibilities
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_defaults_from_element_types_to_root.rb

@@ -0,0 +1,40 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedTransformers
+        class Defaults < Value::Transformer
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module Desugarizers
+                class MoveDefaultsFromElementTypesToRoot < TypeDeclarations::Desugarizer
+                  def applicable?(value)
+                    value.is_a?(::Hash) && value[:type] == :attributes
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    defaults = rawish_type_declaration[:defaults]
+                    defaults = defaults ? defaults.dup : {}
+
+                    element_type_declarations = rawish_type_declaration[:element_type_declarations]
+
+                    element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
+                      if attribute_type_declaration.is_a?(Hash) && attribute_type_declaration.key?(:default)
+                        default = attribute_type_declaration[:default]
+                        element_type_declarations[attribute_name] = attribute_type_declaration.except(:default)
+                        defaults.merge!(attribute_name => default)
+                      end
+                    end
+
+                    rawish_type_declaration[:defaults] = defaults unless defaults.empty?
+
+                    rawish_type_declaration
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/desugarizers/symbolize_defaults.rb

@@ -0,0 +1,31 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedTransformers
+        class Defaults < Value::Transformer
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module Desugarizers
+                class SymbolizeDefaults < TypeDeclarations::Desugarizer
+                  def applicable?(value)
+                    value.is_a?(::Hash) && value[:type] == :attributes && value[:defaults]
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    defaults = rawish_type_declaration[:defaults]
+
+                    if defaults.any? { |key, _| key.is_a?(::String) }
+                      rawish_type_declaration[:defaults] = defaults.transform_keys(&:to_sym)
+                    end
+
+                    rawish_type_declaration
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/hash_with_symbolic_keys.rb

@@ -0,0 +1,37 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedTransformers
+        class Defaults < Value::Transformer
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module TypeDeclarationValidators
+                class HashWithSymbolicKeys < TypeDeclarations::TypeDeclarationValidator
+                  class InvalidDefaultValuesGivenError < Value::DataError
+                    class << self
+                      def message
+                        "Defaults should be a hash with symbolic keys"
+                      end
+                    end
+                  end
+
+                  def applicable?(strict_type_declaration)
+                    strict_type_declaration.is_a?(Hash) && strict_type_declaration.key?(:defaults)
+                  end
+
+                  def validation_errors(strict_type_declaration)
+                    defaults = strict_type_declaration[:defaults]
+
+                    unless defaults.is_a?(Hash) && Util.all_symbolic_keys?(defaults)
+                      build_error(context: { attribute_name: :defaults, value: defaults })
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_transformers/defaults/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/valid_attribute_names.rb

@@ -0,0 +1,60 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedTransformers
+        class Defaults < Value::Transformer
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module TypeDeclarationValidators
+                class ValidAttributeNames < TypeDeclarations::TypeDeclarationValidator
+                  class InvalidDefaultValueGivenError < Value::DataError
+                    class << self
+                      def context_type_declaration
+                        {
+                          invalid_key: :symbol,
+                          valid_attribute_names: [:symbol],
+                          defaults: :attributes
+                        }
+                      end
+
+                      def fatal?
+                        # Since there could be multiple bad defaults
+                        true
+                      end
+                    end
+                  end
+
+                  def applicable?(strict_type_declaration)
+                    defaults = strict_type_declaration[:defaults]
+
+                    defaults.is_a?(::Hash) && Util.all_symbolic_keys?(defaults)
+                  end
+
+                  def validation_errors(strict_type_declaration)
+                    defaults = strict_type_declaration[:defaults]
+
+                    valid_attribute_names = strict_type_declaration[:element_type_declarations].keys
+
+                    # TODO: this should be one error instead of multiple
+                    defaults.keys.map do |key|
+                      unless valid_attribute_names.include?(key)
+                        build_error(
+                          message: "#{key} is not a valid default key, expected one of #{valid_attribute_names}",
+                          context: {
+                            invalid_key: key,
+                            valid_attribute_names:,
+                            defaults:
+                          }
+                        )
+                      end
+                    end.compact
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_transformers/defaults.rb

@@ -0,0 +1,41 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedTransformers
+        class Defaults < Value::Transformer
+          class << self
+            def requires_parent_declaration_data?
+              true
+            end
+          end
+
+          def transform(attributes_hash)
+            to_apply = {}
+
+            defaults.each_pair do |attribute_name, default|
+              if attributes_hash.key?(attribute_name)
+                value = attributes_hash[attribute_name]
+
+                if value.nil?
+                  allow_nil = parent_declaration_data[:element_type_declarations][attribute_name][:allow_nil]
+
+                  unless allow_nil
+                    to_apply[attribute_name] = default
+                  end
+                end
+              else
+                to_apply[attribute_name] = default
+              end
+            end
+
+            if to_apply.empty?
+              attributes_hash
+            else
+              attributes_hash.merge(to_apply)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/move_required_from_element_types_to_root.rb

@@ -0,0 +1,55 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedValidators
+        class Required < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module Desugarizers
+                class MoveRequiredFromElementTypesToRoot < TypeDeclarations::Desugarizer
+                  def applicable?(value)
+                    value.is_a?(::Hash) && value[:type] == :attributes
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    required_attributes = Util.array(rawish_type_declaration[:required])
+                    # TODO: move this to a transformer...
+                    required_attributes = required_attributes.map do |value|
+                      if value.is_a?(::String)
+                        value.to_sym
+                      else
+                        value
+                      end
+                    end
+
+                    element_type_declarations = rawish_type_declaration[:element_type_declarations]
+
+                    element_type_declarations.each_pair do |attribute_name, attribute_type_declaration|
+                      if attribute_type_declaration.is_a?(::Hash) && attribute_type_declaration.key?(:required)
+                        is_required = attribute_type_declaration[:required]
+
+                        if [true, false].include?(is_required)
+                          element_type_declarations[attribute_name] = attribute_type_declaration.except(:required)
+
+                          if is_required
+                            required_attributes << attribute_name
+                          else
+                            required_attributes.delete(attribute_name)
+                          end
+                        end
+                      end
+                    end
+
+                    rawish_type_declaration[:required] = required_attributes unless required_attributes.empty?
+
+                    rawish_type_declaration
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/array_of_symbols.rb

@@ -0,0 +1,47 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedValidators
+        class Required < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module TypeDeclarationValidators
+                class ArrayOfSymbols < TypeDeclarations::TypeDeclarationValidator
+                  class InvalidRequiredAttributesValuesGivenError < Value::DataError
+                    class << self
+                      def message
+                        "Required should be an array of symbols"
+                      end
+
+                      def context_type_declaration
+                        {
+                          value: :duck
+                        }
+                      end
+                    end
+                  end
+
+                  def applicable?(strict_type_declaration)
+                    strict_type_declaration.key?(:required)
+                  end
+
+                  def validation_errors(strict_type_declaration)
+                    required = strict_type_declaration[:required]
+
+                    unless required.is_a?(::Array) && Util.all_symbolic_elements?(required)
+                      build_error
+                    end
+                  end
+
+                  def error_context(value)
+                    { value: }
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/type_declaration_validators/array_with_valid_attribute_names.rb

@@ -0,0 +1,54 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedValidators
+        class Required < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module TypeDeclarationValidators
+                class ArrayWithValidAttributeNames < TypeDeclarations::TypeDeclarationValidator
+                  class InvalidRequiredAttributeNameGivenError < Value::DataError
+                    class << self
+                      def context_type_declaration
+                        {
+                          invalid_required_attribute_name: :symbol,
+                          valid_attribute_names: [:symbol],
+                          required: [:symbol]
+                        }
+                      end
+                    end
+                  end
+
+                  def applicable?(strict_type_declaration)
+                    required = strict_type_declaration[:required]
+
+                    required.is_a?(::Array) && Util.all_symbolic_elements?(required)
+                  end
+
+                  def validation_errors(strict_type_declaration)
+                    required = strict_type_declaration[:required]
+
+                    valid_attribute_names = strict_type_declaration[:element_type_declarations].keys
+
+                    required.map do |key|
+                      unless valid_attribute_names.include?(key)
+                        build_error(
+                          message: "#{key} is not a valid default key, expected one of #{valid_attribute_names}",
+                          context: {
+                            invalid_required_attribute_name: key,
+                            valid_attribute_names:,
+                            required:
+                          }
+                        )
+                      end
+                    end.compact
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/attributes/supported_validators/required.rb

@@ -0,0 +1,51 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedValidators
+        class Required < TypeDeclarations::Validator
+          class MissingRequiredAttributeError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  attribute_name: :symbol
+                }
+              end
+
+              def fatal?
+                true
+              end
+            end
+          end
+
+          def applicable?(value)
+            value.is_a?(::Hash)
+          end
+
+          def required_attribute_names
+            required
+          end
+
+          def validation_errors(attributes_hash)
+            required_attribute_names.map do |required_attribute_name|
+              unless attributes_hash.key?(required_attribute_name)
+                build_error(
+                  message: "Missing required attribute #{required_attribute_name}",
+                  context: { attribute_name: required_attribute_name },
+                  path: [required_attribute_name]
+                )
+              end
+            end.compact
+          end
+
+          def possible_errors
+            required_attribute_names.map do |required_attribute_name|
+              possible_error = PossibleError.new(error_class, processor: self)
+              possible_error.prepend_path!(required_attribute_name)
+              possible_error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/big_decimal/casters/integer.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module BigDecimal
+      module Casters
+        class Integer < Value::Caster
+          def applicable?(value)
+            value.is_a?(::Integer)
+          end
+
+          def applies_message
+            "be a an Integer"
+          end
+
+          def cast(integer)
+            BigDecimal(integer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Foobara
+  module BuiltinTypes
+    module BigDecimal
+      module Casters
+        class String < Value::Caster
+          FLOAT_REGEX = /^-?\d+(\.\d+)?([eE]-?\d+)?$/
+
+          def applicable?(value)
+            value.is_a?(::String) && value =~ FLOAT_REGEX
+          end
+
+          def applies_message
+            "be a string of digits with one decimal point optionally amongst " \
+              "them and optionally with a minus sign in front and optionally an exponent denoted with e"
+          end
+
+          def cast(string)
+            BigDecimal(string)
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/boolean/casters/numeric.rb

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module Boolean
+      module Casters
+        class Numeric < Value::Caster
+          def applicable?(value)
+            [0, 1].include?(value)
+          end
+
+          def applies_message
+            "be 0 or 1"
+          end
+
+          def cast(value)
+            !value.zero?
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/boolean/casters/string_or_symbol.rb

@@ -0,0 +1,27 @@
+module Foobara
+  module BuiltinTypes
+    module Boolean
+      module Casters
+        class StringOrSymbol < Value::Caster
+          TRUE_VALUES =  Set["true", "t", "1", "yes", "y"]
+          FALSE_VALUES = Set["false", "f", "0", "no", "n"]
+          ALLOWED_VALUES = TRUE_VALUES | FALSE_VALUES
+
+          def applicable?(value)
+            value = value.to_s if value.is_a?(::Symbol)
+
+            value.is_a?(::String) && ALLOWED_VALUES.include?(value.downcase)
+          end
+
+          def applies_message
+            "be a String or Symbol that is one of #{ALLOWED_VALUES.join(", ")} (case-insensitive)"
+          end
+
+          def cast(value)
+            TRUE_VALUES.include?(value.to_s.downcase)
+          end
+        end
+      end
+    end
+  end
+end