Validixir.Validations (validixir v1.2.0)

This module contains premade validations for basic elixir types and often used functionality.

Link to this section Summary

Functions

Returns a validation success if the candidate is an atom, returns a failure else.

Returns a validation success if the candidate is a binary, returns a failure else.

Returns a validation success if the candidate is a bitstring, returns a failure else.

Returns a validation success if the candidate is a boolean, returns a failure else.

Returns a validation success if the candidate is an empty list, returns a failure else.

Returns a validation success if the candidate is an exception, returns a failure else.

Returns a validation success if the candidate is a float, returns a failure else.

Returns a validation success if the candidate is a function, returns a failure else.

Returns a validation success if the candidate is an integer, returns a failure else.

Returns a validation success if the candidate is a list, returns a failure else.

Returns a validation success if the candidate is a map, returns a failure else.

Returns a validation success if the given map contains the given key, returns a failure else.

Returns a validation success if the enum contains the elem, returns a failure else.

Returns a validation success if the candidate is a negative integer, returns a failure else.

Returns a validation success if the candidate is nil, returns a failure else. Since all other names are special words in elixir, we chose nil? as the function name.

Returns a validation success if the candidate is an non-empty list, returns a failure else.

Returns a validation success if the enum does not contain the elem, returns a failure else.

Returns a validation success if the candidate is not nil, returns a failure else.

Returns a validation success if the candidate is a number, returns a failure else.

Returns a validation success if the candidate is a pid, returns a failure else.

Returns a validation success if the candidate is a port, returns a failure else.

Returns a validation success if the candidate is a positive integer, returns a failure else.

Returns a validation success if the candidate is a reference, returns a failure else.

Returns a validation success if the candidate is a struct, returns a failure else.

Always returns a validation success.

Returns a validation success if the candidate is a tuple, returns a failure else.

Link to this section Functions

@spec atom(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is an atom, returns a failure else.

examples

Examples

iex> Validixir.Validations.atom(:hello)
%Validixir.Success{candidate: :hello}

iex> Validixir.Validations.atom(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_an_atom, context: Validixir.Validations}
    ],
    message_lookup: %{not_an_atom: true}
}
@spec binary(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a binary, returns a failure else.

examples

Examples

iex> Validixir.Validations.binary("foo")
%Validixir.Success{candidate: "foo"}

iex> Validixir.Validations.binary(<<1::3>>)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: <<1::3>>, message: :not_a_binary, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_binary: true}
}
@spec bitstring(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a bitstring, returns a failure else.

examples

Examples

iex> Validixir.Validations.bitstring("foo")
%Validixir.Success{candidate: "foo"}

iex> Validixir.Validations.bitstring(<<1::3>>)
%Validixir.Success{candidate: <<1::3>>}

iex> Validixir.Validations.bitstring(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_a_bitstring, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_bitstring: true}
}
@spec boolean(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a boolean, returns a failure else.

examples

Examples

iex> Validixir.Validations.boolean(true)
%Validixir.Success{candidate: true}

iex> Validixir.Validations.boolean(nil)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: nil, message: :not_a_boolean, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_boolean: true}
}
Link to this function

empty_list(val)

@spec empty_list(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is an empty list, returns a failure else.

examples

Examples

iex> Validixir.Validations.empty_list([])
%Validixir.Success{candidate: []}

iex> Validixir.Validations.empty_list([1,2,3])
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: [1,2,3], message: :not_an_empty_list, context: Validixir.Validations}
    ],
    message_lookup: %{not_an_empty_list: true}
}

