Merge pull request #1058 from ZyX-I/tabline-fixes

Improve tabline support
This commit is contained in:
Nikolai Aleksandrovich Pavlov 2014-09-05 20:23:11 +04:00
commit 766efe3754
32 changed files with 636 additions and 395 deletions

View File

@ -108,7 +108,7 @@ segments that you may want to customize right away:
The weather segment will try to find your location using a GeoIP lookup,
so unless you're on a VPN you probably won't have to change the location
query.
If you want to change the location query or the temperature unit you'll
have to update the segment arguments. Open a theme file, scroll down to
the weather segment and update it to include unit/location query
@ -134,4 +134,5 @@ References
configuration/reference
configuration/segments
configuration/listers
configuration/selectors
configuration/local

View File

@ -1,3 +1,5 @@
.. _config-listers:
****************
Lister reference
****************

View File

@ -380,6 +380,9 @@ ascii Theme without any unicode characters at all
The segment contents is the return value of the function defined in
the :ref:`function option <config-themes-seg-function>`.
List of function segments is available in :ref:`Segment reference
<config-segments>` section.
``string``
A static string segment where the contents is defined in the
:ref:`contents option <config-themes-seg-contents>`, and the
@ -392,6 +395,9 @@ ascii Theme without any unicode characters at all
<config-themes-seg-segments>` and :ref:`args
<config-themes-seg-args>` options.
List of lister segments is available in :ref:`Lister reference
<config-lister>` section.
.. _config-themes-seg-name:
``name``
@ -493,13 +499,31 @@ ascii Theme without any unicode characters at all
.. _config-themes-seg-exclude_modes:
``exclude_modes``
A list of modes where this segment will be excluded: The segment is
included in all modes, *except* for the modes in this list.
``exclude_modes``, ``include_modes``
A list of modes where this segment will be excluded: the segment is not
included or is included in all modes, *except* for the modes in one of
these lists respectively. If ``exclude_modes`` is not present then it
acts like an empty list (segment is not excluded from any modes).
Without ``include_modes`` it acts like a list with all possible modes
(segment is included in all modes). When there are both
``exclude_modes`` overrides ``include_modes``.
``include_modes``
A list of modes where this segment will be included: The segment is
*not* included in any modes, *except* for the modes in this list.
.. _config-themes-seg-exclude_function:
``exclude_function``, ``include_function``
Function name in a form ``{name}`` or ``{module}.{name}`` (in the first
form ``{module}`` defaults to ``powerline.selectors.{ext}``). Determines
under which condition specific segment will be included or excluded. By
default segment is always included and never excluded.
``exclude_function`` overrides ``include_function``.
.. note::
Options :ref:`exclude_/include_modes
<config-themes-seg-exclude_modes>` complement
``exclude_/include_functions``: segment will be included if it is
included by either ``include_mode`` or ``include_function`` and will
be excluded if it is excluded by either ``exclude_mode`` or
``exclude_function``.
.. _config-themes-seg-display:

View File

@ -1,3 +1,5 @@
.. _config-segments:
*****************
Segment reference
*****************

View File

@ -40,11 +40,6 @@ resulting segment. In addition to :ref:`usual keys that describe segment
<dev-segments-segment>` the following keys may be present (it is advised that
*only* the following keys will be used):
.. _dev-listers-mode:
``mode``
Segment-specific mode. Used to alter segment highlighting.
``priority_multiplier``
Value (usually a ``float``) used to multiply segment priority. It is useful
for finer-grained controlling which segments disappear first: e.g. when

View File

@ -228,6 +228,12 @@ Segment dictionary contains the following keys:
``highlight_group``, ``divider_highlight_group``
Used highlight groups. May be ``None``.
``highlight_group_prefix``
If this key is present then given prefix will be prepended to each highlight
group (both regular and divider) used by this segment in a form
``{prefix}:{group}`` (note the colon). This key is mostly useful for
:ref:`segment listers <dev-listers>`.
.. _dev-segments-seg-around:
``before``, ``after``
@ -254,9 +260,15 @@ Segment dictionary contains the following keys:
``side``
Segment side: ``right`` or ``left``.
``exclude_modes``, ``include_modes``
:ref:`Mode display control lists <config-themes-seg-exclude_modes>`. May be
empty, but may not be ``None``.
``display_condition```
Contains function that takes three position parameters:
:py:class:`powerline.PowerlineLogger` instance, :ref:`segment_info
<dev-segments-info>` dictionary and current mode and returns either ``True``
or ``False`` to indicate whether particular segment should be processed.
This key is constructed based on :ref:`exclude_/include_modes keys
<config-themes-seg-exclude_modes>` and :ref:`exclude_/include_function keys
<config-themes-seg-exclude_function>`.
``width``, ``align``
:ref:`Width and align options <config-themes-seg-align>`. May be ``None``.
@ -275,9 +287,6 @@ Segment dictionary contains the following keys:
``shutdown``
:ref:`Shutdown function <dev-segments-shutdown>`. Accepts no argument.
``mode``
:ref:`Segment-specific mode <dev-listers-mode>`. May be ``None``.
Segments layout
===============

View File

@ -0,0 +1,21 @@
****************************************
Tips and tricks for powerline developers
****************************************
Profiling powerline in Vim
==========================
Given that current directory is the root of the powerline repository the
following command may be used:
.. code-block:: sh
vim --cmd 'let g:powerline_pyeval="powerline#debug#profile_pyeval"' \
--cmd 'set rtp=powerline/bindings/vim' \
-c 'runtime! plugin/powerline.vim' \
{other arguments if needed}
After some time run ``:WriteProfiling {filename}`` Vim command. Currently this
only works with recent Vim and python-2*. It should be easy to modify
:file:`powerline/bindings/vim/autoload/powerline/debug.vim` to suit other
needs.

17
docs/source/selectors.rst Normal file
View File

