Whine.Types

type RuleId = String

newtype Rule

A linting rule is just a function that takes a PureScript module and performs effects in the MonadRules monad. Some of these effects may be reportViolation - that's how rule violations are reported.

The type variable e is a peculiarity of how the language-cst-parser library is structured: the whole AST is parametrized by this type, which represents possible errors with parsing. When the tree is fully parsed successfully, e is set to Void. Otherwise it's some error type.

Because for the purposes of this library we don't actually care whether the parsing was successful, the handler function is polymorphic in e. But we have to have a RangeOf instance for it, because it's a prerequisite for other RangeOf instances for AST nodes, and we do need those, because we need to report a source location for every violation.

Constructors

• Rule (forall e m. MonadRules () m => RangeOf e => Module e -> m Unit)

type Violation :: Row Type -> Typetype Violation r = { message :: String, source :: Maybe SourceRange | r }

Violation is an open record. When generated by a rule implementation, it starts out with just source and message, but at higher stack levels gets annotated with ID of the rule that created the violation (see WithRule), with the file whence the violation came (see WithFile), and with a flag showing if this particular violation was muted (see WithMuted).

type Violations :: Row Type -> Typetype Violations r = Array (Violation r)

type WithRule :: Row Type -> Row Typetype WithRule r = (rule :: RuleId | r)

See comments on Violation

type WithMuted :: Row Type -> Row Typetype WithMuted r = (muted :: Boolean | r)

See comments on Violation

type WithFile :: Row Type -> Row Typetype WithFile r = (file :: File | r)

See comments on Violation

type RuleFactory = JSON -> Either String Rule

See comments on ruleFactory

type RuleFactories = Array (RuleId /\ RuleFactory)

See comments on ruleFactory

type File = { lines :: Maybe (Array String), path :: FilePath }

class MonadReport :: Row Type -> (Type -> Type) -> Constraintclass (Monad m) <= MonadReport v m | m -> v where

Members

• reportViolation :: Violation v -> m Unit

class MonadRules :: Row Type -> (Type -> Type) -> Constraintclass (Monad m, MonadLog m, MonadReport v m) <= MonadRules v m | m -> v

The monad in which each individual rule is run.

ruleFactory :: forall args. RuleId -> Codec args -> (args -> Rule) -> RuleId /\ RuleFactory

This function is intended to pair rules with their IDs. Every rule would take its own args and provide a JSON codec to decode the args, and the list of possible rules and their IDs would be constructed like this:

factories :: ∀ m. RuleFactories m
factories =
  [ ruleFactory "RuleOne" ruleOneArgsCodec ruleOne
  , ruleFactory "RuleTwo" ruleTwoArgsCodec ruleTwo
  ]

ruleOne :: { arg :: Int, anotherArg :: String } -> Rule m
ruleTwo :: {} -> Rule m

ruleFactory takes care of parsing the arguments and reporting any errors, so that the actual rule implementation only has to deal with strongly typed arguments.