diff --git a/dulwich/config.py b/dulwich/config.py
index d19038f3..441c4442 100644
--- a/dulwich/config.py
+++ b/dulwich/config.py
@@ -1,563 +1,566 @@
 # config.py - Reading and writing Git config files
 # Copyright (C) 2011-2013 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Reading and writing Git configuration files.
 
 TODO:
  * preserve formatting when updating configuration files
  * treat subsection names as case-insensitive for [branch.foo] style
    subsections
 """
 
 import errno
 import os
 import sys
 
 from collections import (
     OrderedDict,
     )
 try:
     from collections.abc import (
         Iterable,
         MutableMapping,
         )
 except ImportError:  # python < 3.7
     from collections import (
         Iterable,
         MutableMapping,
         )
 
 from dulwich.file import GitFile
 
 
 SENTINAL = object()
 
 
 def lower_key(key):
     if isinstance(key, (bytes, str)):
         return key.lower()
 
     if isinstance(key, Iterable):
         return type(key)(
             map(lower_key, key)
         )
 
     return key
 
 
 class CaseInsensitiveDict(OrderedDict):
 
     @classmethod
     def make(cls, dict_in=None):
 
         if isinstance(dict_in, cls):
             return dict_in
 
         out = cls()
 
         if dict_in is None:
             return out
 
         if not isinstance(dict_in, MutableMapping):
             raise TypeError
 
         for key, value in dict_in.items():
             out[key] = value
 
         return out
 
     def __setitem__(self, key, value, **kwargs):
         key = lower_key(key)
 
         super(CaseInsensitiveDict, self).__setitem__(key, value,  **kwargs)
 
     def __getitem__(self, item):
         key = lower_key(item)
 
         return super(CaseInsensitiveDict, self).__getitem__(key)
 
     def get(self, key, default=SENTINAL):
         try:
             return self[key]
         except KeyError:
             pass
 
         if default is SENTINAL:
             return type(self)()
 
         return default
 
     def setdefault(self, key, default=SENTINAL):
         try:
             return self[key]
         except KeyError:
             self[key] = self.get(key, default)
 
         return self[key]
 
 
 class Config(object):
     """A Git configuration."""
 
     def get(self, section, name):
         """Retrieve the contents of a configuration setting.
 
         Args:
           section: Tuple with section name and optional subsection namee
           subsection: Subsection name
         Returns:
           Contents of the setting
         Raises:
           KeyError: if the value is not set
         """
         raise NotImplementedError(self.get)
 
     def get_boolean(self, section, name, default=None):
         """Retrieve a configuration setting as boolean.
 
         Args:
           section: Tuple with section name and optional subsection name
           name: Name of the setting, including section and possible
             subsection.
         Returns:
           Contents of the setting
         Raises:
           KeyError: if the value is not set
         """
         try:
             value = self.get(section, name)
         except KeyError:
             return default
         if value.lower() == b"true":
             return True
         elif value.lower() == b"false":
             return False
         raise ValueError("not a valid boolean string: %r" % value)
 
     def set(self, section, name, value):
         """Set a configuration value.
 
         Args:
           section: Tuple with section name and optional subsection namee
           name: Name of the configuration value, including section
             and optional subsection
            value: value of the setting
         """
         raise NotImplementedError(self.set)
 
     def iteritems(self, section):
         """Iterate over the configuration pairs for a specific section.
 
         Args:
           section: Tuple with section name and optional subsection namee
         Returns:
           Iterator over (name, value) pairs
         """
         raise NotImplementedError(self.iteritems)
 
     def itersections(self):
         """Iterate over the sections.
 
         Returns: Iterator over section tuples
         """
         raise NotImplementedError(self.itersections)
 
     def has_section(self, name):
         """Check if a specified section exists.
 
         Args:
           name: Name of section to check for
         Returns:
           boolean indicating whether the section exists
         """
         return (name in self.itersections())
 
 
 class ConfigDict(Config, MutableMapping):
     """Git configuration stored in a dictionary."""
 
     def __init__(self, values=None, encoding=None):
         """Create a new ConfigDict."""
         if encoding is None:
             encoding = sys.getdefaultencoding()
         self.encoding = encoding
         self._values = CaseInsensitiveDict.make(values)
 
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__, self._values)
 
     def __eq__(self, other):
         return (
             isinstance(other, self.__class__) and
             other._values == self._values)
 
     def __getitem__(self, key):
         return self._values.__getitem__(key)
 
     def __setitem__(self, key, value):
         return self._values.__setitem__(key, value)
 
     def __delitem__(self, key):
         return self._values.__delitem__(key)
 
     def __iter__(self):
         return self._values.__iter__()
 
     def __len__(self):
         return self._values.__len__()
 
     @classmethod
     def _parse_setting(cls, name):
         parts = name.split(".")
         if len(parts) == 3:
             return (parts[0], parts[1], parts[2])
         else:
             return (parts[0], None, parts[1])
 
     def _check_section_and_name(self, section, name):
         if not isinstance(section, tuple):
             section = (section, )
 
         section = tuple([
             subsection.encode(self.encoding)
             if not isinstance(subsection, bytes) else subsection
             for subsection in section
             ])
 
         if not isinstance(name, bytes):
             name = name.encode(self.encoding)
 
         return section, name
 
     def get(self, section, name):
         section, name = self._check_section_and_name(section, name)
 
         if len(section) > 1:
             try:
                 return self._values[section][name]
             except KeyError:
                 pass
 
         return self._values[(section[0],)][name]
 
     def set(self, section, name, value):
         section, name = self._check_section_and_name(section, name)
 
         if type(value) not in (bool, bytes):
             value = value.encode(self.encoding)
 
         self._values.setdefault(section)[name] = value
 
     def iteritems(self, section):
         return self._values.get(section).items()
 
     def itersections(self):
         return self._values.keys()
 
 
 def _format_string(value):
     if (value.startswith(b" ") or
             value.startswith(b"\t") or
             value.endswith(b" ") or
             b'#' in value or
             value.endswith(b"\t")):
         return b'"' + _escape_value(value) + b'"'
     else:
         return _escape_value(value)
 
 
 _ESCAPE_TABLE = {
     ord(b"\\"): ord(b"\\"),
     ord(b"\""): ord(b"\""),
     ord(b"n"): ord(b"\n"),
     ord(b"t"): ord(b"\t"),
     ord(b"b"): ord(b"\b"),
     }
 _COMMENT_CHARS = [ord(b"#"), ord(b";")]
 _WHITESPACE_CHARS = [ord(b"\t"), ord(b" ")]
 
 
 def _parse_string(value):
     value = bytearray(value.strip())
     ret = bytearray()
     whitespace = bytearray()
     in_quotes = False
     i = 0
     while i < len(value):
         c = value[i]
         if c == ord(b"\\"):
             i += 1
             try:
                 v = _ESCAPE_TABLE[value[i]]
             except IndexError:
                 raise ValueError(
                     "escape character in %r at %d before end of string" %
                     (value, i))
             except KeyError:
                 raise ValueError(
                     "escape character followed by unknown character "
                     "%s at %d in %r" % (value[i], i, value))
             if whitespace:
                 ret.extend(whitespace)
                 whitespace = bytearray()
             ret.append(v)
         elif c == ord(b"\""):
             in_quotes = (not in_quotes)
         elif c in _COMMENT_CHARS and not in_quotes:
             # the rest of the line is a comment
             break
         elif c in _WHITESPACE_CHARS:
             whitespace.append(c)
         else:
             if whitespace:
                 ret.extend(whitespace)
                 whitespace = bytearray()
             ret.append(c)
         i += 1
 
     if in_quotes:
         raise ValueError("missing end quote")
 
     return bytes(ret)
 
 
 def _escape_value(value):
     """Escape a value."""
     value = value.replace(b"\\", b"\\\\")
     value = value.replace(b"\n", b"\\n")
     value = value.replace(b"\t", b"\\t")
     value = value.replace(b"\"", b"\\\"")
     return value
 
 
 def _check_variable_name(name):
     for i in range(len(name)):
         c = name[i:i+1]
         if not c.isalnum() and c != b'-':
             return False
     return True
 
 
 def _check_section_name(name):
     for i in range(len(name)):
         c = name[i:i+1]
         if not c.isalnum() and c not in (b'-', b'.'):
             return False
     return True
 
 
 def _strip_comments(line):
     comment_bytes = {ord(b"#"), ord(b";")}
     quote = ord(b'"')
     string_open = False
     # Normalize line to bytearray for simple 2/3 compatibility
     for i, character in enumerate(bytearray(line)):
         # Comment characters outside balanced quotes denote comment start
         if character == quote:
             string_open = not string_open
         elif not string_open and character in comment_bytes:
             return line[:i]
     return line
 
 
 class ConfigFile(ConfigDict):
     """A Git configuration file, like .git/config or ~/.gitconfig.
     """
 
     @classmethod
     def from_file(cls, f):
         """Read configuration from a file-like object."""
         ret = cls()
         section = None
         setting = None
         for lineno, line in enumerate(f.readlines()):
             line = line.lstrip()
             if setting is None:
                 # Parse section header ("[bla]")
                 if len(line) > 0 and line[:1] == b"[":
                     line = _strip_comments(line).rstrip()
                     try:
                         last = line.index(b"]")
                     except ValueError:
                         raise ValueError("expected trailing ]")
                     pts = line[1:last].split(b" ", 1)
                     line = line[last+1:]
                     if len(pts) == 2:
                         if pts[1][:1] != b"\"" or pts[1][-1:] != b"\"":
                             raise ValueError(
                                 "Invalid subsection %r" % pts[1])
                         else:
                             pts[1] = pts[1][1:-1]
                         if not _check_section_name(pts[0]):
                             raise ValueError("invalid section name %r" %
                                              pts[0])
                         section = (pts[0], pts[1])
                     else:
                         if not _check_section_name(pts[0]):
                             raise ValueError(
                                 "invalid section name %r" % pts[0])
                         pts = pts[0].split(b".", 1)
                         if len(pts) == 2:
                             section = (pts[0], pts[1])
                         else:
                             section = (pts[0], )
                     ret._values.setdefault(section)
                 if _strip_comments(line).strip() == b"":
                     continue
                 if section is None:
                     raise ValueError("setting %r without section" % line)
                 try:
                     setting, value = line.split(b"=", 1)
                 except ValueError:
                     setting = line
                     value = b"true"
                 setting = setting.strip()
                 if not _check_variable_name(setting):
                     raise ValueError("invalid variable name %s" % setting)
                 if value.endswith(b"\\\n"):
                     continuation = value[:-2]
                 else:
                     continuation = None
                     value = _parse_string(value)
                     ret._values[section][setting] = value
                     setting = None
             else:  # continuation line
                 if line.endswith(b"\\\n"):
                     continuation += line[:-2]
                 else:
                     continuation += line
                     value = _parse_string(continuation)
                     ret._values[section][setting] = value
                     continuation = None
                     setting = None
         return ret
 
     @classmethod
     def from_path(cls, path):
         """Read configuration from a file on disk."""
         with GitFile(path, 'rb') as f:
             ret = cls.from_file(f)
             ret.path = path
             return ret
 
     def write_to_path(self, path=None):
         """Write configuration to a file on disk."""
         if path is None:
             path = self.path
         with GitFile(path, 'wb') as f:
             self.write_to_file(f)
 
     def write_to_file(self, f):
         """Write configuration to a file-like object."""
         for section, values in self._values.items():
             try:
                 section_name, subsection_name = section
             except ValueError:
                 (section_name, ) = section
                 subsection_name = None
             if subsection_name is None:
                 f.write(b"[" + section_name + b"]\n")
             else:
                 f.write(b"[" + section_name +
                         b" \"" + subsection_name + b"\"]\n")
             for key, value in values.items():
                 if value is True:
                     value = b"true"
                 elif value is False:
                     value = b"false"
                 else:
                     value = _format_string(value)
                 f.write(b"\t" + key + b" = " + value + b"\n")
 
 
+def get_xdg_config_home_path(*path_segments):
+    xdg_config_home = os.environ.get(
+        "XDG_CONFIG_HOME", os.path.expanduser("~/.config/"),
+    )
+    return os.path.join(xdg_config_home, *path_segments)
+
+
 class StackedConfig(Config):
     """Configuration which reads from multiple config files.."""
 
     def __init__(self, backends, writable=None):
         self.backends = backends
         self.writable = writable
 
     def __repr__(self):
         return "<%s for %r>" % (self.__class__.__name__, self.backends)
 
     @classmethod
     def default(cls):
         return cls(cls.default_backends())
 
     @classmethod
     def default_backends(cls):
         """Retrieve the default configuration.
 
         See git-config(1) for details on the files searched.
         """
         paths = []
         paths.append(os.path.expanduser("~/.gitconfig"))
-
-        xdg_config_home = os.environ.get(
-            "XDG_CONFIG_HOME", os.path.expanduser("~/.config/"),
-        )
-        paths.append(os.path.join(xdg_config_home, "git", "config"))
+        paths.append(get_xdg_config_home_path("git", "config"))
 
         if "GIT_CONFIG_NOSYSTEM" not in os.environ:
             paths.append("/etc/gitconfig")
 
         backends = []
         for path in paths:
             try:
                 cf = ConfigFile.from_path(path)
             except (IOError, OSError) as e:
                 if e.errno != errno.ENOENT:
                     raise
                 else:
                     continue
             backends.append(cf)
         return backends
 
     def get(self, section, name):
         if not isinstance(section, tuple):
             section = (section, )
         for backend in self.backends:
             try:
                 return backend.get(section, name)
             except KeyError:
                 pass
         raise KeyError(name)
 
     def set(self, section, name, value):
         if self.writable is None:
             raise NotImplementedError(self.set)
         return self.writable.set(section, name, value)
 
 
 def parse_submodules(config):
     """Parse a gitmodules GitConfig file, returning submodules.
 
    Args:
      config: A `ConfigFile`
    Returns:
      list of tuples (submodule path, url, name),
        where name is quoted part of the section's name.
     """
     for section in config.keys():
         section_kind, section_name = section
         if section_kind == b'submodule':
             sm_path = config.get(section, b'path')
             sm_url = config.get(section, b'url')
             yield (sm_path, sm_url, section_name)
diff --git a/dulwich/ignore.py b/dulwich/ignore.py
index 37a0d9ec..a1154af1 100644
--- a/dulwich/ignore.py
+++ b/dulwich/ignore.py
@@ -1,373 +1,374 @@
 # Copyright (C) 2017 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Parsing of gitignore files.
 
 For details for the matching rules, see https://git-scm.com/docs/gitignore
 """
 
 import os.path
 import re
 import sys
 