@ -0,0 +1,17 @@
.. _config-selectors:
******************
Selector functions
******************
Selector functions are functions that return ``True`` or ``False`` depending on
application state. They are used for :ref:`exclude_function and include_function
segment options <config-themes-seg-exclude_function>`.
Available selectors
===================
.. toctree::
:glob:
selectors/*

View File

@ -0,0 +1,6 @@
*************
Vim selectors
*************
.. automodule:: powerline.selectors.vim
:members:

View File

@ -0,0 +1,20 @@
python import cProfile
python powerline_pr = cProfile.Profile()
function powerline#debug#profile_pyeval(s)
python powerline_pr.enable()
try
let ret = pyeval(a:s)
finally
python powerline_pr.disable()
endtry
return ret
endfunction
function powerline#debug#write_profile(fname)
python import vim
python powerline_pr.dump_stats(vim.eval('a:fname'))
python powerline_pr = cProfile.Profile()
endfunction
command -nargs=1 -complete=file WriteProfiling :call powerline#debug#write_profile(<q-args>)

View File

@ -32,14 +32,6 @@ def pick_gradient_value(grad_list, gradient_level):
return grad_list[int(round(gradient_level * (len(grad_list) - 1) / 100))]
def hl_iter(value):
if type(value) is list:
for v in value:
yield v
else:
yield value
class Colorscheme(object):
def __init__(self, colorscheme_config, colors_config):
'''Initialize a colorscheme.'''
@ -105,12 +97,12 @@ class Colorscheme(object):
def get_highlighting(self, groups, mode, gradient_level=None):
trans = self.translations.get(mode, {})
for group in hl_iter(groups):
for group in groups:
group_props = self.get_group_props(mode, trans, group)
if group_props:
break
else:
raise KeyError('Highlighting groups not found in colorscheme: ' + ', '.join(hl_iter(groups)))
raise KeyError('Highlighting groups not found in colorscheme: ' + ', '.join(groups))
if gradient_level is None:
pick_color = self.colors.__getitem__

View File

@ -17,6 +17,15 @@
"many_tabs": "line_current",
"bufnr": "file_directory",
"winnr": "information:unimportant",
"tabnr": "file_directory"
"tabnr": "file_directory",
"tab_nc:file_directory": "information:unimportant",
"tab_nc:file_name": "tab_nc:file_directory",
"tab_nc:tabnr": "tab_nc:file_directory",
"buf_nc:file_directory": "tab_nc:file_directory",
"buf_nc:file_name": "tab_nc:file_name",
"buf_nc:bufnr": "tab_nc:tabnr",
"buf_nc:modified_indicator": "tab_nc:modified_indicator"
}
}

View File

@ -30,7 +30,9 @@
"attached_clients": { "fg": "gray8", "bg": "gray2", "attr": [] },
"error": { "fg": "brightestred", "bg": "darkred", "attr": ["bold"] },
"warning": { "fg": "brightyellow", "bg": "darkorange", "attr": ["bold"] },
"current_tag": { "fg": "gray9", "bg": "gray2", "attr": [] }
"current_tag": { "fg": "gray9", "bg": "gray2", "attr": [] },
"tab_nc:modified_indicator": { "fg": "brightyellow", "bg": "gray2", "attr": ["bold"] }
},
"mode_translations": {
"nc": {
@ -52,44 +54,6 @@
"dark_green_gray": "gray5"
}
},
"tab_nc": {
"colors": {
"brightyellow": "darkorange",
"brightestred": "darkred",
"gray0": "gray0",
"gray1": "gray0",
"gray2": "gray0",
"gray3": "gray1",
"gray4": "gray1",
"gray5": "gray1",
"gray6": "gray1",
"gray7": "gray4",
"gray8": "gray4",
"gray9": "gray4",
"gray10": "gray5",
"white": "gray6",
"dark_green_gray": "gray5"
}
},
"buf_nc": {
"colors": {
"brightyellow": "darkorange",
"brightestred": "darkred",
"gray0": "gray0",
"gray1": "gray0",
"gray2": "gray0",
"gray3": "gray1",
"gray4": "gray1",
"gray5": "gray1",
"gray6": "gray1",
"gray7": "gray4",
"gray8": "gray4",
"gray9": "gray4",
"gray10": "gray5",
"white": "gray6",
"dark_green_gray": "gray5"
}
},
"i": {
"colors": {
"gray0": "darkestblue",

View File

@ -44,26 +44,6 @@
"solarized:base3": "solarized:base1"
}
},
"tab_nc": {
"colors": {
"solarized:base01": "solarized:base02",
"solarized:base00": "solarized:base02",
"solarized:base0": "solarized:base01",
"solarized:base1": "solarized:base00",
"solarized:base2": "solarized:base0",
"solarized:base3": "solarized:base1"
}
},
"buf_nc": {
"colors": {
"solarized:base01": "solarized:base02",
"solarized:base00": "solarized:base02",
"solarized:base0": "solarized:base01",
"solarized:base1": "solarized:base00",
"solarized:base2": "solarized:base0",
"solarized:base3": "solarized:base1"
}
},
"i": {
"groups": {
"background": { "fg": "solarized:base3", "bg": "solarized:base01", "attr": [] },

View File

@ -43,26 +43,6 @@
"solarized:base03": "solarized:base1"
}
},
"tab_nc": {
"colors": {
"solarized:base2": "solarized:base01",
"solarized:base0": "solarized:base01",
"solarized:base00": "solarized:base2",
"solarized:base1": "solarized:base0",
"solarized:base02": "solarized:base00",
"solarized:base03": "solarized:base1"
}
},
"buf_nc": {
"colors": {
"solarized:base2": "solarized:base01",
"solarized:base0": "solarized:base01",
"solarized:base00": "solarized:base2",
"solarized:base1": "solarized:base0",
"solarized:base02": "solarized:base00",
"solarized:base03": "solarized:base1"
}
},
"i": {
"groups": {
"background": { "fg": "solarized:base03", "bg": "solarized:base2", "attr": [] },

View File

@ -4,18 +4,12 @@
"left": [
{
"type": "segment_list",
"function": "powerline.listers.vim.tabbuflister",
"function": "powerline.listers.vim.tablister",
"exclude_function": "single_tab",
"segments": [
{
"function": "tabnr",
"after": " ",
"exclude_modes": ["tab", "buf", "buf_nc"],
"priority": 5
},
{
"function": "bufnr",
"after": " ",
"exclude_modes": ["tab", "buf", "tab_nc"],
"priority": 5
},
{
@ -31,12 +25,33 @@
},
{
"function": "tab_modified_indicator",
"exclude_modes": ["buf", "buf_nc"],
"priority": 5
}
]
},
{
"type": "segment_list",
"function": "powerline.listers.vim.bufferlister",
"include_function": "single_tab",
"segments": [
{
"function": "bufnr",
"after": " ",
"priority": 5
},
{
"function": "file_directory",
"priority": 40
},
{
"function": "file_name",
"args": {
"display_no_file": true
},
"priority": 10
},
{
"function": "modified_indicator",
"exclude_modes": ["tab", "tab_nc"],
"priority": 5
}
]
@ -51,7 +66,18 @@
],
"right": [
{
"function": "single_tab"
"type": "string",
"contents": "Bufs",
"name": "single_tab",
"highlight_group": ["single_tab"],
"include_function": "single_tab"
},
{
"type": "string",
"contents": "Tabs",
"name": "many_tabs",
"highlight_group": ["many_tabs"],
"exclude_function": "single_tab"
}
]
}

View File

@ -9,6 +9,7 @@ import logging
from collections import defaultdict
from copy import copy
from functools import partial
from powerline.lint.markedjson import load
from powerline import generate_config_finder, get_config_paths, load_config
@ -478,18 +479,18 @@ def check_matcher_func(ext, match_name, data, context, echoerr):
echoerr(context='Error while loading matcher functions',
problem='failed to load module {0}'.format(match_module),
problem_mark=match_name.mark)
return True, True
return True, False, True
except AttributeError:
echoerr(context='Error while loading matcher functions',
problem='failed to load matcher function {0}'.format(match_function),
problem_mark=match_name.mark)
return True, True
return True, False, True
if not callable(func):
echoerr(context='Error while loading matcher functions',
problem='loaded "function" {0} is not callable'.format(match_function),
problem_mark=match_name.mark)
return True, True
return True, False, True
if hasattr(func, 'func_code') and hasattr(func.func_code, 'co_argcount'):
if func.func_code.co_argcount != 1:
@ -502,7 +503,7 @@ def check_matcher_func(ext, match_name, data, context, echoerr):
problem_mark=match_name.mark
)
return True, False
return True, False, False
def check_ext(ext, data, context, echoerr):
@ -561,6 +562,9 @@ def check_top_theme(theme, data, context, echoerr):
return True, False, False
function_name_re = '^(\w+\.)*[a-zA-Z_]\w*$'
divider_spec = Spec().type(unicode).len(
'le', 3, (lambda value: 'Divider {0!r} is too large!'.format(value))).copy
ext_theme_spec = Spec().type(unicode).func(lambda *args: check_config('themes', *args)).copy
@ -608,7 +612,8 @@ main_spec = (Spec(
local_themes=Spec(
__tabline__=ext_theme_spec(),
).unknown_spec(
lambda *args: check_matcher_func('vim', *args), ext_theme_spec()
Spec().re(function_name_re).func(partial(check_matcher_func, 'vim')),
ext_theme_spec()
),
).optional(),
ipython=ext_spec().update(
@ -801,6 +806,7 @@ shell_colorscheme_spec = (Spec(
generic_keys = set((
'exclude_modes', 'include_modes',
'exclude_function', 'include_function',
'width', 'align',
'name',
'draw_soft_divider', 'draw_hard_divider',
@ -935,7 +941,7 @@ def check_full_segment_data(segment, data, context, echoerr):
return check_key_compatibility(segment_copy, data, context, echoerr)
def import_segment(name, data, context, echoerr, module):
def import_function(function_type, name, data, context, echoerr, module):
context_has_marks(context)
havemarks(name, module)
@ -949,7 +955,7 @@ def import_segment(name, data, context, echoerr, module):
problem_mark=module.mark)
return None
except AttributeError:
echoerr(context='Error while loading segment function (key {key})'.format(key=context_key(context)),
echoerr(context='Error while loading {0} function (key {key})'.format(function_type, key=context_key(context)),
problem='failed to load function {0} from module {1}'.format(name, module),
problem_mark=name.mark)
return None
@ -964,6 +970,10 @@ def import_segment(name, data, context, echoerr, module):
return func
def import_segment(*args, **kwargs):
return import_function('segment', *args, **kwargs)
def check_segment_function(function_name, data, context, echoerr):
havemarks(function_name)
ext = data['ext']
@ -1334,6 +1344,17 @@ def get_all_possible_functions(data, context, echoerr):
yield func
def check_exinclude_function(name, data, context, echoerr):
ext = data['ext']
module, name = name.rpartition('.')[::2]
if not module:
module = MarkedUnicode('powerline.selectors.' + ext, None)
func = import_function('selector', name, data, context, echoerr, module=module)
if not func:
return True, False, True
return True, False, False
args_spec = Spec(
pl=Spec().error('pl object must be set by powerline').optional(),
segment_info=Spec().error('Segment info dictionary must be set by powerline').optional(),
@ -1341,12 +1362,15 @@ args_spec = Spec(
highlight_group_spec = Spec().type(unicode).copy
segment_module_spec = Spec().type(unicode).func(check_segment_module).optional().copy
sub_segments_spec = Spec()
exinclude_spec = Spec().re(function_name_re).func(check_exinclude_function).copy
segment_spec = Spec(
type=Spec().oneof(type_keys).optional(),
name=Spec().re('^[a-zA-Z_]\w*$').optional(),
function=Spec().re('^(\w+\.)*[a-zA-Z_]\w*$').func(check_segment_function).optional(),
function=Spec().re(function_name_re).func(check_segment_function).optional(),
exclude_modes=Spec().list(vim_mode_spec()).optional(),
include_modes=Spec().list(vim_mode_spec()).optional(),
exclude_function=exinclude_spec().optional(),
include_function=exinclude_spec().optional(),
draw_hard_divider=Spec().type(bool).optional(),
draw_soft_divider=Spec().type(bool).optional(),
draw_inner_divider=Spec().type(bool).optional(),

View File

@ -10,7 +10,7 @@ except ImportError:
vim = {}
def tabpage_updated_segment_info(segment_info, tabpage, mode):
def tabpage_updated_segment_info(segment_info, tabpage):
segment_info = segment_info.copy()
window = tabpage.window
buffer = window.buffer
@ -22,7 +22,6 @@ def tabpage_updated_segment_info(segment_info, tabpage, mode):
window_id=int(window.vars.get('powerline_window_id', -1)),
buffer=buffer,
bufnr=buffer.number,
mode=mode,
)
return segment_info
@ -35,8 +34,7 @@ def tablister(pl, segment_info, **kwargs):
``winnr``, ``window_id``, ``buffer`` and ``bufnr`` keys set to tab-local
ones and additional ``tabpage`` and ``tabnr`` keys.
Sets segment ``mode`` to either ``tab`` (for current tab page) or ``tab_nc``
(for all other tab pages).
Adds either ``tab:`` or ``tab_nc:`` prefix to all segment highlight groups.
Works best with vim-7.4 or later: earlier versions miss tabpage object and
thus window objects are not available as well.
@ -49,15 +47,15 @@ def tablister(pl, segment_info, **kwargs):
return dct
return (
(lambda tabpage, mode: (
tabpage_updated_segment_info(segment_info, tabpage, mode),
add_multiplier(tabpage, {'mode': mode})
(lambda tabpage, prefix: (
tabpage_updated_segment_info(segment_info, tabpage),
add_multiplier(tabpage, {'highlight_group_prefix': prefix})
))(tabpage, 'tab' if tabpage == cur_tabpage else 'tab_nc')
for tabpage in list_tabpages()
)
def buffer_updated_segment_info(segment_info, buffer, mode):
def buffer_updated_segment_info(segment_info, buffer):
segment_info = segment_info.copy()
segment_info.update(
window=None,
@ -65,7 +63,6 @@ def buffer_updated_segment_info(segment_info, buffer, mode):
window_id=None,
buffer=buffer,
bufnr=buffer.number,
mode=mode,
)
return segment_info
@ -78,8 +75,7 @@ def bufferlister(pl, segment_info, show_unlisted=False, **kwargs):
and ``bufnr`` keys set to buffer-specific ones, ``window``, ``winnr`` and
``window_id`` keys set to None.
Sets segment ``mode`` to either ``buf`` (for current buffer) or ``buf_nc``
(for all other buffers).
Adds either ``buf:`` or ``buf_nc:`` prefix to all segment highlight groups.
:param bool show_unlisted:
True if unlisted buffers should be shown as well. Current buffer is
@ -95,12 +91,14 @@ def bufferlister(pl, segment_info, show_unlisted=False, **kwargs):
return (
(
buf_segment_info,
add_multiplier(buf_segment_info['buffer'], {'mode': buf_segment_info['mode']})
add_multiplier(buf_segment_info['buffer'], {'highlight_group_prefix': prefix})
)
for buf_segment_info in (
buffer_updated_segment_info(
segment_info,
buffer,
for buf_segment_info, prefix in (
(
buffer_updated_segment_info(
segment_info,
buffer
),
('buf' if buffer is cur_buffer else 'buf_nc')
)
for buffer in vim.buffers
@ -110,11 +108,3 @@ def bufferlister(pl, segment_info, show_unlisted=False, **kwargs):
or int(vim_getbufoption(buf_segment_info, 'buflisted'))
)
)
@requires_segment_info
def tabbuflister(**kwargs):
if len(list_tabpages()) == 1:
return bufferlister(**kwargs)
else:
return tablister(**kwargs)

View File

@ -266,20 +266,32 @@ class Renderer(object):
for segment in chain(segments_priority, no_priority_segments):
if segment['truncate'] is not None:
segment['contents'] = segment['truncate'](self.pl, current_width - width, segment)
for segment in segments_priority:
if current_width <= width:
break
segments.remove(segment)
segments_priority = iter(segments_priority)
if current_width > width and len(segments) > 100:
# When there are too many segments use faster, but less correct
# algorythm for width computation
diff = current_width - width
for segment in segments_priority:
segments.remove(segment)
diff -= segment['_len']
if diff <= 0:
break
current_width = self._render_length(theme, segments, divider_widths)
if current_width > width:
# When there are not too much use more precise, but much slower
# width computation. It also finishes computations in case
# previous variant did not free enough space.
for segment in segments_priority:
segments.remove(segment)
current_width = self._render_length(theme, segments, divider_widths)
if current_width <= width:
break
del segments_priority
# Distribute the remaining space on spacer segments
segments_spacers = [segment for segment in segments if segment['expand'] is not None]
if segments_spacers:
if not segments_priority:
# Update segment['_len'] and current_width if not already done
# (is not done in shells where there is nothing to remove
# because “priority” key is not specified)
current_width = self._render_length(theme, segments, divider_widths)
distribute_len, distribute_len_remainder = divmod(width - current_width, len(segments_spacers))
for segment in segments_spacers:
segment['contents'] = (
@ -360,50 +372,46 @@ class Renderer(object):
contents_highlighted = ''
draw_divider = segment['draw_' + divider_type + '_divider']
# Pad segments first
contents_raw = contents_raw.translate(self.np_character_translations)
# XXX Make sure self.hl() calls are called in the same order
# segments are displayed. This is needed for Vim renderer to work.
if draw_divider:
divider_raw = self.escape(theme.get_divider(side, divider_type))
if side == 'left':
contents_raw = outer_padding + contents_raw + (divider_spaces * ' ')
else:
contents_raw = (divider_spaces * ' ') + contents_raw + outer_padding
if divider_type == 'soft':
divider_highlight_group_key = 'highlight' if segment['divider_highlight_group'] is None else 'divider_highlight'
divider_fg = segment[divider_highlight_group_key]['fg']
divider_bg = segment[divider_highlight_group_key]['bg']
else:
divider_fg = segment['highlight']['bg']
divider_bg = compare_segment['highlight']['bg']
if side == 'left':
if render_highlighted:
contents_highlighted = self.hl(self.escape(contents_raw), **segment['highlight'])
divider_highlighted = self.hl(divider_raw, divider_fg, divider_bg, False)
segment['_rendered_raw'] = contents_raw + divider_raw
segment['_rendered_hl'] = contents_highlighted + divider_highlighted
else:
if render_highlighted:
divider_highlighted = self.hl(divider_raw, divider_fg, divider_bg, False)
contents_highlighted = self.hl(self.escape(contents_raw), **segment['highlight'])
segment['_rendered_raw'] = divider_raw + contents_raw
segment['_rendered_hl'] = divider_highlighted + contents_highlighted
else:
if side == 'left':
contents_raw = outer_padding + contents_raw
else:
contents_raw = contents_raw + outer_padding
# Replace spaces with no-break spaces
contents_raw = contents_raw.translate(self.np_character_translations)
# Apply highlighting to padded dividers and contents
if render_highlighted:
if draw_divider:
if divider_type == 'soft':
divider_highlight_group_key = 'highlight' if segment['divider_highlight_group'] is None else 'divider_highlight'
divider_fg = segment[divider_highlight_group_key]['fg']
divider_bg = segment[divider_highlight_group_key]['bg']
else:
divider_fg = segment['highlight']['bg']
divider_bg = compare_segment['highlight']['bg']
divider_highlighted = self.hl(divider_raw, divider_fg, divider_bg, False)
contents_highlighted = self.hl(self.escape(contents_raw), **segment['highlight'])
# Append padded raw and highlighted segments to the rendered segment variables
if draw_divider:
if side == 'left':
segment['_rendered_raw'] = contents_raw + divider_raw
segment['_rendered_hl'] = contents_highlighted + divider_highlighted
else:
segment['_rendered_raw'] = divider_raw + contents_raw
segment['_rendered_hl'] = divider_highlighted + contents_highlighted
else:
if side == 'left':
segment['_rendered_raw'] = contents_raw
segment['_rendered_hl'] = contents_highlighted
else:
segment['_rendered_raw'] = contents_raw
segment['_rendered_hl'] = contents_highlighted
segment['_rendered_raw'] = contents_raw
segment['_rendered_hl'] = contents_highlighted
yield segment
def escape(self, string):

View File

@ -40,6 +40,7 @@ class VimRenderer(Renderer):
kwargs['ambigious'] = 2
super(VimRenderer, self).__init__(*args, **kwargs)
self.hl_groups = {}
self.prev_highlight = None
def shutdown(self):
self.theme.shutdown()
@ -126,7 +127,15 @@ class VimRenderer(Renderer):
False, the argument is reset to the terminal defaults. If an argument
is a valid color or attribute, it's added to the vim highlight group.
'''
# We don't need to explicitly reset attributes in vim, so skip those calls
# In order not to hit E541 two consequent identical highlighting
# specifiers may be squashed into one.
attr = attr or 0 # Normalize `attr`
if (fg, bg, attr) == self.prev_highlight:
return ''
self.prev_highlight = (fg, bg, attr)
# We don't need to explicitly reset attributes in vim, so skip those
# calls
if not attr and not bg and not fg:
return ''

View File

@ -102,6 +102,11 @@ def get_attr_func(contents_func, key, args, is_space_func=False):
def process_segment_lister(pl, segment_info, parsed_segments, side, mode, colorscheme,
lister, subsegments, patcher_args):
subsegments = [
subsegment
for subsegment in subsegments
if subsegment['display_condition'](pl, segment_info, mode)
]
for subsegment_info, subsegment_update in lister(pl=pl, segment_info=segment_info, **patcher_args):
draw_inner_divider = subsegment_update.pop('draw_inner_divider', False)
old_pslen = len(parsed_segments)
@ -109,26 +114,16 @@ def process_segment_lister(pl, segment_info, parsed_segments, side, mode, colors
if subsegment_update:
subsegment = subsegment.copy()
subsegment.update(subsegment_update)
if subsegment_update['priority_multiplier'] and subsegment['priority']:
if 'priority_multiplier' in subsegment_update and subsegment['priority']:
subsegment['priority'] *= subsegment_update['priority_multiplier']
subsegment_mode = subsegment_update.get('mode')
if subsegment_mode and (
subsegment_mode in subsegment['exclude_modes']
or (
subsegment['include_modes']
and subsegment_mode not in subsegment['include_modes']
)
):
continue
process_segment(
pl,
side,
subsegment_info,
parsed_segments,
subsegment,
subsegment_mode or mode,
mode,
colorscheme,
)
new_pslen = len(parsed_segments)
@ -138,17 +133,23 @@ def process_segment_lister(pl, segment_info, parsed_segments, side, mode, colors
return None
def set_segment_highlighting(pl, colorscheme, segment):
def set_segment_highlighting(pl, colorscheme, segment, mode):
try:
highlight_group_prefix = segment['highlight_group_prefix']
except KeyError:
hl_groups = lambda hlgs: hlgs
else:
hl_groups = lambda hlgs: [highlight_group_prefix + ':' + hlg for hlg in hlgs] + hlgs
try:
segment['highlight'] = colorscheme.get_highlighting(
segment['highlight_group'],
segment['mode'],
hl_groups(segment['highlight_group']),
mode,
segment.get('gradient_level')
)
if segment['divider_highlight_group']:
segment['divider_highlight'] = colorscheme.get_highlighting(
segment['divider_highlight_group'],
segment['mode']
hl_groups([segment['divider_highlight_group']]),
mode
)
else:
segment['divider_highlight'] = None
@ -161,7 +162,6 @@ def set_segment_highlighting(pl, colorscheme, segment):
def process_segment(pl, side, segment_info, parsed_segments, segment, mode, colorscheme):
segment = segment.copy()
segment['mode'] = mode
pl.prefix = segment['name']
if segment['type'] in ('function', 'segment_list'):
try:
@ -207,17 +207,20 @@ def process_segment(pl, side, segment_info, parsed_segments, segment, mode, colo
if draw_inner_divider is not None:
segment_copy['draw_soft_divider'] = draw_inner_divider
draw_inner_divider = segment_copy.pop('draw_inner_divider', None)
if set_segment_highlighting(pl, colorscheme, segment_copy):
if set_segment_highlighting(pl, colorscheme, segment_copy, mode):
append(segment_copy)
else:
segment['contents'] = contents
if set_segment_highlighting(pl, colorscheme, segment):
if set_segment_highlighting(pl, colorscheme, segment, mode):
parsed_segments.append(segment)
elif segment['width'] == 'auto' or (segment['type'] == 'string' and segment['contents'] is not None):
if set_segment_highlighting(pl, colorscheme, segment):
if set_segment_highlighting(pl, colorscheme, segment, mode):
parsed_segments.append(segment)
always_true = lambda pl, segment_info, mode: True
def gen_segment_getter(pl, ext, common_config, theme_configs, default_module, get_module_attr, top_theme):
data = {
'default_module': default_module or 'powerline.segments.' + ext,
@ -229,12 +232,67 @@ def gen_segment_getter(pl, ext, common_config, theme_configs, default_module, ge
return get_segment_key(merge, segment, theme_configs, data['segment_data'], key, function_name, name, module, default)
data['get_key'] = get_key
def get_selector(function_name):
if '.' in function_name:
module, function_name = function_name.rpartition('.')[::2]
else:
module = 'powerline.selectors.' + ext
function = get_module_attr(module, function_name, prefix='segment_generator/selector_function')
if not function:
pl.error('Failed to get segment selector, ignoring it')
return function
def get_segment_selector(segment, selector_type):
try:
function_name = segment[selector_type + '_function']
except KeyError:
function = None
else:
function = get_selector(function_name)
try:
modes = segment[selector_type + '_modes']
except KeyError:
modes = None
if modes:
if function:
return lambda pl, segment_info, mode: (
mode in modes
or function(pl=pl, segment_info=segment_info, mode=mode)
)
else:
return lambda pl, segment_info, mode: mode in modes
else:
if function:
return lambda pl, segment_info, mode: (
function(pl=pl, segment_info=segment_info, mode=mode)
)
else:
return None
def gen_display_condition(segment):
include_function = get_segment_selector(segment, 'include')
exclude_function = get_segment_selector(segment, 'exclude')
if include_function:
if exclude_function:
return lambda *args: (
include_function(*args)
and not exclude_function(*args))
else:
return include_function
else:
if exclude_function:
return lambda *args: not exclude_function(*args)
else:
return always_true
def get(segment, side):
segment_type = segment.get('type', 'function')
try:
get_segment_info = segment_getters[segment_type]
except KeyError:
raise TypeError('Unknown segment type: {0}'.format(segment_type))
pl.error('Unknown segment type: {0}', segment_type)
return None
try:
contents, _contents_func, module, function_name, name = get_segment_info(data, segment)
@ -253,18 +311,27 @@ def gen_segment_getter(pl, ext, common_config, theme_configs, default_module, ge
pass
if segment_type == 'function':
highlight_group = [module + '.' + function_name, function_name]
highlight_group = [function_name]
else:
highlight_group = segment.get('highlight_group') or name
if segment_type in ('function', 'segment_list'):
args = dict(((str(k), v) for k, v in get_key(True, segment, module, function_name, name, 'args', {}).items()))
args = dict((
(str(k), v)
for k, v in
get_key(True, segment, module, function_name, name, 'args', {}).items()
))
display_condition = gen_display_condition(segment)
if segment_type == 'segment_list':
# Handle startup and shutdown of _contents_func?
subsegments = [
get(subsegment, side)
for subsegment in segment['segments']
subsegment
for subsegment in (
get(subsegment, side)
for subsegment in segment['segments']
) if subsegment
]
return {
'name': name or function_name,
@ -287,15 +354,13 @@ def gen_segment_getter(pl, ext, common_config, theme_configs, default_module, ge
'draw_hard_divider': None,
'draw_inner_divider': None,
'side': side,
'exclude_modes': segment.get('exclude_modes', []),
'include_modes': segment.get('include_modes', []),
'display_condition': display_condition,
'width': None,
'align': None,
'expand': None,
'truncate': None,
'startup': None,
'shutdown': None,
'mode': None,
'_rendered_raw': '',
'_rendered_hl': '',
'_len': None,
@ -337,15 +402,13 @@ def gen_segment_getter(pl, ext, common_config, theme_configs, default_module, ge
'draw_soft_divider': segment.get('draw_soft_divider', True),
'draw_inner_divider': segment.get('draw_inner_divider', False),
'side': side,
'exclude_modes': segment.get('exclude_modes', []),
'include_modes': segment.get('include_modes', []),
'display_condition': display_condition,
'width': segment.get('width'),
'align': segment.get('align', 'l'),
'expand': expand_func,
'truncate': truncate_func,
'startup': startup_func,
'shutdown': shutdown_func,
'mode': None,
'_rendered_raw': '',
'_rendered_hl': '',
'_len': None,

View File

@ -750,7 +750,7 @@ def user(pl, segment_info=None, hide_user=None):
euid = _geteuid()
return [{
'contents': username,
'highlight_group': 'user' if euid != 0 else ['superuser', 'user'],
'highlight_group': ['user'] if euid != 0 else ['superuser', 'user'],
}]
if 'psutil' not in globals():
user = requires_segment_info(user)
@ -966,7 +966,7 @@ class EmailIMAPSegment(KwThreadedSegment):
elif type(unread_count) != int or not max_msgs:
return [{
'contents': str(unread_count),
'highlight_group': 'email_alert',
'highlight_group': ['email_alert'],
}]
else:
return [{

View File

@ -29,7 +29,7 @@ def last_status(pl, segment_info):
'''
if not segment_info['args'].last_exit_code:
return None
return [{'contents': str(segment_info['args'].last_exit_code), 'highlight_group': 'exit_fail'}]
return [{'contents': str(segment_info['args'].last_exit_code), 'highlight_group': ['exit_fail']}]
@requires_segment_info
@ -40,8 +40,14 @@ def last_pipe_status(pl, segment_info):
'''
last_pipe_status = segment_info['args'].last_pipe_status
if any(last_pipe_status):
return [{'contents': str(status), 'highlight_group': 'exit_fail' if status else 'exit_success', 'draw_inner_divider': True}
for status in last_pipe_status]
return [
{
'contents': str(status),
'highlight_group': ['exit_fail' if status else 'exit_success'],
'draw_inner_divider': True
}
for status in last_pipe_status
]
else:
return None

View File

@ -14,7 +14,6 @@ except ImportError:
from powerline.bindings.vim import (vim_get_func, getbufvar, vim_getbufoption,
buffer_name, vim_getwinvar,
register_buffer_cache, current_tabpage,
list_tabpages,
list_tabpage_buffers_segment_info)
from powerline.theme import requires_segment_info, requires_filesystem_watcher
from powerline.lib import add_divider_highlight_group
@ -585,7 +584,7 @@ def trailing_whitespace(pl, segment_info):
@requires_segment_info
def tabnr(pl, segment_info, show_current=False):
def tabnr(pl, segment_info, show_current=True):
'''Show tabpage number
:param bool show_current:
@ -601,7 +600,7 @@ def tabnr(pl, segment_info, show_current=False):
@requires_segment_info
def bufnr(pl, segment_info, show_current=False):
def bufnr(pl, segment_info, show_current=True):
'''Show buffer number
:param bool show_current:
@ -613,7 +612,7 @@ def bufnr(pl, segment_info, show_current=False):
@requires_segment_info
def winnr(pl, segment_info, show_current=False):
def winnr(pl, segment_info, show_current=True):
'''Show window number
:param bool show_current:
@ -622,29 +621,3 @@ def winnr(pl, segment_info, show_current=False):
winnr = segment_info['winnr']
if show_current or winnr != vim.current.window.number:
return str(winnr)
def single_tab(pl, single_text='Bufs', multiple_text='Tabs'):
'''Show one text if there is only one tab and another if there are many
Mostly useful for tabline to indicate what kind of data is shown there.
:param str single_text:
Text displayed when there is only one tabpage. May be None if you do not
want to display anything.
:param str multiple_text:
Text displayed when there is more then one tabpage. May be None if you
do not want to display anything.
Highlight groups used: ``single_tab``, ``many_tabs``.
'''
if len(list_tabpages()) == 1:
return single_text and [{
'contents': single_text,
'highlight_group': ['single_tab'],
}]
else:
return multiple_text and [{
'contents': multiple_text,
'highlight_group': ['many_tabs'],
}]

View File

View File

@ -0,0 +1,10 @@
# vim:fileencoding=utf-8:noet
from __future__ import (unicode_literals, division, absolute_import, print_function)
from powerline.bindings.vim import list_tabpages
def single_tab(pl, segment_info, mode):
'''Returns True if Vim has only one tab opened
'''
return len(list_tabpages()) == 1

View File

@ -135,10 +135,7 @@ class Theme(object):
for side in [side] if side else ['left', 'right']:
parsed_segments = []
for segment in self.segments[line][side]:
# No segment-local modes at this point
if mode not in segment['exclude_modes'] and (
not segment['include_modes'] or mode in segment['include_modes']
):
if segment['display_condition'](self.pl, segment_info, mode):
process_segment(
self.pl,
side,

View File

@ -11,7 +11,7 @@ import tests.vim as vim_module
from tests import TestCase
from tests.lib.config_mock import get_powerline, get_powerline_raw, swap_attributes
from tests.lib import Args
from tests.lib import Args, replace_item
def highlighted_string(s, group, **kwargs):
@ -389,7 +389,7 @@ class TestThemeHierarchy(TestRender):
])
class TestModes(TestRender):
class TestDisplayCondition(TestRender):
@add_args
def test_include_modes(self, p, config):
config['themes/test/default']['segments'] = {
@ -432,13 +432,93 @@ class TestModes(TestRender):
self.assertRenderEqual(p, '{56} s1{6-}>>{--}', mode='m2')
self.assertRenderEqual(p, '{56} s2{6-}>>{--}', mode='m3')
@add_args
def test_exinclude_function_nonexistent_module(self, p, config):
config['themes/test/default']['segments'] = {
'left': [
highlighted_string('s1', 'g1', exclude_function='xxx_nonexistent_module.foo'),
highlighted_string('s2', 'g1', exclude_function='xxx_nonexistent_module.foo', include_function='xxx_nonexistent_module.bar'),
highlighted_string('s3', 'g1', include_function='xxx_nonexistent_module.bar'),
]
}
self.assertRenderEqual(p, '{56} s1{56}>{56}s2{56}>{56}s3{6-}>>{--}')
@add_args
def test_exinclude_function(self, p, config):
config['themes/test/default']['segments'] = {
'left': [
highlighted_string('s1', 'g1', exclude_function='mod.foo'),
highlighted_string('s2', 'g1', exclude_function='mod.foo', include_function='mod.bar'),
highlighted_string('s3', 'g1', include_function='mod.bar'),
]
}
launched = set()
fool = [None]
barl = [None]
def foo(*args, **kwargs):
launched.add('foo')
self.assertEqual(set(kwargs.keys()), set(('pl', 'segment_info', 'mode')))
self.assertEqual(args, ())
return fool[0]
def bar(*args, **kwargs):
launched.add('bar')
self.assertEqual(set(kwargs.keys()), set(('pl', 'segment_info', 'mode')))
self.assertEqual(args, ())
return barl[0]
with replace_item(sys.modules, 'mod', Args(foo=foo, bar=bar)):
fool[0] = True
barl[0] = True
self.assertRenderEqual(p, '{56} s3{6-}>>{--}')
self.assertEqual(launched, set(('foo', 'bar')))
fool[0] = False
barl[0] = True
self.assertRenderEqual(p, '{56} s1{56}>{56}s2{56}>{56}s3{6-}>>{--}')
self.assertEqual(launched, set(('foo', 'bar')))
fool[0] = False
barl[0] = False
self.assertRenderEqual(p, '{56} s1{6-}>>{--}')
self.assertEqual(launched, set(('foo', 'bar')))
fool[0] = True
barl[0] = False
self.assertRenderEqual(p, '{--}')
self.assertEqual(launched, set(('foo', 'bar')))
@add_args
def test_exinclude_modes_override_functions(self, p, config):
config['themes/test/default']['segments'] = {
'left': [
highlighted_string('s1', 'g1', exclude_function='mod.foo', exclude_modes=['m2']),
highlighted_string('s2', 'g1', exclude_function='mod.foo', include_modes=['m2']),
highlighted_string('s3', 'g1', include_function='mod.foo', exclude_modes=['m2']),
highlighted_string('s4', 'g1', include_function='mod.foo', include_modes=['m2']),
]
}
fool = [None]
def foo(*args, **kwargs):
return fool[0]
with replace_item(sys.modules, 'mod', Args(foo=foo)):
fool[0] = True
self.assertRenderEqual(p, '{56} s4{6-}>>{--}', mode='m2')
self.assertRenderEqual(p, '{56} s3{56}>{56}s4{6-}>>{--}', mode='m1')
fool[0] = False
self.assertRenderEqual(p, '{56} s2{56}>{56}s4{6-}>>{--}', mode='m2')
self.assertRenderEqual(p, '{56} s1{6-}>>{--}', mode='m1')
class TestSegmentAttributes(TestRender):
@add_args
def test_no_attributes(self, p, config):
def m1(divider=',', **kwargs):
return divider.join(kwargs.keys()) + divider
sys.modules['bar'] = Args(m1=m1)
config['themes/test/default']['segments'] = {
'left': [
{
@ -446,7 +526,8 @@ class TestSegmentAttributes(TestRender):
}
]
}
self.assertRenderEqual(p, '{56} pl,{6-}>>{--}')
with replace_item(sys.modules, 'bar', Args(m1=m1)):
self.assertRenderEqual(p, '{56} pl,{6-}>>{--}')
@add_args
def test_segment_datas(self, p, config):
@ -464,7 +545,6 @@ class TestSegmentAttributes(TestRender):
}
}
}
sys.modules['bar'] = Args(m1=m1)
config['themes/test/default']['segments'] = {
'left': [
{
@ -472,7 +552,8 @@ class TestSegmentAttributes(TestRender):
}
]
}
self.assertRenderEqual(p, '{56} pl;{6-}>>{--}')
with replace_item(sys.modules, 'bar', Args(m1=m1)):
self.assertRenderEqual(p, '{56} pl;{6-}>>{--}')
@add_args
def test_expand(self, p, config):
@ -483,7 +564,6 @@ class TestSegmentAttributes(TestRender):
return ('-' * amount) + segment['contents']
m1.expand = expand
sys.modules['bar'] = Args(m1=m1)
config['themes/test/default']['segments'] = {
'left': [
{
@ -492,7 +572,8 @@ class TestSegmentAttributes(TestRender):
}
]
}
self.assertRenderEqual(p, '{56} ----pl,{6-}>>{--}', width=10)
with replace_item(sys.modules, 'bar', Args(m1=m1)):
self.assertRenderEqual(p, '{56} ----pl,{6-}>>{--}', width=10)
@add_args
def test_truncate(self, p, config):
@ -503,7 +584,6 @@ class TestSegmentAttributes(TestRender):
return segment['contents'][:-amount]
m1.truncate = truncate
sys.modules['bar'] = Args(m1=m1)
config['themes/test/default']['segments'] = {
'left': [
{
@ -511,7 +591,8 @@ class TestSegmentAttributes(TestRender):
}
]
}
self.assertRenderEqual(p, '{56} p{6-}>>{--}', width=4)
with replace_item(sys.modules, 'bar', Args(m1=m1)):
self.assertRenderEqual(p, '{56} p{6-}>>{--}', width=4)
class TestSegmentData(TestRender):
@ -603,13 +684,13 @@ class TestVim(TestCase):
winnr = window.number
self.assertEqual(powerline.render(window, window_id, winnr), '%#Pl_5_12583104_6_32896_NONE#\xa0\u201cbar\u201d%#Pl_6_32896_NONE_None_NONE#>>')
@classmethod
def setUpClass(cls):
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
def setUpModule():
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
def tearDownModule():
sys.path.pop(0)
@classmethod
def tearDownClass(cls):
sys.path.pop(0)
if __name__ == '__main__':

View File

@ -18,7 +18,7 @@ VBLOCK = chr(ord('V') - 0x40)
SBLOCK = chr(ord('S') - 0x40)
class TestConfig(TestCase):
class TestVimConfig(TestCase):
def test_vim(self):
from powerline.vim import VimPowerline
cfg_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'powerline', 'config_files')
@ -76,6 +76,16 @@ class TestConfig(TestCase):
finally:
vim_module._start_mode('n')
@classmethod
def setUpClass(cls):
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
@classmethod
def tearDownClass(cls):
sys.path.pop(0)
class TestConfig(TestCase):
def test_tmux(self):
from powerline.segments import common
from imp import reload
@ -151,10 +161,7 @@ def setUpModule():
saved_get_config_paths = powerline.get_config_paths
path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'powerline', 'config_files')
powerline.get_config_paths = lambda: [path]
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
old_cwd = os.getcwd()
from powerline.segments import vim
globals()['vim'] = vim
def tearDownModule():
@ -164,7 +171,6 @@ def tearDownModule():
powerline.get_config_paths = saved_get_config_paths
os.chdir(old_cwd)
old_cwd = None
sys.path.pop(0)
if __name__ == '__main__':

View File

@ -15,9 +15,6 @@ from tests.lib import Args, urllib_read, replace_attr, new_module, replace_modul
from tests import TestCase, SkipTest
vim = None
def get_dummy_guess(**kwargs):
if 'directory' in kwargs:
def guess(path, create_watcher):
@ -33,7 +30,7 @@ class TestShell(TestCase):
pl = Pl()
segment_info = {'args': Args(last_exit_code=10)}
self.assertEqual(shell.last_status(pl=pl, segment_info=segment_info), [
{'contents': '10', 'highlight_group': 'exit_fail'}
{'contents': '10', 'highlight_group': ['exit_fail']}
])
segment_info['args'].last_exit_code = 0
self.assertEqual(shell.last_status(pl=pl, segment_info=segment_info), None)
@ -48,9 +45,9 @@ class TestShell(TestCase):
self.assertEqual(shell.last_pipe_status(pl=pl, segment_info=segment_info), None)
segment_info['args'].last_pipe_status = [0, 2, 0]
self.assertEqual(shell.last_pipe_status(pl=pl, segment_info=segment_info), [
{'contents': '0', 'highlight_group': 'exit_success', 'draw_inner_divider': True},
{'contents': '2', 'highlight_group': 'exit_fail', 'draw_inner_divider': True},
{'contents': '0', 'highlight_group': 'exit_success', 'draw_inner_divider': True}
{'contents': '0', 'highlight_group': ['exit_success'], 'draw_inner_divider': True},
{'contents': '2', 'highlight_group': ['exit_fail'], 'draw_inner_divider': True},
{'contents': '0', 'highlight_group': ['exit_success'], 'draw_inner_divider': True}
])
def test_jobnum(self):
@ -338,10 +335,10 @@ class TestCommon(TestCase):
with replace_attr(common, 'psutil', new_psutil):
with replace_attr(common, '_geteuid', lambda: 5):
self.assertEqual(common.user(pl=pl, segment_info=segment_info), [
{'contents': 'def', 'highlight_group': 'user'}
{'contents': 'def', 'highlight_group': ['user']}
])
self.assertEqual(common.user(pl=pl, segment_info=segment_info, hide_user='abc'), [
{'contents': 'def', 'highlight_group': 'user'}
{'contents': 'def', 'highlight_group': ['user']}
])
self.assertEqual(common.user(pl=pl, segment_info=segment_info, hide_user='def'), None)
with replace_attr(common, '_geteuid', lambda: 0):
@ -781,18 +778,18 @@ class TestVim(TestCase):
def test_mode(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.mode(pl=pl, segment_info=segment_info), 'NORMAL')
self.assertEqual(vim.mode(pl=pl, segment_info=segment_info, override={'i': 'INS'}), 'NORMAL')
self.assertEqual(vim.mode(pl=pl, segment_info=segment_info, override={'n': 'NORM'}), 'NORM')
self.assertEqual(self.vim.mode(pl=pl, segment_info=segment_info), 'NORMAL')
self.assertEqual(self.vim.mode(pl=pl, segment_info=segment_info, override={'i': 'INS'}), 'NORMAL')
self.assertEqual(self.vim.mode(pl=pl, segment_info=segment_info, override={'n': 'NORM'}), 'NORM')
with vim_module._with('mode', 'i') as segment_info:
self.assertEqual(vim.mode(pl=pl, segment_info=segment_info), 'INSERT')
self.assertEqual(self.vim.mode(pl=pl, segment_info=segment_info), 'INSERT')
with vim_module._with('mode', chr(ord('V') - 0x40)) as segment_info:
self.assertEqual(vim.mode(pl=pl, segment_info=segment_info), 'V-BLCK')
self.assertEqual(vim.mode(pl=pl, segment_info=segment_info, override={'^V': 'VBLK'}), 'VBLK')
self.assertEqual(self.vim.mode(pl=pl, segment_info=segment_info), 'V-BLCK')
self.assertEqual(self.vim.mode(pl=pl, segment_info=segment_info, override={'^V': 'VBLK'}), 'VBLK')
def test_visual_range(self):
pl = Pl()
vr = partial(vim.visual_range, pl=pl)
vr = partial(self.vim.visual_range, pl=pl)
vim_module.current.window.cursor = [0, 0]
try:
with vim_module._with('mode', 'i') as segment_info:
@ -839,116 +836,116 @@ class TestVim(TestCase):
def test_modified_indicator(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.modified_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.modified_indicator(pl=pl, segment_info=segment_info), None)
segment_info['buffer'][0] = 'abc'
try:
self.assertEqual(vim.modified_indicator(pl=pl, segment_info=segment_info), '+')
self.assertEqual(vim.modified_indicator(pl=pl, segment_info=segment_info, text='-'), '-')
self.assertEqual(self.vim.modified_indicator(pl=pl, segment_info=segment_info), '+')
self.assertEqual(self.vim.modified_indicator(pl=pl, segment_info=segment_info, text='-'), '-')
finally:
vim_module._bw(segment_info['bufnr'])
def test_paste_indicator(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.paste_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.paste_indicator(pl=pl, segment_info=segment_info), None)
with vim_module._with('options', paste=1):
self.assertEqual(vim.paste_indicator(pl=pl, segment_info=segment_info), 'PASTE')
self.assertEqual(vim.paste_indicator(pl=pl, segment_info=segment_info, text='P'), 'P')
self.assertEqual(self.vim.paste_indicator(pl=pl, segment_info=segment_info), 'PASTE')
self.assertEqual(self.vim.paste_indicator(pl=pl, segment_info=segment_info, text='P'), 'P')
def test_readonly_indicator(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.readonly_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.readonly_indicator(pl=pl, segment_info=segment_info), None)
with vim_module._with('bufoptions', readonly=1):
self.assertEqual(vim.readonly_indicator(pl=pl, segment_info=segment_info), 'RO')
self.assertEqual(vim.readonly_indicator(pl=pl, segment_info=segment_info, text='L'), 'L')
self.assertEqual(self.vim.readonly_indicator(pl=pl, segment_info=segment_info), 'RO')
self.assertEqual(self.vim.readonly_indicator(pl=pl, segment_info=segment_info, text='L'), 'L')
def test_file_scheme(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.file_scheme(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.file_scheme(pl=pl, segment_info=segment_info), None)
with vim_module._with('buffer', '/tmp//abc') as segment_info:
self.assertEqual(vim.file_scheme(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.file_scheme(pl=pl, segment_info=segment_info), None)
with vim_module._with('buffer', 'zipfile:/tmp/abc.zip::abc/abc.vim') as segment_info:
self.assertEqual(vim.file_scheme(pl=pl, segment_info=segment_info), 'zipfile')
self.assertEqual(self.vim.file_scheme(pl=pl, segment_info=segment_info), 'zipfile')
def test_file_directory(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), None)
with replace_env('HOME', '/home/foo', os.environ):
with vim_module._with('buffer', '/tmp//abc') as segment_info:
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), '/tmp//')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), '/tmp//')
with vim_module._with('buffer', b'/tmp/\xFF\xFF/abc') as segment_info:
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/<ff><ff>/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/<ff><ff>/')
with vim_module._with('buffer', '/tmp/abc') as segment_info:
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/')
os.environ['HOME'] = '/tmp'
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), '~/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), '~/')
with vim_module._with('buffer', 'zipfile:/tmp/abc.zip::abc/abc.vim') as segment_info:
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=False), 'zipfile:/tmp/abc.zip::abc/')
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=True), '/tmp/abc.zip::abc/')
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/abc.zip::abc/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=False), 'zipfile:/tmp/abc.zip::abc/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=True), '/tmp/abc.zip::abc/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/abc.zip::abc/')
os.environ['HOME'] = '/tmp'
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=False), 'zipfile:/tmp/abc.zip::abc/')
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=True), '/tmp/abc.zip::abc/')
self.assertEqual(vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/abc.zip::abc/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=False), 'zipfile:/tmp/abc.zip::abc/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info, remove_scheme=True), '/tmp/abc.zip::abc/')
self.assertEqual(self.vim.file_directory(pl=pl, segment_info=segment_info), '/tmp/abc.zip::abc/')
def test_file_name(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.file_name(pl=pl, segment_info=segment_info), None)
self.assertEqual(vim.file_name(pl=pl, segment_info=segment_info, display_no_file=True), [
self.assertEqual(self.vim.file_name(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.file_name(pl=pl, segment_info=segment_info, display_no_file=True), [
{'contents': '[No file]', 'highlight_group': ['file_name_no_file', 'file_name']}
])
self.assertEqual(vim.file_name(pl=pl, segment_info=segment_info, display_no_file=True, no_file_text='X'), [
self.assertEqual(self.vim.file_name(pl=pl, segment_info=segment_info, display_no_file=True, no_file_text='X'), [
{'contents': 'X', 'highlight_group': ['file_name_no_file', 'file_name']}
])
with vim_module._with('buffer', '/tmp/abc') as segment_info:
self.assertEqual(vim.file_name(pl=pl, segment_info=segment_info), 'abc')
self.assertEqual(self.vim.file_name(pl=pl, segment_info=segment_info), 'abc')
with vim_module._with('buffer', '/tmp/') as segment_info:
self.assertEqual(vim.file_name(pl=pl, segment_info=segment_info), '')
self.assertEqual(self.vim.file_name(pl=pl, segment_info=segment_info), '')
with vim_module._with('buffer', b'/tmp/\xFF\xFF') as segment_info:
self.assertEqual(vim.file_name(pl=pl, segment_info=segment_info), '<ff><ff>')
self.assertEqual(self.vim.file_name(pl=pl, segment_info=segment_info), '<ff><ff>')
def test_file_size(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.file_size(pl=pl, segment_info=segment_info), '0 B')
self.assertEqual(self.vim.file_size(pl=pl, segment_info=segment_info), '0 B')
with vim_module._with('buffer', os.path.join(os.path.dirname(__file__), 'empty')) as segment_info:
self.assertEqual(vim.file_size(pl=pl, segment_info=segment_info), '0 B')
self.assertEqual(self.vim.file_size(pl=pl, segment_info=segment_info), '0 B')
def test_file_opts(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.file_format(pl=pl, segment_info=segment_info), [
self.assertEqual(self.vim.file_format(pl=pl, segment_info=segment_info), [
{'divider_highlight_group': 'background:divider', 'contents': 'unix'}
])
self.assertEqual(vim.file_encoding(pl=pl, segment_info=segment_info), [
self.assertEqual(self.vim.file_encoding(pl=pl, segment_info=segment_info), [
{'divider_highlight_group': 'background:divider', 'contents': 'utf-8'}
])
self.assertEqual(vim.file_type(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.file_type(pl=pl, segment_info=segment_info), None)
with vim_module._with('bufoptions', filetype='python'):
self.assertEqual(vim.file_type(pl=pl, segment_info=segment_info), [
self.assertEqual(self.vim.file_type(pl=pl, segment_info=segment_info), [
{'divider_highlight_group': 'background:divider', 'contents': 'python'}
])
def test_window_title(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.window_title(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.window_title(pl=pl, segment_info=segment_info), None)
with vim_module._with('wvars', quickfix_title='Abc'):
self.assertEqual(vim.window_title(pl=pl, segment_info=segment_info), 'Abc')
self.assertEqual(self.vim.window_title(pl=pl, segment_info=segment_info), 'Abc')
def test_line_percent(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
segment_info['buffer'][0:-1] = [str(i) for i in range(100)]
try:
self.assertEqual(vim.line_percent(pl=pl, segment_info=segment_info), '1')
self.assertEqual(self.vim.line_percent(pl=pl, segment_info=segment_info), '1')
vim_module._set_cursor(50, 0)
self.assertEqual(vim.line_percent(pl=pl, segment_info=segment_info), '50')
self.assertEqual(vim.line_percent(pl=pl, segment_info=segment_info, gradient=True), [
self.assertEqual(self.vim.line_percent(pl=pl, segment_info=segment_info), '50')
self.assertEqual(self.vim.line_percent(pl=pl, segment_info=segment_info, gradient=True), [
{'contents': '50', 'highlight_group': ['line_percent_gradient', 'line_percent'], 'gradient_level': 50 * 100.0 / 101}
])
finally:
@ -959,9 +956,9 @@ class TestVim(TestCase):
segment_info = vim_module._get_segment_info()
segment_info['buffer'][0:-1] = [str(i) for i in range(99)]
try:
self.assertEqual(vim.line_count(pl=pl, segment_info=segment_info), '100')
self.assertEqual(self.vim.line_count(pl=pl, segment_info=segment_info), '100')
vim_module._set_cursor(50, 0)
self.assertEqual(vim.line_count(pl=pl, segment_info=segment_info), '100')
self.assertEqual(self.vim.line_count(pl=pl, segment_info=segment_info), '100')
finally:
vim_module._bw(segment_info['bufnr'])
@ -971,18 +968,18 @@ class TestVim(TestCase):
try:
segment_info['buffer'][0:-1] = [str(i) for i in range(99)]
vim_module._set_cursor(49, 0)
self.assertEqual(vim.position(pl=pl, segment_info=segment_info), '50%')
self.assertEqual(vim.position(pl=pl, segment_info=segment_info, gradient=True), [
self.assertEqual(self.vim.position(pl=pl, segment_info=segment_info), '50%')
self.assertEqual(self.vim.position(pl=pl, segment_info=segment_info, gradient=True), [
{'contents': '50%', 'highlight_group': ['position_gradient', 'position'], 'gradient_level': 50.0}
])
vim_module._set_cursor(0, 0)
self.assertEqual(vim.position(pl=pl, segment_info=segment_info), 'Top')
self.assertEqual(self.vim.position(pl=pl, segment_info=segment_info), 'Top')
vim_module._set_cursor(97, 0)
self.assertEqual(vim.position(pl=pl, segment_info=segment_info, position_strings={'top': 'Comienzo', 'bottom': 'Final', 'all': 'Todo'}), 'Final')
self.assertEqual(self.vim.position(pl=pl, segment_info=segment_info, position_strings={'top': 'Comienzo', 'bottom': 'Final', 'all': 'Todo'}), 'Final')
segment_info['buffer'][0:-1] = [str(i) for i in range(2)]
vim_module._set_cursor(0, 0)
self.assertEqual(vim.position(pl=pl, segment_info=segment_info, position_strings={'top': 'Comienzo', 'bottom': 'Final', 'all': 'Todo'}), 'Todo')
self.assertEqual(vim.position(pl=pl, segment_info=segment_info, gradient=True), [
self.assertEqual(self.vim.position(pl=pl, segment_info=segment_info, position_strings={'top': 'Comienzo', 'bottom': 'Final', 'all': 'Todo'}), 'Todo')
self.assertEqual(self.vim.position(pl=pl, segment_info=segment_info, gradient=True), [
{'contents': 'All', 'highlight_group': ['position_gradient', 'position'], 'gradient_level': 0.0}
])
finally:
@ -991,34 +988,34 @@ class TestVim(TestCase):
def test_cursor_current(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.line_current(pl=pl, segment_info=segment_info), '1')
self.assertEqual(vim.col_current(pl=pl, segment_info=segment_info), '1')
self.assertEqual(vim.virtcol_current(pl=pl, segment_info=segment_info), [{
self.assertEqual(self.vim.line_current(pl=pl, segment_info=segment_info), '1')
self.assertEqual(self.vim.col_current(pl=pl, segment_info=segment_info), '1')
self.assertEqual(self.vim.virtcol_current(pl=pl, segment_info=segment_info), [{
'highlight_group': ['virtcol_current_gradient', 'virtcol_current', 'col_current'], 'contents': '1', 'gradient_level': 100.0 / 80,
}])
self.assertEqual(vim.virtcol_current(pl=pl, segment_info=segment_info, gradient=False), [{
self.assertEqual(self.vim.virtcol_current(pl=pl, segment_info=segment_info, gradient=False), [{
'highlight_group': ['virtcol_current', 'col_current'], 'contents': '1',
}])
def test_modified_buffers(self):
pl = Pl()
self.assertEqual(vim.modified_buffers(pl=pl), None)
self.assertEqual(self.vim.modified_buffers(pl=pl), None)
def test_branch(self):
pl = Pl()
create_watcher = get_fallback_create_watcher()
branch = partial(vim.branch, pl=pl, create_watcher=create_watcher)
branch = partial(self.vim.branch, pl=pl, create_watcher=create_watcher)
with vim_module._with('buffer', '/foo') as segment_info:
with replace_attr(vim, 'guess', get_dummy_guess(status=lambda: None)):
with replace_attr(vim, 'tree_status', lambda repo, pl: None):
with replace_attr(self.vim, 'guess', get_dummy_guess(status=lambda: None)):
with replace_attr(self.vim, 'tree_status', lambda repo, pl: None):
self.assertEqual(branch(segment_info=segment_info, status_colors=False), [
{'divider_highlight_group': 'branch:divider', 'highlight_group': ['branch'], 'contents': 'foo'}
])
self.assertEqual(branch(segment_info=segment_info, status_colors=True), [
{'divider_highlight_group': 'branch:divider', 'highlight_group': ['branch_clean', 'branch'], 'contents': 'foo'}
])
with replace_attr(vim, 'guess', get_dummy_guess(status=lambda: 'DU')):
with replace_attr(vim, 'tree_status', lambda repo, pl: 'DU'):
with replace_attr(self.vim, 'guess', get_dummy_guess(status=lambda: 'DU')):
with replace_attr(self.vim, 'tree_status', lambda repo, pl: 'DU'):
self.assertEqual(branch(segment_info=segment_info, status_colors=False), [
{'divider_highlight_group': 'branch:divider', 'highlight_group': ['branch'], 'contents': 'foo'}
])
@ -1029,23 +1026,23 @@ class TestVim(TestCase):
def test_file_vcs_status(self):
pl = Pl()
create_watcher = get_fallback_create_watcher()
file_vcs_status = partial(vim.file_vcs_status, pl=pl, create_watcher=create_watcher)
file_vcs_status = partial(self.vim.file_vcs_status, pl=pl, create_watcher=create_watcher)
with vim_module._with('buffer', '/foo') as segment_info:
with replace_attr(vim, 'guess', get_dummy_guess(status=lambda file: 'M')):
with replace_attr(self.vim, 'guess', get_dummy_guess(status=lambda file: 'M')):
self.assertEqual(file_vcs_status(segment_info=segment_info), [
{'highlight_group': ['file_vcs_status_M', 'file_vcs_status'], 'contents': 'M'}
])
with replace_attr(vim, 'guess', get_dummy_guess(status=lambda file: None)):
with replace_attr(self.vim, 'guess', get_dummy_guess(status=lambda file: None)):
self.assertEqual(file_vcs_status(segment_info=segment_info), None)
with vim_module._with('buffer', '/bar') as segment_info:
with vim_module._with('bufoptions', buftype='nofile'):
with replace_attr(vim, 'guess', get_dummy_guess(status=lambda file: 'M')):
with replace_attr(self.vim, 'guess', get_dummy_guess(status=lambda file: 'M')):
self.assertEqual(file_vcs_status(segment_info=segment_info), None)
def test_trailing_whitespace(self):
pl = Pl()
with vim_module._with('buffer', 'tws') as segment_info:
trailing_whitespace = partial(vim.trailing_whitespace, pl=pl, segment_info=segment_info)
trailing_whitespace = partial(self.vim.trailing_whitespace, pl=pl, segment_info=segment_info)
self.assertEqual(trailing_whitespace(), None)
self.assertEqual(trailing_whitespace(), None)
vim_module.current.buffer[0] = ' '
@ -1064,57 +1061,54 @@ class TestVim(TestCase):
def test_tabnr(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.tabnr(pl=pl, segment_info=segment_info, show_current=True), '1')
self.assertEqual(vim.tabnr(pl=pl, segment_info=segment_info, show_current=False), None)
self.assertEqual(self.vim.tabnr(pl=pl, segment_info=segment_info, show_current=True), '1')
self.assertEqual(self.vim.tabnr(pl=pl, segment_info=segment_info, show_current=False), None)
def test_bufnr(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.bufnr(pl=pl, segment_info=segment_info, show_current=True), str(segment_info['bufnr']))
self.assertEqual(vim.bufnr(pl=pl, segment_info=segment_info, show_current=False), None)
self.assertEqual(self.vim.bufnr(pl=pl, segment_info=segment_info, show_current=True), str(segment_info['bufnr']))
self.assertEqual(self.vim.bufnr(pl=pl, segment_info=segment_info, show_current=False), None)
def test_winnr(self):
pl = Pl()
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.winnr(pl=pl, segment_info=segment_info, show_current=True), str(segment_info['winnr']))
self.assertEqual(vim.winnr(pl=pl, segment_info=segment_info, show_current=False), None)
def test_single_tab(self):
pl = Pl()
single_tab = partial(vim.single_tab, pl=pl)
with vim_module._with('tabpage'):
self.assertEqual(single_tab(), [{'highlight_group': ['many_tabs'], 'contents': 'Tabs'}])
self.assertEqual(single_tab(single_text='s', multiple_text='m'), [{'highlight_group': ['many_tabs'], 'contents': 'm'}])
self.assertEqual(single_tab(multiple_text='m'), [{'highlight_group': ['many_tabs'], 'contents': 'm'}])
self.assertEqual(single_tab(single_text='s'), [{'highlight_group': ['many_tabs'], 'contents': 'Tabs'}])
self.assertEqual(single_tab(), [{'highlight_group': ['single_tab'], 'contents': 'Bufs'}])
self.assertEqual(single_tab(single_text='s', multiple_text='m'), [{'highlight_group': ['single_tab'], 'contents': 's'}])
self.assertEqual(single_tab(multiple_text='m'), [{'highlight_group': ['single_tab'], 'contents': 'Bufs'}])
self.assertEqual(single_tab(single_text='s'), [{'highlight_group': ['single_tab'], 'contents': 's'}])
self.assertEqual(self.vim.winnr(pl=pl, segment_info=segment_info, show_current=True), str(segment_info['winnr']))
self.assertEqual(self.vim.winnr(pl=pl, segment_info=segment_info, show_current=False), None)
def test_segment_info(self):
pl = Pl()
with vim_module._with('tabpage'):
with vim_module._with('buffer', '1') as segment_info:
self.assertEqual(vim.tab_modified_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.tab_modified_indicator(pl=pl, segment_info=segment_info), None)
vim_module.current.buffer[0] = ' '
self.assertEqual(vim.tab_modified_indicator(pl=pl, segment_info=segment_info), [{
self.assertEqual(self.vim.tab_modified_indicator(pl=pl, segment_info=segment_info), [{
'contents': '+',
'highlight_group': ['tab_modified_indicator', 'modified_indicator'],
}])
vim_module._undo()
self.assertEqual(vim.tab_modified_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.tab_modified_indicator(pl=pl, segment_info=segment_info), None)
old_buffer = vim_module.current.buffer
vim_module._new('2')
segment_info = vim_module._get_segment_info()
self.assertEqual(vim.tab_modified_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.tab_modified_indicator(pl=pl, segment_info=segment_info), None)
old_buffer[0] = ' '
self.assertEqual(vim.modified_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(vim.tab_modified_indicator(pl=pl, segment_info=segment_info), [{
self.assertEqual(self.vim.modified_indicator(pl=pl, segment_info=segment_info), None)
self.assertEqual(self.vim.tab_modified_indicator(pl=pl, segment_info=segment_info), [{
'contents': '+',
'highlight_group': ['tab_modified_indicator', 'modified_indicator'],
}])
@classmethod
def setUpClass(cls):
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
from powerline.segments import vim
cls.vim = vim
@classmethod
def tearDownClass(cls):
sys.path.pop(0)
old_cwd = None
@ -1122,18 +1116,14 @@ old_cwd = None
def setUpModule():
global old_cwd
global __file__
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
old_cwd = os.getcwd()
__file__ = os.path.abspath(__file__)
os.chdir(os.path.dirname(__file__))
from powerline.segments import vim
globals()['vim'] = vim
def tearDownModule():
global old_cwd
os.chdir(old_cwd)
sys.path.pop(0)
if __name__ == '__main__':

36
tests/test_selectors.py Normal file
View File

@ -0,0 +1,36 @@
# vim:fileencoding=utf-8:noet
from __future__ import (unicode_literals, division, absolute_import, print_function)
import os
import sys
from functools import partial
import tests.vim as vim_module
from tests.lib import Pl
from tests import TestCase
class TestVim(TestCase):
def test_single_tab(self):
pl = Pl()
single_tab = partial(self.vim.single_tab, pl=pl, segment_info=None, mode=None)
with vim_module._with('tabpage'):
self.assertEqual(single_tab(), False)
self.assertEqual(single_tab(), True)
@classmethod
def setUpClass(cls):
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'path')))
from powerline.selectors import vim
cls.vim = vim
@classmethod
def tearDownClass(cls):
sys.path.pop(0)
if __name__ == '__main__':
from tests import main
main()

View File

@ -16,7 +16,7 @@ catch
cquit
endtry
if result isnot# '%#Pl_240_5789784_235_2500134_NONE# 1 %#Pl_240_5789784_235_2500134_NONE#./%#Pl_244_8421504_235_2500134_bold#abc %#Pl_244_8421504_235_2500134_NONE# %#Pl_240_5789784_235_2500134_NONE#2 %#Pl_240_5789784_235_2500134_NONE#./%#Pl_244_8421504_235_2500134_bold#def %#Pl_235_2500134_240_5789784_NONE# %#Pl_250_12369084_240_5789784_NONE#./%#Pl_231_16777215_240_5789784_bold#ghi %#Pl_240_5789784_236_3158064_NONE# %#Pl_231_16777215_236_3158064_NONE#                                           %#Pl_252_13684944_236_3158064_NONE# %#Pl_235_2500134_252_13684944_bold# Tabs '
if result isnot# '%#Pl_247_10395294_236_3158064_NONE# 1 ./abc  2 ./def %#Pl_236_3158064_240_5789784_NONE# %#Pl_250_12369084_240_5789784_NONE#3 ./%#Pl_231_16777215_240_5789784_bold#ghi %#Pl_240_5789784_236_3158064_NONE# %#Pl_231_16777215_236_3158064_NONE#                                         %#Pl_252_13684944_236_3158064_NONE# %#Pl_235_2500134_252_13684944_bold# Tabs '
call writefile(['Unexpected tabline', result], 'message.fail')
cquit
endif
@ -30,7 +30,7 @@ catch
cquit
endtry
if result isnot# '%#Pl_240_5789784_235_2500134_NONE# 1 %#Pl_240_5789784_235_2500134_NONE#./%#Pl_244_8421504_235_2500134_bold#abc %#Pl_244_8421504_235_2500134_NONE# %#Pl_240_5789784_235_2500134_NONE#2 %#Pl_240_5789784_235_2500134_NONE#./%#Pl_244_8421504_235_2500134_bold#def %#Pl_235_2500134_240_5789784_NONE# %#Pl_250_12369084_240_5789784_NONE#./%#Pl_231_16777215_240_5789784_bold#ghi %#Pl_240_5789784_236_3158064_NONE# %#Pl_231_16777215_236_3158064_NONE#                                           %#Pl_252_13684944_236_3158064_NONE# %#Pl_235_2500134_252_13684944_bold# Bufs '
if result isnot# '%#Pl_247_10395294_236_3158064_NONE# 1 ./abc  2 ./def %#Pl_236_3158064_240_5789784_NONE# %#Pl_250_12369084_240_5789784_NONE#3 ./%#Pl_231_16777215_240_5789784_bold#ghi %#Pl_240_5789784_236_3158064_NONE# %#Pl_231_16777215_236_3158064_NONE#                                         %#Pl_252_13684944_236_3158064_NONE# %#Pl_235_2500134_252_13684944_bold# Bufs '
call writefile(['Unexpected tabline (2)', result], 'message.fail')
cquit
endif
@ -42,7 +42,7 @@ catch
call writefile(['Exception while evaluating &tabline (3)', v:exception], 'message.fail')
endtry
if result isnot# '%#Pl_240_5789784_235_2500134_NONE# 1 %#Pl_240_5789784_235_2500134_NONE#./%#Pl_244_8421504_235_2500134_bold#abc %#Pl_244_8421504_235_2500134_NONE# %#Pl_240_5789784_235_2500134_NONE#2 %#Pl_240_5789784_235_2500134_NONE#./%#Pl_244_8421504_235_2500134_bold#def %#Pl_235_2500134_240_5789784_NONE# %#Pl_250_12369084_240_5789784_NONE#./%#Pl_231_16777215_240_5789784_bold#ghi %#Pl_240_5789784_236_3158064_NONE# %#Pl_231_16777215_236_3158064_NONE#                                           %#Pl_252_13684944_236_3158064_NONE# %#Pl_235_2500134_252_13684944_bold# Bufs '
if result isnot# '%#Pl_247_10395294_236_3158064_NONE# 1 ./abc  2 ./def %#Pl_236_3158064_240_5789784_NONE# %#Pl_250_12369084_240_5789784_NONE#3 ./%#Pl_231_16777215_240_5789784_bold#ghi %#Pl_240_5789784_236_3158064_NONE# %#Pl_231_16777215_236_3158064_NONE#                                         %#Pl_252_13684944_236_3158064_NONE# %#Pl_235_2500134_252_13684944_bold# Bufs '
call writefile(['Unexpected tabline (3)', result], 'message.fail')
cquit
endif