Recode - A linter with autocorrection and a refactoring tool

[Marcus]

Recode is an experimental package to lint, autocorrect and refactor code. The package uses the great Sourceror library by @dorgan.

So far, there are only a small number of autocorrections and just one refactoring command.

The following example runs recode in a project with some nonsense code:

> mix recode --dry
Found 11 files, including 2 scripts.
.............................................................................
 File: lib/my_code.ex
[Specs 15/3] Functions should have a @spec type specification.

 File: lib/my_code/alias_expansion.ex
Updates: 1
Changed by: AliasExpansion
001   |defmodule MyCode.AliasExpansion do
002 - |  alias MyCode.{PipeFunOne, SinglePipe}
002 + |  alias MyCode.PipeFunOne
003 + |  alias MyCode.SinglePipe
004   |
005   |  def foo(x) do
[Specs 5/3] Functions should have a @spec type specification.

 File: lib/my_code/alias_order.ex
Updates: 2
Changed by: AliasOrder, AliasExpansion
012   |
013   |defmodule Mycode.AliasOrder do
014 - |  alias MyCode.SinglePipe
014 + |  alias MyCode.Echo
015 + |  alias MyCode.Foxtrot
016   |  alias MyCode.PipeFunOne
017 - |  alias MyCode.{Foxtrot, Echo}
017 + |  alias MyCode.SinglePipe
018   |
019   |  @doc false

 File: lib/my_code/fun.ex
Updates: 1
Changed by: Format
002   |  @moduledoc false
003   |
004 - |
005 - |
006 - |
007 - |
008 - |
004   |  def noop(x), do: x
005   |end

 File: lib/my_code/multi.ex
Updates: 2
Changed by: SinglePipe, PipeFunOne
007   |
008   |  def pipe(x) do
009 - |    x |> double |> double()
009 + |    x |> double() |> double()
010   |  end
011   |
012   |  def single(x) do
013 - |    x |> double()
013 + |    double(x)
014   |  end
015   |

 File: lib/my_code/pipe_fun_one.ex
Updates: 1
Changed by: PipeFunOne
005   |
006   |  def pipe(x) do
007 - |    x |> double |> double()
007 + |    x |> double() |> double()
008   |  end
009   |end

 File: lib/my_code/singel_pipe.ex
Updates: 1
Changed by: SinglePipe
005   |
006   |  def single_pipe(x) do
007 - |    x |> double()
007 + |    double(x)
008   |  end
009   |
010 - |  def reverse(a), do: a |> Enum.reverse()
010 + |  def reverse(a), do: Enum.reverse(a)
011   |end
012   |

 File: test/my_code_test.exs
Updates: 1
Changed by: TestFileExt
Moved from: test/my_code_test.ex

The refactoring task:

> mix recode.rename --dry MyCode.SinglePipe.double dbl
Found 11 files, including 2 scripts.
...........
 File: lib/my_code/alias_expansion.ex
Updates: 1
Changed by: Rename
003   |
004   |  def foo(x) do
005 - |    SinglePipe.double(x) + PipeFunOne.double(x)
005 + |    SinglePipe.dbl(x) + PipeFunOne.double(x)
006   |  end
007   |end

 File: lib/my_code/alias_order.ex
Updates: 1
Changed by: Rename
018   |  @doc false
019   |  def foo do
020 - |    {SinglePipe.double(2), PipeFunOne.double(3)}
020 + |    {SinglePipe.dbl(2), PipeFunOne.double(3)}
021   |  end
022   |

 File: lib/my_code/singel_pipe.ex
Updates: 1
Changed by: Rename
002   |  @moduledoc false
003   |
004 - |  def double(x), do: x + x
004 + |  def dbl(x), do: x + x
005   |
006   |  def single_pipe(x) do
007 - |    x |> double()
007 + |    x |> dbl()
008   |  end
009   |

Differences to Credo

recode was started as a plugin for credo. Unfortunately it was not possible
to implement autocorrection as a plugin because the traversation of the code does
not support changing the code.

Maybe some code lines from recode could be used as inspiration for credo
to bring the autocorrect feature to credo.

Other differences:

• recode requiers Elixir 1.12, credo requiers Elixir 1.7
• recode has autocorrection
• credo has much more checkers
• credo is faster
• credo has more features

[lud]

Hello,

Recode chokes on this:

  import :timer

WIth error:

** (FunctionClauseError) no function clause matching in Recode.Context.get_alias/2    
    
    The following arguments were given to Recode.Context.get_alias/2:
    
        # 1
        {:__block__, [trailing_comments: [], leading_comments: [], line: 3, column: 10], [:timer]}
    
        # 2
        %Recode.Context{aliases: [{MyApp.Util.TimeInterval, [trailing_comments: [], leading_comments: [], end_of_expression: [newlines: 1, line: 2, column: 36], line: 2, column: 3], nil}], assigns: %{}, definition: nil, doc: nil, impl: nil, imports: [], module: {MyApp.Util.TimeIntervalTest, [trailing_comments: [], leading_comments: [], do: [line: 1, column: 43], end: [line: 17, column: 1], line: 1, column: 1]}, moduledoc: nil, requirements: [], spec: nil, usages: []}
    
    Attempted function clauses (showing 3 out of 3):
    
        defp get_alias({:__aliases__, _meta, name}, _context) when is_list(name)
        defp get_alias({:unquote, _meta, _args} = expr, _context)
        defp get_alias({:__MODULE__, _meta1, _args}, %Recode.Context{} = context)
    
    (recode 0.1.2) lib/recode/context.ex:516: Recode.Context.get_alias/2

The error is emitted at the start of the command, so it stops the execution. Otherwise I have other errors that are logged.