iex> Validixir.Validations.empty_list(%{})
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: %{}, message: :not_an_empty_list, context: Validixir.Validations}
    ],
    message_lookup: %{not_an_empty_list: true}
}
@spec exception(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is an exception, returns a failure else.

examples

Examples

iex> Validixir.Validations.exception(%RuntimeError{})
%Validixir.Success{candidate: %RuntimeError{}}

iex> Validixir.Validations.exception(%{})
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: %{}, message: :not_an_exception, context: Validixir.Validations}
    ],
    message_lookup: %{not_an_exception: true}
}
@spec float(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a float, returns a failure else.

examples

Examples

iex> Validixir.Validations.float(12.2)
%Validixir.Success{candidate: 12.2}

iex> Validixir.Validations.float(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_a_float, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_float: true}
}
@spec function(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a function, returns a failure else.

examples

Examples

iex> Validixir.Validations.function(&Validixir.pure/1)
%Validixir.Success{candidate: &Validixir.pure/1}

iex> Validixir.Validations.function(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_a_function, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_function: true}
}
@spec integer(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is an integer, returns a failure else.

examples

Examples

iex> Validixir.Validations.integer(12)
%Validixir.Success{candidate: 12}

iex> Validixir.Validations.integer(12.2)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12.2, message: :not_an_integer, context: Validixir.Validations}
    ],
    message_lookup: %{not_an_integer: true}
}
@spec list(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a list, returns a failure else.

examples

Examples

iex> Validixir.Validations.list([1, 2, 3])
%Validixir.Success{candidate: [1,2,3]}

iex> Validixir.Validations.list([])
%Validixir.Success{candidate: []}

iex> Validixir.Validations.list(%{})
%Validixir.Failure{errors: [
       %Validixir.Error{candidate: %{}, message: :not_a_list, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_list: true}
}

Returns a validation success if the candidate is a map, returns a failure else.

examples

Examples

iex> Validixir.Validations.map(%{})
%Validixir.Success{candidate: %{}}

iex> Validixir.Validations.map(%Validixir.Success{candidate: 12})
%Validixir.Success{candidate: %Validixir.Success{candidate: 12}}

iex> Validixir.Validations.map([])
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: [], message: :not_a_map, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_map: true}
}
@spec map_key(map(), any()) :: Validixir.validation_result_t(any())

Returns a validation success if the given map contains the given key, returns a failure else.

examples

Examples

iex> Validixir.Validations.map_key(%{hello: :world}, :hello)
%Validixir.Success{candidate: {%{hello: :world}, :hello}}

iex> Validixir.Validations.map_key(%{}, :hello)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: {%{}, :hello}, message: :not_a_key_of_map, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_key_of_map: true}
}
Link to this function

member(enum, elem)

@spec member(Enum.t(), any()) :: Validixir.validation_result_t(any())

Returns a validation success if the enum contains the elem, returns a failure else.

examples

Examples

iex> Validixir.Validations.member([1,2,3], 1)
%Validixir.Success{candidate: {[1,2,3], 1}}

iex> Validixir.Validations.member([], 1)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: {[], 1}, message: :not_a_member, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_member: true}
}

iex> Validixir.Validations.member([1,2,3], 12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: {[1,2,3], 12}, message: :not_a_member, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_member: true}
}
Link to this function

neg_integer(val)

@spec neg_integer(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a negative integer, returns a failure else.

examples

Examples

iex> Validixir.Validations.neg_integer(-12)
%Validixir.Success{candidate: -12}

iex> Validixir.Validations.neg_integer(0)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 0, message: :not_a_negative_integer, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_negative_integer: true}
}

iex> Validixir.Validations.neg_integer(2)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 2, message: :not_a_negative_integer, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_negative_integer: true}
}
@spec nil?(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is nil, returns a failure else. Since all other names are special words in elixir, we chose nil? as the function name.

examples

Examples

iex> Validixir.Validations.nil?(nil)
%Validixir.Success{candidate: nil}

iex> Validixir.Validations.nil?(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_nil, context: Validixir.Validations}
    ],
    message_lookup: %{not_nil: true}
}
Link to this function

non_empty_list(val)

