Packages
pedantic

0.1.0
0.1.1 0.1.0
Bidirectional, error-accumulating validation and sanitization codecs for Gleam.
HexDocs
Current section
Files
Jump to
Readme 2 Versions 2 Dependencies Dependants Files Activity
pedantic src pedantic@codec.erl
Raw
src/pedantic@codec.erl

-module(pedantic@codec).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/pedantic/codec.gleam").
-export([custom/2, list/1, optional/1, dict/1, object/2, field/4, key_optional/4, default/2, key_with_default/5, build/1, refine/2, min/2, max/2, min_length/2, max_length/2, trim/1, lowercase/1, uppercase/1, collapse_whitespace/1, replace/3, remove_chars/2, allow_chars/2, strip_control_chars/1, normalize_email/1, normalize_uuid/1, default_if_blank/2, empty_as_none/1, positive/1, negative/1, non_negative/1, non_positive/1, length/2, email/2, uuid/2, check/3, assert_that/3, with_error_formatter/2, with_error_message/2, with_template/2, min_size/2, max_size/2, non_empty_list/1, title/2, describe/2, example/2]).
-export_type([codec/1, object_builder/2]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type codec(FGR) :: {codec,
        pedantic@report:type_graph(),
        pedantic@decode:decoder(FGR),
        pedantic@encode:encoder(FGR)}.

-opaque object_builder(FGS, FGT) :: {object_builder,
        pedantic@decode:object_builder(FGS, FGT),
        pedantic@encode:object_builder(FGT)}.

-file("src/pedantic/codec.gleam", 26).
?DOC(" Bidirectional custom pair constructor.\n").
-spec custom(pedantic@decode:decoder(FGU), pedantic@encode:encoder(FGU)) -> codec(FGU).
custom(Decoder, Encoder) ->
    {codec, erlang:element(2, Decoder), Decoder, Encoder}.

-file("src/pedantic/codec.gleam", 93).
?DOC(" List combinator.\n").
-spec list(codec(FGY)) -> codec(list(FGY)).
list(Element_codec) ->
    {codec,
        {list, erlang:element(2, Element_codec)},
        pedantic@decode:list(erlang:element(3, Element_codec)),
        pedantic@encode:list(erlang:element(4, Element_codec))}.

-file("src/pedantic/codec.gleam", 102).
?DOC(" Option/Optional combinator representing absent or nullable values.\n").
-spec optional(codec(FHC)) -> codec(gleam@option:option(FHC)).
optional(Inner_codec) ->
    {codec,
        {option, erlang:element(2, Inner_codec)},
        pedantic@decode:optional(erlang:element(3, Inner_codec)),
        pedantic@encode:optional(erlang:element(4, Inner_codec))}.

-file("src/pedantic/codec.gleam", 111).
?DOC(" Dict combinator.\n").
-spec dict(codec(FHG)) -> codec(gleam@dict:dict(binary(), FHG)).
dict(Value_codec) ->
    {codec,
        {dict, erlang:element(2, Value_codec)},
        pedantic@decode:dict(erlang:element(3, Value_codec)),
        pedantic@encode:dict(erlang:element(4, Value_codec))}.

-file("src/pedantic/codec.gleam", 120).
?DOC(" Initializes an ObjectBuilder for a custom record constructor.\n").
-spec object(binary(), FHL) -> object_builder(FHL, any()).
object(Name, Constructor) ->
    {object_builder,
        pedantic@decode:object(Name, Constructor),
        pedantic@encode:object(Name)}.

-file("src/pedantic/codec.gleam", 131).
?DOC(" Applies a field description, codec, and getter function to the object builder.\n").
-spec field(
    object_builder(fun((FHP) -> FHQ), FHR),
    binary(),
    codec(FHP),
    fun((FHR) -> FHP)
) -> object_builder(FHQ, FHR).
field(Builder, Name, Field_codec, Get) ->
    {object_builder,
        pedantic@decode:field(
            erlang:element(2, Builder),
            Name,
            erlang:element(3, Field_codec)
        ),
        pedantic@encode:field(
            erlang:element(3, Builder),
            Name,
            erlang:element(4, Field_codec),
            Get
        )}.

-file("src/pedantic/codec.gleam", 157).
?DOC(" Declares an optional key in the object builder, resolving to Option(t).\n").
-spec key_optional(
    object_builder(fun((gleam@option:option(FHX)) -> FHZ), FIA),
    binary(),
    codec(FHX),
    fun((FIA) -> gleam@option:option(FHX))
) -> object_builder(FHZ, FIA).
key_optional(Builder, Name, Field_codec, Get) ->
    Opt_codec = optional(Field_codec),
    field(Builder, Name, Opt_codec, Get).

-file("src/pedantic/codec.gleam", 191).
?DOC(" Adapts an optional codec with a default value fallback.\n").
-spec default(codec(gleam@option:option(FIT)), FIT) -> codec(FIT).
default(Codec, Default_val) ->
    New_decoder = pedantic@decode:default(erlang:element(3, Codec), Default_val),
    New_encoder = {encoder,
        erlang:element(2, erlang:element(4, Codec)),
        fun(Val) ->
            (erlang:element(3, erlang:element(4, Codec)))({some, Val})
        end},
    {codec, erlang:element(2, Codec), New_decoder, New_encoder}.

-file("src/pedantic/codec.gleam", 168).
?DOC(" Declares an optional key with fallback default value.\n").
-spec key_with_default(
    object_builder(fun((FIH) -> FII), FIJ),
    binary(),
    codec(FIH),
    FIH,
    fun((FIJ) -> FIH)
) -> object_builder(FII, FIJ).
key_with_default(Builder, Name, Field_codec, Default_val, Get) ->
    Opt_codec = begin
        _pipe = optional(Field_codec),
        default(_pipe, Default_val)
    end,
    field(Builder, Name, Opt_codec, Get).

-file("src/pedantic/codec.gleam", 180).
?DOC(" Finalizes the ObjectBuilder, converting it into a full bidirectional Codec.\n").
-spec build(object_builder(FIP, FIP)) -> codec(FIP).
build(Builder) ->
    Final_decoder = pedantic@decode:build(erlang:element(2, Builder)),
    Final_encoder = pedantic@encode:build(erlang:element(3, Builder)),
    {codec, erlang:element(2, Final_decoder), Final_decoder, Final_encoder}.

-file("src/pedantic/codec.gleam", 205).
?DOC(" Refines a codec with custom validation rules.\n").
-spec refine(
    codec(FIX),
    fun((FIX) -> {ok, FIX} | {error, pedantic@report:error_kind()})
) -> codec(FIX).
refine(Codec, Rule) ->
    New_decoder = pedantic@decode:refine(erlang:element(3, Codec), Rule),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 214).