Otherwise it is a great tool, thank you!

[Marcus]

0.4.0

The new release removes the mix task recode.rename to get focus on the linting and auto-correction.

The package was divided. The part that takes care of the files, sources and the project is now in rewrite.

The output for a --dry/--verbose run has been updated:

> cd examples/my_code
> mix recode --dry
Found 13 files, including 2 scripts.
...........................................................................................
 File: lib/my_code.ex
[Specs 15/3] Functions should have a @spec type specification.

 File: lib/my_code/alias_expansion.ex
Updates: 1
Changed by: AliasExpansion
1 1   |defmodule MyCode.AliasExpansion do
2   - |  alias MyCode.{PipeFunOne, SinglePipe}
  2 + |  alias MyCode.PipeFunOne
  3 + |  alias MyCode.SinglePipe
3 4   |
4 5   |  def foo(x) do
   ...|
[Specs 5/3] Functions should have a @spec type specification.

 File: lib/my_code/alias_order.ex
Updates: 2
Changed by: AliasOrder, AliasExpansion
     ...|
12 12   |
13 13   |defmodule Mycode.AliasOrder do
14    - |  alias MyCode.SinglePipe
   14 + |  alias MyCode.Echo
   15 + |  alias MyCode.Foxtrot
15 16   |  alias MyCode.PipeFunOne
16    - |  alias MyCode.{Foxtrot, Echo}
   17 + |  alias MyCode.SinglePipe
17 18   |
18 19   |  @doc false
     ...|

 File: lib/my_code/fun.ex
Updates: 1
Changed by: Format
     ...|
 2  2   |  @moduledoc false
 3  3   |
 4    - |
 5    - |
 6    - |
 7    - |
 8    - |
 9  4   |  def noop(x), do: x
10  5   |end
     ...|

 File: lib/my_code/multi.ex
Updates: 2
Changed by: SinglePipe, PipeFunOne
     ...|
 7  7   |
 8  8   |  def pipe(x) do
 9    - |    x |> double |> double()
    9 + |    x |> double() |> double()
10 10   |  end
11 11   |
12 12   |  def single(x) do
13    - |    x |> double()
   13 + |    double(x)
14 14   |  end
15 15   |
     ...|

 File: lib/my_code/pipe_fun_one.ex
Updates: 1
Changed by: PipeFunOne
     ...|
 5  5   |
 6  6   |  def pipe(x) do
 7    - |    x |> double |> double()
    7 + |    x |> double() |> double()
 8  8   |  end
 9  9   |end
     ...|

 File: lib/my_code/same_line.ex
[Specs 2/3] Functions should have a @spec type specification.

 File: lib/my_code/singel_pipe.ex
Updates: 1
Changed by: SinglePipe
     ...|
 5  5   |
 6  6   |  def single_pipe(x) do
 7    - |    x |> double()
    7 + |    double(x)
 8  8   |  end
 9  9   |
10    - |  def reverse(a), do: a |> Enum.reverse()
   10 + |  def reverse(a), do: Enum.reverse(a)
11 11   |end
12 12   |

 File: test/my_code_test.exs
Updates: 1
Changed by: TestFileExt
Moved from: test/my_code_test.ex

[mohammedzeglam]

awesome project i use it, it similar to hlint in some functionality.

[Marcus]

I have release 0.5.0 of recode. The new version adds the Recode.FormatterPlugin. This plugin allows you to run Recode autocorrecting tasks together when executing mix format. See the documentation of Recode.FormatterPlugin for how to set this up.

[Marcus]

Recode version 0.6.0 is now available.

The new version adds

• the mix task recode.help to print a list of all recode tasks or the doc for a given recode task
• the mix task recode.update.config to update an existing recode config.
• aliases for all options available for mix recode.
• Recode.Task.TagFIXME to check for FIXME tags.
• Recode.Task.TagTODO to check for TODO tags.
• Recode.Task.Nesting to report issues when functions are nested too deep.
• Recode.Task.FilterCount to rewrite Enum.filter(fn ...) |> Enum.count() to Enum.count(fn ...).
• Recode.Task.Dbg to remove dbg calls or report issues for such calls.
• Recode.Task.IOInspect to remove IO.inspect calls or report issues for such calls.

The tasks Dbg and IOInspect are configured with autocorrect: false in the default config. To remove all calls to dbg and IO.inspect, you can use mix recode like this:

> mix recode -av -t IOInspect -t Dbg
Found 18 files, including 3 scripts.
....................................
 File: lib/my_code/multi.ex
Updates: 2
Changed by: Dbg, IOInspect
     ...|
 7  7   |
 8  8   |  def pipe(x) do
 9    - |    x |> double |> double() |> dbg()
    9 + |    x |> double |> double()
10 10   |  end
11 11   |
     ...|
22 22   |    |> Enum.filter(fn x -> rem(x, 2) == 0 end)
23 23   |    |> Enum.count()
24    - |    |> IO.inspect()
25 24   |  end
26 25   |end
     ...|

Finished in 0.04 seconds.

The -av stands for the switches --autocorrect and --verbose. The switch
--verbose causes recode to display all changes as a diff on the console.

An example for FilterCount:

> mix recode -d -t FilterCount
Found 18 files, including 3 scripts.
..................
 File: lib/my_code/multi.ex
Updates: 1
Changed by: FilterCount
     ...|
20 20   |  def my_count(list) do
21 21   |    list
22    - |    |> Enum.filter(fn x -> rem(x, 2) == 0 end)
23    - |    |> Enum.count()
   22 + |    |> Enum.count(fn x -> rem(x, 2) == 0 end)
24 23   |    |> IO.inspect()
25 24   |  end
     ...|

Finished in 0.04 seconds.