+from dulwich.config import get_xdg_config_home_path
+
 
 def _translate_segment(segment):
     if segment == b"*":
         return b'[^/]+'
     res = b""
     i, n = 0, len(segment)
     while i < n:
         c = segment[i:i+1]
         i = i+1
         if c == b'*':
             res += b'[^/]*'
         elif c == b'?':
             res += b'[^/]'
         elif c == b'[':
             j = i
             if j < n and segment[j:j+1] == b'!':
                 j = j+1
             if j < n and segment[j:j+1] == b']':
                 j = j+1
             while j < n and segment[j:j+1] != b']':
                 j = j+1
             if j >= n:
                 res += b'\\['
             else:
                 stuff = segment[i:j].replace(b'\\', b'\\\\')
                 i = j+1
                 if stuff.startswith(b'!'):
                     stuff = b'^' + stuff[1:]
                 elif stuff.startswith(b'^'):
                     stuff = b'\\' + stuff
                 res += b'[' + stuff + b']'
         else:
             res += re.escape(c)
     return res
 
 
 def translate(pat):
     """Translate a shell PATTERN to a regular expression.
 
     There is no way to quote meta-characters.
 
     Originally copied from fnmatch in Python 2.7, but modified for Dulwich
     to cope with features in Git ignore patterns.
     """
 
     res = b'(?ms)'
 
     if b'/' not in pat[:-1]:
         # If there's no slash, this is a filename-based match
         res += b'(.*/)?'
 
     if pat.startswith(b'**/'):
         # Leading **/
         pat = pat[2:]
         res += b'(.*/)?'
 
     if pat.startswith(b'/'):
         pat = pat[1:]
 
     for i, segment in enumerate(pat.split(b'/')):
         if segment == b'**':
             res += b'(/.*)?'
             continue
         else:
             res += ((re.escape(b'/') if i > 0 else b'') +
                     _translate_segment(segment))
 
     if not pat.endswith(b'/'):
         res += b'/?'
 
     return res + b'\\Z'
 
 
 def read_ignore_patterns(f):
     """Read a git ignore file.
 
     Args:
       f: File-like object to read from
     Returns: List of patterns
     """
 
     for line in f:
         line = line.rstrip(b"\r\n")
 
         # Ignore blank lines, they're used for readability.
         if not line:
             continue
 
         if line.startswith(b'#'):
             # Comment
             continue
 
         # Trailing spaces are ignored unless they are quoted with a backslash.
         while line.endswith(b' ') and not line.endswith(b'\\ '):
             line = line[:-1]
         line = line.replace(b'\\ ', b' ')
 
         yield line
 
 
 def match_pattern(path, pattern, ignorecase=False):
     """Match a gitignore-style pattern against a path.
 
     Args:
       path: Path to match
       pattern: Pattern to match
       ignorecase: Whether to do case-sensitive matching
     Returns:
       bool indicating whether the pattern matched
     """
     return Pattern(pattern, ignorecase).match(path)
 
 
 class Pattern(object):
     """A single ignore pattern."""
 
     def __init__(self, pattern, ignorecase=False):
         self.pattern = pattern
         self.ignorecase = ignorecase
         if pattern[0:1] == b'!':
             self.is_exclude = False
             pattern = pattern[1:]
         else:
             if pattern[0:1] == b'\\':
                 pattern = pattern[1:]
             self.is_exclude = True
         flags = 0
         if self.ignorecase:
             flags = re.IGNORECASE
         self._re = re.compile(translate(pattern), flags)
 
     def __bytes__(self):
         return self.pattern
 
     def __str__(self):
         return self.pattern.decode(sys.getfilesystemencoding())
 
     def __eq__(self, other):
         return (type(self) == type(other) and
                 self.pattern == other.pattern and
                 self.ignorecase == other.ignorecase)
 
     def __repr__(self):
         return "%s(%s, %r)" % (
             type(self).__name__, self.pattern, self.ignorecase)
 
     def match(self, path):
         """Try to match a path against this ignore pattern.
 
         Args:
           path: Path to match (relative to ignore location)
         Returns: boolean
         """
         return bool(self._re.match(path))
 
 
 class IgnoreFilter(object):
 
     def __init__(self, patterns, ignorecase=False):
         self._patterns = []
         self._ignorecase = ignorecase
         for pattern in patterns:
             self.append_pattern(pattern)
 
     def append_pattern(self, pattern):
         """Add a pattern to the set."""
         self._patterns.append(Pattern(pattern, self._ignorecase))
 
     def find_matching(self, path):
         """Yield all matching patterns for path.
 
         Args:
           path: Path to match
         Returns:
           Iterator over  iterators
         """
         if not isinstance(path, bytes):
             path = path.encode(sys.getfilesystemencoding())
         for pattern in self._patterns:
             if pattern.match(path):
                 yield pattern
 
     def is_ignored(self, path):
         """Check whether a path is ignored.
 
         For directories, include a trailing slash.
 
         Returns: status is None if file is not mentioned, True if it is
             included, False if it is explicitly excluded.
         """
         status = None
         for pattern in self.find_matching(path):
             status = pattern.is_exclude
         return status
 
     @classmethod
     def from_path(cls, path, ignorecase=False):
         with open(path, 'rb') as f:
             ret = cls(read_ignore_patterns(f), ignorecase)
             ret._path = path
             return ret
 
     def __repr__(self):
         if getattr(self, '_path', None) is None:
             return "<%s>" % (type(self).__name__)
         else:
             return "%s.from_path(%r)" % (type(self).__name__, self._path)
 
 
 class IgnoreFilterStack(object):
     """Check for ignore status in multiple filters."""
 
     def __init__(self, filters):
         self._filters = filters
 
     def is_ignored(self, path):
         """Check whether a path is explicitly included or excluded in ignores.
 
         Args:
           path: Path to check
         Returns:
           None if the file is not mentioned, True if it is included,
           False if it is explicitly excluded.
         """
         status = None
         for filter in self._filters:
             status = filter.is_ignored(path)
             if status is not None:
                 return status
         return status
 
 
 def default_user_ignore_filter_path(config):
     """Return default user ignore filter path.
 
     Args:
       config: A Config object
     Returns:
       Path to a global ignore file
     """
     try:
         return config.get((b'core', ), b'excludesFile')
     except KeyError:
         pass
 
