--- /dev/null
+"""Code shared between the API classes."""
+import functools
+
+from msgpack import unpackb
+
+from pynvim.compat import unicode_errors_default
+
+__all__ = ()
+
+
+class NvimError(Exception):
+ pass
+
+
+class Remote(object):
+
+ """Base class for Nvim objects(buffer/window/tabpage).
+
+ Each type of object has it's own specialized class with API wrappers around
+ the msgpack-rpc session. This implements equality which takes the remote
+ object handle into consideration.
+ """
+
+ def __init__(self, session, code_data):
+ """Initialize from session and code_data immutable object.
+
+ The `code_data` contains serialization information required for
+ msgpack-rpc calls. It must be immutable for Buffer equality to work.
+ """
+ self._session = session
+ self.code_data = code_data
+ self.handle = unpackb(code_data[1])
+ self.api = RemoteApi(self, self._api_prefix)
+ self.vars = RemoteMap(self, self._api_prefix + 'get_var',
+ self._api_prefix + 'set_var',
+ self._api_prefix + 'del_var')
+ self.options = RemoteMap(self, self._api_prefix + 'get_option',
+ self._api_prefix + 'set_option')
+
+ def __repr__(self):
+ """Get text representation of the object."""
+ return '<%s(handle=%r)>' % (
+ self.__class__.__name__,
+ self.handle,
+ )
+
+ def __eq__(self, other):
+ """Return True if `self` and `other` are the same object."""
+ return (hasattr(other, 'code_data')
+ and other.code_data == self.code_data)
+
+ def __hash__(self):
+ """Return hash based on remote object id."""
+ return self.code_data.__hash__()
+
+ def request(self, name, *args, **kwargs):
+ """Wrapper for nvim.request."""
+ return self._session.request(name, self, *args, **kwargs)
+
+
+class RemoteApi(object):
+
+ """Wrapper to allow api methods to be called like python methods."""
+
+ def __init__(self, obj, api_prefix):
+ """Initialize a RemoteApi with object and api prefix."""
+ self._obj = obj
+ self._api_prefix = api_prefix
+
+ def __getattr__(self, name):
+ """Return wrapper to named api method."""
+ return functools.partial(self._obj.request, self._api_prefix + name)
+
+
+def transform_keyerror(exc):
+ if isinstance(exc, NvimError):
+ if exc.args[0].startswith('Key not found:'):
+ return KeyError(exc.args[0])
+ if exc.args[0].startswith('Invalid option name:'):
+ return KeyError(exc.args[0])
+ return exc
+
+
+class RemoteMap(object):
+ """Represents a string->object map stored in Nvim.
+
+ This is the dict counterpart to the `RemoteSequence` class, but it is used
+ as a generic way of retrieving values from the various map-like data
+ structures present in Nvim.
+
+ It is used to provide a dict-like API to vim variables and options.
+ """
+
+ _set = None
+ _del = None
+
+ def __init__(self, obj, get_method, set_method=None, del_method=None):
+ """Initialize a RemoteMap with session, getter/setter."""
+ self._get = functools.partial(obj.request, get_method)
+ if set_method:
+ self._set = functools.partial(obj.request, set_method)
+ if del_method:
+ self._del = functools.partial(obj.request, del_method)
+
+ def __getitem__(self, key):
+ """Return a map value by key."""
+ try:
+ return self._get(key)
+ except NvimError as exc:
+ raise transform_keyerror(exc)
+
+ def __setitem__(self, key, value):
+ """Set a map value by key(if the setter was provided)."""
+ if not self._set:
+ raise TypeError('This dict is read-only')
+ self._set(key, value)
+
+ def __delitem__(self, key):
+ """Delete a map value by associating None with the key."""
+ if not self._del:
+ raise TypeError('This dict is read-only')
+ try:
+ return self._del(key)
+ except NvimError as exc:
+ raise transform_keyerror(exc)
+
+ def __contains__(self, key):
+ """Check if key is present in the map."""
+ try:
+ self._get(key)
+ return True
+ except Exception:
+ return False
+
+ def get(self, key, default=None):
+ """Return value for key if present, else a default value."""
+ try:
+ return self.__getitem__(key)
+ except KeyError:
+ return default
+
+
+class RemoteSequence(object):
+
+ """Represents a sequence of objects stored in Nvim.
+
+ This class is used to wrap msgapck-rpc functions that work on Nvim
+ sequences(of lines, buffers, windows and tabpages) with an API that
+ is similar to the one provided by the python-vim interface.
+
+ For example, the 'windows' property of the `Nvim` class is a RemoteSequence
+ sequence instance, and the expression `nvim.windows[0]` is translated to
+ session.request('nvim_list_wins')[0].
+
+ One important detail about this class is that all methods will fetch the
+ sequence into a list and perform the necessary manipulation
+ locally(iteration, indexing, counting, etc).
+ """
+
+ def __init__(self, session, method):
+ """Initialize a RemoteSequence with session, method."""
+ self._fetch = functools.partial(session.request, method)
+
+ def __len__(self):
+ """Return the length of the remote sequence."""
+ return len(self._fetch())
+
+ def __getitem__(self, idx):
+ """Return a sequence item by index."""
+ if not isinstance(idx, slice):
+ return self._fetch()[idx]
+ return self._fetch()[idx.start:idx.stop]
+
+ def __iter__(self):
+ """Return an iterator for the sequence."""
+ items = self._fetch()
+ for item in items:
+ yield item
+
+ def __contains__(self, item):
+ """Check if an item is present in the sequence."""
+ return item in self._fetch()
+
+
+def _identity(obj, session, method, kind):
+ return obj
+
+
+def decode_if_bytes(obj, mode=True):
+ """Decode obj if it is bytes."""
+ if mode is True:
+ mode = unicode_errors_default
+ if isinstance(obj, bytes):
+ return obj.decode("utf-8", errors=mode)
+ return obj
+
+
+def walk(fn, obj, *args, **kwargs):
+ """Recursively walk an object graph applying `fn`/`args` to objects."""
+ if type(obj) in [list, tuple]:
+ return list(walk(fn, o, *args) for o in obj)
+ if type(obj) is dict:
+ return dict((walk(fn, k, *args), walk(fn, v, *args)) for k, v in
+ obj.items())
+ return fn(obj, *args, **kwargs)
projects / dotfiles / .git / blobdiff