mirror of
https://github.com/codespell-project/codespell.git
synced 2025-08-06 18:24:41 +08:00
9672234591
* Read options from config * Fix assert in test * Fix tests * Fix readme to pass rst checks in Travis * Also support .codespellrc config file * Fix flake8 error * CLI args override config args * Rename tool:codespell to just codespell in config * Fix typo in readme * Remove unnecessary check for existance of config files (configparser already handles this case)
537 lines
17 KiB
Python
537 lines
17 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from __future__ import print_function
|
|
|
|
import contextlib
|
|
import inspect
|
|
import os
|
|
import os.path as op
|
|
from shutil import copyfile
|
|
import subprocess
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
import codespell_lib as cs_
|
|
from codespell_lib._codespell import EX_USAGE, EX_OK, EX_DATAERR
|
|
|
|
|
|
def test_constants():
|
|
"""Test our EX constants."""
|
|
assert EX_OK == 0
|
|
assert EX_USAGE == 64
|
|
assert EX_DATAERR == 65
|
|
|
|
|
|
class MainWrapper(object):
|
|
"""Compatibility wrapper for when we used to return the count."""
|
|
|
|
def main(self, *args, count=True, std=False, **kwargs):
|
|
if count:
|
|
args = ('--count',) + args
|
|
code = cs_.main(*args, **kwargs)
|
|
capsys = inspect.currentframe().f_back.f_locals['capsys']
|
|
stdout, stderr = capsys.readouterr()
|
|
assert code in (EX_OK, EX_USAGE, EX_DATAERR)
|
|
if code == EX_DATAERR: # have some misspellings
|
|
code = int(stderr.split('\n')[-2])
|
|
elif code == EX_OK and count:
|
|
code = int(stderr.split('\n')[-2])
|
|
assert code == 0
|
|
if std:
|
|
return (code, stdout, stderr)
|
|
else:
|
|
return code
|
|
|
|
|
|
cs = MainWrapper()
|
|
|
|
|
|
def run_codespell(args=(), cwd=None):
|
|
"""Run codespell."""
|
|
args = ('--count',) + args
|
|
proc = subprocess.Popen(
|
|
['codespell'] + list(args), cwd=cwd,
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
stderr = proc.communicate()[1].decode('utf-8')
|
|
count = int(stderr.split('\n')[-2])
|
|
return count
|
|
|
|
|
|
def test_command(tmpdir):
|
|
"""Test running the codespell executable."""
|
|
# With no arguments does "."
|
|
d = str(tmpdir)
|
|
assert run_codespell(cwd=d) == 0
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned\nAbandonned\nABANDONNED\nAbAnDoNnEd')
|
|
assert run_codespell(cwd=d) == 4
|
|
|
|
|
|
def test_basic(tmpdir, capsys):
|
|
"""Test some basic functionality."""
|
|
assert cs.main('_does_not_exist_') == 0
|
|
fname = op.join(str(tmpdir), 'tmp')
|
|
with open(fname, 'w') as f:
|
|
pass
|
|
code, _, stderr = cs.main('-D', 'foo', f.name, std=True)
|
|
assert code == EX_USAGE, 'missing dictionary'
|
|
assert 'cannot find dictionary' in stderr
|
|
assert cs.main(fname) == 0, 'empty file'
|
|
with open(fname, 'a') as f:
|
|
f.write('this is a test file\n')
|
|
assert cs.main(fname) == 0, 'good'
|
|
with open(fname, 'a') as f:
|
|
f.write('abandonned\n')
|
|
assert cs.main(fname) == 1, 'bad'
|
|
with open(fname, 'a') as f:
|
|
f.write('abandonned\n')
|
|
assert cs.main(fname) == 2, 'worse'
|
|
with open(fname, 'a') as f:
|
|
f.write('tim\ngonna\n')
|
|
assert cs.main(fname) == 2, 'with a name'
|
|
assert cs.main('--builtin', 'clear,rare,names,informal', fname) == 4
|
|
code, _, stderr = cs.main(fname, '--builtin', 'foo', std=True)
|
|
assert code == EX_USAGE # bad type
|
|
assert 'Unknown builtin dictionary' in stderr
|
|
d = str(tmpdir)
|
|
code, _, stderr = cs.main(fname, '-D', op.join(d, 'foo'), std=True)
|
|
assert code == EX_USAGE # bad dict
|
|
assert 'cannot find dictionary' in stderr
|
|
os.remove(fname)
|
|
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned\nAbandonned\nABANDONNED\nAbAnDoNnEd')
|
|
assert cs.main(d) == 4
|
|
code, _, stderr = cs.main('-w', d, std=True)
|
|
assert code == 0
|
|
assert 'FIXED:' in stderr
|
|
with open(op.join(d, 'bad.txt')) as f:
|
|
new_content = f.read()
|
|
assert cs.main(d) == 0
|
|
assert new_content == 'abandoned\nAbandoned\nABANDONED\nabandoned'
|
|
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned abandonned\n')
|
|
assert cs.main(d) == 2
|
|
code, stdout, stderr = cs.main(
|
|
'-q', '16', '-w', d, count=False, std=True)
|
|
assert code == 0
|
|
assert stdout == stderr == ''
|
|
assert cs.main(d) == 0
|
|
|
|
# empty directory
|
|
os.mkdir(op.join(d, 'test'))
|
|
assert cs.main(d) == 0
|
|
|
|
|
|
def test_interactivity(tmpdir, capsys):
|
|
"""Test interaction"""
|
|
# Windows can't read a currently-opened file, so here we use
|
|
# NamedTemporaryFile just to get a good name
|
|
with open(op.join(str(tmpdir), 'tmp'), 'w') as f:
|
|
pass
|
|
try:
|
|
assert cs.main(f.name) == 0, 'empty file'
|
|
with open(f.name, 'w') as f:
|
|
f.write('abandonned\n')
|
|
assert cs.main('-i', '-1', f.name) == 1, 'bad'
|
|
with FakeStdin('y\n'):
|
|
assert cs.main('-i', '3', f.name) == 1
|
|
with FakeStdin('n\n'):
|
|
code, stdout, _ = cs.main('-w', '-i', '3', f.name, std=True)
|
|
assert code == 0
|
|
assert '==>' in stdout
|
|
with FakeStdin('x\ny\n'):
|
|
assert cs.main('-w', '-i', '3', f.name) == 0
|
|
assert cs.main(f.name) == 0
|
|
finally:
|
|
os.remove(f.name)
|
|
|
|
# New example
|
|
with open(op.join(str(tmpdir), 'tmp2'), 'w') as f:
|
|
pass
|
|
try:
|
|
with open(f.name, 'w') as f:
|
|
f.write('abandonned\n')
|
|
assert cs.main(f.name) == 1
|
|
with FakeStdin(' '): # blank input -> Y
|
|
assert cs.main('-w', '-i', '3', f.name) == 0
|
|
assert cs.main(f.name) == 0
|
|
finally:
|
|
os.remove(f.name)
|
|
|
|
# multiple options
|
|
with open(op.join(str(tmpdir), 'tmp3'), 'w') as f:
|
|
pass
|
|
try:
|
|
with open(f.name, 'w') as f:
|
|
f.write('ackward\n')
|
|
|
|
assert cs.main(f.name) == 1
|
|
with FakeStdin(' \n'): # blank input -> nothing
|
|
assert cs.main('-w', '-i', '3', f.name) == 0
|
|
assert cs.main(f.name) == 1
|
|
with FakeStdin('0\n'): # blank input -> nothing
|
|
assert cs.main('-w', '-i', '3', f.name) == 0
|
|
assert cs.main(f.name) == 0
|
|
with open(f.name, 'r') as f_read:
|
|
assert f_read.read() == 'awkward\n'
|
|
with open(f.name, 'w') as f:
|
|
f.write('ackward\n')
|
|
assert cs.main(f.name) == 1
|
|
with FakeStdin('x\n1\n'): # blank input -> nothing
|
|
code, stdout, _ = cs.main('-w', '-i', '3', f.name, std=True)
|
|
assert code == 0
|
|
assert 'a valid option' in stdout
|
|
assert cs.main(f.name) == 0
|
|
with open(f.name, 'r') as f:
|
|
assert f.read() == 'backward\n'
|
|
finally:
|
|
os.remove(f.name)
|
|
|
|
|
|
def test_summary(tmpdir, capsys):
|
|
"""Test summary functionality."""
|
|
with open(op.join(str(tmpdir), 'tmp'), 'w') as f:
|
|
pass
|
|
code, stdout, stderr = cs.main(f.name, std=True, count=False)
|
|
assert code == 0
|
|
assert stdout == stderr == '', 'no output'
|
|
code, stdout, stderr = cs.main(f.name, '--summary', std=True)
|
|
assert code == 0
|
|
assert stderr == '0\n'
|
|
assert 'SUMMARY' in stdout
|
|
assert len(stdout.split('\n')) == 5
|
|
with open(f.name, 'w') as f:
|
|
f.write('abandonned\nabandonned')
|
|
assert code == 0
|
|
code, stdout, stderr = cs.main(f.name, '--summary', std=True)
|
|
assert stderr == '2\n'
|
|
assert 'SUMMARY' in stdout
|
|
assert len(stdout.split('\n')) == 7
|
|
assert 'abandonned' in stdout.split()[-2]
|
|
|
|
|
|
def test_ignore_dictionary(tmpdir, capsys):
|
|
"""Test ignore dictionary functionality."""
|
|
d = str(tmpdir)
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('1 abandonned 1\n2 abandonned 2\nabondon\n')
|
|
bad_name = f.name
|
|
assert cs.main(bad_name) == 3
|
|
with open(op.join(d, 'ignore.txt'), 'w') as f:
|
|
f.write('abandonned\n')
|
|
assert cs.main('-I', f.name, bad_name) == 1
|
|
|
|
|
|
def test_ignore_word_list(tmpdir, capsys):
|
|
"""Test ignore word list functionality."""
|
|
d = str(tmpdir)
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned\nabondon\nabilty\n')
|
|
assert cs.main(d) == 3
|
|
assert cs.main('-Labandonned,someword', '-Labilty', d) == 1
|
|
|
|
|
|
def test_custom_regex(tmpdir, capsys):
|
|
"""Test custom word regex."""
|
|
d = str(tmpdir)
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned_abondon\n')
|
|
assert cs.main(d) == 0
|
|
assert cs.main('-r', "[a-z]+", d) == 2
|
|
code, stdout, _ = cs.main('-r', '[a-z]+', '--write-changes', d, std=True)
|
|
assert code == EX_USAGE
|
|
assert 'ERROR:' in stdout
|
|
|
|
|
|
def test_exclude_file(tmpdir, capsys):
|
|
"""Test exclude file functionality."""
|
|
d = str(tmpdir)
|
|
with open(op.join(d, 'bad.txt'), 'wb') as f:
|
|
f.write('1 abandonned 1\n2 abandonned 2\n'.encode('utf-8'))
|
|
bad_name = f.name
|
|
assert cs.main(bad_name) == 2
|
|
with open(op.join(d, 'tmp.txt'), 'wb') as f:
|
|
f.write('1 abandonned 1\n'.encode('utf-8'))
|
|
assert cs.main(bad_name) == 2
|
|
assert cs.main('-x', f.name, bad_name) == 1
|
|
|
|
|
|
def test_encoding(tmpdir, capsys):
|
|
"""Test encoding handling."""
|
|
# Some simple Unicode things
|
|
with open(op.join(str(tmpdir), 'tmp'), 'w') as f:
|
|
pass
|
|
# with CaptureStdout() as sio:
|
|
assert cs.main(f.name) == 0
|
|
with open(f.name, 'wb') as f:
|
|
f.write(u'naïve\n'.encode('utf-8'))
|
|
assert cs.main(f.name) == 0
|
|
assert cs.main('-e', f.name) == 0
|
|
with open(f.name, 'ab') as f:
|
|
f.write(u'naieve\n'.encode('utf-8'))
|
|
assert cs.main(f.name) == 1
|
|
# Binary file warning
|
|
with open(f.name, 'wb') as f:
|
|
f.write(b'\x00\x00naiive\x00\x00')
|
|
code, stdout, stderr = cs.main(f.name, std=True, count=False)
|
|
assert code == 0
|
|
assert stdout == stderr == ''
|
|
code, stdout, stderr = cs.main('-q', '0', f.name, std=True, count=False)
|
|
assert code == 0
|
|
assert stdout == ''
|
|
assert 'WARNING: Binary file' in stderr
|
|
|
|
|
|
def test_ignore(tmpdir, capsys):
|
|
"""Test ignoring of files and directories."""
|
|
d = str(tmpdir)
|
|
with open(op.join(d, 'good.txt'), 'w') as f:
|
|
f.write('this file is okay')
|
|
assert cs.main(d) == 0
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned')
|
|
assert cs.main(d) == 1
|
|
assert cs.main('--skip=bad*', d) == 0
|
|
assert cs.main('--skip=bad.txt', d) == 0
|
|
subdir = op.join(d, 'ignoredir')
|
|
os.mkdir(subdir)
|
|
with open(op.join(subdir, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned')
|
|
assert cs.main(d) == 2
|
|
assert cs.main('--skip=bad*', d) == 0
|
|
assert cs.main('--skip=*ignoredir*', d) == 1
|
|
assert cs.main('--skip=ignoredir', d) == 1
|
|
assert cs.main('--skip=*ignoredir/bad*', d) == 1
|
|
|
|
|
|
def test_check_filename(tmpdir, capsys):
|
|
"""Test filename check."""
|
|
d = str(tmpdir)
|
|
# Empty file
|
|
with open(op.join(d, 'abandonned.txt'), 'w') as f:
|
|
f.write('')
|
|
assert cs.main('-f', d) == 1
|
|
# Normal file with contents
|
|
with open(op.join(d, 'abandonned.txt'), 'w') as f:
|
|
f.write('.')
|
|
assert cs.main('-f', d) == 1
|
|
# Normal file with binary contents
|
|
with open(op.join(d, 'abandonned.txt'), 'wb') as f:
|
|
f.write(b'\x00\x00naiive\x00\x00')
|
|
assert cs.main('-f', d) == 1
|
|
|
|
|
|
@pytest.mark.skipif((not hasattr(os, "mkfifo") or not callable(os.mkfifo)),
|
|
reason='requires os.mkfifo')
|
|
def test_check_filename_irregular_file(tmpdir, capsys):
|
|
"""Test irregular file filename check."""
|
|
# Irregular file (!isfile())
|
|
d = str(tmpdir)
|
|
os.mkfifo(op.join(d, 'abandonned'))
|
|
assert cs.main('-f', d) == 1
|
|
d = str(tmpdir)
|
|
|
|
|
|
def test_check_hidden(tmpdir, capsys):
|
|
"""Test ignoring of hidden files."""
|
|
d = str(tmpdir)
|
|
# visible file
|
|
with open(op.join(d, 'test.txt'), 'w') as f:
|
|
f.write('abandonned\n')
|
|
assert cs.main(op.join(d, 'test.txt')) == 1
|
|
assert cs.main(d) == 1
|
|
# hidden file
|
|
os.rename(op.join(d, 'test.txt'), op.join(d, '.test.txt'))
|
|
assert cs.main(op.join(d, '.test.txt')) == 0
|
|
assert cs.main(d) == 0
|
|
assert cs.main('--check-hidden', op.join(d, '.test.txt')) == 1
|
|
assert cs.main('--check-hidden', d) == 1
|
|
# hidden file with typo in name
|
|
os.rename(op.join(d, '.test.txt'), op.join(d, '.abandonned.txt'))
|
|
assert cs.main(op.join(d, '.abandonned.txt')) == 0
|
|
assert cs.main(d) == 0
|
|
assert cs.main('--check-hidden', op.join(d, '.abandonned.txt')) == 1
|
|
assert cs.main('--check-hidden', d) == 1
|
|
assert cs.main('--check-hidden', '--check-filenames',
|
|
op.join(d, '.abandonned.txt')) == 2
|
|
assert cs.main('--check-hidden', '--check-filenames', d) == 2
|
|
# hidden directory
|
|
assert cs.main(d) == 0
|
|
assert cs.main('--check-hidden', d) == 1
|
|
assert cs.main('--check-hidden', '--check-filenames', d) == 2
|
|
os.mkdir(op.join(d, '.abandonned'))
|
|
copyfile(op.join(d, '.abandonned.txt'),
|
|
op.join(d, '.abandonned', 'abandonned.txt'))
|
|
assert cs.main(d) == 0
|
|
assert cs.main('--check-hidden', d) == 2
|
|
assert cs.main('--check-hidden', '--check-filenames', d) == 5
|
|
|
|
|
|
def test_case_handling(tmpdir, capsys):
|
|
"""Test that capitalized entries get detected properly."""
|
|
# Some simple Unicode things
|
|
with open(op.join(str(tmpdir), 'tmp'), 'w') as f:
|
|
pass
|
|
# with CaptureStdout() as sio:
|
|
assert cs.main(f.name) == 0
|
|
with open(f.name, 'wb') as f:
|
|
f.write('this has an ACII error'.encode('utf-8'))
|
|
code, stdout, _ = cs.main(f.name, std=True)
|
|
assert code == 1
|
|
assert 'ASCII' in stdout
|
|
code, _, stderr = cs.main('-w', f.name, std=True)
|
|
assert code == 0
|
|
assert 'FIXED' in stderr
|
|
with open(f.name, 'rb') as f:
|
|
assert f.read().decode('utf-8') == 'this has an ASCII error'
|
|
|
|
|
|
def test_context(tmpdir, capsys):
|
|
"""Test context options."""
|
|
d = str(tmpdir)
|
|
with open(op.join(d, 'context.txt'), 'w') as f:
|
|
f.write('line 1\nline 2\nline 3 abandonned\nline 4\nline 5')
|
|
|
|
# symmetric context, fully within file
|
|
code, stdout, _ = cs.main('-C', '1', d, std=True)
|
|
assert code == 1
|
|
lines = stdout.split('\n')
|
|
assert len(lines) == 5
|
|
assert lines[0] == ': line 2'
|
|
assert lines[1] == '> line 3 abandonned'
|
|
assert lines[2] == ': line 4'
|
|
|
|
# requested context is bigger than the file
|
|
code, stdout, _ = cs.main('-C', '10', d, std=True)
|
|
assert code == 1
|
|
lines = stdout.split('\n')
|
|
assert len(lines) == 7
|
|
assert lines[0] == ': line 1'
|
|
assert lines[1] == ': line 2'
|
|
assert lines[2] == '> line 3 abandonned'
|
|
assert lines[3] == ': line 4'
|
|
assert lines[4] == ': line 5'
|
|
|
|
# only before context
|
|
code, stdout, _ = cs.main('-B', '2', d, std=True)
|
|
assert code == 1
|
|
lines = stdout.split('\n')
|
|
assert len(lines) == 5
|
|
assert lines[0] == ': line 1'
|
|
assert lines[1] == ': line 2'
|
|
assert lines[2] == '> line 3 abandonned'
|
|
|
|
# only after context
|
|
code, stdout, _ = cs.main('-A', '1', d, std=True)
|
|
assert code == 1
|
|
lines = stdout.split('\n')
|
|
assert len(lines) == 4
|
|
assert lines[0] == '> line 3 abandonned'
|
|
assert lines[1] == ': line 4'
|
|
|
|
# asymmetric context
|
|
code, stdout, _ = cs.main('-B', '2', '-A', '1', d, std=True)
|
|
assert code == 1
|
|
lines = stdout.split('\n')
|
|
assert len(lines) == 6
|
|
assert lines[0] == ': line 1'
|
|
assert lines[1] == ': line 2'
|
|
assert lines[2] == '> line 3 abandonned'
|
|
assert lines[3] == ': line 4'
|
|
|
|
# both '-C' and '-A' on the command line
|
|
code, stdout, _ = cs.main('-C', '2', '-A', '1', d, std=True)
|
|
assert code == EX_USAGE
|
|
lines = stdout.split('\n')
|
|
assert 'ERROR' in lines[0]
|
|
|
|
# both '-C' and '-B' on the command line
|
|
code, stdout, stderr = cs.main('-C', '2', '-B', '1', d, std=True)
|
|
assert code == EX_USAGE
|
|
lines = stdout.split('\n')
|
|
assert 'ERROR' in lines[0]
|
|
|
|
|
|
def test_ignore_regex_flag(tmpdir, capsys):
|
|
"""Test ignore regex flag functionality."""
|
|
d = str(tmpdir)
|
|
|
|
# Invalid regex.
|
|
code, stdout, _ = cs.main('--ignore-regex=(', std=True)
|
|
assert code == EX_USAGE
|
|
assert 'usage:' in stdout
|
|
|
|
with open(op.join(d, 'flag.txt'), 'w') as f:
|
|
f.write('# Please see http://example.com/abandonned for info\n')
|
|
# Test file has 1 invalid entry, and it's not ignored by default.
|
|
assert cs.main(f.name) == 1
|
|
# An empty regex is the default value, and nothing is ignored.
|
|
assert cs.main(f.name, '--ignore-regex=') == 1
|
|
assert cs.main(f.name, '--ignore-regex=""') == 1
|
|
# Non-matching regex results in nothing being ignored.
|
|
assert cs.main(f.name, '--ignore-regex=^$') == 1
|
|
# A word can be ignored.
|
|
assert cs.main(f.name, '--ignore-regex=abandonned') == 0
|
|
# Ignoring part of the word can result in odd behavior.
|
|
assert cs.main(f.name, '--ignore-regex=nn') == 0
|
|
|
|
with open(op.join(d, 'flag.txt'), 'w') as f:
|
|
f.write('abandonned donn\n')
|
|
# Test file has 2 invalid entries.
|
|
assert cs.main(f.name) == 2
|
|
# Ignoring donn breaks them both.
|
|
assert cs.main(f.name, '--ignore-regex=donn') == 0
|
|
# Adding word breaks causes only one to be ignored.
|
|
assert cs.main(f.name, r'--ignore-regex=\Wdonn\W') == 1
|
|
|
|
|
|
def test_config(tmpdir, capsys):
|
|
"""
|
|
Tests loading options from a config file.
|
|
"""
|
|
d = str(tmpdir)
|
|
|
|
# Create sample files.
|
|
with open(op.join(d, 'bad.txt'), 'w') as f:
|
|
f.write('abandonned donn\n')
|
|
with open(op.join(d, 'good.txt'), 'w') as f:
|
|
f.write("good")
|
|
|
|
# Create a config file.
|
|
conffile = op.join(d, 'config.cfg')
|
|
with open(conffile, 'w') as f:
|
|
f.write(
|
|
'[codespell]\n'
|
|
'skip = bad.txt\n'
|
|
'count = \n'
|
|
)
|
|
|
|
# Should fail when checking both.
|
|
code, stdout, _ = cs.main(d, count=True, std=True)
|
|
# Code in this case is not exit code, but count of misspellings.
|
|
assert code == 2
|
|
assert 'bad.txt' in stdout
|
|
|
|
# Should pass when skipping bad.txt
|
|
code, stdout, _ = cs.main('--config', conffile, d, count=True, std=True)
|
|
assert code == 0
|
|
assert 'bad.txt' not in stdout
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def FakeStdin(text):
|
|
if sys.version[0] == '2':
|
|
from StringIO import StringIO
|
|
else:
|
|
from io import StringIO
|
|
oldin = sys.stdin
|
|
try:
|
|
in_ = StringIO(text)
|
|
sys.stdin = in_
|
|
yield
|
|
finally:
|
|
sys.stdin = oldin
|