elvis_rule behaviour (elvis_core v4.2.0)

View Source

Summary

Types

def/0
ignorable/0
t/0

Callbacks

default/1

Functions

def(Rule)
defkeys(Rule)
defmap(Map)
disabled(Rule)
execute(Rule, ElvisConfig)
file(Rule)
file(Rule, File)
from_tuple(Rule)
ignorable(Ignorable)
ignored(Needle, Rule)
is_ignorable(Module)
is_valid_from_tuple(Tuple)
name(Rule)
new(NS, Name)
new(NS, Name, Def)
ns(Rule)
option(Key, Rule)
same(RuleL, RuleR)

Loose equality comparison for a specific use case

Types

def/0

-opaque def()

ignorable/0

-opaque ignorable()

t/0

-opaque t()

Callbacks

default/1

-callback default(RuleName :: atom()) -> def().

Functions

def(Rule)

-spec def(t()) -> def().

defkeys(Rule)

-spec defkeys(t()) -> [atom()].

defmap(Map)

-spec defmap(map()) -> def().

disabled(Rule)

-spec disabled(t()) -> boolean().

execute(Rule, ElvisConfig)

-spec execute(t(), ElvisConfig) -> Results
                 when
                     ElvisConfig :: elvis_config:t(),
                     Results :: [elvis_result:rule() | elvis_result:elvis_error()].

file(Rule)

-spec file(t()) -> elvis_file:t().

file(Rule, File)

-spec file(t(), elvis_file:t()) -> t().

from_tuple(Rule)

-spec from_tuple(Rule | NSName | NSNameDef) -> t() | invalid_tuple
                    when
                        Rule :: t(),
                        NSName :: {NS :: module(), Name :: atom()},
                        NSNameDef :: {NS :: module(), Name :: atom(), Def :: disable | map()}.

ignorable(Ignorable)

-spec ignorable(module() | {module(), atom()} | {module(), atom(), arity()}) -> ignorable().

ignored(Needle, Rule)

-spec ignored(Needle :: ignorable(), t()) -> boolean().

is_ignorable(Module)

-spec is_ignorable(term()) -> boolean().

is_valid_from_tuple(Tuple)

-spec is_valid_from_tuple(tuple()) -> {true, t()} | {false, string()}.

name(Rule)

-spec name(t()) -> atom().

new(NS, Name)

-spec new(NS :: module(), Name :: atom()) -> t().

new(NS, Name, Def)

-spec new(NS :: module(), Name :: atom(), Def :: def()) -> t().

ns(Rule)

-spec ns(t()) -> module().

option(Key, Rule)

-spec option(Key :: atom(), t()) -> Value :: undefined | term().

same(RuleL, RuleR)

-spec same(t(), t()) -> boolean().

Loose equality comparison for a specific use case