?DOC(" Restricts an Int codec to values greater than or equal to the minimum.\n").
-spec min(codec(integer()), integer()) -> codec(integer()).
min(Codec, Minimum) ->
    New_decoder = pedantic@decode:min(erlang:element(3, Codec), Minimum),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 220).
?DOC(" Restricts an Int codec to values less than or equal to the maximum.\n").
-spec max(codec(integer()), integer()) -> codec(integer()).
max(Codec, Maximum) ->
    New_decoder = pedantic@decode:max(erlang:element(3, Codec), Maximum),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 226).
?DOC(" Restricts a String codec to a minimum length.\n").
-spec min_length(codec(binary()), integer()) -> codec(binary()).
min_length(Codec, Minimum) ->
    New_decoder = pedantic@decode:min_length(erlang:element(3, Codec), Minimum),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 232).
?DOC(" Restricts a String codec to a maximum length.\n").
-spec max_length(codec(binary()), integer()) -> codec(binary()).
max_length(Codec, Maximum) ->
    New_decoder = pedantic@decode:max_length(erlang:element(3, Codec), Maximum),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 239).
-spec trim(codec(binary())) -> codec(binary()).
trim(Codec) ->
    New_decoder = pedantic@decode:trim(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 244).
-spec lowercase(codec(binary())) -> codec(binary()).
lowercase(Codec) ->
    New_decoder = pedantic@decode:lowercase(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 249).
