Disallow this

if true do
  1
end

unless [] do
  1
end

etc.

Mega, second, micro.

Disallow this

unless not predicate do
  something
end

and this

unless !predicate do
  something
end

in favour of this

if predicate do
  something
end

Can share logic with IfNot (#13)

It's easy to forget to add the rule to the list. Time for some metaprogramming. :)

Something to think about: We probably want to specify a list of rules that walk the AST only (see #15), so we'd probably want to insert this information into this list at compile time.

Register the error as a script error and don't run tests

Function names must be snake_case

http://elixir.community/styleguide has a number of points to follow. It'd be good if we could deal with everything on this.

?

Inspired by @Joe-noh in #21 .

Prefer ~s("""\n) over "\"\"\"\n"

Disallow functions with more than N arguments. 4?

Scary warey

And you know, Emacs flycheck too, I guess.

Hell, why not?

Rewrite to correct the failing rules where possible. As in go fmt or rubocop -a

After discussion in #35

Disallow these

foo   ==  false
foo   ==  true
foo   === false
foo   === true
foo   !=  false
foo   !=  true
foo   !== false
foo   !== true
true  ==  foo
true  === foo
true  !=  foo
true  !== foo
false ==  foo
false === foo
false !=  foo
false !== foo

Because they're totally pointless.

Enforce presence of @moduledocs

Expressions should not be terminated by semicolons.

x = 1;
y = 2;

"""
Hello, world!                   
There is whitespace here ^^^
"""

The second line is reported as an error, I don't think it should be. Rubocop has the same behaviour :(

Perhaps we should only disable it for triple quote strings """. That'd probably be easier too.

The solution involves @external_resource, but how exactly? Can we specify an entire directory to be an external resource, rather than all the files in it?

"This is #{ "not" } permitted."
"Nor is #{ :this }."

And so on.

Disallow this

IEx.pry

As it's probably a leftover from debugging.

Disallow this

if not predicate do
  something
end

and this

if !predicate do
  something
end

in favour of this

unless predicate do
  something
end

Is it possible to have a hex package install and add a binary to $PATH?

Hell, is it possible to easily install a hex package outside of a mix project?

It was super handy for eca6b06

This requires #5 to be implemented first. Being able to do something like the following would be useful:

mix dogma --config code_style.exs
mix dogma --config code_quality.exs

The first argument in a chain of pipes should be a bare value, not a function call with an argument.

I've worded this poorly.

Some heathens don't believe in sticking to 80 columns.

Colours are raaaad

We should pick a delimiter for sigils and stick to it unless the sigil contains that delimiter.

It feels like regexs should use /.

i.e. build upon #32

With documentation and tests!

Module attributes should be snake_case

defmodule Foo do

  @like_this  :ok
  @butNotThis :error
end

There are times were we cannot get enough information from the AST alone, in which case we need to inspect the source of the script itself.

When doing this, it's easy to mistake the contents of a string for code, resulting in false positives.

For example, if we wanted to ensure that the + operator always had a space around it, this code should not register any errors

(String.graphemes("4+5") |> length) + 5

But unless we have a way of telling that it's in a string, we probably will probably get a false positive.

What about code in heredocs, or multi line strings?

defmodule Foo do
  """
  defmodule Bar do
    Uh oh, what's going on here?
  end
  """
end

Currently we run each rule in turn on each file. The results in walking the AST multiple times. We could lump all the AST walking rules together and walk the tree once, applying them to each node in turn.

Currently no one is using this linter, and performance is not yet an issue, so I'm going to focus on rules and usability for the mean time.

CamelCase 4 lyfe