Merge lp:~jameinel/bzr-explorer/wt_model into lp:~bzr-explorer-dev/bzr-explorer/trunk.old

[John A Meinel]

[John A Meinel (jameinel)]

I don't think this is 100% ready for merging, but I figured I should make sure other people were aware that I was working on it.

This patch builds on my earlier "add a test suite" patches, so hopefully that noise doesn't bother anyone (since those still haven't landed yet).

Anyway, this add as WorkingTreeModel class. It could be arguably called an "IterChangesModel" because it wraps the result of iter_changes() into a QtAbstractItemModel class.

That basically allows you to see the versioned status, etc. It uses want_unversioned=True so that it gives the status of all files (if only because you need a directory to be able to put children underneath it.)

Some of the motivation was wanting to be able to handle:
https://bugs.edge.launchpad.net/bzr-explorer/+bug/396662
(working tree should de-emphasize ignored files)

I was also wondering if something like this would be better placed into QBzr, since they likely need it there as well.

[Alexander Belchenko (bialix)]

I think the current approach is to use treewidget from qbzr. I think this won't be merged.

[John A Meinel (jameinel)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Alexander Belchenko wrote:
> I think the current approach is to use treewidget from qbzr. I think this won't be merged.

Feel free to reject it, I'm only getting an OOPS when I try to visit the
LP page.

John
=:->

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iEYEARECAAYFAkuC2agACgkQJdeBCYSNAAMNmwCgix6ye3NGh1ptktgRvO8vHKhk
d3YAnAxuk7IV9rdrpedj901I2UvuZz4N
=IvWj
-----END PGP SIGNATURE-----

Unmerged revisions

181. By John A Meinel on 2009-07-09

We now pick a different bunch of columns.

It actually looks pretty interesting now.

180. By John A Meinel on 2009-07-09

Include the full set of values that are given from iter_changes.

179. By John A Meinel on 2009-07-09

Switch to using WT.iter_changes(WT.basis_tree())

This gives us more status information, which makes it more interesting
overall.

178. By John A Meinel on 2009-07-09

Add a decoration for column 0 from the QDirModel

177. By John A Meinel on 2009-07-09

Merge basic-tests updates

176. By John A Meinel on 2009-07-08

Start trying to add pixmaps for the WTModel.

175. By John A Meinel on 2009-07-07

Fix a couple edge cases in the wt_browser.py that were causing issues

174. By John A Meinel on 2009-07-07

Update the WorkingTreeModel to have a genuinely artificial root item.

173. By John A Meinel on 2009-07-07

Hack in the new model to get it viewable.
It would seem I need to re-think the root object.
It seems views have to have an indexable object to view.
Which means that we need an arbitrary root object, and then
the root-id of the filesystem will be a child of that.

172. By John A Meinel on 2009-07-07

Implement support for WTModel.data(), I believe this makes a complete model.

=== modified file '__init__.py'
--- __init__.py	2009-06-30 10:55:21 +0000
+++ __init__.py	2009-07-07 19:39:48 +0000
@@ -29,7 +29,7 @@
 lazy_import(globals(), '''
 from PyQt4 import QtGui, QtCore
 
-from bzrlib.plugins.explorer.lib.explorer import QExplorerMainWindow
+from bzrlib.plugins.explorer.lib import explorer
 ''')
 
 
@@ -38,15 +38,9 @@
     import bzrlib.plugins.qbzr.lib
 
 
-def test_suite():
-    """Called by bzrlib to fetch tests for this plugin"""
-    from unittest import TestSuite, TestLoader
-    #from bzrlib.plugins.explorer.lib.tests import ...
-    loader = TestLoader()
-    suite = TestSuite()
-    for module in []:
-        suite.addTests(loader.loadTestsFromModule(module))
-    return suite
+def load_tests(basic_tests, module, loader):
+    from bzrlib.plugins.explorer.tests import load_tests
+    return load_tests(basic_tests, module, loader)
 
 
 class cmd_explorer(Command):
@@ -114,7 +108,7 @@
         # TODO: setup exception handler ala QBzrCommand
         # (inheriting directly from QBzrCommands cause a metadata error?)
         app = QtGui.QApplication(sys.argv)
-        window = QExplorerMainWindow(location=location, profile=hat,
+        window = explorer.QExplorerMainWindow(location=location, profile=hat,
             desktop=desktop, dry_run=dry_run, preferences=prefs)
         window.show()
         app.exec_()

=== modified file 'lib/wt_browser.py'
--- lib/wt_browser.py	2009-07-02 06:50:18 +0000
+++ lib/wt_browser.py	2009-07-07 22:37:42 +0000
@@ -19,6 +19,9 @@
 from PyQt4 import QtCore, QtGui
 
 from bzrlib.plugins.explorer.lib.i18n import gettext, N_
+from bzrlib.plugins.explorer.lib import (
+    wt_model,
+    )
 from bzrlib.plugins.explorer.lib.kinds import (
     OPEN_FOLDER_ACTION,
     EDIT_ACTION,
@@ -39,21 +42,22 @@
 
     def _build_ui(self):
         # Init them model and view
-        model = QtGui.QDirModel()
+        from bzrlib import workingtree
+        model = wt_model.WorkingTreeModel(workingtree.WorkingTree.open('.'))
         # sort flags for tree view: direcotries first,
         # on Windows items are case-insensitive
         flags = QtCore.QDir.SortFlags(QtCore.QDir.Name|QtCore.QDir.DirsFirst)
         if sys.platform == 'win32':
             flags |= QtCore.QDir.IgnoreCase
-        model.setSorting(flags)
+        # model.setSorting(flags)
         view = QtGui.QTreeView()
         view.setModel(model)
 
         # Hide all except the Name column
-        for i in  range(1, model.columnCount()):
-            view.setColumnHidden(i, True)
-        if getattr(view, 'setHeaderHidden', None):
-            view.setHeaderHidden(True)
+        # for i in  range(1, model.columnCount()):
+        #     view.setColumnHidden(i, True)
+        # if getattr(view, 'setHeaderHidden', None):
+        #     view.setHeaderHidden(True)
 
         # Build a button bar for the view
         browse_button = QtGui.QPushButton()
@@ -131,6 +135,7 @@
             self._action_callback("open", unicode(path))
 
     def do_current_changed(self, model_index, prev_model_index):
+        return
         model = model_index.model()
         fileinfo = model.fileInfo(model_index)
         self._edit_button.setEnabled(fileinfo and not fileinfo.isDir())
@@ -147,7 +152,7 @@
         else:
             # Show the tree
             self.stacked.setCurrentIndex(1)
-            index = self.model.index(path)
+            index = self.model.index(0, 0, None)
             self.view.setRootIndex(index)
         self._root = path
         self._selected_fileinfo = None

=== added file 'lib/wt_model.py'
--- lib/wt_model.py	1970-01-01 00:00:00 +0000
+++ lib/wt_model.py	2009-07-09 19:46:58 +0000
@@ -0,0 +1,269 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Implement a Model defining interactions with a WorkingTree"""
+
+from bzrlib import osutils, workingtree
+
+from PyQt4 import QtCore, QtGui
+
+
+# TODO: consider that this is similar to what one would want for an
+#       InventoryModel, except we should have extra attributes like
+#       "is_modified", etc. Also consider that for a working tree, we probably
+#       need to handle files that are unknown and ignored.
+class _WTItem(object):
+    """Encapsulates the display information for a given item.
+
+    :ivar children:
+    :type children: A list of _WTItem objects
+    """
+
+    _versioned_map = {(True, True): ' ', # versioned in both
+                      (True, False): '-', # versioned in source
+                      (False, True): '+', # versioned in target
+                      (False, False): '-', # versioned in neither
+                     }
+
+    def __init__(self, file_id, is_modified, path, name, kind, versioned,
+                 executable, parent_id, old_path, old_name, old_kind,
+                 was_versioned, old_executable, old_parent_id, parent,
+                 ignore_pattern):
+        """Create a new _WTItem
+        """
+        self.file_id = file_id
+        self.path = path
+        self.name = name
+        self.kind = kind
+        self.versioned = versioned
+        self.is_modified = is_modified
+        self.ignore_pattern = ignore_pattern
+        self.executable = executable
+        self.parent_id = parent_id
+        self.old_path = old_path
+        self.old_kind = old_kind
+        self.old_name = old_name
+        self.was_versioned = was_versioned
+        self.old_executable = old_executable
+        self.old_parent_id = old_parent_id
+        self.parent = parent
+        # Note: this creates a cyclical reference, consider using parent
+        #       instead
+        self.children = []
+        # Determine the status of this file
+        self.status = None
+        if self.versioned is not None and self.was_versioned is not None:
+            self._determine_status()
+
+    def _determine_status(self):
+        if self.ignore_pattern is not None:
+            self.status = 'I  '
+            return
+        # Generally copied from bzrlib.delta.report_changes
+        exe_status = ' '
+        # files are "renamed" if they are moved or if name changes, as long
+        # as it had a value
+        if (self.old_name is not None and self.name is not None
+            and self.old_parent_id is not None
+            and self.parent_id is not None
+            and (self.old_name != self.name
+                 or self.parent_id != self.old_parent_id)):
+            versioned_status = 'R' # Renamed implies versioned in both
+        else:
+            versioned_status = self._versioned_map[
+                (self.was_versioned, self.versioned)]
+        if self.old_kind != self.kind:
+            if self.old_kind is None:
+                modified_status = 'N' # created
+            elif self.kind is None:
+                modified_status = 'D' # deleted
+            else:
+                modified_status = 'K' # kind changed
+        else:
+            if self.is_modified:
+                modified_status = 'M' # modified
+            else:
+                modified_status = ' ' # unchanged
+            if self.kind == 'file':
+                if (self.executable != self.old_executable):
+                    exe_status = '*'
+        self.status = modified_status + versioned_status + exe_status
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__,
+                           self.__dict__)
+
+    def row(self):
+        """Return the row for this object in the parents children list."""
+        if self.parent is None:
+            return 0
+        return self.parent.children.index(self)
+
+    def _from_iter_changes(self, wt, changes):
+        dir_by_id = {}
+        dir_by_path = {}
+        for (file_id, paths, did_change, versions, parent_ids, names, kinds,
+             executables) in changes:
+            if file_id is None:
+                # not versioned
+                parent_dir = osutils.dirname(paths[1])
+                if names[1] == '': # unversioned root?
+                    raise ValueError('not supported yet')
+                parent = dir_by_path[parent_dir]
+                ignore_pattern = wt.is_ignored(paths[1])
+            else:
+                if parent_ids[1] is None: # Root entry
+                    # Or maybe this happens for unversioned files?
+                    assert names[1] == ''
+                    parent = self
+                else:
+                    parent = dir_by_id[parent_ids[1]]
+                ignore_pattern = None
+            item = _WTItem(file_id, did_change, paths[1], names[1], kinds[1],
+                           versions[1], executables[1], parent_ids[1],
+                           paths[0], names[0], kinds[0], versions[0],
+                           executables[0], parent_ids[0], parent,
+                           ignore_pattern)
+            parent.children.append(item)
+            if kinds[1] == 'directory':
+                dir_by_id[file_id] = item
+                dir_by_path[paths[1]] = item
+
+    @classmethod
+    def create_from_wt(cls, wt):
+        """Create the _WTItem tree structure from an inventory."""
+        wt.lock_read()
+        try:
+            basis_tree = wt.basis_tree()
+            basis_tree.lock_read()
+            try:
+                root_wt_item = cls(*([None]*16))
+                changes = wt.iter_changes(basis_tree, include_unchanged=True,
+                    require_versioned=False, want_unversioned=True)
+                root_wt_item._from_iter_changes(wt, changes)
+            finally:
+                basis_tree.unlock()
+        finally:
+            wt.unlock()
+        return root_wt_item
+
+
+class WorkingTreeModel(QtCore.QAbstractItemModel):
+
+    _headers = [
+        'name',
+        'kind',
+        'status',
+        'path',
+        ]
+    _column_to_attribute = dict(enumerate(_headers))
+
+    def __init__(self, wt, parent=None):
+        QtCore.QAbstractItemModel.__init__(self, parent)
+        self._wt = wt
+        self._dirmodel = QtGui.QDirModel()
+        self._root_wt_item = _WTItem.create_from_wt(self._wt)
+
+    def index(self, row, column, parent=None):
+        """Return the QModelIndex for the given item.
+
+        :param row: In this case, the Nth file for the given directory
+        :type row: int
+        :param column: The data attribute for the given file/dir
+        :type column: int
+        :param parent: the containing directory
+        :type parent: QModelIndex
+        :return: The index object to reference the given data
+        :rtype: QModelIndex
+        """
+        if parent is None:
+            parent = QtCore.QModelIndex()
+            parent_item = self._root_wt_item
+        if not self.hasIndex(row, column, parent):
+            return QtCore.QModelIndex()
+
+        if not parent.isValid():
+            parent_item = self._root_wt_item
+        else:
+            parent_item = parent.internalPointer()
+        child = parent_item.children[row]
+        return self.createIndex(row, column, child)
+
+    def parent(self, index):
+        if index is None or not index.isValid():
+            return QtCore.QModelIndex()
+
+        item = index.internalPointer()
+        if item.parent is None or item.parent is self._root_wt_item:
+            return QtCore.QModelIndex()
+        return self.createIndex(item.parent.row(), 0, item.parent)
+
+    def rowCount(self, parent=None):
+        if parent is None or not parent.isValid():
+            parent_item = self._root_wt_item
+        else:
+            parent_item = parent.internalPointer()
+        return len(parent_item.children)
+
+    # implement def hasChildren(self, ...) if rowCount is expensive
+    # We could do this, by looking at Item.kind
+    # For now, though, we don't lazily load anything, so leave it alone
+
+    def columnCount(self, parent=None):
+        # this can vary based on parent, but *doesn't*
+        return len(WorkingTreeModel._headers)
+
+    def headerData(self, section, orientation, role):
+        """Return the header to show for a given entry."""
+        headers = WorkingTreeModel._headers
+        if (orientation == QtCore.Qt.Horizontal
+            and role == QtCore.Qt.DisplayRole
+            and section < len(headers)):
+            return QtCore.QVariant(headers[section])
+        return QtCore.QVariant()
+
+    def flags(self, index):
+        if index is None or not index.isValid():
+            # This should really be a QtCore.Qt.ItemFlags object, not sure how
+            # to cast it into one, though
+            return 0
+        return (QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
+
+    def data(self, index, role):
+        if index is None or not index.isValid():
+            return QtCore.QVariant()
+        # TODO: implement uspport for Qt.DecorationRole, if we return a
+        #       QPixmap, then we will get the displayed icon.
+        item = index.internalPointer()
+        if role == QtCore.Qt.DecorationRole and index.column() == 0:
+            # Return the decoration from an QDirModel
+            dir_index = self._dirmodel.index(item.path)
+            data = self._dirmodel.data(dir_index, role)
+            return data
+        if role != QtCore.Qt.DisplayRole:
+            return QtCore.QVariant()
+        attr = self._column_to_attribute[index.column()]
+        return QtCore.QVariant(getattr(item, attr, None))
+
+    # implement def setData(self, ...) if we want to be editable
+
+    # Interesting Role list:
+    #   QtCore.Qt.DisplayRole, QtCore.Qt.ToolTipRole, QtCore.Qt.WhatsThisRole
+
+    # Do we want to incrementally populate? Perhaps this would be useful for an
+    # IterChangesModel
+    # def fetchMore(self, ...)
+    # def canFetchmore(self, ...)

=== added directory 'tests'
=== added file 'tests/__init__.py'
--- tests/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/__init__.py	2009-07-09 17:44:53 +0000
@@ -0,0 +1,88 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Test Suite for bzr-explorer"""
+
+from bzrlib.tests import (
+    TestCase,
+    TestCaseInTempDir,
+    TestCaseWithTransport,
+    )
+
+
+class TestCaseWithQt(TestCaseWithTransport):
+    """Many GUI functions require a QApplication to be running.
+
+    This class ensures a QtApplication is running during setUp.
+    """
+
+    _app = None
+
+    def setUp(self):
+        super(TestCaseWithQt, self).setUp()
+        self.ensureApp()
+        self.logger = self.createLogger()
+
+    def ensureApp(self):
+        if TestCaseWithQt._app is None:
+            from PyQt4 import QtGui
+            TestCaseWithQt._app = QtGui.QApplication(['bzr-explorer-test-app'])
+            # It seems we can leave it running.
+
+    def createLogger(self, *args):
+        from PyQt4 import QtCore
+
+        class ConnectionLogger(QtCore.QObject):
+
+            def __init__(self, *args):
+                QtCore.QObject.__init__(self, *args)
+                # A log of actions that have occurrred
+                self.log = []
+
+            def createNamedSlot(self, signal_name):
+                """Create a new slot, which tracks the signal name given.
+
+                :param signal_name: The name of the signal we are connecting
+                :return: A function that can be used as a signal to this logger.
+                """
+                def named_slot(*args):
+                    self.log.append((signal_name,) + args)
+                return named_slot
+
+            def connectToNamedSlot(self, signal, source):
+                """Create a new named slot, and connect the signal from source.
+
+                :param signal: The value to pass to QtCore.SIGNAL, this will
+                    also be the name logged when the signal is activated.
+                :param source: An object that can generate the given signal.
+                """
+                slot = self.createNamedSlot(signal)
+                QtCore.QObject.connect(source, QtCore.SIGNAL(signal), slot)
+
+        return ConnectionLogger(*args)
+
+
+def load_tests(basic_tests, module, loader):
+    suite = loader.suiteClass()
+    suite.addTests(basic_tests)
+
+    mod_names = [__name__ + '.' + x for x in [
+        'test_test_suite',
+        'test_welcome',
+        'test_wt_model',
+    ]]
+    suite.addTests(loader.loadTestsFromModuleNames(mod_names))
+    return suite

=== added file 'tests/test_test_suite.py'
--- tests/test_test_suite.py	1970-01-01 00:00:00 +0000
+++ tests/test_test_suite.py	2009-07-08 20:28:10 +0000
@@ -0,0 +1,66 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Tests for the testing infrastructure in bzr-explorer."""
+
+from PyQt4 import QtCore, QtGui
+
+from bzrlib.plugins.explorer import tests
+
+
+class _Emitter(QtCore.QObject):
+
+    def trigger_foo(self):
+        self.emit(QtCore.SIGNAL('foo()'))
+
+    def trigger_bar(self, arg1, arg2):
+        self.emit(QtCore.SIGNAL('bar(int, int)'), arg1, arg2)
+
+
+class TestTestCaseWithQt(tests.TestCaseWithQt):
+
+    def test_create_qpixmap(self):
+        pixmap = QtGui.QPixmap()
+
+    def test_logger_named_slot(self):
+        slot = self.logger.createNamedSlot('trapping_foo')
+        emitter = _Emitter()
+        QtCore.QObject.connect(emitter, QtCore.SIGNAL('foo()'), slot)
+        self.assertEqual([], self.logger.log)
+        emitter.trigger_foo()
+        self.assertEqual([('trapping_foo',)], self.logger.log)
+        emitter.trigger_bar(1, 2) # not connected
+        self.assertEqual([('trapping_foo',)], self.logger.log)
+        emitter.trigger_foo()
+        self.assertEqual([('trapping_foo',), ('trapping_foo',)],
+                         self.logger.log)
+        slot = self.logger.createNamedSlot('trapping_bar')
+        QtCore.QObject.connect(emitter, QtCore.SIGNAL('bar(int, int)'), slot)
+        emitter.trigger_bar(1, 2)
+        self.assertEqual([('trapping_foo',), ('trapping_foo',),
+                          ('trapping_bar', 1, 2),
+                         ], self.logger.log)
+
+    def test_connectToNamedSlot(self):
+        emitter = _Emitter()
+        self.logger.connectToNamedSlot('foo()', emitter)
+        self.logger.connectToNamedSlot('bar(int, int)', emitter)
+        emitter.trigger_foo()
+        self.assertEqual([('foo()',)], self.logger.log)
+        emitter.trigger_bar(3, 4)
+        self.assertEqual([('foo()',), ('bar(int, int)', 3, 4)],
+                         self.logger.log)
+

=== added file 'tests/test_welcome.py'
--- tests/test_welcome.py	1970-01-01 00:00:00 +0000
+++ tests/test_welcome.py	2009-07-08 19:40:55 +0000
@@ -0,0 +1,27 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Tests for the WelcomeModel"""
+
+from bzrlib.plugins.explorer import tests
+from bzrlib.plugins.explorer.lib import welcome
+
+
+class TestWelcomeModel(tests.TestCaseInTempDir):
+
+    def test__init__(self):
+        model = welcome.WelcomeModel('a url', None, None, None)
+

=== added file 'tests/test_wt_model.py'
--- tests/test_wt_model.py	1970-01-01 00:00:00 +0000
+++ tests/test_wt_model.py	2009-07-09 19:46:58 +0000
@@ -0,0 +1,325 @@
+# Copyright (C) 2009 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""tests for the WorkingTreeModel class"""
+
+from PyQt4 import QtCore, QtGui
+
+from bzrlib import (
+    errors,
+    inventory,
+    tests,
+    )
+
+from bzrlib.plugins.explorer.lib import wt_model
+from bzrlib.plugins.explorer.tests import TestCaseWithQt
+
+
+class TestWTModel(TestCaseWithQt):
+
+    def test_flags_empty(self):
+        wt = self.make_branch_and_tree('.')
+        model = wt_model.WorkingTreeModel(wt)
+        self.assertEqual(0, model.flags(QtCore.QModelIndex()))
+
+    def test_flags_are_readonly(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['a_file'])
+        model = wt_model.WorkingTreeModel(wt)
+        index = model.index(0, 0, None)
+        self.assertEqual(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable,
+                         model.flags(index))
+
+    def test_data_invalid(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['a_file'])
+        model = wt_model.WorkingTreeModel(wt)
+        res = model.data(QtCore.QModelIndex(), QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertFalse(res.isValid())
+        index = model.index(0, 0, None)
+        # TODO: We probably could implement ToolTipRole, perhaps returning the
+        #       full path?
+        res = model.data(QtCore.QModelIndex(), QtCore.Qt.ToolTipRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertFalse(res.isValid())
+
+    def test_data(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['dir/', 'dir/a_file', 'b_file'])
+        wt.add(['dir', 'dir/a_file', 'b_file'],
+               ['dir-id', 'a-id', 'b-id'])
+        model = wt_model.WorkingTreeModel(wt)
+        root_index = model.index(0, 0, None)
+        index = model.index(1, 0, root_index)
+        res = model.data(index, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertEqual('dir', res.toString())
+        index = model.index(1, 2, root_index)
+        res = model.data(index, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        # New file, just added, no executable
+        self.assertEqual('N+ ', res.toString())
+        a_index = model.index(0, 0, index)
+        res = model.data(a_index, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertEqual('a_file', res.toString())
+        a_index = model.index(0, 3, index)
+        res = model.data(a_index, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertEqual('dir/a_file', res.toString())
+
+    def test_data_decoraterole(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['a_file.txt'])
+        wt.add(['a_file.txt'], ['a-id'])
+        model = wt_model.WorkingTreeModel(wt)
+        root_index = model.index(0, 0, None)
+        a_index = model.index(0, 0, root_index)
+        self.assertEqual('a_file.txt', a_index.internalPointer().name)
+        res = model.data(a_index, QtCore.Qt.DecorationRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertTrue(res.isValid())
+        self.assertEqual('QIcon', res.typeName())
+        # For records not at column 0, we should get nothing
+        a_index = model.index(0, 1, root_index)
+        res = model.data(a_index, QtCore.Qt.DecorationRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertFalse(res.isValid())
+
+    def test_index_invalid(self):
+        wt = self.make_branch_and_tree('.')
+        model = wt_model.WorkingTreeModel(wt)
+        res = model.index(100, 100, None)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertFalse(res.isValid())
+
+    def test_index_empty(self):
+        wt = self.make_branch_and_tree('.')
+        model = wt_model.WorkingTreeModel(wt)
+        res = model.index(0, 0, None)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertTrue(res.isValid())
+
+    def test_index_one_item(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['a_file'])
+        model = wt_model.WorkingTreeModel(wt)
+        res = model.index(0, 0, None)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertTrue(res.isValid())
+        self.assertEqual('', res.internalPointer().name)
+
+    def test_index_subdir(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['dir/', 'dir/a_file', 'b_file'])
+        wt.add(['dir', 'dir/a_file', 'b_file'],
+               ['dir-id', 'a-id', 'b-id'])
+        model = wt_model.WorkingTreeModel(wt)
+        root_index = model.index(0, 0, None)
+        self.assertIsInstance(root_index, QtCore.QModelIndex)
+        self.assertTrue(root_index.isValid())
+        res = model.index(1, 0, root_index)
+        self.assertEqual('dir', res.internalPointer().name)
+        res = model.index(0, 0, res)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertTrue(res.isValid())
+        self.assertEqual('a_file', res.internalPointer().name)
+
+    def test_rowCount_simple(self):
+        wt = self.make_branch_and_tree('.')
+        model = wt_model.WorkingTreeModel(wt)
+        self.assertEqual(1, model.rowCount())
+
+    def test_rowCount_subdirs(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['dir/', 'dir/a_file', 'b_file'])
+        wt.add(['dir', 'dir/a_file', 'b_file'],
+               ['dir-id', 'a-id', 'b-id'])
+        model = wt_model.WorkingTreeModel(wt)
+        self.assertEqual(1, model.rowCount())
+        root_index = model.index(0, 0, None)
+        self.assertIsInstance(root_index, QtCore.QModelIndex)
+        self.assertTrue(root_index.isValid())
+        self.assertEqual('', root_index.internalPointer().name)
+        self.assertEqual(2, model.rowCount(root_index))
+
+    def test_parent_empty(self):
+        wt = self.make_branch_and_tree('.')
+        model = wt_model.WorkingTreeModel(wt)
+        res = model.parent(QtCore.QModelIndex())
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertFalse(res.isValid())
+        res = model.parent(None)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertFalse(res.isValid())
+
+    def test_parent_with_subdirs(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['dir/', 'dir/a_file', 'b_file'])
+        wt.add(['dir', 'dir/a_file', 'b_file'],
+               ['dir-id', 'a-id', 'b-id'])
+        model = wt_model.WorkingTreeModel(wt)
+        self.assertEqual(1, model.rowCount())
+        root_index = model.index(0, 0, None)
+        self.assertIsInstance(root_index, QtCore.QModelIndex)
+        self.assertTrue(root_index.isValid())
+        self.assertEqual('', root_index.internalPointer().name)
+        res = model.parent(root_index)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertFalse(res.isValid())
+        dir_index = model.index(1, 0, root_index)
+        self.assertIsInstance(dir_index, QtCore.QModelIndex)
+        self.assertTrue(dir_index.isValid())
+        self.assertEqual('dir', dir_index.internalPointer().name)
+        res = model.parent(dir_index)
+        self.assertIsInstance(res, QtCore.QModelIndex)
+        self.assertTrue(res.isValid())
+        self.assertEqual('', res.internalPointer().name)
+
+    def test_headerData(self):
+        wt = self.make_branch_and_tree('.')
+        model = wt_model.WorkingTreeModel(wt)
+        self.assertEqual(len(model._headers), model.columnCount())
+        res = model.headerData(0, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertEqual('name', res.toString())
+        res = model.headerData(1, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)
+        self.assertEqual('kind', res.toString())
+        res = model.headerData(2, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)
+        self.assertEqual('status', res.toString())
+        res = model.headerData(3, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)
+        self.assertEqual('path', res.toString())
+
+        res = model.headerData(len(model._headers),
+                               QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertTrue(res.isNull())
+        res = model.headerData(0, QtCore.Qt.Vertical, QtCore.Qt.DisplayRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertTrue(res.isNull())
+        res = model.headerData(0, QtCore.Qt.Vertical, QtCore.Qt.ToolTipRole)
+        self.assertIsInstance(res, QtCore.QVariant)
+        self.assertTrue(res.isNull())
+
+
+class Test_WTItem(tests.TestCaseWithTransport):
+
+    def test_from_wt_simple(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['a_file'])
+        wt.add(['a_file'], ['file-id'])
+        wt.set_root_id('root-id')
+        root_item = wt_model._WTItem.create_from_wt(wt)
+        self.assertIsInstance(root_item, wt_model._WTItem)
+        self.assertIs(None, root_item.path)
+        self.assertEqual(1, len(root_item.children))
+        tree_root_item = root_item.children[0]
+        self.assertEqual('', tree_root_item.path)
+        self.assertEqual('', tree_root_item.name)
+        self.assertEqual('directory', tree_root_item.kind)
+        self.assertEqual('root-id', tree_root_item.file_id)
+        self.assertIs(None, tree_root_item.old_kind)
+        self.assertIs(root_item, tree_root_item.parent)
+        self.assertEqual(1, len(tree_root_item.children))
+        child = tree_root_item.children[0]
+        self.assertEqual('a_file', child.path)
+        self.assertEqual('a_file', child.name)
+        self.assertEqual('file', child.kind)
+        self.assertEqual('file-id', child.file_id)
+        self.assertIs(None, child.old_kind)
+        self.assertEqual(tree_root_item, child.parent)
+        self.assertEqual(0, child.row())
+
+    def test_unversioned_from_wt(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['a_file', 'unversioned-file'])
+        wt.set_root_id('root-id')
+        wt.add(['a_file'], ['file-id'])
+        root_item = wt_model._WTItem.create_from_wt(wt)
+        self.assertIsInstance(root_item, wt_model._WTItem)
+        self.assertIs(None, root_item.path)
+        self.assertEqual(1, len(root_item.children))
+        tree_root_item = root_item.children[0]
+        self.assertIsInstance(tree_root_item, wt_model._WTItem)
+        self.assertEqual('', tree_root_item.path)
+        self.assertEqual('', tree_root_item.name)
+        self.assertEqual('directory', tree_root_item.kind)
+        self.assertEqual('root-id', tree_root_item.file_id)
+        self.assertIs(None, tree_root_item.old_kind)
+        self.assertIs(root_item, tree_root_item.parent)
+        self.assertEqual(2, len(tree_root_item.children))
+        child = tree_root_item.children[0]
+        self.assertEqual('a_file', child.path)
+        self.assertEqual('a_file', child.name)
+        self.assertEqual('file', child.kind)
+        self.assertEqual('file-id', child.file_id)
+        self.assertIs(None, child.old_kind)
+        self.assertEqual(tree_root_item, child.parent)
+        self.assertEqual(0, child.row())
+        child = tree_root_item.children[1]
+        self.assertEqual('unversioned-file', child.path)
+        self.assertEqual('unversioned-file', child.name)
+        self.assertEqual('file', child.kind)
+        self.assertIs(None, child.file_id)
+        self.assertIs(None, child.old_kind)
+        self.assertEqual(tree_root_item, child.parent)
+        self.assertEqual(1, child.row())
+
+    def test_with_subdirs(self):
+        wt = self.make_branch_and_tree('.')
+        self.build_tree(['dir/', 'dir/subdir/',
+                         'dir/subdir/a_file'])
+        wt.set_root_id('root-id')
+        wt.add(['dir', 'dir/subdir', 'dir/subdir/a_file'],
+               ['dir-id', 'subdir-id', 'file-id'])
+        root_item = wt_model._WTItem.create_from_wt(wt)
+        self.assertIsInstance(root_item, wt_model._WTItem)
+        self.assertIs(None, root_item.path)
+        self.assertEqual(1, len(root_item.children))
+        tree_root_item = root_item.children[0]
+        self.assertIsInstance(tree_root_item, wt_model._WTItem)
+        self.assertEqual('root-id', tree_root_item.file_id)
+        self.assertIs(root_item, tree_root_item.parent)
+        self.assertEqual(1, len(tree_root_item.children))
+        child = tree_root_item.children[0]
+        self.assertEqual('dir', child.path)
+        self.assertEqual('dir', child.name)
+        self.assertEqual('directory', child.kind)
+        self.assertEqual('dir-id', child.file_id)
+        self.assertIs(None, child.old_kind)
+        self.assertEqual(tree_root_item, child.parent)
+        self.assertEqual(0, tree_root_item.row())
+        self.assertEqual(1, len(child.children))
+        this_dir = child
+        child = this_dir.children[0]
+        self.assertEqual('dir/subdir', child.path)
+        self.assertEqual('subdir', child.name)
+        self.assertEqual('directory', child.kind)
+        self.assertEqual('subdir-id', child.file_id)
+        self.assertIs(None, child.old_kind)
+        self.assertEqual(this_dir, child.parent)
+        self.assertEqual(0, child.row())
+        self.assertEqual(1, len(child.children))
+        this_dir = child
+        child = this_dir.children[0]
+        self.assertEqual('dir/subdir/a_file', child.path)
+        self.assertEqual('a_file', child.name)
+        self.assertEqual('file', child.kind)
+        self.assertEqual('file-id', child.file_id)
+        self.assertIs(None, child.old_kind)
+        self.assertEqual(this_dir, child.parent)
+        self.assertEqual(0, child.row())