-spec uppercase(codec(binary())) -> codec(binary()).
uppercase(Codec) ->
    New_decoder = pedantic@decode:uppercase(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 254).
-spec collapse_whitespace(codec(binary())) -> codec(binary()).
collapse_whitespace(Codec) ->
    New_decoder = pedantic@decode:collapse_whitespace(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 259).
-spec replace(codec(binary()), binary(), binary()) -> codec(binary()).
replace(Codec, Pattern, Replacement) ->
    New_decoder = pedantic@decode:replace(
        erlang:element(3, Codec),
        Pattern,
        Replacement
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 268).
-spec remove_chars(codec(binary()), binary()) -> codec(binary()).
remove_chars(Codec, Characters) ->
    New_decoder = pedantic@decode:remove_chars(
        erlang:element(3, Codec),
        Characters
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 273).
-spec allow_chars(codec(binary()), binary()) -> codec(binary()).
allow_chars(Codec, Characters) ->
    New_decoder = pedantic@decode:allow_chars(
        erlang:element(3, Codec),
        Characters
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 278).
-spec strip_control_chars(codec(binary())) -> codec(binary()).
strip_control_chars(Codec) ->
    New_decoder = pedantic@decode:strip_control_chars(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 283).
-spec normalize_email(codec(binary())) -> codec(binary()).
normalize_email(Codec) ->
    New_decoder = pedantic@decode:normalize_email(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 288).
-spec normalize_uuid(codec(binary())) -> codec(binary()).
normalize_uuid(Codec) ->
    New_decoder = pedantic@decode:normalize_uuid(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 293).
-spec default_if_blank(codec(binary()), binary()) -> codec(binary()).
default_if_blank(Codec, Default_value) ->
    New_decoder = pedantic@decode:default_if_blank(
        erlang:element(3, Codec),
        Default_value
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 301).
-spec empty_as_none(codec(binary())) -> codec(gleam@option:option(binary())).
empty_as_none(Codec) ->
    New_decoder = pedantic@decode:empty_as_none(erlang:element(3, Codec)),
    New_encoder = pedantic@encode:optional(erlang:element(4, Codec)),
    {codec, {option, erlang:element(2, Codec)}, New_decoder, New_encoder}.

-file("src/pedantic/codec.gleam", 311).
-spec positive(codec(integer())) -> codec(integer()).
positive(Codec) ->
    New_decoder = pedantic@decode:positive(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 316).
-spec negative(codec(integer())) -> codec(integer()).
negative(Codec) ->
    New_decoder = pedantic@decode:negative(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 321).
-spec non_negative(codec(integer())) -> codec(integer()).
non_negative(Codec) ->
    New_decoder = pedantic@decode:non_negative(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 326).
-spec non_positive(codec(integer())) -> codec(integer()).
non_positive(Codec) ->
    New_decoder = pedantic@decode:non_positive(erlang:element(3, Codec)),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 331).
-spec length(codec(binary()), integer()) -> codec(binary()).
length(Codec, Len) ->
    New_decoder = pedantic@decode:length(erlang:element(3, Codec), Len),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 336).
-spec email(codec(binary()), binary()) -> codec(binary()).
email(Codec, Msg) ->
    New_decoder = pedantic@decode:email(erlang:element(3, Codec), Msg),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 341).
-spec uuid(codec(binary()), binary()) -> codec(binary()).
uuid(Codec, Msg) ->
    New_decoder = pedantic@decode:uuid(erlang:element(3, Codec), Msg),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 346).
