def __init__()

in pylib/vcsreplicator/vcsreplicator/config.py [0:0]

• 59 lines of code
• 21 McCabe index (conditional complexity)

    def __init__(self, filename=None):
        self.c = RawConfigParser()

        if filename:
            if not os.path.exists(filename):
                raise ValueError("config file does not exist: %s" % filename)

            self.c.read(filename)

        if self.c.has_section("path_rewrites"):
            self._path_rewrites = self.c.items("path_rewrites")
        else:
            self._path_rewrites = []

        if self.c.has_section("pull_url_rewrites"):
            self._pull_url_rewrites = self.c.items("pull_url_rewrites")
        else:
            self._pull_url_rewrites = []

        if self.c.has_section("public_url_rewrites"):
            self._public_url_rewrites = self.c.items("public_url_rewrites")
        else:
            self._public_url_rewrites = []

        if self.c.has_section("replicationpathrewrites"):
            self._replication_path_rewrites = self.c.items("replicationpathrewrites")
        else:
            self._replication_path_rewrites = []

        if self.c.has_section("replicationrules"):
            re_includes, re_excludes = [], []
            self.path_includes, self.path_excludes = {}, {}
            for key, value in self.c.items("replicationrules"):
                (behaviour, name), (ruletype, rule) = key.split("."), value.split(":")

                if ruletype == "re":
                    # Decide which list is correct and append to it
                    restore = re_includes if behaviour == "include" else re_excludes
                    restore.append((name, rule))

                elif ruletype == "path":
                    exstore = (
                        self.path_includes
                        if behaviour == "include"
                        else self.path_excludes
                    )
                    exstore[rule] = name
                else:
                    raise Exception("bad ruletype %s" % ruletype)

            # Create the in/out rules as an `or` of all the rules
            includes_string = "|".join(
                create_namedgroup(name, rule) for name, rule in re_includes
            )
            excludes_string = "|".join(
                create_namedgroup(name, rule) for name, rule in re_excludes
            )

            self.include_regex = (
                re.compile(includes_string) if includes_string else None
            )
            self.exclude_regex = (
                re.compile(excludes_string) if excludes_string else None
            )

            self.has_filters = bool(
                self.path_includes
                or self.path_excludes
                or self.include_regex
                or self.exclude_regex
            )
        else:
            self.has_filters = False