305 lines
8.4 KiB
Python
305 lines
8.4 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright 2010-2014 The pygit2 contributors
|
|
#
|
|
# This file is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License, version 2,
|
|
# as published by the Free Software Foundation.
|
|
#
|
|
# In addition to the permissions in the GNU General Public License,
|
|
# the authors give you unlimited permission to link the compiled
|
|
# version of this file into combinations with other programs,
|
|
# and to distribute those combinations without any restriction
|
|
# coming from the use of this file. (The General Public License
|
|
# restrictions do apply in other respects; for example, they cover
|
|
# modification of the file, and distribution when not linked into
|
|
# a combined executable.)
|
|
#
|
|
# This file is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; see the file COPYING. If not, write to
|
|
# the Free Software Foundation, 51 Franklin Street, Fifth Floor,
|
|
# Boston, MA 02110-1301, USA.
|
|
|
|
# Import from the future
|
|
from __future__ import absolute_import, unicode_literals
|
|
|
|
# Import from pygit2
|
|
from .errors import check_error
|
|
from .ffi import ffi, C
|
|
from .utils import to_bytes, is_string
|
|
|
|
|
|
def assert_string(v, desc):
|
|
if not is_string(v):
|
|
raise TypeError("%s must be a string" % desc)
|
|
|
|
|
|
class ConfigIterator(object):
|
|
|
|
def __init__(self, config, ptr):
|
|
self._iter = ptr
|
|
self._config = config
|
|
|
|
def __del__(self):
|
|
C.git_config_iterator_free(self._iter)
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def _next_entry(self):
|
|
centry = ffi.new('git_config_entry **')
|
|
err = C.git_config_next(centry, self._iter)
|
|
check_error(err)
|
|
|
|
return centry[0]
|
|
|
|
def next(self):
|
|
return self.__next__()
|
|
|
|
def __next__(self):
|
|
entry = self._next_entry()
|
|
name = ffi.string(entry.name).decode('utf-8')
|
|
|
|
return name
|
|
|
|
|
|
class ConfigMultivarIterator(ConfigIterator):
|
|
def __next__(self):
|
|
entry = self._next_entry()
|
|
|
|
return ffi.string(entry.value).decode('utf-8')
|
|
|
|
|
|
class Config(object):
|
|
"""Git configuration management"""
|
|
|
|
def __init__(self, path=None):
|
|
cconfig = ffi.new('git_config **')
|
|
|
|
if not path:
|
|
err = C.git_config_new(cconfig)
|
|
else:
|
|
assert_string(path, "path")
|
|
err = C.git_config_open_ondisk(cconfig, to_bytes(path))
|
|
|
|
check_error(err, True)
|
|
self._config = cconfig[0]
|
|
|
|
@classmethod
|
|
def from_c(cls, repo, ptr):
|
|
config = cls.__new__(cls)
|
|
config._repo = repo
|
|
config._config = ptr
|
|
|
|
return config
|
|
|
|
def __del__(self):
|
|
C.git_config_free(self._config)
|
|
|
|
def _get(self, key):
|
|
assert_string(key, "key")
|
|
|
|
cstr = ffi.new('char **')
|
|
err = C.git_config_get_string(cstr, self._config, to_bytes(key))
|
|
|
|
return err, cstr
|
|
|
|
def _get_string(self, key):
|
|
err, cstr = self._get(key)
|
|
|
|
if err == C.GIT_ENOTFOUND:
|
|
raise KeyError(key)
|
|
|
|
check_error(err)
|
|
return cstr[0]
|
|
|
|
def __contains__(self, key):
|
|
err, cstr = self._get(key)
|
|
|
|
if err == C.GIT_ENOTFOUND:
|
|
return False
|
|
|
|
check_error(err)
|
|
|
|
return True
|
|
|
|
def __getitem__(self, key):
|
|
val = self._get_string(key)
|
|
|
|
return ffi.string(val).decode('utf-8')
|
|
|
|
def __setitem__(self, key, value):
|
|
assert_string(key, "key")
|
|
|
|
err = 0
|
|
if isinstance(value, bool):
|
|
err = C.git_config_set_bool(self._config, to_bytes(key), value)
|
|
elif isinstance(value, int):
|
|
err = C.git_config_set_int64(self._config, to_bytes(key), value)
|
|
else:
|
|
err = C.git_config_set_string(self._config, to_bytes(key),
|
|
to_bytes(value))
|
|
|
|
check_error(err)
|
|
|
|
def __delitem__(self, key):
|
|
assert_string(key, "key")
|
|
|
|
err = C.git_config_delete_entry(self._config, to_bytes(key))
|
|
check_error(err)
|
|
|
|
def __iter__(self):
|
|
citer = ffi.new('git_config_iterator **')
|
|
err = C.git_config_iterator_new(citer, self._config)
|
|
check_error(err)
|
|
|
|
return ConfigIterator(self, citer[0])
|
|
|
|
def get_multivar(self, name, regex=None):
|
|
"""get_multivar(name[, regex]) -> [str, ...]
|
|
|
|
Get each value of a multivar ''name'' as a list. The optional ''regex''
|
|
parameter is expected to be a regular expression to filter the
|
|
variables we're interested in."""
|
|
|
|
assert_string(name, "name")
|
|
|
|
citer = ffi.new('git_config_iterator **')
|
|
err = C.git_config_multivar_iterator_new(citer, self._config,
|
|
to_bytes(name),
|
|
to_bytes(regex))
|
|
check_error(err)
|
|
|
|
return ConfigMultivarIterator(self, citer[0])
|
|
|
|
def set_multivar(self, name, regex, value):
|
|
"""set_multivar(name, regex, value)
|
|
|
|
Set a multivar ''name'' to ''value''. ''regexp'' is a regular
|
|
expression to indicate which values to replace"""
|
|
|
|
assert_string(name, "name")
|
|
assert_string(regex, "regex")
|
|
assert_string(value, "value")
|
|
|
|
err = C.git_config_set_multivar(self._config, to_bytes(name),
|
|
to_bytes(regex), to_bytes(value))
|
|
check_error(err)
|
|
|
|
def get_bool(self, key):
|
|
"""get_bool(key) -> Bool
|
|
|
|
Look up *key* and parse its value as a boolean as per the git-config
|
|
rules
|
|
|
|
Truthy values are: 'true', 1, 'on' or 'yes'. Falsy values are: 'false',
|
|
0, 'off' and 'no'"""
|
|
|
|
val = self._get_string(key)
|
|
res = ffi.new('int *')
|
|
err = C.git_config_parse_bool(res, val)
|
|
check_error(err)
|
|
|
|
return res[0] != 0
|
|
|
|
def get_int(self, key):
|
|
"""get_int(key) -> int
|
|
|
|
Look up *key* and parse its value as an integer as per the git-config
|
|
rules.
|
|
|
|
A value can have a suffix 'k', 'm' or 'g' which stand for 'kilo',
|
|
'mega' and 'giga' respectively"""
|
|
|
|
val = self._get_string(key)
|
|
res = ffi.new('int64_t *')
|
|
err = C.git_config_parse_int64(res, val)
|
|
check_error(err)
|
|
|
|
return res[0]
|
|
|
|
def add_file(self, path, level=0, force=0):
|
|
"""add_file(path, level=0, force=0)
|
|
|
|
Add a config file instance to an existing config."""
|
|
|
|
err = C.git_config_add_file_ondisk(self._config, to_bytes(path), level,
|
|
force)
|
|
check_error(err)
|
|
|
|
def snapshot(self):
|
|
"""Create a snapshot from this Config object
|
|
|
|
This means that looking up multiple values will use the same version
|
|
of the configuration files
|
|
"""
|
|
|
|
ccfg = ffi.new('git_config **')
|
|
err = C.git_config_snapshot(ccfg, self._config)
|
|
check_error(err)
|
|
|
|
return Config.from_c(self._repo, ccfg[0])
|
|
|
|
#
|
|
# Methods to parse a string according to the git-config rules
|
|
#
|
|
|
|
@staticmethod
|
|
def parse_bool(text):
|
|
res = ffi.new('int *')
|
|
err = C.git_config_parse_bool(res, to_bytes(text))
|
|
check_error(err)
|
|
|
|
return res[0] != 0
|
|
|
|
@staticmethod
|
|
def parse_int(text):
|
|
res = ffi.new('int64_t *')
|
|
err = C.git_config_parse_int64(res, to_bytes(text))
|
|
check_error(err)
|
|
|
|
return res[0]
|
|
|
|
#
|
|
# Static methods to get specialized version of the config
|
|
#
|
|
|
|
@staticmethod
|
|
def _from_found_config(fn):
|
|
buf = ffi.new('git_buf *', (ffi.NULL, 0))
|
|
err = fn(buf)
|
|
check_error(err, True)
|
|
cpath = ffi.string(buf.ptr).decode()
|
|
C.git_buf_free(buf)
|
|
|
|
return Config(cpath)
|
|
|
|
@staticmethod
|
|
def get_system_config():
|
|
"""get_system_config() -> Config
|
|
|
|
Return an object representing the system configuration file."""
|
|
|
|
return Config._from_found_config(C.git_config_find_system)
|
|
|
|
@staticmethod
|
|
def get_global_config():
|
|
"""get_global_config() -> Config
|
|
|
|
Return an object representing the global configuration file."""
|
|
|
|
return Config._from_found_config(C.git_config_find_global)
|
|
|
|
@staticmethod
|
|
def get_xdg_config():
|
|
"""get_xdg_config() -> Config
|
|
|
|
Return an object representing the global configuration file."""
|
|
|
|
return Config._from_found_config(C.git_config_find_xdg)
|