foobara 0.0.1

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

@@ -0,0 +1,41 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class OneOf < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendRegisteredTypeDeclaration
+              module Desugarizers
+                class ModuleDesugarizer < TypeDeclarations::Desugarizer
+                  def applicable?(rawish_type_declaration)
+                    rawish_type_declaration.is_a?(::Hash) && rawish_type_declaration[:one_of].is_a?(::Module)
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    mod = rawish_type_declaration[:one_of]
+
+                    one_of = Util.constant_values(mod)
+
+                    one_of = begin
+                      one_of.sort
+                    rescue
+                      # :nocov:
+                      one_of.sort_by(&:inspect)
+                      # :nocov:
+                    end
+
+                    rawish_type_declaration.merge(one_of:)
+                  end
+
+                  def priority
+                    Priority::LOW
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+      module SupportedValidators
+        class OneOf < TypeDeclarations::Validator
+          class ValueNotValidError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  value: :duck,
+                  valid_values: [:duck]
+                }
+              end
+            end
+          end
+
+          def valid_values
+            declaration_data
+          end
+
+          def validation_errors(value)
+            unless valid_values.include?(value)
+              build_error(value)
+            end
+          end
+
+          def error_message(value)
+            "#{value} is not one of #{valid_values}"
+          end
+
+          def error_context(value)
+            {
+              value:,
+              valid_values:
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/duck.rb

@@ -0,0 +1,6 @@
+module Foobara
+  module BuiltinTypes
+    module Duck
+    end
+  end
+end

data/projects/builtin_types/src/duckture.rb

@@ -0,0 +1,6 @@
+module Foobara
+  module BuiltinTypes
+    module Duckture
+    end
+  end
+end

data/projects/builtin_types/src/email/transformers/downcase.rb

@@ -0,0 +1,15 @@
+module Foobara
+  module BuiltinTypes
+    module Email
+      module Transformers
+        # Seems like it might be cleaner to just assemble these parts in one place instead of in different files?
+        # Hard to say.
+        class Downcase < BuiltinTypes::String::SupportedTransformers::Downcase
+          def always_applicable?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/email/validator_base.rb

@@ -0,0 +1,94 @@
+module Foobara
+  module BuiltinTypes
+    module Email
+      class ValidatorBase < TypeDeclarations::Validator
+        singleton_class.define_method :error_classes do
+          @error_classes ||= begin
+            error_short_name = "#{Util.non_full_name(self)}Error"
+            error_class_name = "#{name}::#{error_short_name}"
+
+            error_class = Util.make_class(error_class_name, Value::DataError) do
+              class << self
+                def context_type_declaration
+                  {
+                    value: :duck,
+                    regex: :duck, # TODO: make regex type
+                    negate_regex: :duck # TODO: make :boolean
+                  }
+                end
+
+                def message
+                  Util.humanize(symbol)
+                end
+              end
+            end
+
+            [error_class]
+          end
+        end
+
+        def always_applicable?
+          true
+        end
+
+        def regex
+          # :nocov:
+          raise "subclass responsibility"
+          # :nocov:
+        end
+
+        def negate_regex?
+          false
+        end
+
+        def error_context(value)
+          {
+            value:,
+            regex:,
+            negate_regex: negate_regex?
+          }
+        end
+
+        def validation_errors(email)
+          build_error if email.send(negate_regex? ? :=~ : :!~, regex)
+        end
+      end
+
+      module Validators
+        # This is getting kind of convoluted. TODO: unroll all of this into different files instead of dynamically
+        # creating classes here
+        {
+          true => {
+            must_have_an_at_sign: /\A[^@]+\z/,
+            cannot_have_multiple_at_signs: /@.*@/,
+            first_part_cannot_start_with_or_end_with_a_dot_or_have_two_dots_in_a_row: /(^\.|\.@|\.\..*@)/,
+            domain_cannot_start_with_or_end_with_a_hyphen: /(@-|-$)/,
+            first_part_cannot_be_empty: /\A@/,
+            second_part_cannot_be_empty: /@\z/
+          },
+          false => {
+            cannot_exceed_64_characters: /\A.{0,64}\z/,
+            first_part_has_bad_characters: /\A[.a-z\d_!#$%&'*+\/=?^‘{|}~-]+@/,
+            second_part_has_bad_characters: /@[.a-z\d-]+\z/
+          }
+        }.each do |negate, rule_set|
+          rule_set.each_pair do |symbol, regex|
+            class_name = "#{name}::#{Util.classify(symbol)}"
+
+            Util.make_class(class_name, ValidatorBase) do
+              define_method :regex do
+                regex
+              end
+
+              if negate
+                define_method :negate_regex? do
+                  true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module Float
+      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)
+            integer.to_f
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Foobara
+  module BuiltinTypes
+    module Float
+      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)
+            string.to_f
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Foobara
+  module BuiltinTypes
+    module Integer
+      module Casters
+        class String < Value::Caster
+          INTEGER_REGEX = /^-?\d+$/
+
+          def applicable?(value)
+            value.is_a?(::String) && value =~ INTEGER_REGEX
+          end
+
+          def applies_message
+            "be a string of digits optionally with a minus sign in front"
+          end
+
+          def cast(string)
+            string.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/number/supported_validators/max.rb

