rename all resource with Resource Suffixe to avoid trouble with multiple class with same name

tracim/lib/webdav/dav_provider.py

         path = normpath(path)
         root_path = environ['http_authenticator.realm']
 
-        # If the requested path is the root, then we return a Root resource
+        # If the requested path is the root, then we return a RootResource resource
         if path == root_path:
-            return resources.Root(path, environ, user=user, session=session)
+            return resources.RootResource(path, environ, user=user, session=session)
 
         workspace_api = WorkspaceApi(current_user=user, session=session)
         workspace = self.get_workspace_from_path(path, workspace_api)
 
-        # If the request path is in the form root/name, then we return a Workspace resource
+        # If the request path is in the form root/name, then we return a WorkspaceResource resource
         parent_path = dirname(path)
         if parent_path == root_path:
             if not workspace:
                 return None
-            return resources.Workspace(
+            return resources.WorkspaceResource(
                 path=path,
                 environ=environ,
                 workspace=workspace,
 
         # Easy cases : path either end with /.deleted, /.archived or /.history, then we return corresponding resources
         if path.endswith(SpecialFolderExtension.Archived) and self._show_archive:
-            return resources.ArchivedFolder(path, environ, workspace, content)
+            return resources.ArchivedFolderResource(path, environ, workspace, content)
 
         if path.endswith(SpecialFolderExtension.Deleted) and self._show_delete:
-            return resources.DeletedFolder(path, environ, workspace, content)
+            return resources.DeletedFolderResource(path, environ, workspace, content)
 
         if path.endswith(SpecialFolderExtension.History) and self._show_history:
             is_deleted_folder = re.search(r'/\.deleted/\.history$', path) is not None
                 else HistoryType.Archived if is_archived_folder \
                 else HistoryType.Standard
 
-            return resources.HistoryFolder(path, environ, workspace, content, type)
+            return resources.HistoryFolderResource(path, environ, workspace, content, type)
 
         # Now that's more complicated, we're trying to find out if the path end with /.history/file_name
         is_history_file_folder = re.search(r'/\.history/([^/]+)$', path) is not None
 
         if is_history_file_folder and self._show_history:
-            return resources.HistoryFileFolder(
+            return resources.HistoryFileFolderResource(
                 path=path,
                 environ=environ,
                 content=content
             content = self.get_content_from_revision(content_revision, content_api)
 
             if content.type == ContentType.File:
-                return resources.HistoryFile(path, environ, content, content_revision)
+                return resources.HistoryFileResource(path, environ, content, content_revision)
             else:
                 return resources.HistoryOtherFile(path, environ, content, content_revision)
 
         if content is None:
             return None
         if content.type == ContentType.Folder:
-            return resources.Folder(
+            return resources.FolderResource(
                 path=path,
                 environ=environ,
                 workspace=content.workspace,
                 user=user,
             )
         elif content.type == ContentType.File:
-            return resources.File(
+            return resources.FileResource(
                 path=path,
                 environ=environ,
                 content=content,
                 user=user
             )
         else:
-            return resources.OtherFile(
+            return resources.OtherFileResource(
                 path=path,
                 environ=environ,
                 content=content,

tracim/lib/webdav/resources.py

         transaction.commit()
 
 
-class Root(DAVCollection):
+class RootResource(DAVCollection):
     """
-    Root ressource that represents tracim's home, which contains all workspaces
+    RootResource ressource that represents tracim's home, which contains all workspaces
     """
 
     def __init__(self, path: str, environ: dict, user: User, session: Session):
-        super(Root, self).__init__(path, environ)
+        super(RootResource, self).__init__(path, environ)
 
         self.user = user
         self.session = session
         )
 
     def __repr__(self) -> str:
-        return '<DAVCollection: Root>'
+        return '<DAVCollection: RootResource>'
 
     def getMemberNames(self) -> [str]:
         """
             workspace = self.workspace_api.get_one_by_label(label)
             workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', transform_to_display(workspace.label))
 
-            return Workspace(workspace_path, self.environ, workspace)
+            return WorkspaceResource(
+                workspace_path,
+                self.environ,
+                workspace,
+            )
         except AttributeError:
             return None
 
         self.path, '' if self.path == '/' else '/', transform_to_display(new_workspace.label))
 
         transaction.commit()
-        return Workspace(workspace_path, self.environ, new_workspace)
+        return WorkspaceResource(workspace_path, self.environ, new_workspace)
 
     def getMemberList(self):
         """
         for workspace in self.workspace_api.get_all():
             workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', workspace.label)
             members.append(
-                Workspace(
+                WorkspaceResource(
                     path=workspace_path,
                     environ=self.environ,
                     workspace=workspace,
         return members
 
 
-class Workspace(DAVCollection):
+class WorkspaceResource(DAVCollection):
     """
     Workspace resource corresponding to tracim's workspaces.
     Direct children can only be folders, though files might come later on and are supported
                  user: User,
                  session: Session
     ) -> None:
-        super(Workspace, self).__init__(path, environ)
+        super(WorkspaceResource, self).__init__(path, environ)
 
         self.workspace = workspace
         self.content = None
             path=self.path + '/' + file_name
         )
 
-    def createCollection(self, label: str) -> 'Folder':
+    def createCollection(self, label: str) -> 'FolderResource':
         """
         Create a new folder for the current workspace. As it's not possible for the user to choose
         which types of content are allowed in this folder, we allow allow all of them.
 
         transaction.commit()
 
-        return Folder('%s/%s' % (self.path, transform_to_display(label)),
-                      self.environ,
-                      content=folder,
-                      session=self.session,
-                      user=self.user,
-                      workspace=self.workspace,
-                      )
+        return FolderResource('%s/%s' % (self.path, transform_to_display(label)),
+                              self.environ,
+                              content=folder,
+                              session=self.session,
+                              user=self.user,
+                              workspace=self.workspace,
+                              )
 
     def delete(self):
         """For now, it is not possible to delete a workspace through the webdav client."""
 
             if content.type == ContentType.Folder:
                 members.append(
-                    Folder(
+                    FolderResource(
                         path=content_path,
                         environ=self.environ,
                         workspace=self.workspace,
             elif content.type == ContentType.File:
                 self._file_count += 1
                 members.append(
-                    File(
+                    FileResource(
                         path=content_path,
                         environ=self.environ,
                         content=content,
             else:
                 self._file_count += 1
                 members.append(
-                    OtherFile(
+                    OtherFileResource(
                         content_path,
                         self.environ,
                         content,
 
         if self._file_count > 0 and self.provider.show_history():
             members.append(
-                HistoryFolder(
+                HistoryFolderResource(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
                     content=self.content,
 
         if self.provider.show_delete():
             members.append(
-                DeletedFolder(
+                DeletedFolderResource(
                     path=self.path + '/' + ".deleted",
                     environ=self.environ,
                     content=self.content,
 
         if self.provider.show_archive():
             members.append(
-                ArchivedFolder(
+                ArchivedFolderResource(
                     path=self.path + '/' + ".archived",
                     environ=self.environ,
                     content=self.content,
         return members
 
 
-class Folder(Workspace):
+class FolderResource(WorkspaceResource):
     """
-    Folder resource corresponding to tracim's folders.
+    FolderResource resource corresponding to tracim's folders.
     Direct children can only be either folder, files, pages or threads
     By default when creating new folders, we allow them to contain all types of content
     """
             user: User,
             session: Session
     ):
-        super(Folder, self).__init__(
+        super(FolderResource, self).__init__(
             path=path,
             environ=environ,
             workspace=workspace,
             try:
                 if content.type == ContentType.Folder:
                     members.append(
-                        Folder(
+                        FolderResource(
                             path=content_path,
                             environ=self.environ,
                             workspace=self.workspace,
                 elif content.type == ContentType.File:
                     self._file_count += 1
                     members.append(
-                        File(
+                        FileResource(
                             path=content_path,
                             environ=self.environ,
                             content=content,
                 else:
                     self._file_count += 1
                     members.append(
-                        OtherFile(
+                        OtherFileResource(
                             path=content_path,
                             environ=self.environ,
                             content=content,
 
         if self._file_count > 0 and self.provider.show_history():
             members.append(
-                HistoryFolder(
+                HistoryFolderResource(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
                     content=self.content,
 
         if self.provider.show_delete():
             members.append(
-                DeletedFolder(
+                DeletedFolderResource(
                     path=self.path + '/' + ".deleted",
                     environ=self.environ,
                     content=self.content,
 
         if self.provider.show_archive():
             members.append(
-                ArchivedFolder(
+                ArchivedFolderResource(
                     path=self.path + '/' + ".archived",
                     environ=self.environ,
                     content=self.content,
 # Those object are now not in used by tracim and also not tested,
 
 
-class HistoryFolder(Folder):
+class HistoryFolderResource(FolderResource):
     """
     A virtual resource which contains a sub-folder for every files (DAVNonCollection) contained in the parent
     folder
                  content: Content=None,
                  type: str=HistoryType.Standard
     ) -> None:
-        super(HistoryFolder, self).__init__(
+        super(HistoryFolderResource, self).__init__(
             path=path,
             environ=environ,
             workspace=workspace,
         )
 
     def __repr__(self) -> str:
-        return "<DAVCollection: HistoryFolder (%s)>" % self.content.file_name
+        return "<DAVCollection: HistoryFolderResource (%s)>" % self.content.file_name
 
     def getCreationDate(self) -> float:
         return mktime(datetime.now().timetuple())
             content_parent=self.content
         )
 
-        return HistoryFileFolder(
+        return HistoryFileFolderResource(
             path='%s/%s' % (self.path, content.get_label_as_file()),
             environ=self.environ,
             content=content,
         
         for content in children:
             if content.is_archived == self._is_archived and content.is_deleted == self._is_deleted:
-                members.append(HistoryFileFolder(
+                members.append(HistoryFileFolderResource(
                     path='%s/%s' % (self.path, content.get_label_as_file()),
                     environ=self.environ,
                     content=content,
         return members
 
 
-class DeletedFolder(HistoryFolder):
+class DeletedFolderResource(HistoryFolderResource):
     """
     A virtual resources which exists for every folder or workspaces which contains their deleted children
     """
             session: Session,
             content: Content=None
     ):
-        super(DeletedFolder, self).__init__(
+        super(DeletedFolderResource, self).__init__(
             path=path,
             environ=environ,
             workspace=workspace,
         self._file_count = 0
 
     def __repr__(self):
-        return "<DAVCollection: DeletedFolder (%s)" % self.content.file_name
+        return "<DAVCollection: DeletedFolderResource (%s)" % self.content.file_name
 
     def getCreationDate(self) -> float:
         return mktime(datetime.now().timetuple())
 
                 if content.type == ContentType.Folder:
                     members.append(
-                        Folder(
+                        FolderResource(
                             content_path,
                             self.environ,
                             self.workspace,
                 elif content.type == ContentType.File:
                     self._file_count += 1
                     members.append(
-                        File(
+                        FileResource(
                             content_path,
                             self.environ,
                             content,
                 else:
                     self._file_count += 1
                     members.append(
-                        OtherFile(
+                        OtherFileResource(
                             content_path,
                             self.environ,
                             content,
 
         if self._file_count > 0 and self.provider.show_history():
             members.append(
-                HistoryFolder(
+                HistoryFolderResource(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
                     content=self.content,
         return members
 
 
-class ArchivedFolder(HistoryFolder):
+class ArchivedFolderResource(HistoryFolderResource):
     """
     A virtual resources which exists for every folder or workspaces which contains their archived children
     """
             session: Session,
             content: Content=None
     ):
-        super(ArchivedFolder, self).__init__(
+        super(ArchivedFolderResource, self).__init__(
             path=path,
             environ=environ,
             workspace=workspace,
         self._file_count = 0
 
     def __repr__(self) -> str:
-        return "<DAVCollection: ArchivedFolder (%s)" % self.content.file_name
+        return "<DAVCollection: ArchivedFolderResource (%s)" % self.content.file_name
 
     def getCreationDate(self) -> float:
         return mktime(datetime.now().timetuple())
 
                 if content.type == ContentType.Folder:
                     members.append(
-                        Folder(
+                        FolderResource(
                             content_path,
                             self.environ,
                             self.workspace,
                 elif content.type == ContentType.File:
                     self._file_count += 1
                     members.append(
-                        File(
+                        FileResource(
                             content_path,
                             self.environ,
                             content,
                 else:
                     self._file_count += 1
                     members.append(
-                        OtherFile(
+                        OtherFileResource(
                             content_path,
                             self.environ,
                             content,
 
         if self._file_count > 0 and self.provider.show_history():
             members.append(
-                HistoryFolder(
+                HistoryFolderResource(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
                     content=self.content,
         return members
 
 
-class HistoryFileFolder(HistoryFolder):
+class HistoryFileFolderResource(HistoryFolderResource):
     """
     A virtual resource that contains for a given content (file/page/thread) all its revisions
     """
             user: User,
             session: Session
     ) -> None:
-        super(HistoryFileFolder, self).__init__(
+        super(HistoryFileFolderResource, self).__init__(
             path=path,
             environ=environ,
             workspace=content.workspace,
         )
 
     def __repr__(self) -> str:
-        return "<DAVCollection: HistoryFileFolder (%s)" % self.content.file_name
+        return "<DAVCollection: HistoryFileFolderResource (%s)" % self.content.file_name
 
     def getDisplayName(self) -> str:
         return self.content.get_label_as_file()
         left_side = '%s/(%d - %s) ' % (self.path, revision.revision_id, revision.revision_type)
 
         if self.content.type == ContentType.File:
-            return HistoryFile(
+            return HistoryFileResource(
                 path='%s%s' % (left_side, transform_to_display(revision.file_name)),
                 environ=self.environ,
                 content=self.content,
             left_side = '%s/(%d - %s) ' % (self.path, content.revision_id, content.revision_type)
 
             if self.content.type == ContentType.File:
-                members.append(HistoryFile(
+                members.append(HistoryFileResource(
                     path='%s%s' % (left_side, transform_to_display(content.file_name)),
                     environ=self.environ,
                     content=self.content,
         return members
 
 
-class File(DAVNonCollection):
+class FileResource(DAVNonCollection):
     """
-    File resource corresponding to tracim's files
+    FileResource resource corresponding to tracim's files
     """
     def __init__(
             self,
             user: User,
             session: Session,
     ) -> None:
-        super(File, self).__init__(path, environ)
+        super(FileResource, self).__init__(path, environ)
 
         self.content = content
         self.user = user
         # self.setPropertyValue('Win32FileAttributes', '00000021')
 
     def __repr__(self) -> str:
-        return "<DAVNonCollection: File (%d)>" % self.content.revision_id
+        return "<DAVNonCollection: FileResource (%d)>" % self.content.revision_id
 
     def getContentLength(self) -> int:
         return self.content.depot_file.file.content_length
         ).action()
 
 
-class HistoryFile(File):
+class HistoryFileResource(FileResource):
     """
     A virtual resource corresponding to a specific tracim's revision's file
     """
     def __init__(self, path: str, environ: dict, content: Content, user: User, session: Session, content_revision: ContentRevisionRO):
-        super(HistoryFile, self).__init__(path, environ, content, user=user, session=session)
+        super(HistoryFileResource, self).__init__(path, environ, content, user=user, session=session)
         self.content_revision = content_revision
 
     def __repr__(self) -> str:
-        return "<DAVNonCollection: HistoryFile (%s-%s)" % (self.content.content_id, self.content.file_name)
+        return "<DAVNonCollection: HistoryFileResource (%s-%s)" % (self.content.content_id, self.content.file_name)
 
     def getDisplayName(self) -> str:
         left_side = '(%d - %s) ' % (self.content_revision.revision_id, self.content_revision.revision_type)
         raise DAVError(HTTP_FORBIDDEN)
 
 
-class OtherFile(File):
+class OtherFileResource(FileResource):
     """
-    File resource corresponding to tracim's page and thread
+    FileResource resource corresponding to tracim's page and thread
     """
     def __init__(self, path: str, environ: dict, content: Content, user:User, session: Session):
-        super(OtherFile, self).__init__(path, environ, content, user=user, session=session)
+        super(OtherFileResource, self).__init__(path, environ, content, user=user, session=session)
 
         self.content_revision = self.content.revision
 
         return self.path
 
     def __repr__(self) -> str:
-        return "<DAVNonCollection: OtherFile (%s)" % self.content.file_name
+        return "<DAVNonCollection: OtherFileResource (%s)" % self.content.file_name
 
     def getContentLength(self) -> int:
         return len(self.content_designed)
             )
 
 
-class HistoryOtherFile(OtherFile):
+class HistoryOtherFile(OtherFileResource):
     """
     A virtual resource corresponding to a specific tracim's revision's page and thread
     """

tracim/tests/library/test_webdav.py

 from tracim.tests import eq_
 from tracim.lib.core.notifications import DummyNotifier
 from tracim.lib.webdav.dav_provider import Provider
-from tracim.lib.webdav.resources import Root
+from tracim.lib.webdav.resources import RootResource
 from tracim.models import Content
 from tracim.models import ContentRevisionRO
 from tracim.tests import StandardTest
                 'bob@fsf.local',
             )
         )
-        assert root, 'Path / should return a Root instance'
-        assert isinstance(root, Root)
+        assert root, 'Path / should return a RootResource instance'
+        assert isinstance(root, RootResource)
 
     def test_unit__list_workspaces_with_user__ok(self):
         provider = self._get_provider(self.app_config)
                 'bob@fsf.local',
             )
         )
-        assert root, 'Path / should return a Root instance'
-        assert isinstance(root, Root), 'Path / should return a Root instance'
+        assert root, 'Path / should return a RootResource instance'
+        assert isinstance(root, RootResource), 'Path / should return a RootResource instance'
 
         children = root.getMemberList()
         eq_(
             2,
             len(children),
-            msg='Root should return 2 workspaces instead {0}'.format(
+            msg='RootResource should return 2 workspaces instead {0}'.format(
                 len(children),
             )
         )
                 'admin@admin.admin',
             )
         )
-        assert root, 'Path / should return a Root instance'
-        assert isinstance(root, Root), 'Path / should return a Root instance'
+        assert root, 'Path / should return a RootResource instance'
+        assert isinstance(root, RootResource), 'Path / should return a RootResource instance'
 
         children = root.getMemberList()
         eq_(
             2,
             len(children),
-            msg='Root should return 2 workspaces instead {0}'.format(
+            msg='RootResource should return 2 workspaces instead {0}'.format(
                 len(children),
             )
         )