Validixir.Validations (validixir v1.2.2)

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 otherwise.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Always returns a validation success.

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

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 otherwise.

examples

Examples

iex> Validixir.Validations.atom(:hello)
{:ok, :hello}

iex> Validixir.Validations.atom(12)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.binary("foo")
{:ok, "foo"}

iex> Validixir.Validations.binary(<<1::3>>)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.bitstring("foo")
{:ok, "foo"}

iex> Validixir.Validations.bitstring(<<1::3>>)
{:ok, <<1::3>>}

iex> Validixir.Validations.bitstring(12)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.boolean(true)
{:ok, true}

iex> Validixir.Validations.boolean(nil)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.empty_list([])
{:ok, []}

iex> Validixir.Validations.empty_list([1,2,3])
{:error, %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(%{})
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.exception(%RuntimeError{})
{:ok, %RuntimeError{}}

iex> Validixir.Validations.exception(%{})
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.float(12.2)
{:ok, 12.2}

iex> Validixir.Validations.float(12)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.function(&Validixir.pure/1)
{:ok, &Validixir.pure/1}

iex> Validixir.Validations.function(12)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.integer(12)
{:ok, 12}

iex> Validixir.Validations.integer(12.2)
{:error, %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 otherwise.

examples

Examples

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

iex> Validixir.Validations.list([])
{:ok, []}

iex> Validixir.Validations.list(%{})
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.map(%{})
{:ok, %{}}

iex> person_struct = %Example.Person{name: "s", username: "h", email: "s@h.b", address: "s h b"}
iex> Validixir.Validations.map(person_struct)
{:ok, person_struct}

iex> Validixir.Validations.map([])
{:error, %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 otherwise.

examples

Examples

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

iex> Validixir.Validations.map_key(%{}, :hello)
{:error, %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 otherwise.

examples

Examples

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

iex> Validixir.Validations.member([], 1)
{:error, %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)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.neg_integer(-12)
{:ok, -12}

iex> Validixir.Validations.neg_integer(0)
{:error, %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)
{:error, %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 otherwise. Since all other names are special words in elixir, we chose nil? for the name of the function.

examples

Examples

iex> Validixir.Validations.nil?(nil)
{:ok, nil}

iex> Validixir.Validations.nil?(12)
{:error, %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 a non-empty list, returns a failure otherwise.

examples

Examples

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

iex> Validixir.Validations.non_empty_list([])
{:error, %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(%{})
{:error, %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 otherwise.

examples

Examples

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

iex> Validixir.Validations.not_a_member([], 1)
{:ok, {[], 1}}

iex> Validixir.Validations.not_a_member([1,2,3], 1)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.not_nil(12)
{:ok, 12}

iex> Validixir.Validations.not_nil(nil)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.number(12.2)
{:ok, 12.2}

iex> Validixir.Validations.number(12)
{:ok, 12}

iex> Validixir.Validations.number(nil)
{:error, %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 otherwise.

examples

Examples

iex> Validixir.Validations.pid(self())
{:ok, self()}

iex> Validixir.Validations.pid(12)
{:error, %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 otherwise.

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 otherwise.

examples

Examples

iex> Validixir.Validations.pos_integer(12)
{:ok, 12}

iex> Validixir.Validations.pos_integer(0)
{:error, %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)
{:error, %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 otherwise.

examples

Examples

iex> ref = make_ref()
iex> Validixir.Validations.reference(ref)
{:ok, ref}

iex> Validixir.Validations.reference(12)
{:error, %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 otherwise.

examples

Examples

iex> person_struct = %Example.Person{name: "s", username: "h", email: "s@h.b", address: "s h b"}
iex> Validixir.Validations.struct(person_struct)
{:ok, person_struct}

iex> Validixir.Validations.struct(%{})
{:error, %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)
{:ok, 12}
@spec tuple(any()) :: Validixir.validation_result_t(any())

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

examples

Examples

iex> Validixir.Validations.tuple({1,2,3})
{:ok, {1,2,3}}

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