def test_eq(setup_cfg_path):
    updater1 = ConfigUpdater()
    updater1.read(setup_cfg_path)
    updater2 = ConfigUpdater()
    updater2.read(setup_cfg_path)
    assert updater1 == updater2
    updater1.remove_section('metadata')
    assert updater1 != updater2
    assert updater1 != updater2['metadata']
    assert updater2['metadata'] != updater2['metadata']['author']
    assert not updater1.remove_section('metadata')
def test_eq(setup_cfg_path):
    updater1 = ConfigUpdater()
    updater1.read(setup_cfg_path)
    updater2 = ConfigUpdater()
    updater2.read(setup_cfg_path)
    assert updater1 == updater2
    updater1.remove_section("metadata")
    assert updater1 != updater2
    assert updater1 != updater2["metadata"]
    assert updater2["metadata"] != updater2["metadata"]["author"]
    assert not updater1.remove_section("metadata")
Exemple #3
0
class CCFile:
    def __init__(self, filename):

        self.filename = filename
        self.updater = ConfigUpdater()
        self.updater.read(filename)

        for section in self.updater.sections_blocks():
            validate(section, filename)

        self._readonly = None
        self._last_modified = time.time()
        self.slm = {}

    def __iter__(self) -> CCNode:
        for section in self.updater.sections_blocks():
            yield CCNode(self, section)

    @property
    def readonly(self) -> bool:
        file = None
        try:
            file = open(self.filename, 'w')
        except:
            readonly = True
        else:
            readonly = False
        finally:
            if file is not None:
                file.close()

        return readonly

    def write(self):
        with contextlib.suppress(Exception):
            self.updater.update_file()

    def move_after(self, section: Section, reference: Section = None):

        self.updater.remove_section(section.name)
        if reference is None:
            sections = self.updater.sections()
            if len(sections) > 0:
                reference = self.updater[sections[0]]
                reference.add_before.section(section)
            else:
                self.updater.add_section(section)
        else:
            reference.add_after.section(section)

        self.tick()

    def add_node(self) -> Optional[CCNode]:
        if self.readonly is True:
            return None

        while 1:
            id = uuid.uuid4().hex
            try:
                self.updater.add_section(id)
            except DuplicateSectionError:
                continue
            except:
                return None
            else:
                break

        return CCNode(self, self.updater[id])

    def remove_node(self, section: Section) -> bool:
        if self.readonly is True:
            return False

        self.updater.remove_section(section.name)
        return True

    @property
    def last_modified(self):
        return int(self._last_modified)

    def tick(self, last_modified=None):
        self.write()
        if last_modified is None:
            last_modified = time.time()
        self._last_modified = last_modified

    def get_section_last_modified(self, id) -> int:
        return self.slm.get(id, 0)

    def set_section_last_modified(self, id, last_modified=None):
        if last_modified is None:
            last_modified = time.time()
        self.slm[id] = last_modified