@spec non_empty_list(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is an non-empty list, returns a failure else.

examples

Examples

iex> Validixir.Validations.non_empty_list([1,2,3])
%Validixir.Success{candidate: [1,2,3]}

iex> Validixir.Validations.non_empty_list([])
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: [], message: :not_a_non_empty_list, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_non_empty_list: true}
}

iex> Validixir.Validations.non_empty_list(%{})
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: %{}, message: :not_a_non_empty_list, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_non_empty_list: true}
}
Link to this function

not_a_member(enum, elem)

@spec not_a_member(Enum.t(), any()) :: Validixir.validation_result_t(any())

Returns a validation success if the enum does not contain the elem, returns a failure else.

examples

Examples

iex> Validixir.Validations.not_a_member([1,2,3], 4)
%Validixir.Success{candidate: {[1,2,3], 4}}

iex> Validixir.Validations.not_a_member([], 1)
%Validixir.Success{candidate: {[], 1}}

iex> Validixir.Validations.not_a_member([1,2,3], 1)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: {[1,2,3], 1}, message: :is_a_member, context: Validixir.Validations}
    ],
    message_lookup: %{is_a_member: true}
}
@spec not_nil(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is not nil, returns a failure else.

examples

Examples

iex> Validixir.Validations.not_nil(12)
%Validixir.Success{candidate: 12}

iex> Validixir.Validations.not_nil(nil)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: nil, message: :is_nil, context: Validixir.Validations}
    ],
    message_lookup: %{is_nil: true}
}
@spec number(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a number, returns a failure else.

examples

Examples

iex> Validixir.Validations.number(12.2)
%Validixir.Success{candidate: 12.2}

iex> Validixir.Validations.number(12)
%Validixir.Success{candidate: 12}

iex> Validixir.Validations.number(nil)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: nil, message: :not_a_number, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_number: true}
}

Returns a validation success if the candidate is a pid, returns a failure else.

examples

Examples

iex> Validixir.Validations.pid(self())
%Validixir.Success{candidate: self()}

iex> Validixir.Validations.pid(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_a_pid, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_pid: true}
}
@spec port(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a port, returns a failure else.

Link to this function

pos_integer(val)

@spec pos_integer(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a positive integer, returns a failure else.

examples

Examples

iex> Validixir.Validations.pos_integer(12)
%Validixir.Success{candidate: 12}

iex> Validixir.Validations.pos_integer(0)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 0, message: :not_a_positive_integer, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_positive_integer: true}
}

iex> Validixir.Validations.pos_integer(-2)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: -2, message: :not_a_positive_integer, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_positive_integer: true}
}
@spec reference(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a reference, returns a failure else.

examples

Examples

iex> ref = make_ref()
iex> Validixir.Validations.reference(ref)
%Validixir.Success{candidate: ref}

iex> Validixir.Validations.reference(12)
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: 12, message: :not_a_reference, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_reference: true}
}
@spec struct(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a struct, returns a failure else.

examples

Examples

iex> Validixir.Validations.struct(Validixir.Success.make("abc"))
%Validixir.Success{candidate: Validixir.Success.make("abc")}

iex> Validixir.Validations.struct(%{})
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: %{}, message: :not_a_struct, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_struct: true}
}
Link to this function

succeed(candidate)

Always returns a validation success.

examples

Examples

iex> Validixir.Validations.succeed(12)
%Validixir.Success{candidate: 12}
@spec tuple(any()) :: Validixir.validation_result_t(any())

Returns a validation success if the candidate is a tuple, returns a failure else.

examples

Examples

iex> Validixir.Validations.tuple({1,2,3})
%Validixir.Success{candidate: {1,2,3}}

iex> Validixir.Validations.tuple([1,2,3])
%Validixir.Failure{errors: [
      %Validixir.Error{candidate: [1,2,3], message: :not_a_tuple, context: Validixir.Validations}
    ],
    message_lookup: %{not_a_tuple: true}
}