Ignore vim swap and python compiled files
Implement the conversion of automata to regex
Make the `aut2regex` pass a test with looping
Add a `delete_state` function for branching

Skip the test for branching to give way for the implementation of
the `delete_state`. The function `delete_state` will be used to
incrementally delete all the states so that the initial and
final states are the only left. The labels between the states before
the state the selected state and after will be a regex that has the
same effect when that state is present.
Implement a `reverse_path` for `delete_state`

This will make finding the previous state of a given node be easier
and cleaner if we will add the full implementation of it.
Make it work when there are three states

The start state in the original is not included in the reverse because
of the final state having no nodes to point to. So we will assume that
the keys of the original and the reverse are equal. If there are
states in the set of next states that are not in the original, it is
wrong by default and should throw an error.
Add a test for branching case for `reverse_path`
Add a doc string to a test
Add a test for dangling node
Implement a full version of deletion of a state

This will now delete a state and connect all possible paths from the
previous states to the next states of the state in consideration.
This will also detects the looping so that it will not be considered
when detecting the possible paths.

It goes like this
     0  1,-v 2
-> a ---> b ---> c
If b is deleted, the resulting regex should be 01*2 because it will
accept a 0, then many number of one (which can be none) and then 2.
Make the state having no successor deleted

When there is a branch and loops to itself, the reference is not
deleted.
Add another test for the deletion of state

Check for the looping of state going back to the previous
Make the regex of state having many loop efficient

Put the star operator outside the alternatives and put parenthesis
if there are more than one loop.
Delete a redundant test
Add a test for alternatives of the same label
Make it an executable script

This will be use as a hook for git
Implement the conversion of automata to regex

Delete all the states that are not initial or final. After that we
have an automata which is composed of only one state (of which can loop
to itself) or two state automata.

In case of two state automata, we can have the final regex for free
by adding an state before the start state and state after the final
state and delete the start and final states. The pre-start state will
have the regex of the whole automata. We assume here that the
pre-starting state will have only one resulting state. It would be an
error if it is not otherwise.
Change the name of pre-start and post-final state
Add a test for the two length automata

The states loop with itself and loop with each other. The regex will
represent the equivalent of the automata.
Merge the two cases of the final form of automata

Remove the code that is supposed to be on the `delete_state` from the
`auto2regex`. Having the pre and post states are useful even for the
case of length 1. It will also give the final regex form of the
automata.

Rearrange the order of adding state and deletion so that the case of
one state automata will pass the test. Deleting the state before adding
the post-final state will not give the correct answer if that state is
also the final state. The pre-start state will not have the combined
regex of the starting/final state.