MainController.sortingMode() - Code Metrics - Inspection of "first attempt custom sorting. more cleanup necessa..." - QTodoTxt/QTodoTxt2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — qml ( 9c2cb2...7f61bc )

by Olivier

created 2017-05-03 18:06 UTC

MainController.sortingMode() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
dl	0
loc	3
rs	10

import logging
import os
import string

from PyQt5 import QtCore

from qtodotxt.lib import tasklib
from qtodotxt.lib.file import File

from qtodotxt.filters_tree_controller import FiltersTreeController
from qtodotxt.lib.filters import SimpleTextFilter, FutureFilter, IncompleteTasksFilter, CompleteTasksFilter

logger = logging.getLogger(__name__)


class MainController(QtCore.QObject):

    error = QtCore.pyqtSignal(str, arguments=["msg"])
    fileExternallyModified = QtCore.pyqtSignal()

    def __init__(self, args):
        super(MainController, self).__init__()
        self._args = args
        self._filteredTasks = []
        self._sortingMode = "default"
        # use object variable for setting only used in this class
        # others are accessed through QSettings
        self._settings = QtCore.QSettings()
        self._showCompleted = self._settings.value("show_completed", False)
        self._showFuture = self._settings.value("show_completed", True)
        self._file = File()
        self._file.fileModified.connect(self.fileExternallyModified)
        self._modified = False
        self._filters_tree_controller = FiltersTreeController()
        self._title = "QTodoTxt"
        self._recentFiles = self._settings.value("recent_files", [])
        self._searchText = ""
        self._currentFilters = []
        # self._currentFilters = self._settings.value("current_filters", ["All"])  # move to QML
        self._updateCompletionStrings()

    def _taskModified(self, task):
        self.setModified()
        self.auto_save()
        if not task.text:
            self.deleteTask(task)
            return
        self.applyFilters()

    def showError(self, msg):
        logger.debug("ERROR: %s", msg)
        self.error.emit(msg)

    completionChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QStringList', notify=completionChanged)
    def completionStrings(self):
        return self._completionStrings

    def _updateCompletionStrings(self):
        contexts = ['@' + name for name in self._file.getAllContexts()]
        projects = ['+' + name for name in self._file.getAllProjects()]
        lowest_priority = self._settings.value("lowest_priority", "D")
        idx = string.ascii_uppercase.index(lowest_priority) + 1
        priorities = ['(' + val + ')' for val in string.ascii_uppercase[:idx]]
        self._completionStrings = contexts + projects + priorities + ['due:']
        self.completionChanged.emit()

    @QtCore.pyqtSlot('QModelIndexList')
    def filterByIndexes(self, idxs):
        filters = [self._filters_tree_controller.model.itemFromIndex(idx).filter for idx in idxs]
        self.setFilters(filters)

    def setFilters(self, filters):
        self._currentFilters = filters
        self.applyFilters()

    @QtCore.pyqtSlot('QString', 'int', result='int')
    def newTask(self, text='', after=None):
        task = tasklib.Task(text)
        if bool(self._settings.value("Preferences/add_creation_date", False, type=bool)):
            task.addCreationDate()
        task.modified.connect(self._taskModified)
        if after is None:
            after = len(self._filteredTasks) - 1
        self._file.tasks.append(task)
        self._filteredTasks.insert(after + 1, task)  # force the new task to be visible
        self.setModified()
        self.auto_save()
        self.filteredTasksChanged.emit()
        return after + 1

    @QtCore.pyqtSlot('QVariant')
    def deleteTask(self, task):
        if not isinstance(task, tasklib.Task):
            # if task is not a task assume it is an int
            task = self.filteredTasks[task]
        self._file.tasks.remove(task)
        self.setModified()
        self.auto_save()
        self.applyFilters()  # update filtered list for UI

    @property
    def allTasks(self):
        return self._file.tasks

    @allTasks.setter
    def allTasks(self, tasks):
        self._file.tasks = tasks

    filteredTasksChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QVariant', notify=filteredTasksChanged)
    def filteredTasks(self):
        return self._filteredTasks

    showFutureChanged = QtCore.pyqtSignal('bool')

    @QtCore.pyqtProperty('bool', notify=showFutureChanged)
    def showFuture(self):
        return self._showFuture

    @showFuture.setter
    def showFuture(self, val):
        self._showFuture = val
        self.showFutureChanged.emit(val)
        self.applyFilters()

    sortingModeChanged = QtCore.pyqtSignal(str)

    @QtCore.pyqtProperty(str, notify=showFutureChanged)
    def sortingMode(self):
        return self._sortingMode

    @sortingMode.setter
    def sortingMode(self, val):
        self._sortingMode = val
        self.sortingModeChanged.emit(val)
        self.applyFilters()


    searchTextChanged = QtCore.pyqtSignal(str)

    @QtCore.pyqtProperty('QString', notify=searchTextChanged)
    def searchText(self):
        return self._searchText

    @searchText.setter
    def searchText(self, txt):
        self._searchText = txt
        self.applyFilters()
        self.searchTextChanged.emit(txt)

    showCompletedChanged = QtCore.pyqtSignal('bool')

    @QtCore.pyqtProperty('bool', notify=showCompletedChanged)
    def showCompleted(self):
        return self._showCompleted

    @showCompleted.setter
    def showCompleted(self, val):
        self._showCompleted = val
        self.showCompletedChanged.emit(val)
        self.applyFilters()

    def auto_save(self):
        if bool(self._settings.value("Preferences/auto_save", True, type=bool)):
            self.save()

    def start(self):
        if self._args.file:
            filename = self._args.file
        else:
            filename = self._settings.value("last_open_file")

        if filename:
            try:
                self.open(filename)
            except OSError as ex:
                self.showError(str(ex))

        self.applyFilters()
        self._updateTitle()

    filtersUpdated = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QVariant', notify=filtersUpdated)
    def filtersModel(self):
        return self._filters_tree_controller.model

    def _updateFilterTree(self):
        self._filters_tree_controller.showFilters(self._file)
        self.filtersUpdated.emit()

    def applyFilters(self):
        # First we filter with filters tree
        tasks = tasklib.filterTasks(self._currentFilters, self._file.tasks)
        # Then with our search text
        if self._searchText:
            tasks = tasklib.filterTasks([SimpleTextFilter(self._searchText)], tasks)
        # with future filter if needed
        if not self._showFuture:
            tasks = tasklib.filterTasks([FutureFilter()], tasks)
        # with complete filter if needed
        if not self._showCompleted and not CompleteTasksFilter() in self._currentFilters:
            tasks = tasklib.filterTasks([IncompleteTasksFilter()], tasks)
        if self._sortingMode:
            tasks = getattr(tasklib.TaskSorter, self._sortingMode)(tasks)
        self._filteredTasks = tasks
        self.filteredTasksChanged.emit()

    @QtCore.pyqtSlot()
    def archiveCompletedTasks(self):
        done = [task for task in self._file.tasks if task.is_complete]
        for task in done:
            self._file.saveDoneTask(task)
            self._file.tasks.remove(task)
        self.applyFilters()
        self.setModified()
        self.auto_save()

    modifiedChanged = QtCore.pyqtSignal(bool)

    @QtCore.pyqtProperty('bool', notify=modifiedChanged)
    def modified(self):
        return self._modified

    def setModified(self, val=True):
        self._modified = val
        self._updateTitle()
        if val:
            self._updateCompletionStrings()
            self._updateFilterTree()
        self.modifiedChanged.emit(val)

    @QtCore.pyqtSlot("QUrl")
    @QtCore.pyqtSlot()
    def save(self, path=None):
        if not path:
            path = self._file.filename
        elif isinstance(path, QtCore.QUrl):
            path = path.toLocalFile()
        self._file.filename = path

        logger.debug('MainController, saving file: %s.', path)
        try:
            self._file.save(path)
        except OSError as ex:
            logger.exception("Error saving file %s", path)
            self.showError(ex)
            return
        self._settings.setValue("last_open_file", path)
        self._settings.sync()
        self.setModified(False)

    def _updateTitle(self):
        title = 'QTodoTxt - '
        if self._file.filename:
            filename = os.path.basename(self._file.filename)
            title += filename
        else:
            title += 'Untitled'
        if self._modified:
            title += ' (*)'
        self._title = title
        self.titleChanged.emit(self._title)

    titleChanged = QtCore.pyqtSignal(str)

    @QtCore.pyqtProperty('QString', notify=titleChanged)
    def title(self):
        return self._title

    @QtCore.pyqtSlot(result='bool')
    def canExit(self):
        self.auto_save()
        return not self._modified

    def new(self):
        if self.canExit():
            self._file = File()
            self._loadFileToUI()

    @QtCore.pyqtSlot()
    def reload(self):
        self.open(self._file.filename)

    @QtCore.pyqtSlot('QUrl')
    @QtCore.pyqtSlot('QString')
    def open(self, filename):
        if isinstance(filename, QtCore.QUrl):
            filename = filename.toLocalFile()
        logger.debug('MainController.open called with filename="%s"', filename)
        try:
            self._file.load(filename)
        except Exception as ex:
            self.showError(self.tr("Error opening file: {}.\n Exception:{}").format(filename, ex))
            return
        self._loadFileToUI()
        self._settings.setValue("last_open_file", filename)
        for task in self._file.tasks:
            task.modified.connect(self._taskModified)
        self.applyFilters()
        self.updateRecentFile()

    recentFilesChanged = QtCore.pyqtSignal()

    @QtCore.pyqtProperty('QVariant', notify=recentFilesChanged)
    def recentFiles(self):
        return self._recentFiles

    def updateRecentFile(self):
        if self._file.filename in self._recentFiles:
            self._recentFiles.remove(self._file.filename)
        self._recentFiles.insert(0, self._file.filename)
        self._recentFiles = self._recentFiles[:int(self._settings.value("max_recent_files", 6))]
        self._settings.setValue("recent_files", self._recentFiles)
        self.recentFilesChanged.emit()

    def _loadFileToUI(self):
        self.setModified(False)
        self.applyFilters()
        self._updateCompletionStrings()
        self._updateFilterTree()


