cola/gitcfg.py

   1 from __future__ import division, absolute_import, unicode_literals
   2
   3 import copy
   4 import fnmatch
   5 import os
   6 import re
   7 import struct
   8 from binascii import unhexlify
   9 from os.path import join
  10
  11 from . import core
  12 from . import git
  13 from . import observable
  14 from .compat import int_types
  15 from .decorators import memoize
  16 from .git import STDOUT
  17 from .compat import ustr
  18
  19 BUILTIN_READER = os.environ.get('GIT_COLA_BUILTIN_CONFIG_READER', False)
  20
  21 _USER_CONFIG = core.expanduser(join('~', '.gitconfig'))
  22 _USER_XDG_CONFIG = core.expanduser(
  23         join(core.getenv('XDG_CONFIG_HOME', join('~', '.config')),
  24              'git', 'config'))
  25
  26
  27 @memoize
  28 def current():
  29     """Return the GitConfig singleton."""
  30     return GitConfig()
  31
  32
  33 def _stat_info():
  34     # Try /etc/gitconfig as a fallback for the system config
  35     paths = [('system', '/etc/gitconfig'),
  36              ('user', _USER_XDG_CONFIG),
  37              ('user', _USER_CONFIG)]
  38     config = git.current().git_path('config')
  39     if config:
  40         paths.append(('repo', config))
  41
  42     statinfo = []
  43     for category, path in paths:
  44         try:
  45             statinfo.append((category, path, core.stat(path).st_mtime))
  46         except OSError:
  47             continue
  48     return statinfo
  49
  50
  51 def _cache_key():
  52     # Try /etc/gitconfig as a fallback for the system config
  53     paths = ['/etc/gitconfig',
  54              _USER_XDG_CONFIG,
  55              _USER_CONFIG]
  56     config = git.current().git_path('config')
  57     if config:
  58         paths.append(config)
  59
  60     mtimes = []
  61     for path in paths:
  62         try:
  63             mtimes.append(core.stat(path).st_mtime)
  64         except OSError:
  65             continue
  66     return mtimes
  67
  68
  69 def _config_to_python(v):
  70     """Convert a Git config string into a Python value"""
  71
  72     if v in ('true', 'yes'):
  73         v = True
  74     elif v in ('false', 'no'):
  75         v = False
  76     else:
  77         try:
  78             v = int(v)
  79         except ValueError:
  80             pass
  81     return v
  82
  83
  84 def _config_key_value(line, splitchar):
  85     """Split a config line into a (key, value) pair"""
  86
  87     try:
  88         k, v = line.split(splitchar, 1)
  89     except ValueError:
  90         # the user has a emptyentry in their git config,
  91         # which Git interprets as meaning "true"
  92         k = line
  93         v = 'true'
  94     return k, _config_to_python(v)
  95
  96
  97 class GitConfig(observable.Observable):
  98     """Encapsulate access to git-config values."""
  99
 100     message_user_config_changed = 'user_config_changed'
 101     message_repo_config_changed = 'repo_config_changed'
 102
 103     def __init__(self):
 104         observable.Observable.__init__(self)
 105         self.git = git.current()
 106         self._map = {}
 107         self._system = {}
 108         self._user = {}
 109         self._user_or_system = {}
 110         self._repo = {}
 111         self._all = {}
 112         self._cache_key = None
 113         self._configs = []
 114         self._config_files = {}
 115         self._value_cache = {}
 116         self._attr_cache = {}
 117         self._find_config_files()
 118
 119     def reset(self):
 120         self._map.clear()
 121         self._system.clear()
 122         self._user.clear()
 123         self._user_or_system.clear()
 124         self._repo.clear()
 125         self._all.clear()
 126         self._cache_key = None
 127         self._configs = []
 128         self._config_files.clear()
 129         self._value_cache = {}
 130         self._attr_cache = {}
 131         self._find_config_files()
 132
 133     def user(self):
 134         return copy.deepcopy(self._user)
 135
 136     def repo(self):
 137         return copy.deepcopy(self._repo)
 138
 139     def all(self):
 140         return copy.deepcopy(self._all)
 141
 142     def _find_config_files(self):
 143         """
 144         Classify git config files into 'system', 'user', and 'repo'.
 145
 146         Populates self._configs with a list of the files in
 147         reverse-precedence order.  self._config_files is populated with
 148         {category: path} where category is one of 'system', 'user', or 'repo'.
 149
 150         """
 151         # Try the git config in git's installation prefix
 152         statinfo = _stat_info()
 153         self._configs = [x[1] for x in statinfo]
 154         self._config_files = {}
 155         for (cat, path, mtime) in statinfo:
 156             self._config_files[cat] = path
 157
 158     def update(self):
 159         """Read config values from git."""
 160         if self._cached():
 161             return
 162         self._read_configs()
 163
 164     def _cached(self):
 165         """
 166         Return True when the cache matches.
 167
 168         Updates the cache and returns False when the cache does not match.
 169
 170         """
 171         cache_key = _cache_key()
 172         if self._cache_key is None or cache_key != self._cache_key:
 173             self._cache_key = cache_key
 174             return False
 175         return True
 176
 177     def _read_configs(self):
 178         """Read git config value into the system, user and repo dicts."""
 179         self._map.clear()
 180         self._system.clear()
 181         self._user.clear()
 182         self._user_or_system.clear()
 183         self._repo.clear()
 184         self._all.clear()
 185
 186         if 'system' in self._config_files:
 187             self._system.update(
 188                     self.read_config(self._config_files['system']))
 189
 190         if 'user' in self._config_files:
 191             self._user.update(
 192                     self.read_config(self._config_files['user']))
 193
 194         if 'repo' in self._config_files:
 195             self._repo.update(
 196                     self.read_config(self._config_files['repo']))
 197
 198         for dct in (self._system, self._user):
 199             self._user_or_system.update(dct)
 200
 201         for dct in (self._system, self._user, self._repo):
 202             self._all.update(dct)
 203
 204     def read_config(self, path):
 205         """Return git config data from a path as a dictionary."""
 206
 207         if BUILTIN_READER:
 208             return self._read_config_file(path)
 209
 210         dest = {}
 211         args = ('--null', '--file', path, '--list')
 212         config_lines = self.git.config(*args)[STDOUT].split('\0')
 213         for line in config_lines:
 214             if not line:
 215                 # the user has an invalid entry in their git config
 216                 continue
 217             k, v = _config_key_value(line, '\n')
 218             self._map[k.lower()] = k
 219             dest[k] = v
 220         return dest
 221
 222     def _read_config_file(self, path):
 223         """Read a .gitconfig file into a dict"""
 224
 225         config = {}
 226         header_simple = re.compile(r'^\[(\s+)]$')
 227         header_subkey = re.compile(r'^\[(\s+) "(\s+)"\]$')
 228
 229         with core.xopen(path, 'rt') as f:
 230             file_lines = f.readlines()
 231
 232         stripped_lines = [line.strip() for line in file_lines]
 233         lines = [line for line in stripped_lines if bool(line)]
 234         prefix = ''
 235         for line in lines:
 236             if line.startswith('#'):
 237                 continue
 238
 239             match = header_simple.match(line)
 240             if match:
 241                 prefix = match.group(1) + '.'
 242                 continue
 243             match = header_subkey.match(line)
 244             if match:
 245                 prefix = match.group(1) + '.' + match.group(2) + '.'
 246                 continue
 247
 248             k, v = _config_key_value(line, '=')
 249             k = prefix + k
 250             self._map[k.lower()] = k
 251             config[k] = v
 252
 253         return config
 254
 255     def _get(self, src, key, default):
 256         self.update()
 257         try:
 258             value = self._get_with_fallback(src, key)
 259         except KeyError:
 260             value = default
 261         return value
 262
 263     def _get_with_fallback(self, src, key):
 264         try:
 265             return src[key]
 266         except KeyError:
 267             pass
 268         key = self._map.get(key.lower(), key)
 269         try:
 270             return src[key]
 271         except KeyError:
 272             pass
 273         # Allow the final KeyError to bubble up
 274         return src[key.lower()]
 275
 276     def get(self, key, default=None):
 277         """Return the string value for a config key."""
 278         return self._get(self._all, key, default)
 279
 280     def get_all(self, key):
 281         """Return all values for a key"""
 282         status, out, err = self.git.config(key, z=True, get_all=True)
 283         if status == 0:
 284             result = [x for x in out.rstrip(chr(0)).split(chr(0)) if x]
 285         else:
 286             result = []
 287         return result
 288
 289     def get_user(self, key, default=None):
 290         return self._get(self._user, key, default)
 291
 292     def get_repo(self, key, default=None):
 293         return self._get(self._repo, key, default)
 294
 295     def get_user_or_system(self, key, default=None):
 296         return self._get(self._user_or_system, key, default)
 297
 298     def python_to_git(self, value):
 299         if type(value) is bool:
 300             if value:
 301                 return 'true'
 302             else:
 303                 return 'false'
 304         if isinstance(value, int_types):
 305             return ustr(value)
 306         return value
 307
 308     def set_user(self, key, value):
 309         if value is None:
 310             self.unset_user(key)
 311             return
 312         self.git.config('--global', key, self.python_to_git(value))
 313         self.update()
 314         msg = self.message_user_config_changed
 315         self.notify_observers(msg, key, value)
 316
 317     def set_repo(self, key, value):
 318         self.git.config(key, self.python_to_git(value))
 319         self.update()
 320         msg = self.message_repo_config_changed
 321         self.notify_observers(msg, key, value)
 322
 323     def unset_user(self, key):
 324         self.git.config('--global', '--unset', key)
 325         self.update()
 326         msg = self.message_repo_config_changed
 327         self.notify_observers(msg, key, None)
 328
 329     def find(self, pat):
 330         pat = pat.lower()
 331         match = fnmatch.fnmatch
 332         result = {}
 333         self.update()
 334         for key, val in self._all.items():
 335             if match(key.lower(), pat):
 336                 result[key] = val
 337         return result
 338
 339     def get_cached(self, key, default=None):
 340         cache = self._value_cache
 341         try:
 342             value = cache[key]
 343         except KeyError:
 344             value = cache[key] = self.get(key, default=default)
 345         return value
 346
 347     def gui_encoding(self):
 348         return self.get_cached('gui.encoding', default='utf-8')
 349
 350     def is_per_file_attrs_enabled(self):
 351         return self.get_cached('cola.fileattributes', default=False)
 352
 353     def file_encoding(self, path):
 354         if not self.is_per_file_attrs_enabled():
 355             return self.gui_encoding()
 356         cache = self._attr_cache
 357         try:
 358             value = cache[path]
 359         except KeyError:
 360             value = cache[path] = (self._file_encoding(path) or
 361                                    self.gui_encoding())
 362         return value
 363
 364     def _file_encoding(self, path):
 365         """Return the file encoding for a path"""
 366         status, out, err = self.git.check_attr('encoding', '--', path)
 367         if status != 0:
 368             return None
 369         header = '%s: encoding: ' % path
 370         if out.startswith(header):
 371             encoding = out[len(header):].strip()
 372             if (encoding != 'unspecified' and
 373                     encoding != 'unset' and
 374                     encoding != 'set'):
 375                 return encoding
 376         return None
 377
 378     def get_guitool_opts(self, name):
 379         """Return the guitool.<name> namespace as a dict
 380
 381         The dict keys are simplified so that "guitool.$name.cmd" is accessible
 382         as `opts[cmd]`.
 383
 384         """
 385         prefix = len('guitool.%s.' % name)
 386         guitools = self.find('guitool.%s.*' % name)
 387         return dict([(key[prefix:], value)
 388                      for (key, value) in guitools.items()])
 389
 390     def get_guitool_names(self):
 391         guitools = self.find('guitool.*.cmd')
 392         prefix = len('guitool.')
 393         suffix = len('.cmd')
 394         return sorted([name[prefix:-suffix]
 395                        for (name, cmd) in guitools.items()])
 396
 397     def get_guitool_names_and_shortcuts(self):
 398         """Return guitool names and their configured shortcut"""
 399         names = self.get_guitool_names()
 400         return [(name, self.get('guitool.%s.shortcut' % name))
 401                 for name in names]
 402
 403     def terminal(self):
 404         term = self.get('cola.terminal', None)
 405         if not term:
 406             # find a suitable default terminal
 407             term = 'xterm -e'  # for mac osx
 408             candidates = ('xfce4-terminal', 'konsole', 'gnome-terminal')
 409             for basename in candidates:
 410                 if core.exists('/usr/bin/%s' % basename):
 411                     term = '%s -e' % basename
 412                     break
 413         return term
 414
 415     def color(self, key, default):
 416         string = self.get('cola.color.%s' % key, default)
 417         string = core.encode(string)
 418         default = core.encode(default)
 419         struct_layout = core.encode('BBB')
 420         try:
 421             r, g, b = struct.unpack(struct_layout, unhexlify(string))
 422         except Exception:
 423             r, g, b = struct.unpack(struct_layout, unhexlify(default))
 424         return (r, g, b)