-    xdg_config_home = os.environ.get("XDG_CONFIG_HOME", "~/.config/")
-    return os.path.join(xdg_config_home, 'git', 'ignore')
+    return get_xdg_config_home_path('git', 'ignore')
 
 
 class IgnoreFilterManager(object):
     """Ignore file manager."""
 
     def __init__(self, top_path, global_filters, ignorecase):
         self._path_filters = {}
         self._top_path = top_path
         self._global_filters = global_filters
         self._ignorecase = ignorecase
 
     def __repr__(self):
         return "%s(%s, %r, %r)" % (
             type(self).__name__, self._top_path,
             self._global_filters,
             self._ignorecase)
 
     def _load_path(self, path):
         try:
             return self._path_filters[path]
         except KeyError:
             pass
 
         p = os.path.join(self._top_path, path, '.gitignore')
         try:
             self._path_filters[path] = IgnoreFilter.from_path(
                 p, self._ignorecase)
         except IOError:
             self._path_filters[path] = None
         return self._path_filters[path]
 
     def find_matching(self, path):
         """Find matching patterns for path.
 
         Stops after the first ignore file with matches.
 
         Args:
           path: Path to check
         Returns:
           Iterator over Pattern instances
         """
         if os.path.isabs(path):
             raise ValueError('%s is an absolute path' % path)
         filters = [(0, f) for f in self._global_filters]
         if os.path.sep != '/':
             path = path.replace(os.path.sep, '/')
         parts = path.split('/')
         for i in range(len(parts)+1):
             dirname = '/'.join(parts[:i])
             for s, f in filters:
                 relpath = '/'.join(parts[s:i])
                 if i < len(parts):
                     # Paths leading up to the final part are all directories,
                     # so need a trailing slash.
                     relpath += '/'
                 matches = list(f.find_matching(relpath))
                 if matches:
                     return iter(matches)
             ignore_filter = self._load_path(dirname)
             if ignore_filter is not None:
                 filters.insert(0, (i, ignore_filter))
         return iter([])
 
     def is_ignored(self, path):
         """Check whether a path is explicitly included or excluded in ignores.
 
         Args:
           path: Path to check
         Returns:
           None if the file is not mentioned, True if it is included,
           False if it is explicitly excluded.
         """
         matches = list(self.find_matching(path))
         if matches:
             return matches[-1].is_exclude
         return None
 
     @classmethod
     def from_repo(cls, repo):
         """Create a IgnoreFilterManager from a repository.
 
         Args:
           repo: Repository object
         Returns:
           A `IgnoreFilterManager` object
         """
         global_filters = []
         for p in [
                 os.path.join(repo.controldir(), 'info', 'exclude'),
                 default_user_ignore_filter_path(repo.get_config_stack())]:
             try:
                 global_filters.append(
                     IgnoreFilter.from_path(os.path.expanduser(p)))
             except IOError:
                 pass
         config = repo.get_config_stack()
         ignorecase = config.get_boolean((b'core'), (b'ignorecase'), False)
         return cls(repo.path, global_filters, ignorecase)