Config: move to cffi

This halves the amount of code we have to take into account for dealing
with the config.

There is a slight change in the API. Config.get_multivar() returns an
iterator instead of a list, which lets us reuse code from the general
iterator and is closer to libgit2's API.

Author: carlosmn

pygit2/__init__.py

@@ -38,6 +38,7 @@
 from .settings import Settings
 from .credentials import *
 from .remote import Remote, get_credentials
+from .config import Config
 from .errors import check_error
 from .ffi import ffi, C, to_str
 

pygit2/config.py

@@ -0,0 +1,259 @@
+# -*- 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
+
+from _pygit2 import Oid
+
+from .ffi import ffi, C, to_str, is_string
+from .errors import check_error, GitError
+from .refspec import Refspec
+
+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')
+        value = ffi.string(entry.value).decode('utf-8')
+
+        return name, value
+
+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_str(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_str(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()
+
+    def __setitem__(self, key, value):
+        assert_string(key, "key")
+
+        err = 0
+        if isinstance(value, bool):
+            err = C.git_config_set_bool(self._config, to_str(key), value)
+        elif isinstance(value, int):
+            err = C.git_config_set_int64(self._config, to_str(key), value)
+        else:
+            err = C.git_config_set_string(self._config, to_str(key), to_str(value))
+
+        check_error(err)
+
+    def __delitem__(self, key):
+        assert_string(key, "key")
+
+        err = C.git_config_delete_entry(self._config, to_str(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_str(name), to_str(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_str(name), to_str(regex), to_str(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_str(path), level, force)
+        check_error(err)
+
+    #
+    # Static methods to get specialized version of the config
+    #
+
+    @staticmethod
+    def _from_found_config(fn):
+        buf = ffi.new('char []', C.GIT_PATH_MAX)
+        err = fn(buf, C.GIT_PATH_MAX)
+        check_error(err, True)
+        return Config(ffi.string(buf).decode())
+
+    @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)

pygit2/decl.h

@@ -5,8 +5,11 @@ typedef ... git_push;
 typedef ... git_cred;
 typedef ... git_diff_file;
 typedef ... git_tree;
+typedef ... git_config;
+typedef ... git_config_iterator;
 
 #define GIT_OID_RAWSZ ...
+#define GIT_PATH_MAX ...
 
 typedef struct git_oid {
 	unsigned char id[20];
@@ -212,3 +215,49 @@ int git_clone(git_repository **out,
 		const char *url,
 		const char *local_path,
 		const git_clone_options *options);
+
+
+typedef enum {
+	GIT_CONFIG_LEVEL_SYSTEM = 1,
+	GIT_CONFIG_LEVEL_XDG = 2,
+	GIT_CONFIG_LEVEL_GLOBAL = 3,
+	GIT_CONFIG_LEVEL_LOCAL = 4,
+	GIT_CONFIG_LEVEL_APP = 5,
+	GIT_CONFIG_HIGHEST_LEVEL = -1,
+} git_config_level_t;
+
+typedef struct {
+	const char *name;
+	const char *value;
+	git_config_level_t level;
+} git_config_entry;
+
+int git_repository_config(git_config **out, git_repository *repo);
+void git_config_free(git_config *cfg);
+
+int git_config_get_string(const char **out, const git_config *cfg, const char *name);
+int git_config_set_string(git_config *cfg, const char *name, const char *value);
+int git_config_set_bool(git_config *cfg, const char *name, int value);
+int git_config_set_int64(git_config *cfg, const char *name, int64_t value);
+
+int git_config_parse_bool(int *out, const char *value);
+int git_config_parse_int64(int64_t *out, const char *value);
+
+int git_config_delete_entry(git_config *cfg, const char *name);
+int git_config_add_file_ondisk(git_config *cfg,
+	const char *path,
+	git_config_level_t level,
+	int force);
+
+int git_config_iterator_new(git_config_iterator **out, const git_config *cfg);
+int git_config_next(git_config_entry **entry, git_config_iterator *iter);
+void git_config_iterator_free(git_config_iterator *iter);
+
+int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *cfg, const char *name, const char *regexp);
+int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value);
+
+int git_config_new(git_config **out);
+int git_config_open_ondisk(git_config **out, const char *path);
+int git_config_find_system(char *out, size_t length);
+int git_config_find_global(char *out, size_t length);
+int git_config_find_xdg(char *out, size_t length);

pygit2/errors.py

@@ -33,7 +33,7 @@
 
 from _pygit2 import GitError
 
-def check_error(err):
+def check_error(err, io=False):
     if err >= 0:
         return
 
@@ -45,7 +45,10 @@ def check_error(err):
     if err in [C.GIT_EEXISTS, C.GIT_EINVALIDSPEC, C.GIT_EEXISTS, C.GIT_EAMBIGUOUS]:
         raise ValueError(message)
     elif err == C.GIT_ENOTFOUND:
-        raise KeyError(message)
+        if io:
+            raise IOError(message)
+        else:
+            raise KeyError(message)
     elif err == C.GIT_EINVALIDSPEC:
         raise ValueError(message)
     elif err == C.GIT_ITEROVER:

pygit2/repository.py

@@ -38,6 +38,7 @@
 from .ffi import ffi, C, to_str
 from .errors import check_error
 from .remote import Remote
+from .config import Config
 
 class Repository(_Repository):
 
@@ -110,6 +111,23 @@ def remotes(self):
             C.git_strarray_free(names)
 
 
+    #
+    # Configuration
+    #
+    @property
+    def config(self):
+        """The configuration file for this repository
+
+        If a the configuration hasn't been set yet, the default config for
+        repository will be returned, including global and system configurations
+        (if they are available)."""
+
+        cconfig = ffi.new('git_config **')
+        err = C.git_repository_config(cconfig, self._repo)
+        check_error(err)
+
+        return Config.from_c(self, cconfig[0])
+
     #
     # References
     #