Merge pull request #30 from matthew-brett/proposed-refactor

MRG: refactor for Python 3, testing rst_tables.vim

Author: nvie

README.rst

@@ -19,10 +19,6 @@ Installation
        git clone git://github.com/nvie/vim-rst-tables.git
        cd vim-rst-tables
 
-3. Make the project::
-
-       python build.py
-
 4. Copy the file ``ftplugin/rst_tables.vim`` to your ``~/.vim/ftplugin``
    directory. If your vim is not already configured to source scripts
    in this directory, make sure to add the appropriate command to your

ftplugin/rst_tables.vim

@@ -16,8 +16,36 @@ if exists("g:loaded_rst_tables_ftplugin")
 endif
 let loaded_rst_tables_ftplugin = 1
 
-python << endpython
+" Default to Python 2
+let py_cmd_ver = 'python'
+let py_cmd_ver_other = 'python3'
+" Allow user to select Python 3
+if exists('g:rst_prefer_python_version') &&
+            \ g:rst_prefer_python_version == 3
+    let py_cmd_ver = 'python3'
+    let py_cmd_ver_other = 'python'
+endif
+if !has(py_cmd_ver)
+    let py_cmd_ver = py_cmd_ver_other
+    if !has(py_cmd_ver)
+        echoerr "Error: Requires Vim compiled with +python or +python3"
+        finish
+    endif
+endif
+
+if py_cmd_ver == 'python'
+    command! -nargs=1 Python python <args>
+else
+    command! -nargs=1 Python python3 <args>
+endif
+
+Python << endpython
+
 import vim
+
+import sys
+PY2 = sys.version_info[0] < 2
+
 import re
 import textwrap
 import unicodedata
@@ -44,7 +72,7 @@ def get_table_bounds():
     else:
         lower -= 1
 
-    match = re.match('^(\s*).*$', vim.current.buffer[upper-1])
+    match = re.match(r'^(\s*).*$', vim.current.buffer[upper-1])
 
     return (upper, lower, match.group(1))
 
@@ -65,11 +93,11 @@ def join_rows(rows, sep='\n'):
             field_text = field.strip()
             if field_text:
                 output[i].append(field_text)
-    return map(lambda lines: sep.join(lines), output)
+    return [sep.join(lines) for lines in output]
 
 
 def line_is_separator(line):
-    return re.match('^[\t +=-]+$', line)
+    return re.match(r'^[\t +=-]+$', line)
 
 
 def has_line_seps(raw_lines):
@@ -85,20 +113,19 @@ def partition_raw_lines(raw_lines):
 
     """
     if not has_line_seps(raw_lines):
-        return map(lambda x: [x], raw_lines)
+        return [[x] for x in raw_lines]
 
     curr_part = []
     parts = [curr_part]
     for line in raw_lines:
-        line = line.encode('utf8')
         if line_is_separator(line):
             curr_part = []
             parts.append(curr_part)
         else:
             curr_part.append(line)
 
     # remove any empty partitions (typically the first and last ones)
-    return filter(lambda x: x != [], parts)
+    return [x for x in parts if x!= []]
 
 
 def unify_table(table):
@@ -107,7 +134,8 @@ def unify_table(table):
     empty (i.e. all rows have that field empty), the column is removed.
 
     """
-    max_fields = max(map(lambda row: len(row), table))
+    max_fields = max([len(row) for row in table])
+
     empty_cols = [True] * max_fields
     output = []
     for row in table:
@@ -145,8 +173,8 @@ def split_table_row(row_string):
 
 def parse_table(raw_lines):
     row_partition = partition_raw_lines(raw_lines)
-    lines = map(lambda row_string: join_rows(map(split_table_row, row_string)),
-                row_partition)
+    lines = [join_rows([split_table_row(row) for row in row_string])
+             for row_string in row_partition]
     return unify_table(lines)
 
 
@@ -165,7 +193,8 @@ def table_line(widths, header=False):
 
 
 def get_field_width(field_text):
