[pitivi: 43/65] Changed PresetManager to allow the user to have a preset called Default. Fixes bug 652397.

[Thibault Saunier <tsaunier src gnome org>]

commit 37f6325278d3fb20e000288b3fc8366da3940b7f
Author: Alex BÄluÈ <alexandru balut gmail com>
Date:   Sun Jun 12 22:21:20 2011 +0200

    Changed PresetManager to allow the user to have a preset called Default.
    Fixes bug 652397.

 pitivi/ui/preset.py  |  122 +++++++++++++++++++++++++++++++++++---------------
 tests/Makefile.am    |    1 +
 tests/test_preset.py |  116 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 202 insertions(+), 37 deletions(-)
---
diff --git a/pitivi/ui/preset.py b/pitivi/ui/preset.py
index e85773c..04fefd9 100644
--- a/pitivi/ui/preset.py
+++ b/pitivi/ui/preset.py
@@ -1,6 +1,6 @@
 # PiTiVi , Non-linear video editor
 #
-#       pitivi/ui/controller.py
+#       pitivi/ui/preset.py
 #
 # Copyright (c) 2010, Brandon Lewis <brandon_lewis berkeley edu>
 #
@@ -19,55 +19,107 @@
 # Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 # Boston, MA 02110-1301, USA.
 
-from pitivi.settings import xdg_data_home
-from ConfigParser import SafeConfigParser
-from pitivi.ui.dynamic import DynamicWidget
-from pitivi.ui.common import set_combo_value, get_combo_value
+import ConfigParser
 import os.path
-import gtk
+
 import gst
+import gtk
+
+from pitivi.settings import xdg_data_home
+
 
 
 class PresetManager(object):
+    """Abstract class for storing a list of presets.
+
+    Subclasses must provide a filename attribute.
+
+    @cvar filename: The name of the file where the presets will be stored.
+    @type filename: str
+    """
 
     def __init__(self):
-        self.path = os.path.join(xdg_data_home(), "pitivi", self.filename)
         self.presets = {}
         self.widget_map = {}
         self.ordered = gtk.ListStore(str, object)
         self.cur_preset = None
         self.ignore = False
 
+    def _getFilename(self):
+        return os.path.join(xdg_data_home(), "pitivi", self.filename)
+
     def load(self):
-        try:
-            fin = open(self.path, "r")
-            parser = SafeConfigParser()
-            parser.readfp(fin)
-            self._load(parser)
-        except IOError:
-            pass
+        parser = ConfigParser.SafeConfigParser()
+        if not parser.read(self._getFilename()):
+            # The file probably does not exist yet.
+            return
+        self._loadPresetsFromParser(parser)
 
     def save(self):
-        fout = open(self.path, "w")
-        parser = SafeConfigParser()
-        self._save(parser)
+        parser = ConfigParser.SafeConfigParser()
+        self._savePresetsToParser(parser)
+        fout = open(self._getFilename(), "w")
         parser.write(fout)
+        fout.close()
 
-    def _load(self, parser):
+    def _loadPresetsFromParser(self, parser):
         for section in sorted(parser.sections()):
-            self.loadSection(parser, section)
+            values = self._loadPreset(parser, section)
+            preset = self._convertSectionNameToPresetName(section)
+            self.addPreset(preset, values)
+
+    def _savePresetsToParser(self, parser):
+        for preset, properties in self.ordered:
+            values = self.presets[preset]
+            section = self._convertPresetNameToSectionName(preset)
+            self._savePreset(parser, section, values)
+
+    def _loadPreset(self, parser, section):
+        """Load the specified section from the specified config parser.
+
+        @param parser: The config parser from which the section will be loaded.
+        @type parser: ConfigParser
+        @param section: The name of the section to be loaded.
+        @type section: str
+        @return: A dict representing a preset.
+        """
+        raise NotImplemented
 
-    def _save(self, parser):
-        for name, properties in self.ordered:
-            self.saveSection(parser, name)
+    def _savePreset(self, parser, section, values):
+        """Create the specified section into the specified config parser.
 
-    def loadSection(self, parser, section):
+        @param parser: The config parser in which the section will be created.
+        @type parser: ConfigParser
+        @param section: The name of the section to be created.
+        @type section: str
+        @param values: The values of a preset.
+        @type values: dict
+        """
         raise NotImplemented
 
-    def saveSection(self, parser, section):
-        raise NotImplemented
+    def _convertSectionNameToPresetName(self, section):
+        # A section name for a ConfigParser can have any name except "default"!
+        assert section != "default"
+        if section.rstrip("_").lower() == "default":
+            return section[:-1]
+        else:
+            return section
+
+    def _convertPresetNameToSectionName(self, preset):
+        if preset.rstrip("_").lower() == "default":
+            # We add an _ to allow the user to have a preset named "default".
+            return "%s_" % preset
+        else:
+            return preset
 
     def addPreset(self, name, values):
+        """Add a new preset.
+
+        @param name: The name of the new preset.
+        @type name: str
+        @param values: The values of the new preset.
+        @type values: dict
+        """
         self.presets[name] = values
         self.ordered.append((name, values))
 
@@ -129,7 +181,7 @@ class VideoPresetManager(PresetManager):
 
     filename = "video_presets"
 
-    def loadSection(self, parser, section):
+    def _loadPreset(self, parser, section):
         width = parser.getint(section, "width")
         height = parser.getint(section, "height")
 
