import os.path
import pathlib
import tempfile
import unittest
from textwrap import dedent

from rope.base.exceptions import ResourceNotFoundError, RopeError
from rope.base.fscommands import FileSystemCommands
from rope.base.libutils import path_to_resource
from rope.base.project import NoProject, Project, _realpath
from rope.base.resourceobserver import FilteredResourceObserver
from ropetest import testutils


class ProjectTest(unittest.TestCase):
    def setUp(self):
        unittest.TestCase.setUp(self)
        self.project = testutils.sample_project(
            foldername="sampleproject", ropefolder=None
        )
        self.project_root = self.project.address
        self._make_sample_project()
        self.no_project = NoProject()

    def _make_sample_project(self):
        self.sample_file = "sample_file.txt"
        self.sample_path = os.path.join(self.project_root, "sample_file.txt")
        if not os.path.exists(self.project_root):
            os.mkdir(self.project_root)
        self.sample_folder = "sample_folder"
        os.mkdir(os.path.join(self.project_root, self.sample_folder))
        sample = open(self.sample_path, "w")
        sample.write("sample text\n")
        sample.close()

    def tearDown(self):
        testutils.remove_project(self.project)
        unittest.TestCase.tearDown(self)

    def test_project_creation(self):
        self.assertEqual(_realpath(self.project_root), self.project.address)

    def test_getting_project_file(self):
        project_file = self.project.get_resource(self.sample_file)
        self.assertTrue(project_file is not None)

    def test_project_file_reading(self):
        projectFile = self.project.get_resource(self.sample_file)
        self.assertEqual("sample text\n", projectFile.read())

    def test_getting_not_existing_project_file(self):
        with self.assertRaises(ResourceNotFoundError):
            self.project.get_resource("DoesNotExistFile.txt")

    def test_writing_in_project_files(self):
        project_file = self.project.get_resource(self.sample_file)
        project_file.write("another text\n")
        self.assertEqual("another text\n", project_file.read())

    def test_creating_files(self):
        project_file = "newfile.txt"
        self.project.root.create_file(project_file)
        newFile = self.project.get_resource(project_file)
        self.assertTrue(newFile is not None)

    def test_creating_files_that_already_exist(self):
        with self.assertRaises(RopeError):
            self.project.root.create_file(self.sample_file)

    def test_making_root_folder_if_it_does_not_exist(self):
        with tempfile.TemporaryDirectory(dir=testutils.RUN_TMP_DIR) as tmpdir:
            project_root = pathlib.Path(tmpdir) / "sampleproject2"
            assert not project_root.exists()

            project = Project(project_root)

            assert project_root.exists()
            assert project_root.is_dir()

    def test_failure_when_project_root_exists_and_is_a_file(self):
        with tempfile.TemporaryDirectory(dir=testutils.RUN_TMP_DIR) as tmpdir:
            project_root = pathlib.Path(tmpdir) / "sampleproject2"
            project_root.touch()
            assert project_root.exists() and project_root.is_file()

            with self.assertRaises(RopeError):
                Project(project_root)

    def test_creating_folders(self):
        folderName = "SampleFolder"
        self.project.root.create_folder(folderName)
        folderPath = os.path.join(self.project.address, folderName)
        self.assertTrue(os.path.exists(folderPath) and os.path.isdir(folderPath))

    def test_making_folder_that_already_exists(self):
        folderName = "SampleFolder"
        with self.assertRaises(RopeError):
            self.project.root.create_folder(folderName)
            self.project.root.create_folder(folderName)

    def test_failing_if_creating_folder_while_file_already_exists(self):
        folderName = "SampleFolder"
        with self.assertRaises(RopeError):
            self.project.root.create_file(folderName)
            self.project.root.create_folder(folderName)

    def test_creating_file_inside_folder(self):
        folder_name = "sampleFolder"
        file_name = "sample2.txt"
        file_path = folder_name + "/" + file_name
        parent_folder = self.project.root.create_folder(folder_name)
        parent_folder.create_file(file_name)
        file = self.project.get_resource(file_path)
        file.write("sample notes")
        self.assertEqual(file_path, file.path)
        self.assertEqual(
            "sample notes", open(os.path.join(self.project.address, file_path)).read()
        )

    def test_failing_when_creating_file_inside_non_existent_folder(self):
        with self.assertRaises(ResourceNotFoundError):
            self.project.root.create_file("NonexistentFolder/SomeFile.txt")

    def test_nested_directories(self):
        folder_name = "SampleFolder"
        parent = self.project.root.create_folder(folder_name)
        parent.create_folder(folder_name)
        folder_path = os.path.join(self.project.address, folder_name, folder_name)
        self.assertTrue(os.path.exists(folder_path) and os.path.isdir(folder_path))

    def test_removing_files(self):
        self.assertTrue(os.path.exists(self.sample_path))
        self.project.get_resource(self.sample_file).remove()
        self.assertFalse(os.path.exists(self.sample_path))

    def test_removing_files_invalidating_in_project_resource_pool(self):
        root_folder = self.project.root
        my_file = root_folder.create_file("my_file.txt")
        my_file.remove()
        self.assertFalse(root_folder.has_child("my_file.txt"))

    def test_removing_directories(self):
        self.assertTrue(
            os.path.exists(os.path.join(self.project.address, self.sample_folder))
        )
        self.project.get_resource(self.sample_folder).remove()
        self.assertFalse(
            os.path.exists(os.path.join(self.project.address, self.sample_folder))
        )

    def test_removing_non_existent_files(self):
        with self.assertRaises(ResourceNotFoundError):
            self.project.get_resource("NonExistentFile.txt").remove()

    def test_removing_nested_files(self):
        file_name = self.sample_folder + "/sample_file.txt"
        self.project.root.create_file(file_name)
        self.project.get_resource(file_name).remove()
        self.assertTrue(
            os.path.exists(os.path.join(self.project.address, self.sample_folder))
        )
        self.assertTrue(
            not os.path.exists(os.path.join(self.project.address, file_name))
        )

    def test_file_get_name(self):
        file = self.project.get_resource(self.sample_file)
        self.assertEqual(self.sample_file, file.name)
        file_name = "nestedFile.txt"
        parent = self.project.get_resource(self.sample_folder)
        filePath = self.sample_folder + "/" + file_name
        parent.create_file(file_name)
        nestedFile = self.project.get_resource(filePath)
        self.assertEqual(file_name, nestedFile.name)

    def test_folder_get_name(self):
        folder = self.project.get_resource(self.sample_folder)
        self.assertEqual(self.sample_folder, folder.name)

    def test_file_get_path(self):
        file = self.project.get_resource(self.sample_file)
        self.assertEqual(self.sample_file, file.path)
        fileName = "nestedFile.txt"
        parent = self.project.get_resource(self.sample_folder)
        filePath = self.sample_folder + "/" + fileName
        parent.create_file(fileName)
        nestedFile = self.project.get_resource(filePath)
        self.assertEqual(filePath, nestedFile.path)

    def test_folder_get_path(self):
        folder = self.project.get_resource(self.sample_folder)
        self.assertEqual(self.sample_folder, folder.path)

    def test_is_folder(self):
        self.assertTrue(self.project.get_resource(self.sample_folder).is_folder())
        self.assertTrue(not self.project.get_resource(self.sample_file).is_folder())

    def testget_children(self):
        children = self.project.get_resource(self.sample_folder).get_children()
        self.assertEqual([], children)

    def test_nonempty_get_children(self):
        file_name = "nestedfile.txt"
        filePath = self.sample_folder + "/" + file_name
        parent = self.project.get_resource(self.sample_folder)
        parent.create_file(file_name)
        children = parent.get_children()
        self.assertEqual(1, len(children))
        self.assertEqual(filePath, children[0].path)

    def test_nonempty_get_children2(self):
        file_name = "nestedfile.txt"
        folder_name = "nestedfolder.txt"
        filePath = self.sample_folder + "/" + file_name
        folderPath = self.sample_folder + "/" + folder_name
        parent = self.project.get_resource(self.sample_folder)
        parent.create_file(file_name)
        parent.create_folder(folder_name)
        children = parent.get_children()
        self.assertEqual(2, len(children))
        self.assertTrue(filePath == children[0].path or filePath == children[1].path)
        self.assertTrue(
            folderPath == children[0].path or folderPath == children[1].path
        )

    def test_does_not_fail_for_permission_denied(self):
        with tempfile.TemporaryDirectory(suffix="bad_dir") as bad_dir:
            os.chmod(bad_dir, 0o000)
            try:
                parent = self.project.get_resource(self.sample_folder)

                parent.get_children()

            finally:
                os.chmod(bad_dir, 0o755)

    def test_getting_files(self):
        files = self.project.root.get_files()
        self.assertEqual(1, len(files))
        self.assertTrue(self.project.get_resource(self.sample_file) in files)

    def test_getting_folders(self):
        folders = self.project.root.get_folders()
        self.assertEqual(1, len(folders))
        self.assertTrue(self.project.get_resource(self.sample_folder) in folders)

    def test_nested_folder_get_files(self):
        parent = self.project.root.create_folder("top")
        parent.create_file("file1.txt")
        parent.create_file("file2.txt")
        files = parent.get_files()
        self.assertEqual(2, len(files))
        self.assertTrue(self.project.get_resource("top/file2.txt") in files)
        self.assertEqual(0, len(parent.get_folders()))

    def test_nested_folder_get_folders(self):
        parent = self.project.root.create_folder("top")
        parent.create_folder("dir1")
        parent.create_folder("dir2")
        folders = parent.get_folders()
        self.assertEqual(2, len(folders))
        self.assertTrue(self.project.get_resource("top/dir1") in folders)
        self.assertEqual(0, len(parent.get_files()))

    def test_root_folder(self):
        root_folder = self.project.root
        self.assertEqual(2, len(root_folder.get_children()))
        self.assertEqual("", root_folder.path)
        self.assertEqual("", root_folder.name)

    def test_get_all_files(self):
        files = tuple(self.project.get_files())
        self.assertEqual(1, len(files))
        self.assertEqual(self.sample_file, files[0].name)

    def test_get_all_files_after_changing(self):
        self.assertEqual(1, len(self.project.get_files()))
        myfile = self.project.root.create_file("myfile.txt")
        self.assertEqual(2, len(self.project.get_files()))
        myfile.move("newfile.txt")
        self.assertEqual(2, len(self.project.get_files()))
        self.project.get_file("newfile.txt").remove()
        self.assertEqual(1, len(self.project.get_files()))

    def test_multifile_get_all_files(self):
        fileName = "nestedFile.txt"
        parent = self.project.get_resource(self.sample_folder)
        parent.create_file(fileName)
        files = list(self.project.get_files())
        self.assertEqual(2, len(files))
        self.assertTrue(fileName == files[0].name or fileName == files[1].name)

    def test_ignoring_dot_pyc_files_in_get_files(self):
        root = self.project.address
        src_folder = os.path.join(root, "src")
        os.mkdir(src_folder)
        test_pyc = os.path.join(src_folder, "test.pyc")
        open(test_pyc, "w").close()
        for x in self.project.get_files():
            self.assertNotEqual("src/test.pyc", x.path)

    def test_folder_creating_files(self):
        projectFile = "NewFile.txt"
        self.project.root.create_file(projectFile)
        new_file = self.project.get_resource(projectFile)
        self.assertTrue(new_file is not None and not new_file.is_folder())

    def test_folder_creating_nested_files(self):
        project_file = "NewFile.txt"
        parent_folder = self.project.get_resource(self.sample_folder)
        parent_folder.create_file(project_file)
        new_file = self.project.get_resource(self.sample_folder + "/" + project_file)
        self.assertTrue(new_file is not None and not new_file.is_folder())

    def test_folder_creating_files2(self):
        projectFile = "newfolder"
        self.project.root.create_folder(projectFile)
        new_folder = self.project.get_resource(projectFile)
        self.assertTrue(new_folder is not None and new_folder.is_folder())

    def test_folder_creating_nested_files2(self):
        project_file = "newfolder"
        parent_folder = self.project.get_resource(self.sample_folder)
        parent_folder.create_folder(project_file)
        new_folder = self.project.get_resource(self.sample_folder + "/" + project_file)
        self.assertTrue(new_folder is not None and new_folder.is_folder())

    def test_folder_get_child(self):
        folder = self.project.root
        folder.create_file("myfile.txt")
        folder.create_folder("myfolder")
        self.assertEqual(
            self.project.get_resource("myfile.txt"), folder.get_child("myfile.txt")
        )
        self.assertEqual(
            self.project.get_resource("myfolder"), folder.get_child("myfolder")
        )

    def test_folder_get_child_nested(self):
        root = self.project.root
        folder = root.create_folder("myfolder")
        folder.create_file("myfile.txt")
        folder.create_folder("myfolder")
        self.assertEqual(
            self.project.get_resource("myfolder/myfile.txt"),
            folder.get_child("myfile.txt"),
        )
        self.assertEqual(
            self.project.get_resource("myfolder/myfolder"), folder.get_child("myfolder")
        )

    def test_project_root_is_root_folder(self):
        self.assertEqual("", self.project.root.path)

    def test_moving_files(self):
        root_folder = self.project.root
        my_file = root_folder.create_file("my_file.txt")
        my_file.move("my_other_file.txt")
        self.assertFalse(my_file.exists())
        root_folder.get_child("my_other_file.txt")

    def test_moving_folders(self):
        root_folder = self.project.root
        my_folder = root_folder.create_folder("my_folder")
        my_file = my_folder.create_file("my_file.txt")
        my_folder.move("new_folder")
        self.assertFalse(root_folder.has_child("my_folder"))
        self.assertFalse(my_file.exists())
        self.assertTrue(root_folder.get_child("new_folder") is not None)

    def test_moving_destination_folders(self):
        root_folder = self.project.root
        my_folder = root_folder.create_folder("my_folder")
        my_file = root_folder.create_file("my_file.txt")
        my_file.move("my_folder")
        self.assertFalse(root_folder.has_child("my_file.txt"))
        self.assertFalse(my_file.exists())
        my_folder.get_child("my_file.txt")

    def test_moving_files_and_resource_objects(self):
        root_folder = self.project.root
        my_file = root_folder.create_file("my_file.txt")
        old_hash = hash(my_file)
        my_file.move("my_other_file.txt")
        self.assertEqual(old_hash, hash(my_file))

    def test_file_encoding_reading(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = (
            b"# -*- coding: utf-8 -*-\n"
            + br"#\N{LATIN SMALL LETTER I WITH DIAERESIS}\n"
        ).decode("utf8")
        file = open(sample_file.real_path, "wb")
        file.write(contents.encode("utf-8"))
        file.close()
        self.assertEqual(contents, sample_file.read())

    def test_file_encoding_writing(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = (
            b"# -*- coding: utf-8 -*-\n" + br"\N{LATIN SMALL LETTER I WITH DIAERESIS}\n"
        ).decode("utf8")
        sample_file.write(contents)
        self.assertEqual(contents, sample_file.read())

    def test_using_utf8_when_writing_in_case_of_errors(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = br"\n\N{LATIN SMALL LETTER I WITH DIAERESIS}\n".decode("utf8")
        sample_file.write(contents)
        self.assertEqual(contents, sample_file.read())

    def test_encoding_declaration_in_the_second_line(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"\n# -*- coding: latin-1 -*-\n\xa9\n"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertEqual(contents, sample_file.read().encode("latin-1"))

    def test_not_an_encoding_declaration(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"def my_method(self, encoding='latin-1'):\n    var = {}\n\xc2\xa9\n"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertEqual(contents, sample_file.read().encode("utf-8"))
        self.assertNotEqual(contents, sample_file.read().encode("latin-1"))

    def test_read_bytes(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"\n# -*- coding: latin-1 -*-\n\xa9\n"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertEqual(contents, sample_file.read_bytes())

    def test_file_with_unix_line_ending(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"1\n"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertIsNone(sample_file.newlines)
        self.assertEqual("1\n", sample_file.read())
        self.assertEqual("\n", sample_file.newlines)

        sample_file.write("1\n")
        self.assertEqual(b"1\n", sample_file.read_bytes())

    def test_file_with_dos_line_ending(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"1\r\n"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertIsNone(sample_file.newlines)
        self.assertEqual("1\n", sample_file.read())
        self.assertEqual("\r\n", sample_file.newlines)

        sample_file.write("1\n")
        self.assertEqual(b"1\r\n", sample_file.read_bytes())

    def test_file_with_mac_line_ending(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"1\r"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertIsNone(sample_file.newlines)
        self.assertEqual("1\n", sample_file.read())
        self.assertEqual("\r", sample_file.newlines)

        sample_file.write("1\n")
        self.assertEqual(b"1\r", sample_file.read_bytes())

    def test_file_binary(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"1\r\n"
        file = open(sample_file.real_path, "wb")
        file.write(contents)
        file.close()
        self.assertIsNone(sample_file.newlines)
        self.assertEqual(b"1\r\n", sample_file.read_bytes())
        self.assertIsNone(sample_file.newlines)

        sample_file.write(b"1\nx\r")
        self.assertEqual((b"1\nx\r"), sample_file.read_bytes())

    # TODO: Detecting utf-16 encoding
    def xxx_test_using_utf16(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = b"# -*- coding: utf-16 -*-\n# This is a sample file ...\n"
        file = open(sample_file.real_path, "w")
        file.write(contents.encode("utf-16"))
        file.close()
        sample_file.write(contents)
        self.assertEqual(contents, sample_file.read())

    # XXX: supporting utf_8_sig
    def xxx_test_file_encoding_reading_for_notepad_styles(self):
        sample_file = self.project.root.create_file("my_file.txt")
        contents = "#\N{LATIN SMALL LETTER I WITH DIAERESIS}\n"
        file = open(sample_file.real_path, "w")
        # file.write('\xef\xbb\xbf')
        file.write(contents.encode("utf-8-sig"))
        file.close()
        self.assertEqual(contents, sample_file.read())

    def test_using_project_get_file(self):
        myfile = self.project.get_file(self.sample_file)
        self.assertTrue(myfile.exists())

    def test_using_file_create(self):
        myfile = self.project.get_file("myfile.txt")
        self.assertFalse(myfile.exists())
        myfile.create()
        self.assertTrue(myfile.exists())
        self.assertFalse(myfile.is_folder())

    def test_using_folder_create(self):
        myfolder = self.project.get_folder("myfolder")
        self.assertFalse(myfolder.exists())
        myfolder.create()
        self.assertTrue(myfolder.exists())
        self.assertTrue(myfolder.is_folder())

    def test_exception_when_creating_twice(self):
        with self.assertRaises(RopeError):
            myfile = self.project.get_file("myfile.txt")
            myfile.create()
            myfile.create()

    def test_exception_when_parent_does_not_exist(self):
        with self.assertRaises(ResourceNotFoundError):
            myfile = self.project.get_file("myfolder/myfile.txt")
            myfile.create()

    def test_simple_path_to_resource(self):
        myfile = self.project.root.create_file("myfile.txt")
        self.assertEqual(myfile, path_to_resource(self.project, myfile.real_path))
        self.assertEqual(
            myfile, path_to_resource(self.project, myfile.real_path, type="file")
        )
        myfolder = self.project.root.create_folder("myfolder")
        self.assertEqual(myfolder, path_to_resource(self.project, myfolder.real_path))
        self.assertEqual(
            myfolder, path_to_resource(self.project, myfolder.real_path, type="folder")
        )

    @testutils.skipNotPOSIX()
    def test_ignoring_symlinks_inside_project(self):
        project2 = testutils.sample_project(folder_name="sampleproject2")
        mod = project2.root.create_file("mod.py")
        try:
            path = os.path.join(self.project.address, "linkedfile.txt")
            os.symlink(mod.real_path, path)
            files = self.project.root.get_files()
            self.assertEqual(1, len(files))
        finally:
            testutils.remove_project(project2)

    def test_getting_empty_source_folders(self):
        self.assertEqual([], self.project.get_source_folders())

    def test_root_source_folder(self):
        self.project.root.create_file("sample.py")
        source_folders = self.project.get_source_folders()
        self.assertEqual(1, len(source_folders))
        self.assertTrue(self.project.root in source_folders)

    def test_root_source_folder2(self):
        self.project.root.create_file("mod1.py")
        self.project.root.create_file("mod2.py")
        source_folders = self.project.get_source_folders()
        self.assertEqual(1, len(source_folders))
        self.assertTrue(self.project.root in source_folders)

    def test_src_source_folder(self):
        src = self.project.root.create_folder("src")
        src.create_file("sample.py")
        source_folders = self.project.get_source_folders()
        self.assertEqual(1, len(source_folders))
        self.assertTrue(self.project.get_resource("src") in source_folders)

    def test_packages(self):
        src = self.project.root.create_folder("src")
        pkg = src.create_folder("package")
        pkg.create_file("__init__.py")
        source_folders = self.project.get_source_folders()
        self.assertEqual(1, len(source_folders))
        self.assertTrue(src in source_folders)

    def test_multi_source_folders(self):
        src = self.project.root.create_folder("src")
        package = src.create_folder("package")
        package.create_file("__init__.py")
        test = self.project.root.create_folder("test")
        test.create_file("alltests.py")
        source_folders = self.project.get_source_folders()
        self.assertEqual(2, len(source_folders))
        self.assertTrue(src in source_folders)
        self.assertTrue(test in source_folders)

    def test_multi_source_folders2(self):
        testutils.create_module(self.project, "mod1")
        src = self.project.root.create_folder("src")
        package = testutils.create_package(self.project, "package", src)
        testutils.create_module(self.project, "mod2", package)
        source_folders = self.project.get_source_folders()
        self.assertEqual(2, len(source_folders))
        self.assertTrue(self.project.root in source_folders and src in source_folders)


class ResourceObserverTest(unittest.TestCase):
    def setUp(self):
        super().setUp()
        self.project = testutils.sample_project()

    def tearDown(self):
        testutils.remove_project(self.project)
        super().tearDown()

    def test_resource_change_observer(self):
        sample_file = self.project.root.create_file("my_file.txt")
        sample_file.write("a sample file version 1")
        sample_observer = _SampleObserver()
        self.project.add_observer(sample_observer)
        sample_file.write("a sample file version 2")
        self.assertEqual(1, sample_observer.change_count)
        self.assertEqual(sample_file, sample_observer.last_changed)

    def test_resource_change_observer_after_removal(self):
        sample_file = self.project.root.create_file("my_file.txt")
        sample_file.write("text")
        sample_observer = _SampleObserver()
        self.project.add_observer(
            FilteredResourceObserver(sample_observer, [sample_file])
        )
        sample_file.remove()
        self.assertEqual(1, sample_observer.change_count)
        self.assertEqual(sample_file, sample_observer.last_removed)

    def test_resource_change_observer2(self):
        sample_file = self.project.root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(sample_observer)
        self.project.remove_observer(sample_observer)
        sample_file.write("a sample file version 2")
        self.assertEqual(0, sample_observer.change_count)

    def test_resource_change_observer_for_folders(self):
        root_folder = self.project.root
        my_folder = root_folder.create_folder("my_folder")
        my_folder_observer = _SampleObserver()
        root_folder_observer = _SampleObserver()
        self.project.add_observer(
            FilteredResourceObserver(my_folder_observer, [my_folder])
        )
        self.project.add_observer(
            FilteredResourceObserver(root_folder_observer, [root_folder])
        )
        my_file = my_folder.create_file("my_file.txt")
        self.assertEqual(1, my_folder_observer.change_count)
        my_file.move("another_file.txt")
        self.assertEqual(2, my_folder_observer.change_count)
        self.assertEqual(1, root_folder_observer.change_count)
        self.project.get_resource("another_file.txt").remove()
        self.assertEqual(2, my_folder_observer.change_count)
        self.assertEqual(2, root_folder_observer.change_count)

    def test_resource_change_observer_after_moving(self):
        sample_file = self.project.root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(sample_observer)
        sample_file.move("new_file.txt")
        self.assertEqual(1, sample_observer.change_count)
        self.assertEqual(
            (sample_file, self.project.get_resource("new_file.txt")),
            sample_observer.last_moved,
        )

    def test_revalidating_files(self):
        root = self.project.root
        my_file = root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(FilteredResourceObserver(sample_observer, [my_file]))
        os.remove(my_file.real_path)
        self.project.validate(root)
        self.assertEqual(my_file, sample_observer.last_removed)
        self.assertEqual(1, sample_observer.change_count)

    def test_revalidating_files_and_no_changes2(self):
        root = self.project.root
        my_file = root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(FilteredResourceObserver(sample_observer, [my_file]))
        self.project.validate(root)
        self.assertEqual(None, sample_observer.last_moved)
        self.assertEqual(0, sample_observer.change_count)

    def test_revalidating_folders(self):
        root = self.project.root
        my_folder = root.create_folder("myfolder")
        my_file = my_folder.create_file("myfile.txt")  # noqa
        sample_observer = _SampleObserver()
        self.project.add_observer(
            FilteredResourceObserver(sample_observer, [my_folder])
        )
        testutils.remove_recursively(my_folder.real_path)
        self.project.validate(root)
        self.assertEqual(my_folder, sample_observer.last_removed)
        self.assertEqual(1, sample_observer.change_count)

    def test_removing_and_adding_resources_to_filtered_observer(self):
        my_file = self.project.root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        filtered_observer = FilteredResourceObserver(sample_observer)
        self.project.add_observer(filtered_observer)
        my_file.write("1")
        self.assertEqual(0, sample_observer.change_count)
        filtered_observer.add_resource(my_file)
        my_file.write("2")
        self.assertEqual(1, sample_observer.change_count)
        filtered_observer.remove_resource(my_file)
        my_file.write("3")
        self.assertEqual(1, sample_observer.change_count)

    def test_validation_and_changing_files(self):
        my_file = self.project.root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        timekeeper = _MockChangeIndicator()
        filtered_observer = FilteredResourceObserver(
            sample_observer, [my_file], timekeeper=timekeeper
        )
        self.project.add_observer(filtered_observer)
        self._write_file(my_file.real_path)
        timekeeper.set_indicator(my_file, 1)
        self.project.validate(self.project.root)
        self.assertEqual(1, sample_observer.change_count)

    def test_validation_and_changing_files2(self):
        my_file = self.project.root.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        timekeeper = _MockChangeIndicator()
        self.project.add_observer(
            FilteredResourceObserver(sample_observer, [my_file], timekeeper=timekeeper)
        )
        timekeeper.set_indicator(my_file, 1)
        my_file.write("hey")
        self.assertEqual(1, sample_observer.change_count)
        self.project.validate(self.project.root)
        self.assertEqual(1, sample_observer.change_count)

    def test_not_reporting_multiple_changes_to_folders(self):
        root = self.project.root
        file1 = root.create_file("file1.txt")
        file2 = root.create_file("file2.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(
            FilteredResourceObserver(sample_observer, [root, file1, file2])
        )
        os.remove(file1.real_path)
        os.remove(file2.real_path)
        self.assertEqual(0, sample_observer.change_count)
        self.project.validate(self.project.root)
        self.assertEqual(3, sample_observer.change_count)

    def _write_file(self, path):
        my_file = open(path, "w")
        my_file.write("\n")
        my_file.close()

    def test_moving_and_being_interested_about_a_folder_and_a_child(self):
        my_folder = self.project.root.create_folder("my_folder")
        my_file = my_folder.create_file("my_file.txt")
        sample_observer = _SampleObserver()
        filtered_observer = FilteredResourceObserver(
            sample_observer, [my_folder, my_file]
        )
        self.project.add_observer(filtered_observer)
        my_folder.move("new_folder")
        self.assertEqual(2, sample_observer.change_count)

    def test_contains_for_folders(self):
        folder1 = self.project.root.create_folder("folder")
        folder2 = self.project.root.create_folder("folder2")
        self.assertFalse(folder1.contains(folder2))

    def test_validating_when_created(self):
        root = self.project.root
        my_file = self.project.get_file("my_file.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(FilteredResourceObserver(sample_observer, [my_file]))
        open(my_file.real_path, "w").close()
        self.project.validate(root)
        self.assertEqual(my_file, sample_observer.last_created)
        self.assertEqual(1, sample_observer.change_count)

    def test_validating_twice_when_created(self):
        root = self.project.root
        my_file = self.project.get_file("my_file.txt")
        sample_observer = _SampleObserver()
        self.project.add_observer(FilteredResourceObserver(sample_observer, [my_file]))
        open(my_file.real_path, "w").close()
        self.project.validate(root)
        self.project.validate(root)
        self.assertEqual(my_file, sample_observer.last_created)
        self.assertEqual(1, sample_observer.change_count)

    def test_changes_and_adding_resources(self):
        root = self.project.root  # noqa
        file1 = self.project.get_file("file1.txt")
        file2 = self.project.get_file("file2.txt")
        file1.create()
        sample_observer = _SampleObserver()
        self.project.add_observer(
            FilteredResourceObserver(sample_observer, [file1, file2])
        )
        file1.move(file2.path)
        self.assertEqual(2, sample_observer.change_count)
        self.assertEqual(file2, sample_observer.last_created)
        self.assertEqual((file1, file2), sample_observer.last_moved)

    def test_validating_get_files_list(self):
        root = self.project.root  # noqa
        self.assertEqual(0, len(self.project.get_files()))
        file = open(os.path.join(self.project.address, "myfile.txt"), "w")
        file.close()
        self.project.validate()
        self.assertEqual(1, len(self.project.get_files()))

    def test_clear_observed_resources_for_filtered_observers(self):
        sample_file = self.project.root.create_file("myfile.txt")
        sample_observer = _SampleObserver()
        filtered = FilteredResourceObserver(sample_observer)
        self.project.add_observer(filtered)
        filtered.add_resource(sample_file)
        filtered.clear_resources()
        sample_file.write("1")
        self.assertEqual(0, sample_observer.change_count)


class _MockChangeIndicator:
    def __init__(self):
        self.times = {}

    def set_indicator(self, resource, time):
        self.times[resource] = time

    def get_indicator(self, resource):
        return self.times.get(resource, 0)


class _SampleObserver:
    def __init__(self):
        self.change_count = 0
        self.last_changed = None
        self.last_moved = None
        self.last_created = None
        self.last_removed = None

    def resource_changed(self, resource):
        self.last_changed = resource
        self.change_count += 1

    def resource_moved(self, resource, new_resource):
        self.last_moved = (resource, new_resource)
        self.change_count += 1

    def resource_created(self, resource):
        self.last_created = resource
        self.change_count += 1

    def resource_removed(self, resource):
        self.last_removed = resource
        self.change_count += 1


class OutOfProjectTest(unittest.TestCase):
    def setUp(self):
        super().setUp()
        self.test_directory = "temp_test_directory"
        testutils.remove_recursively(self.test_directory)
        os.mkdir(self.test_directory)
        self.project = testutils.sample_project()
        self.no_project = NoProject()

    def tearDown(self):
        testutils.remove_project(self.project)
        testutils.remove_recursively(self.test_directory)
        super().tearDown()

    def test_simple_out_of_project_file(self):
        sample_file_path = os.path.join(self.test_directory, "sample.txt")
        sample_file = open(sample_file_path, "w")
        sample_file.write("sample content\n")
        sample_file.close()
        sample_resource = self.no_project.get_resource(sample_file_path)
        self.assertEqual("sample content\n", sample_resource.read())

    def test_simple_out_of_project_folder(self):
        sample_folder_path = os.path.join(self.test_directory, "sample_folder")
        os.mkdir(sample_folder_path)
        sample_folder = self.no_project.get_resource(sample_folder_path)
        self.assertEqual([], sample_folder.get_children())

        sample_file_path = os.path.join(sample_folder_path, "sample.txt")
        open(sample_file_path, "w").close()
        sample_resource = self.no_project.get_resource(sample_file_path)
        self.assertEqual(sample_resource, sample_folder.get_children()[0])

    def test_using_absolute_path(self):
        sample_file_path = os.path.join(self.test_directory, "sample.txt")
        open(sample_file_path, "w").close()
        normal_sample_resource = self.no_project.get_resource(sample_file_path)
        absolute_sample_resource = self.no_project.get_resource(
            os.path.abspath(sample_file_path)
        )
        self.assertEqual(normal_sample_resource, absolute_sample_resource)

    def test_folder_get_child(self):
        sample_folder_path = os.path.join(self.test_directory, "sample_folder")
        os.mkdir(sample_folder_path)
        sample_folder = self.no_project.get_resource(sample_folder_path)
        self.assertEqual([], sample_folder.get_children())

        sample_file_path = os.path.join(sample_folder_path, "sample.txt")
        open(sample_file_path, "w").close()
        sample_resource = self.no_project.get_resource(sample_file_path)
        self.assertTrue(sample_folder.has_child("sample.txt"))
        self.assertFalse(sample_folder.has_child("doesnothave.txt"))
        self.assertEqual(sample_resource, sample_folder.get_child("sample.txt"))

    def test_out_of_project_files_and_path_to_resource(self):
        sample_file_path = os.path.join(self.test_directory, "sample.txt")
        sample_file = open(sample_file_path, "w")
        sample_file.write("sample content\n")
        sample_file.close()
        sample_resource = self.no_project.get_resource(sample_file_path)
        self.assertEqual(
            sample_resource, path_to_resource(self.project, sample_file_path)
        )


class _MockFSCommands:
    def __init__(self):
        self.log = ""
        self.fscommands = FileSystemCommands()

    def create_file(self, path):
        self.log += "create_file "
        self.fscommands.create_file(path)

    def create_folder(self, path):
        self.log += "create_folder "
        self.fscommands.create_folder(path)

    def move(self, path, new_location):
        self.log += "move "
        self.fscommands.move(path, new_location)

    def remove(self, path):
        self.log += "remove "
        self.fscommands.remove(path)

    def read(self, path):
        self.log += "read "
        return self.fscommands.read(path)


class _DeprecatedFSCommands:
    def __init__(self):
        self.log = ""
        self.fscommands = FileSystemCommands()

    def create_file(self, path):
        self.log += "create_file "
        self.fscommands.create_file(path)

    def create_folder(self, path):
        self.log += "create_folder "
        self.fscommands.create_folder(path)

    def move(self, path, new_location):
        self.log += "move "
        self.fscommands.move(path, new_location)

    def remove(self, path):
        self.log += "remove "
        self.fscommands.remove(path)


class RopeFolderTest(unittest.TestCase):
    def setUp(self):
        super().setUp()
        self.project = None

    def tearDown(self):
        if self.project:
            testutils.remove_project(self.project)
        super().tearDown()

    def test_none_project_rope_folder(self):
        self.project = testutils.sample_project(ropefolder=None)
        self.assertTrue(self.project.ropefolder is None)

    def test_getting_project_rope_folder(self):
        self.project = testutils.sample_project()
        self.assertTrue(self.project.ropefolder.exists())
        self.assertEqual(".ropeproject", self.project.ropefolder.path)

    def test_setting_ignored_resources(self):
        self.project = testutils.sample_project(ignored_resources=["myfile.txt"])
        myfile = self.project.get_file("myfile.txt")
        file2 = self.project.get_file("file2.txt")
        self.assertTrue(self.project.is_ignored(myfile))
        self.assertFalse(self.project.is_ignored(file2))

    def test_ignored_folders(self):
        self.project = testutils.sample_project(ignored_resources=["myfolder"])
        myfolder = self.project.root.create_folder("myfolder")
        self.assertTrue(self.project.is_ignored(myfolder))
        myfile = myfolder.create_file("myfile.txt")
        self.assertTrue(self.project.is_ignored(myfile))

    def test_ignored_resources_and_get_files(self):
        self.project = testutils.sample_project(
            ignored_resources=["myfile.txt"], ropefolder=None
        )
        myfile = self.project.get_file("myfile.txt")
        self.assertEqual(0, len(self.project.get_files()))
        myfile.create()
        self.assertEqual(0, len(self.project.get_files()))

    def test_ignored_resources_and_get_files2(self):
        self.project = testutils.sample_project(
            ignored_resources=["myfile.txt"], ropefolder=None
        )
        myfile = self.project.root.create_file("myfile.txt")  # noqa
        self.assertEqual(0, len(self.project.get_files()))

    def test_setting_ignored_resources_patterns(self):
        self.project = testutils.sample_project(ignored_resources=["m?file.*"])
        myfile = self.project.get_file("myfile.txt")
        file2 = self.project.get_file("file2.txt")
        self.assertTrue(self.project.is_ignored(myfile))
        self.assertFalse(self.project.is_ignored(file2))

    def test_star_should_not_include_slashes(self):
        self.project = testutils.sample_project(ignored_resources=["f*.txt"])
        folder = self.project.root.create_folder("folder")
        file1 = folder.create_file("myfile.txt")
        file2 = folder.create_file("file2.txt")
        self.assertFalse(self.project.is_ignored(file1))
        self.assertTrue(self.project.is_ignored(file2))

    def test_normal_fscommands(self):
        fscommands = _MockFSCommands()
        self.project = testutils.sample_project(fscommands=fscommands)
        myfile = self.project.get_file("myfile.txt")
        myfile.create()
        self.assertEqual("create_file ", fscommands.log)

    def test_fscommands_and_ignored_resources(self):
        fscommands = _MockFSCommands()
        self.project = testutils.sample_project(
            fscommands=fscommands, ignored_resources=["myfile.txt"], ropefolder=None
        )
        myfile = self.project.get_file("myfile.txt")
        myfile.create()
        self.assertEqual("", fscommands.log)

    def test_deprecated_fscommands(self):
        fscommands = _DeprecatedFSCommands()
        self.project = testutils.sample_project(fscommands=fscommands)
        myfile = self.project.get_file("myfile.txt")
        myfile.create()
        self.assertEqual("create_file ", fscommands.log)

    def test_ignored_resources_and_prefixes(self):
        self.project = testutils.sample_project(ignored_resources=[".hg"])
        myfile = self.project.root.create_file(".hgignore")
        self.assertFalse(self.project.is_ignored(myfile))

    def test_loading_config_dot_py(self):
        self.project = testutils.sample_project()
        config = self.project.get_file(".ropeproject/config.py")
        if not config.exists():
            config.create()
        config.write(dedent("""\
            def set_prefs(prefs):
                prefs["ignored_resources"] = ["myfile.txt"]
            def project_opened(project):
                project.root.create_file("loaded")
        """))
        self.project.close()
        self.project = Project(self.project.address)
        self.assertTrue(self.project.get_file("loaded").exists())
        myfile = self.project.get_file("myfile.txt")
        self.assertTrue(self.project.is_ignored(myfile))

    def test_loading_pyproject(self):
        self.project = testutils.sample_project()
        config = self.project.get_file("pyproject.toml")
        if not config.exists():
            config.create()
        config.write(dedent("""\
            [tool.rope]
            ignored_resources=["pyproject.py"]
        """))
        self.project.close()
        self.project = Project(self.project.address)
        myfile = self.project.get_file("pyproject.py")
        self.assertTrue(self.project.is_ignored(myfile))

    def test_loading_pyproject_empty_file(self):
        self.project = testutils.sample_project()
        config = self.project.get_file("pyproject.toml")
        if not config.exists():
            config.create()
        config.write("")
        self.project.close()
        self.project = Project(self.project.address)
        myfile = self.project.get_file("pyproject.py")
        self.assertFalse(self.project.is_ignored(myfile))

    def test_loading_pyproject_no_tool_section(self):
        self.project = testutils.sample_project()
        config = self.project.get_file("pyproject.toml")
        if not config.exists():
            config.create()
        config.write(dedent("""\
            [project]
            name = 'testproject'
        """))
        self.project.close()
        self.project = Project(self.project.address)
        myfile = self.project.get_file("pyproject.py")
        self.assertFalse(self.project.is_ignored(myfile))

    def test_loading_pyproject_no_tool_rope_section(self):
        self.project = testutils.sample_project()
        config = self.project.get_file("pyproject.toml")
        if not config.exists():
            config.create()
        config.write(dedent("""\
            [tool.anothertool]
            name = 'testproject'
        """))
        self.project.close()
        self.project = Project(self.project.address)
        myfile = self.project.get_file("pyproject.py")
        self.assertFalse(self.project.is_ignored(myfile))

    def test_ignoring_syntax_errors(self):
        self.project = testutils.sample_project(
            ropefolder=None, ignore_syntax_errors=True
        )
        mod = testutils.create_module(self.project, "mod")
        mod.write("xyz print")
        pymod = self.project.get_pymodule(mod)  # noqa

    def test_compressed_history(self):
        self.project = testutils.sample_project(compress_history=True)
        mod = testutils.create_module(self.project, "mod")
        mod.write("")

    def test_compressed_objectdb(self):
        self.project = testutils.sample_project(compress_objectdb=True)
        mod = testutils.create_module(self.project, "mod")
        self.project.pycore.analyze_module(mod)

    def test_nested_dot_ropeproject_folder(self):
        self.project = testutils.sample_project(ropefolder=".f1/f2")
        ropefolder = self.project.ropefolder
        self.assertEqual(".f1/f2", ropefolder.path)
        self.assertTrue(ropefolder.exists())