-    return max(map(get_string_width, field_text.split('\n')))
+    return max([len(s) for s in field_text.split('\n')])
+
 
 def get_string_width(string):
     width = 0
@@ -178,8 +207,8 @@ def get_string_width(string):
     return width
 
 def split_row_into_lines(row):
-    row = map(lambda field: field.split('\n'), row)
-    height = max(map(lambda field_lines: len(field_lines), row))
+    row = [field.split('\n') for field in row]
+    height = max([len(field_lines) for field_lines in row])
     turn_table = []
     for i in range(height):
         fields = []
@@ -221,23 +250,21 @@ def get_column_widths_from_border_spec(slice):
         left = 1
     if border[-1] == '+':
         right = -1
-    return map(lambda drawing: max(0, len(drawing) - 2), border[left:right].split('+'))
+    # This will return one width if there are no + characters
+    return [max(0, len(drawing) - 2) for drawing in border[left:right].split('+')]
 
 
 def pad_fields(row, widths):
     """Pads fields of the given row, so each field lines up nicely with the
     others.
 
     """
-    widths = map(lambda w: ' %-' + str(w) + 's ', widths)
+    widths = [' %-' + str(w) + 's ' for w in widths]
 
     # Pad all fields using the calculated widths
     new_row = []
     for i in range(len(row)):
-        col = row[i]
-        col = col.decode('utf8')
-        col = widths[i] % col.strip()
-        col = col.encode('utf8')
+        col = widths[i] % row[i].strip()
         new_row.append(col)
     return new_row
 
@@ -260,7 +287,7 @@ def draw_table(indent, table, manual_widths=None):
         col_widths = manual_widths
 
     # Reserve room for the spaces
-    sep_col_widths = map(lambda x: x + 2, col_widths)
+    sep_col_widths = [x + 2 for x in col_widths]
     header_line = table_line(sep_col_widths, header=True)
     normal_line = table_line(sep_col_widths, header=False)
 
@@ -288,29 +315,38 @@ def draw_table(indent, table, manual_widths=None):
     return output
 
 
+def proc_table(func):
+    upper, lower, indent = get_table_bounds()
+    table_txt = vim.current.buffer[upper - 1:lower]
+    if PY2:
+        encoding = vim.eval("&encoding")
+        table_txt = [codecs.decode(x, encoding) for x in table_txt]
+    table_txt = func(indent, table_txt)
+    if PY2:
+        table_txt = [codecs.encode(x, encoding) for x in table_txt]
+    vim.current.buffer[upper - 1:lower] = table_txt
+
+
+def _reformat(indent, table_txt):
+    table = parse_table(table_txt)
+    return draw_table(indent, table)
+
+
 @bridged
 def reformat_table():
-    upper, lower, indent = get_table_bounds()
-    encoding = vim.eval("&encoding")
-    slice = map(lambda x: codecs.decode(x, encoding), \
-    	vim.current.buffer[upper - 1:lower])
-    table = parse_table(slice)
-    slice = draw_table(indent, table)
-    vim.current.buffer[upper - 1:lower] = map(lambda x: \
-    	codecs.encode(x, encoding), slice)
+    proc_table(_reformat)
+
+
+def _reflow(indent, table_txt):
+    widths = get_column_widths_from_border_spec(table_txt)
+    table = parse_table(table_txt)
+    return draw_table(indent, table, widths)
 
 
 @bridged
 def reflow_table():
-    upper, lower, indent = get_table_bounds()
-    encoding = vim.eval("&encoding")
-    slice = map(lambda x: codecs.decode(x, encoding), \
-    	vim.current.buffer[upper - 1:lower])
-    widths = get_column_widths_from_border_spec(slice)
-    table = parse_table(slice)
-    slice = draw_table(indent, table, widths)
-    vim.current.buffer[upper - 1:lower] = map(lambda x: \
-    	codecs.encode(x, encoding), slice)
+    proc_table(_reflow)
+
 
 endpython