Skip to content
Find file
Fetching contributors…
Cannot retrieve contributors at this time
334 lines (284 sloc) 13.6 KB
# Mock out the vim library
import sys
sys.path = ['tests/mocks'] + sys.path
import vim
import mock
vimvar = {}
def fake_eval(x):
global vimvar
return vimvar[x]
vim.eval = fake_eval
vim.current = mock.Mock()
vimvar['foo'] = 'bar'
# Begin normal module loading
import os
import unittest
# Load test subjects
from rst_tables import get_table_bounds, reformat_table, parse_table, \
reflow_table, draw_table, table_line, get_column_widths, \
get_column_widths_from_border_spec, pad_fields, unify_table, \
join_rows, partition_raw_lines, split_row_into_lines, \
reflow_row_contents
class TestRSTTableFormatter(unittest.TestCase):
def setUp(self):
# Default vim cursor for all tests is at line 4
vim.current = mock.Mock()
self.set_vim_cursor(4, 0)
def tearDown(self):
del vim.current
def set_vim_cursor(self, row, col):
vim.current.window.cursor = (row, col)
def read_fixture(self, name):
return open(os.path.join('tests/fixtures/', name + '.txt'),
'r').read().split('\n')
def load_fixture_in_vim(self, name):
vim.current.buffer = self.read_fixture(name)
def testGetBounds(self):
self.load_fixture_in_vim('default')
self.assertEquals((3, 6), get_table_bounds())
def testGetBoundsOnBeginOfFile(self):
self.load_fixture_in_vim('default')
vim.current.window.cursor = (1, 0)
self.assertEquals((1, 1), get_table_bounds())
def testGetBoundsOnEndOfFile(self):
self.load_fixture_in_vim('default')
vim.current.window.cursor = (8, 0)
self.assertEquals((8, 9), get_table_bounds())
def testJoinSimpleRows(self):
input_rows = [['x', 'y', 'z'], ['foo', 'bar']]
expected = ['x\nfoo', 'y\nbar', 'z']
self.assertEquals(expected, join_rows(input_rows))
input_rows.append(['apple', '', 'pear'])
expected = ['x foo apple', 'y bar', 'z pear']
self.assertEquals(expected, join_rows(input_rows, sep=' '))
def testPartitionRawLines(self):
self.assertEquals([], partition_raw_lines([]))
self.assertEquals([['']], partition_raw_lines(['']))
self.assertEquals(
[['foo'], ['bar']],
partition_raw_lines(['foo', 'bar']))
self.assertEquals(
[['foo'], ['bar']],
partition_raw_lines(['foo', '+----+', 'bar']))
self.assertEquals(
[['foo', 'bar'], ['baz']],
partition_raw_lines(['+-----+', 'foo', 'bar', '----', 'baz']))
def testParseSimpleTable(self):
self.assertEquals([['x y z']], parse_table(['x y z']))
self.assertEquals([['x', 'y z']], parse_table(['x y z']))
self.assertEquals([['x', 'y', 'z']], parse_table(['x y z']))
def testParseTable(self):
self.load_fixture_in_vim('default')
expected = [
['Column 1', 'Column 2'],
['Foo', 'Put two (or more) spaces as a field separator.'],
['Bar', 'Even very very long lines like these are fine, as long as you do not put in line endings here.'],
['Qux', 'This is the last line.'],
]
self.assertEquals(expected, parse_table(vim.current.buffer[2:6]))
def testParseTableUnifiesColumns(self):
input = ['x y', 'a b c', 'only one']
expected = [['x', 'y', ''], ['a', 'b', 'c'], ['only one', '', '']]
self.assertEquals(expected, parse_table(input))
def testUnifyTables(self):
input = [[' x ', ' y'], ['xxx', ' yyyy ', 'zz']]
expected = [[' x ', ' y', ''], ['xxx', ' yyyy ', 'zz']]
self.assertEquals(expected, unify_table(input))
def testUnifyTablesRemovesEmptyColumns(self):
input = [['x', '', 'y'], ['xxx', '', 'yyyy', 'zz', ' ']]
expected = [['x', 'y', ''], ['xxx', 'yyyy', 'zz']]
self.assertEquals(expected, unify_table(input))
def testParseDealsWithSpacesAtLineEnd(self):
input = ['x y ', 'a b ', 'only one']
expected = [['x', 'y'], ['a', 'b'], ['only one', '']]
self.assertEquals(expected, parse_table(input))
def testParseValidTable(self):
input = ['+-----+----+',
'| Foo | Mu |',
'+=====+====+',
'| x | y |',
'+-----+----+']
expect = [['Foo', 'Mu'], ['x', 'y']]
self.assertEquals(expect, parse_table(input))
def testParseCorruptedTable(self):
input = ['+---+---------+',
'| Foo | Mu |',
'+=====+====+',
'| x | This became somewhat larger |',
'blah | A new line| ',
'+-----+----+']
expect = [['Foo', 'Mu'],
['x\nblah', 'This became somewhat larger\nA new line']]
self.assertEquals(expect, parse_table(input))
input = ['+---+---------+',
'| Foo | Mu |',
'+=====+====+',
'| x | This became somewhat larger |',
'blah | A new line|| ',
'+-----+----+']
expect = [['Foo', 'Mu'],
['x\nblah', 'This became somewhat larger\nA new line']]
self.assertEquals(expect, parse_table(input))
def testParseMultiLineFields(self):
input = """\
+-----+---------------------+
| Foo | Bar |
+=====+=====================+
| x | This is a long line |
| | that is spread out |
| | over multiple lines |
+-----+---------------------+""".split('\n')
expect = [['Foo', 'Bar'],
['x', 'This is a long line\nthat is spread out\nover multiple lines']]
self.assertEquals(expect, parse_table(input))
def testSplitRowIntoLines(self):
input = ['Foo', 'Bar']
expect = [['Foo', 'Bar']]
self.assertEquals(expect, split_row_into_lines(input))
input = ['One\nTwo\nThree', 'Only one']
expect = [['One', 'Only one'], ['Two', ''], ['Three', '']]
self.assertEquals(expect, split_row_into_lines(input))
input = ['One\n\n\nThree', 'Foo\nBar']
expect = [['One', 'Foo'], ['', 'Bar'], ['', ''], ['Three', '']]
self.assertEquals(expect, split_row_into_lines(input))
def testDrawMultiLineFields(self):
input = [['Foo', 'Bar'],
['x', 'This is a long line\nthat is spread out\nover multiple lines']]
expect = """\
+-----+---------------------+
| Foo | Bar |
+=====+=====================+
| x | This is a long line |
| | that is spread out |
| | over multiple lines |
+-----+---------------------+""".split('\n')
self.assertEquals(expect, draw_table(input))
def testTableLine(self):
self.assertEquals('', table_line([], True))
self.assertEquals('++', table_line([0], True))
self.assertEquals('+++', table_line([0,0], True))
self.assertEquals('++-+', table_line([0,1]))
self.assertEquals('+===+', table_line([3], True))
self.assertEquals('+===+====+', table_line([3,4], True))
self.assertEquals('+------------------+---+--------------------+',
table_line([18,3,20]))
def testGetColumnWidths(self):
self.assertEquals([], get_column_widths([[]]))
self.assertEquals([0], get_column_widths([['']]))
self.assertEquals([1,2,3], get_column_widths([['x','yy','zzz']]))
self.assertEquals([3,3,3],
get_column_widths(
[
['x','y','zzz'],
['xxx','yy','z'],
['xx','yyy','zz'],
]))
def testGetColumnWidthsForMultiLineFields(self):
self.assertEquals([3,6],
get_column_widths([['Foo\nBar\nQux',
'This\nis\nreally\nneat!']]))
def testGetColumnWidthsFromBorderSpec(self):
input = ['+----+-----+--+-------+',
'| xx | xxx | | xxxxx |',
'+====+=====+==+=======+']
self.assertEquals([2, 3, 0, 5],
get_column_widths_from_border_spec(input))
def testPadFields(self):
table = [['Name', 'Type', 'Description'],
['Lollypop', 'Candy', 'Yummy'],
['Crisps', 'Snacks', 'Even more yummy, I tell you!']]
expected_padding = [
[' Name ', ' Type ', ' Description '],
[' Lollypop ', ' Candy ', ' Yummy '],
[' Crisps ', ' Snacks ', ' Even more yummy, I tell you! ']]
widths = get_column_widths(table)
for input, expect in zip(table, expected_padding):
self.assertEquals(expect, pad_fields(input, widths))
def testReflowRowContentsWithEnoughWidth(self):
input = ['Foo\nbar', 'This line\nis spread\nout over\nfour lines.']
expect = ['Foo bar', 'This line is spread out over four lines.']
self.assertEquals(expect, reflow_row_contents(input, [99,99]))
def testReflowRowContentsWithWrapping(self):
input = ['Foo\nbar', 'This line\nis spread\nout over\nfour lines.']
expect = ['Foo bar', 'This line is spread\nout over four lines.']
self.assertEquals(expect, reflow_row_contents(input, [10,20]))
input = ['Foo\nbar', 'This line\nis spread\nout over\nfour lines.']
expect = ['Foo bar', 'This\nline\nis\nspread\nout\nover\nfour\nlines.']
self.assertEquals(expect, reflow_row_contents(input, [10,6]))
def testReflowRowContentsWithoutRoom(self):
#self.assertEquals(expect, reflow_row_contents(input))
pass
def testDrawTable(self):
self.assertEquals([], draw_table([]))
self.assertEquals(['+--+', '| |', '+==+'], draw_table([['']]))
self.assertEquals(['+-----+', '| Foo |', '+=====+'],
draw_table([['Foo']]))
self.assertEquals(
['+-----+----+',
'| Foo | Mu |',
'+=====+====+',
'| x | y |',
'+-----+----+'],
draw_table([['Foo', 'Mu'], ['x', 'y']]))
def testCreateTable(self):
self.load_fixture_in_vim('default')
expect = """\
This is paragraph text *before* the table.
+----------+------------------------------------------------------------------------------------------------+
| Column 1 | Column 2 |
+==========+================================================================================================+
| Foo | Put two (or more) spaces as a field separator. |
+----------+------------------------------------------------------------------------------------------------+
| Bar | Even very very long lines like these are fine, as long as you do not put in line endings here. |
+----------+------------------------------------------------------------------------------------------------+
| Qux | This is the last line. |
+----------+------------------------------------------------------------------------------------------------+
This is paragraph text *after* the table, with
a line ending.
""".split('\n')
reformat_table()
self.assertEquals(expect, vim.current.buffer)
def testCreateComplexTable(self):
raw_lines = self.read_fixture('multiline-cells')
# strip off the last (empty) line from raw_lines (since that line does
# not belong to the table
del raw_lines[-1]
expect = """\
+----------------+---------------------------------------------------------------+
| Feature | Description |
+================+===============================================================+
| Ease of use | Drop dead simple! |
+----------------+---------------------------------------------------------------+
| Foo | Bar, qux, mux |
+----------------+---------------------------------------------------------------+
| Predictability | Lorem ipsum dolor sit amet, consectetur adipiscing elit. |
+----------------+---------------------------------------------------------------+
| | Nullam congue dapibus aliquet. Integer ut rhoncus leo. In hac |
+----------------+---------------------------------------------------------------+
| | habitasse platea dictumst. Phasellus pretium iaculis. |
+----------------+---------------------------------------------------------------+
""".rstrip().split('\n')
self.assertEquals(expect, draw_table(parse_table(raw_lines)))
def testReflowTable(self):
self.load_fixture_in_vim('reflow')
expect = """\
This is paragraph text *before* the table.
+----------+--------------------------+
| Column 1 | Column 2 |
+==========+==========================+
| Foo | Put two (or more) spaces |
| | as a field separator. |
+----------+--------------------------+
| Bar | Even very very long |
| | lines like these are |
| | fine, as long as you do |
| | not put in line endings |
| | here. |
+----------+--------------------------+
| Qux | This is the last line. |
+----------+--------------------------+
This is paragraph text *after* the table, with
a line ending.
""".split('\n')
reflow_table()
self.assertEquals(expect, vim.current.buffer)
Something went wrong with that request. Please try again.