1			import logging
2			import os
3			import string
4
5			from PyQt5 import QtCore
6
7			from qtodotxt.lib import tasklib
8			from qtodotxt.lib.file import File
9
10			from qtodotxt.filters_tree_controller import FiltersTreeController
11			from qtodotxt.lib.filters import SimpleTextFilter, FutureFilter, IncompleteTasksFilter, CompleteTasksFilter
12
13			logger = logging.getLogger(__name__)
14
15
16			class MainController(QtCore.QObject):
17
18			error = QtCore.pyqtSignal(str, arguments=["msg"])
19			fileExternallyModified = QtCore.pyqtSignal()
20
21			def __init__(self, args):
22			super(MainController, self).__init__()
23			self._args = args
24			self._filteredTasks = []
25			self._sortingMode = "default"
26			# use object variable for setting only used in this class
27			# others are accessed through QSettings
28			self._settings = QtCore.QSettings()
29			self._showCompleted = self._settings.value("show_completed", False)
30			self._showFuture = self._settings.value("show_completed", True)
31			self._file = File()
32			self._file.fileModified.connect(self.fileExternallyModified)
33			self._modified = False
34			self._filters_tree_controller = FiltersTreeController()
35			self._title = "QTodoTxt"
36			self._recentFiles = self._settings.value("recent_files", [])
37			self._searchText = ""
38			self._currentFilters = []
39			# self._currentFilters = self._settings.value("current_filters", ["All"]) # move to QML
40			self._updateCompletionStrings()
41
42			def _taskModified(self, task):
43			self.setModified()
44			self.auto_save()
45			if not task.text:
46			self.deleteTask(task)
47			return
48			self.applyFilters()
49
50			def showError(self, msg):
51			logger.debug("ERROR: %s", msg)
52			self.error.emit(msg)
53
54			completionChanged = QtCore.pyqtSignal()
55
56			@QtCore.pyqtProperty('QStringList', notify=completionChanged)
57			def completionStrings(self):
58			return self._completionStrings
59
60			def _updateCompletionStrings(self):
61			contexts = ['@' + name for name in self._file.getAllContexts()]
62			projects = ['+' + name for name in self._file.getAllProjects()]
63			lowest_priority = self._settings.value("lowest_priority", "D")
64			idx = string.ascii_uppercase.index(lowest_priority) + 1
65			priorities = ['(' + val + ')' for val in string.ascii_uppercase[:idx]]
66			self._completionStrings = contexts + projects + priorities + ['due:']
67			self.completionChanged.emit()
68
69			@QtCore.pyqtSlot('QModelIndexList')
70			def filterByIndexes(self, idxs):
71			filters = [self._filters_tree_controller.model.itemFromIndex(idx).filter for idx in idxs]
72			self.setFilters(filters)
73
74			def setFilters(self, filters):
75			self._currentFilters = filters
76			self.applyFilters()
77
78			@QtCore.pyqtSlot('QString', 'int', result='int')
79			def newTask(self, text='', after=None):
80			task = tasklib.Task(text)
81			if bool(self._settings.value("Preferences/add_creation_date", False, type=bool)):
82			task.addCreationDate()
83			task.modified.connect(self._taskModified)
84			if after is None:
85			after = len(self._filteredTasks) - 1
86			self._file.tasks.append(task)
87			self._filteredTasks.insert(after + 1, task) # force the new task to be visible
88			self.setModified()
89			self.auto_save()
90			self.filteredTasksChanged.emit()
91			return after + 1
92
93			@QtCore.pyqtSlot('QVariant')
94			def deleteTask(self, task):
95			if not isinstance(task, tasklib.Task):
96			# if task is not a task assume it is an int
97			task = self.filteredTasks[task]
98			self._file.tasks.remove(task)
99			self.setModified()
100			self.auto_save()
101			self.applyFilters() # update filtered list for UI
102
103			@property
104			def allTasks(self):
105			return self._file.tasks
106
107			@allTasks.setter
108			def allTasks(self, tasks):
109			self._file.tasks = tasks
110
111			filteredTasksChanged = QtCore.pyqtSignal()
112
113			@QtCore.pyqtProperty('QVariant', notify=filteredTasksChanged)
114			def filteredTasks(self):
115			return self._filteredTasks
116
117			showFutureChanged = QtCore.pyqtSignal('bool')
118
119			@QtCore.pyqtProperty('bool', notify=showFutureChanged)
120			def showFuture(self):
121			return self._showFuture
122
123			@showFuture.setter
124			def showFuture(self, val):
125			self._showFuture = val
126			self.showFutureChanged.emit(val)
127			self.applyFilters()
128
129			sortingModeChanged = QtCore.pyqtSignal(str)
130
131			@QtCore.pyqtProperty(str, notify=showFutureChanged)
132			def sortingMode(self):
133			return self._sortingMode
134
135			@sortingMode.setter
136			def sortingMode(self, val):
137			self._sortingMode = val
138			self.sortingModeChanged.emit(val)
139			self.applyFilters()
140
141
142			searchTextChanged = QtCore.pyqtSignal(str)
143
144			@QtCore.pyqtProperty('QString', notify=searchTextChanged)
145			def searchText(self):
146			return self._searchText
147
148			@searchText.setter
149			def searchText(self, txt):
150			self._searchText = txt
151			self.applyFilters()
152			self.searchTextChanged.emit(txt)
153
154			showCompletedChanged = QtCore.pyqtSignal('bool')
155
156			@QtCore.pyqtProperty('bool', notify=showCompletedChanged)
157			def showCompleted(self):
158			return self._showCompleted
159
160			@showCompleted.setter
161			def showCompleted(self, val):
162			self._showCompleted = val
163			self.showCompletedChanged.emit(val)
164			self.applyFilters()
165
166			def auto_save(self):
167			if bool(self._settings.value("Preferences/auto_save", True, type=bool)):
168			self.save()
169
170			def start(self):
171			if self._args.file:
172			filename = self._args.file
173			else:
174			filename = self._settings.value("last_open_file")
175
176			if filename:
177			try:
178			self.open(filename)
179			except OSError as ex:
180			self.showError(str(ex))
181
182			self.applyFilters()
183			self._updateTitle()
184
185			filtersUpdated = QtCore.pyqtSignal()
186
187			@QtCore.pyqtProperty('QVariant', notify=filtersUpdated)
188			def filtersModel(self):
189			return self._filters_tree_controller.model
190
191			def _updateFilterTree(self):
192			self._filters_tree_controller.showFilters(self._file)
193			self.filtersUpdated.emit()
194
195			def applyFilters(self):
196			# First we filter with filters tree
197			tasks = tasklib.filterTasks(self._currentFilters, self._file.tasks)
198			# Then with our search text
199			if self._searchText:
200			tasks = tasklib.filterTasks([SimpleTextFilter(self._searchText)], tasks)
201			# with future filter if needed
202			if not self._showFuture:
203			tasks = tasklib.filterTasks([FutureFilter()], tasks)
204			# with complete filter if needed
205			if not self._showCompleted and not CompleteTasksFilter() in self._currentFilters:
206			tasks = tasklib.filterTasks([IncompleteTasksFilter()], tasks)
207			if self._sortingMode:
208			tasks = getattr(tasklib.TaskSorter, self._sortingMode)(tasks)
209			self._filteredTasks = tasks
210			self.filteredTasksChanged.emit()
211
212			@QtCore.pyqtSlot()
213			def archiveCompletedTasks(self):
214			done = [task for task in self._file.tasks if task.is_complete]
215			for task in done:
216			self._file.saveDoneTask(task)
217			self._file.tasks.remove(task)
218			self.applyFilters()
219			self.setModified()
220			self.auto_save()
221
222			modifiedChanged = QtCore.pyqtSignal(bool)
223
224			@QtCore.pyqtProperty('bool', notify=modifiedChanged)
225			def modified(self):
226			return self._modified
227
228			def setModified(self, val=True):
229			self._modified = val
230			self._updateTitle()
231			if val:
232			self._updateCompletionStrings()
233			self._updateFilterTree()
234			self.modifiedChanged.emit(val)
235
236			@QtCore.pyqtSlot("QUrl")
237			@QtCore.pyqtSlot()
238			def save(self, path=None):
239			if not path:
240			path = self._file.filename
241			elif isinstance(path, QtCore.QUrl):
242			path = path.toLocalFile()
243			self._file.filename = path
244
245			logger.debug('MainController, saving file: %s.', path)
246			try:
247			self._file.save(path)
248			except OSError as ex:
249			logger.exception("Error saving file %s", path)
250			self.showError(ex)
251			return
252			self._settings.setValue("last_open_file", path)
253			self._settings.sync()
254			self.setModified(False)
255
256			def _updateTitle(self):
257			title = 'QTodoTxt - '
258			if self._file.filename:
259			filename = os.path.basename(self._file.filename)
260			title += filename
261			else:
262			title += 'Untitled'
263			if self._modified:
264			title += ' (*)'
265			self._title = title
266			self.titleChanged.emit(self._title)
267
268			titleChanged = QtCore.pyqtSignal(str)
269
270			@QtCore.pyqtProperty('QString', notify=titleChanged)
271			def title(self):
272			return self._title
273
274			@QtCore.pyqtSlot(result='bool')
275			def canExit(self):
276			self.auto_save()
277			return not self._modified
278
279			def new(self):
280			if self.canExit():
281			self._file = File()
282			self._loadFileToUI()
283
284			@QtCore.pyqtSlot()
285			def reload(self):
286			self.open(self._file.filename)
287
288			@QtCore.pyqtSlot('QUrl')
289			@QtCore.pyqtSlot('QString')
290			def open(self, filename):
291			if isinstance(filename, QtCore.QUrl):
292			filename = filename.toLocalFile()
293			logger.debug('MainController.open called with filename="%s"', filename)
294			try:
295			self._file.load(filename)
296			except Exception as ex:
297			self.showError(self.tr("Error opening file: {}.\n Exception:{}").format(filename, ex))
298			return
299			self._loadFileToUI()
300			self._settings.setValue("last_open_file", filename)
301			for task in self._file.tasks:
302			task.modified.connect(self._taskModified)
303			self.applyFilters()
304			self.updateRecentFile()
305
306			recentFilesChanged = QtCore.pyqtSignal()
307
308			@QtCore.pyqtProperty('QVariant', notify=recentFilesChanged)
309			def recentFiles(self):
310			return self._recentFiles
311
312			def updateRecentFile(self):
313			if self._file.filename in self._recentFiles:
314			self._recentFiles.remove(self._file.filename)
315			self._recentFiles.insert(0, self._file.filename)
316			self._recentFiles = self._recentFiles[:int(self._settings.value("max_recent_files", 6))]
317			self._settings.setValue("recent_files", self._recentFiles)
318			self.recentFilesChanged.emit()
319
320			def _loadFileToUI(self):
321			self.setModified(False)
322			self.applyFilters()
323			self._updateCompletionStrings()
324			self._updateFilterTree()
325

QTodoTxt / QTodoTxt2

Push — qml ( 9c2cb2...7f61bc )

MainController.sortingMode() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like