@@ -141,15 +193,13 @@ class VideoPresetManager(PresetManager):
         par_denom = parser.getint(section, "par-denom")
         par = gst.Fraction(par_num, par_denom)
 
-        self.addPreset(section, {
+        return {
             "width": width,
             "height": height,
             "frame-rate": rate,
-            "par": par,
-        })
+            "par": par}
 
-    def saveSection(self, parser, section):
-        values = self.presets[section]
+    def _savePreset(self, parser, section, values):
         parser.add_section(section)
         parser.set(section, "width", str(values["width"]))
         parser.set(section, "height", str(values["height"]))
@@ -167,19 +217,17 @@ class AudioPresetManager(PresetManager):
 
     filename = "audio_presets"
 
-    def loadSection(self, parser, section):
+    def _loadPreset(self, parser, section):
         channels = parser.getint(section, "channels")
         depth = parser.getint(section, "depth")
         rate = parser.getint(section, "sample-rate")
 
-        self.addPreset(section, {
+        return {
             "channels": channels,
             "depth": depth,
-            "sample-rate": rate,
-        })
+            "sample-rate": rate}
 
-    def saveSection(self, parser, section):
-        values = self.presets[section]
+    def _savePreset(self, parser, section, values):
         parser.add_section(section)
         parser.set(section, "channels", str(values["channels"]))
         parser.set(section, "depth", str(values["depth"]))
diff --git a/tests/Makefile.am b/tests/Makefile.am
index b1d088c..1326d4d 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -34,6 +34,7 @@ tests = \
 
 integration_tests = \
 	test_integration.py \
+	test_preset.py \
 	test_still_image.py
 
 EXTRA_DIST = \
diff --git a/tests/test_preset.py b/tests/test_preset.py
new file mode 100644
index 0000000..ce6301e
--- /dev/null
+++ b/tests/test_preset.py
@@ -0,0 +1,116 @@
+# PiTiVi , Non-linear video editor
+#
+#       tests/test_preset.py
+#
+# Copyright (c) 2011, Alex Balut <alexandru balut gmail com>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+# Boston, MA 02110-1301, USA.
+
+import os.path
+import shutil
+import tempfile
+from unittest import TestCase
+
+from pitivi.ui.preset import PresetManager
+
+
+class SimplePresetManager(PresetManager):
+    """A preset manager that stores any (str: str) dict."""
+
+    def __init__(self, empty_dir):
+        PresetManager.__init__(self)
+        self.dir = empty_dir
+
+    def _getFilename(self):
+        return os.path.join(self.dir, 'simple')
+
+    def _loadPreset(self, parser, section):
+        return dict(parser.items(section))
+
+    def _savePreset(self, parser, section, values):
+        parser.add_section(section)
+        for name, value in values.iteritems():
+            parser.set(section, name, value)
+
+
+class TestProjectManager(TestCase):
+
+    def setUp(self):
+        self.tempdir = tempfile.mkdtemp()
+        self.manager = SimplePresetManager(self.tempdir)
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+
+    def testConvertPresetNameToSectionName(self):
+        self.assertEqual(
+                'my preset',
+                self.manager._convertPresetNameToSectionName('my preset'))
+        self.assertEqual(
+                'my preset_',
+                self.manager._convertPresetNameToSectionName('my preset_'))
+        self.assertEqual(
+                'default_x_',
+                self.manager._convertPresetNameToSectionName('default_x_'))
+
+        # Test that default_* preset names get a _ character at the end.
+        self.assertEqual(
+                'Default_',
+                self.manager._convertPresetNameToSectionName('Default'))
+        self.assertEqual(
+                'defaulT__',
+                self.manager._convertPresetNameToSectionName('defaulT_'))
+
+    def testConvertSectionNameToPresetName(self):
+        self.assertEqual(
+                'my preset',
+                self.manager._convertSectionNameToPresetName('my preset'))
+        self.assertEqual(
+                'my preset_',
+                self.manager._convertSectionNameToPresetName('my preset_'))
+        self.assertEqual(
+                'default_x_',
+                self.manager._convertSectionNameToPresetName('default_x_'))
+
+        # Test that default_+ section names loose the last character.
+        self.assertEqual(
+                'Default',
+                self.manager._convertSectionNameToPresetName('Default_'))
+        self.assertEqual(
+                'defaulT_',
+                self.manager._convertSectionNameToPresetName('defaulT__'))
+
+    def testSaveAndLoad(self):
+        self.manager.addPreset('preset one', {'name1': '1A'})
+        self.manager.addPreset('default_', {'name2': '2A'})
+        self.manager.addPreset('Default', {'name1': '1B', 'name2': '2B'})
+        self.manager.save()
+
+        other_manager = SimplePresetManager(self.tempdir)
+        other_manager.load()
+
+        default = other_manager.presets['Default']
+        self.assertEqual(2, len(default))
+        self.assertEqual('1B', default['name1'])
+        self.assertEqual('2B', default['name2'])
+
+        default_ = other_manager.presets['default_']
+        self.assertEqual(1, len(default_))
+        self.assertEqual('2A', default_['name2'])
+
+        preset_one = other_manager.presets['preset one']
+        self.assertEqual(1, len(preset_one))
+        self.assertEqual('1A', preset_one['name1'])