deb50536f0
These are only needed in C code. With Python files the signatures are automatically generated. The only drawback is the return value is not included in the signature, so document it in the body of the docstring.
286 lines
8.3 KiB
Python
286 lines
8.3 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()
|
|
return ffi.string(entry.name).decode('utf-8')
|
|
|
|
|
|
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 each value of a multivar ''name'' as a list of strings.
|
|
|
|
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 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):
|
|
"""Look up *key* and parse its value as a boolean as per the git-config
|
|
rules. Return a boolean value (True or False).
|
|
|
|
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):
|
|
"""Look up *key* and parse its value as an integer as per the git-config
|
|
rules. Return an integer.
|
|
|
|
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 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():
|
|
"""Return a <Config> object representing the system configuration file.
|
|
"""
|
|
return Config._from_found_config(C.git_config_find_system)
|
|
|
|
@staticmethod
|
|
def get_global_config():
|
|
"""Return a <Config> object representing the global configuration file.
|
|
"""
|
|
return Config._from_found_config(C.git_config_find_global)
|
|
|
|
@staticmethod
|
|
def get_xdg_config():
|
|
"""Return a <Config> object representing the global configuration file.
|
|
"""
|
|
return Config._from_found_config(C.git_config_find_xdg)
|