@@ -0,0 +1,41 @@
+module Foobara
+  module BuiltinTypes
+    module Number
+      module SupportedValidators
+        class Max < TypeDeclarations::Validator
+          class MaxExceededError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  value: :number,
+                  max: :number
+                }
+              end
+            end
+          end
+
+          def max
+            declaration_data
+          end
+
+          def validation_errors(value)
+            if value > max
+              build_error(value)
+            end
+          end
+
+          def error_message(value)
+            "Max exceeded. #{value} is larger than #{max}"
+          end
+
+          def error_context(value)
+            {
+              value:,
+              max:
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/number/supported_validators/min.rb

@@ -0,0 +1,41 @@
+module Foobara
+  module BuiltinTypes
+    module Number
+      module SupportedValidators
+        class Min < TypeDeclarations::Validator
+          class BelowMinimumError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  value: :number,
+                  min: :number
+                }
+              end
+            end
+          end
+
+          def min
+            declaration_data
+          end
+
+          def validation_errors(value)
+            if value < min
+              build_error(value)
+            end
+          end
+
+          def error_message(value)
+            "Below minimum allowed. #{value} is less than #{min}"
+          end
+
+          def error_context(value)
+            {
+              value:,
+              min:
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module String
+      module Casters
+        class Numeric < Value::Caster
+          def applicable?(value)
+            value.is_a?(::Numeric)
+          end
+
+          def applies_message
+            "be a Numeric"
+          end
+
+          def cast(string)
+            string.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module String
+      module Casters
+        class Symbol < Value::Caster
+          def applicable?(value)
+            value.is_a?(::Symbol)
+          end
+
+          def applies_message
+            "be a Symbol"
+          end
+
+          def cast(string)
+            string.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/string/supported_transformers/downcase.rb

@@ -0,0 +1,11 @@
+module Foobara
+  module BuiltinTypes
+    # TODO: Rename to StringType to avoid needing to remember ::String elsewhere in the code
+    module String
+      module SupportedTransformers
+        class Downcase < Value::Transformer.subclass(transform: :downcase.to_proc, name: "Downcase")
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/string/supported_validators/matches.rb

@@ -0,0 +1,41 @@
+module Foobara
+  module BuiltinTypes
+    module String
+      module SupportedValidators
+        class Matches < TypeDeclarations::Validator
+          class DoesNotMatchError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  value: :string,
+                  regex: :duck # TODO: make a regex type??
+                }
+              end
+            end
+          end
+
+          def regex
+            declaration_data
+          end
+
+          def validation_errors(string)
+            if string !~ regex
+              build_error(string)
+            end
+          end
+
+          def error_message(value)
+            "#{value.inspect} did not match #{regex.inspect}"
+          end
+
+          def error_context(value)
+            {
+              value:,
+              regex: regex.to_s
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/string/supported_validators/max_length.rb

@@ -0,0 +1,37 @@
+module Foobara
+  module BuiltinTypes
+    module String
+      module SupportedValidators
+        class MaxLength < TypeDeclarations::Validator
+          class MaxLengthExceededError < Foobara::Value::DataError
+            class << self
+              def context_type_declaration
+                {
+                  value: :string,
+                  max_length: :integer
+                }
+              end
+            end
+          end
+
+          def validation_errors(string)
+            if string.length > max_length
+              build_error(string)
+            end
+          end
+
+          def error_message(_value)
+            "Max length exceeded. Cannot be longer than #{max_length}"
+          end
+
+          def error_context(value)
+            {
+              value:,
+              max_length:
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Foobara
+  module BuiltinTypes
+    module Symbol
+      module Casters
+        class String < Value::Caster
+          def applicable?(value)
+            value.is_a?(::String)
+          end
+
+          def applies_message
+            "be a String"
+          end
+
+          def cast(string)
+            string.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/tuple/supported_processors/element_type_declarations/type_declaration_extension/extend_tuple_type_declaration/desugarizers/set_size.rb

@@ -0,0 +1,32 @@
+module Foobara
+  module BuiltinTypes
+    module Tuple
+      module SupportedProcessors
+        class ElementTypeDeclarations < TypeDeclarations::ElementProcessor
+          module TypeDeclarationExtension
+            module ExtendTupleTypeDeclaration
+              module Desugarizers
+                class SetSize < TypeDeclarations::Desugarizer
+                  def applicable?(value)
+                    if value.is_a?(::Hash)
+                      value.key?(:element_type_declarations) && value[:type] == :tuple && !value.key?(:size)
+                    end
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    rawish_type_declaration[:size] = rawish_type_declaration[:element_type_declarations].size
+                    rawish_type_declaration
+                  end
+
+                  def priority
+                    Priority::LOW
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/builtin_types/src/tuple/supported_processors/element_type_declarations/type_declaration_extension/extend_tuple_type_declaration/type_declaration_validators/size_matches.rb

@@ -0,0 +1,50 @@
+module Foobara
+  module BuiltinTypes
+    module Tuple
+      module SupportedProcessors
+        class ElementTypeDeclarations < TypeDeclarations::ElementProcessor
+          module TypeDeclarationExtension
+            module ExtendTupleTypeDeclaration
+              module TypeDeclarationValidators
+                class SizeMatches < TypeDeclarations::TypeDeclarationValidator
+                  class IncorrectSizeError < Value::DataError
+                    class << self
+                      def context_type_declaration
+                        {
+                          expected_size: :integer,
+                          actual_size: :integer,
+                          value: :array
+                        }
+                      end
+                    end
+                  end
+
+                  def applicable?(strict_type_declaration)
+                    strict_type_declaration.key?(:size)
+                  end
+
+                  def validation_errors(strict_type_declaration)
+                    size = strict_type_declaration[:size]
+                    element_type_declarations = strict_type_declaration[:element_type_declarations]
+                    element_type_declarations_size = element_type_declarations.size
+
+                    if size != element_type_declarations_size
+                      build_error(
+                        message: "Expected tuple to have #{size} elements but it had #{element_type_declarations_size}",
+                        context: {
+                          expected_size: size,
+                          actual_size: element_type_declarations_size,
+                          value: strict_type_declaration
+                        }
+                      )
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Foobara
+  module BuiltinTypes
+    module Tuple
+      module SupportedProcessors
+        # TODO: how to relate size to this? I guess a TypeDeclarationValidator is a good idea here to make sure
+        # that element_type_declarations.size matches size if both are present and a Desugarizer that sets them both?
+        class ElementTypeDeclarations < TypeDeclarations::ElementProcessor
+          def applicable?(value)
+            # Size mismatch is handled by size validator later so just bail out here since without a correct
+            # size we don't really know what to expect to happen if we proceed.
+            # TODO: would be nice to have the Size validator run earlier in the process so that we wouldn't have
+            # to check this here.
+            value.size == element_type_declarations.size
+          end
+
+          def element_types
+            @element_types ||= element_type_declarations.map do |type_declaration|
+              type_for_declaration(type_declaration)
+            end
+          end
+
+          def process_value(array)
+            errors = []
+
+            array.each.with_index do |element, index|
+              element_outcome = element_types[index].process_value(element)
+
+              if element_outcome.success?
+                array[index] = element_outcome.result
+              else
+                element_outcome.each_error do |error|
+                  error.prepend_path!(index)
+
+                  errors << error
+                end
+              end
+            end
+
+            Outcome.new(result: array, errors:)
+          end
+
+          def possible_errors
+            possibilities = super.dup
+
+            element_types.each.with_index do |element_type, index|
+              element_type.possible_errors.each do |possible_error|
+                possible_error = possible_error.dup
+                possible_error.prepend_path!(index)
+                possibilities << possible_error
+              end
+            end
+
+            possibilities
+          end
+        end
+      end
+    end
+  end
+end

data/projects/callback/lib/foobara/callback.rb

@@ -0,0 +1 @@
+module Foobara::Callback; end

data/projects/callback/src/block/after.rb

@@ -0,0 +1,10 @@
+module Foobara
+  module Callback
+    class Block
+      class After < Block
+        include Concerns::KeywordArgumentableBlock
+        include Concerns::BlockParameterNotAllowed
+      end
+    end
+  end
+end