-spec check(codec(FKX), fun((FKX) -> boolean()), binary()) -> codec(FKX).
check(Codec, Predicate, Msg) ->
    New_decoder = pedantic@decode:check(
        erlang:element(3, Codec),
        Predicate,
        Msg
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 355).
-spec assert_that(
    codec(FLA),
    fun((FLA) -> boolean()),
    pedantic@report:error_kind()
) -> codec(FLA).
assert_that(Codec, Predicate, Error) ->
    New_decoder = pedantic@decode:assert_that(
        erlang:element(3, Codec),
        Predicate,
        Error
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 364).
-spec with_error_formatter(
    codec(FLD),
    fun((gleam@dynamic:dynamic_(), pedantic@report:error_kind()) -> binary())
) -> codec(FLD).
with_error_formatter(Codec, Formatter) ->
    New_decoder = pedantic@decode:with_error_formatter(
        erlang:element(3, Codec),
        Formatter
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 372).
-spec with_error_message(codec(FLG), binary()) -> codec(FLG).
with_error_message(Codec, Msg) ->
    New_decoder = pedantic@decode:with_error_message(
        erlang:element(3, Codec),
        Msg
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 377).
-spec with_template(codec(FLJ), binary()) -> codec(FLJ).
with_template(Codec, Template) ->
    New_decoder = pedantic@decode:with_template(
        erlang:element(3, Codec),
        Template
    ),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 382).
-spec min_size(codec(list(FLM)), integer()) -> codec(list(FLM)).
min_size(Codec, Minimum) ->
    New_decoder = pedantic@decode:min_size(erlang:element(3, Codec), Minimum),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 387).
-spec max_size(codec(list(FLR)), integer()) -> codec(list(FLR)).
max_size(Codec, Maximum) ->
    New_decoder = pedantic@decode:max_size(erlang:element(3, Codec), Maximum),
    {codec, erlang:element(2, Codec), New_decoder, erlang:element(4, Codec)}.

-file("src/pedantic/codec.gleam", 394).
-spec non_empty_list(codec(FLW)) -> codec(list(FLW)).
non_empty_list(Element_codec) ->
    New_decoder = pedantic@decode:non_empty_list(
        erlang:element(3, Element_codec)
    ),
    {codec,
        {list, erlang:element(2, Element_codec)},
        New_decoder,
        pedantic@encode:list(erlang:element(4, Element_codec))}.

-file("src/pedantic/codec.gleam", 406).
?DOC(" Sets the title metadata in the AST graph.\n").
-spec title(codec(FMA), binary()) -> codec(FMA).
title(Codec, Name) ->
    New_decoder = pedantic@decode:title(erlang:element(3, Codec), Name),
    New_encoder = pedantic@encode:title(erlang:element(4, Codec), Name),
    {codec, erlang:element(2, New_decoder), New_decoder, New_encoder}.

-file("src/pedantic/codec.gleam", 413).
?DOC(" Sets the description metadata in the AST graph.\n").
-spec describe(codec(FMD), binary()) -> codec(FMD).
describe(Codec, Desc) ->
    New_decoder = pedantic@decode:describe(erlang:element(3, Codec), Desc),
    New_encoder = pedantic@encode:describe(erlang:element(4, Codec), Desc),
    {codec, erlang:element(2, New_decoder), New_decoder, New_encoder}.

-file("src/pedantic/codec.gleam", 420).
?DOC(" Sets the example metadata in the AST graph.\n").
-spec example(codec(FMG), gleam@dynamic:dynamic_()) -> codec(FMG).
example(Codec, Ex) ->
    New_decoder = pedantic@decode:example(erlang:element(3, Codec), Ex),
    New_encoder = pedantic@encode:example(erlang:element(4, Codec), Ex),
    {codec, erlang:element(2, New_decoder), New_decoder, New_encoder}.
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT