Correct commonly misspelled English words... quickly.

new as of 2016-01-12

$ misspell all.html your.txt important.md files.go
your.txt:42:10 found "initialised" a misspelling of "initialized"

# ^ file, line, column

You'll need golang 1.5 installed to compile it. But after that it's a standalone binary.

If people want pre-compiled binaries, file a ticket please.

You can run misspell recursively using the following notation:

misspell directory/**/*

or

find . -name '*' | xargs misspell

Yes!

Print messages to stderr only:

$ echo "zeebra" | misspell
stdin:1:0:found "zeebra" a misspelling of "zebra"

Print messages to stderr, and corrected text to stdout:

$ echo "zeebra" | misspell -w
stdin:1:0:corrected "zeebra" to "zebra"
zebra

Only print the corrected text to stdout:

$ echo "zeebra" | misspell -w -q
zebra

Yes! If the file ends in .go, then misspell will only check spelling in comments.

If you want to force a file to be checked as a golang source, use -source=go on the command line. Conversely, you can check a golang source as if it were pure text by using -source=text. You might want to do this since many variable names have misspellings in them!

I'm told the using -source=go works well for ruby, javascript, java, c and c++.

It doesn't work well for python and bash.

gometalinter runs multiple golang linters, and it works well with misspell too.

After go get -u github.com/client9/misspell you need to add it, then enable it, like so:

gometalinter --disable-all \
   --linter='misspell:misspell ./*.go:PATH:LINE:COL:MESSAGE' --enable=misspell \
   ./...

Using the -f template flag you can pass in a golang text template to format the output.

The built-in template uses everything, including the js function to escape the original text.

{{ .Filename }}:{{ .Line }}:{{ .Column }}:corrected "{{ js .Original }}" to "{{ js .Corrected }}"

To just print probable misspellings:

-f '{{ .Original }}'

This corrects commonly misspelled English words in computer source code, and other text-based formats (.txt, .md, etc).

It is designed to run quickly so it can be used as a pre-commit hook with minimal burden on the developer.

It does not work with binary formats (e.g. Word, etc).

It is not a complete spell-checking program nor a grammar checker.

Some other misspelling correctors:

• https://github.com/vlajos/misspell_fixer
• https://github.com/lyda/misspell-check
• https://github.com/lucasdemarchi

They all work but had problems that prevented me from using them at scale:

• slow, all of the above check one misspelling at a time (i.e. linear) using regexps
• not MIT/Apache2 licensed (or equivalent)
• have dependencies that don't work for me (python3, bash, linux sed, etc)

That said, they might be perfect for you and many have more features that this project!

Easily 100x to 1000x faster. You should be able to check and correct 1000 files in under 250ms.

MIT

It started with a word list from Wikipedia and then edited to remove false positives.

Then additional words were added based on actually mistakes seen in the wild.

This uses the mighty power of golang's strings.Replacer which is a implementation or variation of the Aho–Corasick algorithm. This makes multiple substring matches simultaneously

In addition this uses multiple CPU cores to work on multiple files.

Unlike the other projects, this doesn't know what a "word" is. There may be more false positives and false negatives due to this. On the other hand, it sometimes catches things others don't.

Either way, please file bugs and we'll fix them!

Since it operates in parallel to make corrections, it can be non-obvious to determine exactly what word was corrected.

Run using -debug flag on the file you want. It should then print what word it is trying to correct. Then file a bug describing the problem. Thanks!

The matching function is case-sensitive, so variable names that are multiple worlds either in all-upper or all-lower case sometimes can cause false positives. For instance a variable named bodyreader could trigger a false positive since yrea is in the middle that could be corrected to year. Other problems happen if the variable name uses a English contraction that should use an apostrophe. The best way of fixing this is to use the Effective Go naming conventions and use camelCase for variable names. You can check your code using golint