Version bump

Exchanged os.rename with shutil.move since there was a problem with
moving files between different filesystems.

README.rst

@@ -126,9 +126,14 @@ Options used:
 
 * ``wrapper`` (required) with ``cd32`` as an value
 * ``wrapper_archive`` (required) path to the archive with CD32 iso/cue/wav
-* ``wrapper_archiver`` (required) archiver to use for storage save state
+* ``wrapper_archiver`` (conditionally required) archiver to use for storage
+  save state
 * ``wrapper_gui_msg`` (optional) if set to "1", will display a graphical
   message during extracting files
+* ``wrapper_save_state`` (optional) if set to "1", will load/archive save state
+  directory, defined as ``$CONFIG/[save-state-dir-name]`` using provided
+  ``wrapper_archiver`` archiver. If this option is enabled,
+  ``wrapper_archiver`` will be required.
 
 Let's see some sample config for a game, which is saved as
 ``ChaosEngine.fs-uae``:
@@ -139,6 +144,7 @@ Let's see some sample config for a game, which is saved as
    [config]
    wrapper = cd32
    wrapper_archive = ChaosEngine.7z
+   wrapper_archiver = 7z
    wrapper_gui_msg = 1
 
    amiga_model = CD32
@@ -165,14 +171,15 @@ Now, there several thing will happen:
 - Archive with game assists will be extracted in that directory
 - Configuration file will be copied into that directory, and renamed to
   ``Config.fs-uae``
-- If there is saved state, it also would be extracted there
+- If ``wrapper_save_state`` is set, and there is saved state archive, it also
+  would be extracted there
 - ``fs-uae`` will be launched inside that directory
 
 Next, after ``fs-uae`` quit, there will:
 
-- Create archive containing save state with name like the configuration file
+- Optionally create archive containing save state with name like the
-  with additional ``_save`` suffix. In this example it would be
+  configuration file with additional ``_save`` suffix. In this example it would
-  ``ChaosEngine_save.7z``.
+  be ``ChaosEngine_save.7z``.
 - Wipe out temporary directory
 
 archive
@@ -180,14 +187,19 @@ archive
 
 Options used:
 
-* ``wrapper`` (required) with ``cd32`` as an value
+* ``wrapper`` (required) with ``archive`` as an value
 * ``wrapper_archive`` (required) path to the archive with assets (usually means
-* ``wrapper_archiver`` (required) archiver to use for storage save state
   whole system directories, floppies or hard disk images)
+* ``wrapper_archiver`` (conditionally required) archiver to use for storage
+  save state
 * ``wrapper_gui_msg`` (optional) if set to "1", will display a graphical
   message during extracting files
 * ``wrapper_persist_data`` (optional) if set to "1", will compress (possibly
   changed) data, replacing original archive
+* ``wrapper_save_state`` (optional) if set to "1", will archive save state
+  directory, defined as ``$CONFIG/[save-state-dir-name]`` using provided
+  ``wrapper_archiver`` archiver. If this option is enabled,
+  ``wrapper_archiver`` will be required.
 
 Example configuration:
 
@@ -197,9 +209,10 @@ Example configuration:
    [config]
    wrapper = archive
    wrapper_archive = Workbench_3.1.tar.bz2
+   wrapper_archiver = lha
    wrapper_gui_msg = 1
    wrapper_persist_data = 1
-
+   wrapper_save_state = 1
    ...
 
 And execution is as usual:
@@ -212,11 +225,12 @@ This module will do several steps (similar as with ``cd32`` wrapper):
 
 - create temporary directory
 - extract provided in configuration archive
-- extract save state (if exists)
+- extract save state (if ``wrapper_save_state`` is set to ``1`` and archive
+  with save exists)
 - copy configuration under name ``Config.fs-uae``
 - run the fs-uae emulator
-- create archive with save state (if save state directory place is *not* a
+- optionally create archive with save state (if save state directory place is
-  global one)
+  *not* a global one)
 - optionally create new archive under the same name as the original one and
   replace it with original one.
 

fs_uae_wrapper/archive.py

@@ -40,7 +40,6 @@ class Archive(base.Base):
         if not super(Archive, self).run():
             return False
 
-        self._set_assets_paths()
         if not self._extract():
             return False
 
@@ -66,9 +65,6 @@ class Archive(base.Base):
 
         validation_result = super(Archive, self)._validate_options()
 
-        if not super(Archive, self)._validate_options():
-            validation_result = False
-
         if 'wrapper_archive' not in self.all_options:
             sys.stderr.write("Configuration lacks of required "
                              "`wrapper_archive' option.\n")
@@ -97,7 +93,7 @@ class Archive(base.Base):
         if not utils.create_archive(arch, title):
             return False
 
-        os.rename(arch, self.arch_filepath)
+        shutil.move(arch, self.arch_filepath)
         os.chdir(curdir)
         return True
 

fs_uae_wrapper/base.py

@@ -47,6 +47,8 @@ class Base(object):
 
         self.dir = tempfile.mkdtemp()
 
+        self._set_assets_paths()
+
         return True
 
     def clean(self):
@@ -91,15 +93,17 @@ class Base(object):
         conf_base = os.path.basename(self.conf_file)
         conf_base = os.path.splitext(conf_base)[0]
 
-        arch = self.all_options['wrapper_archive']
+        arch = self.all_options.get('wrapper_archive')
+        if arch:
             if os.path.isabs(arch):
                 self.arch_filepath = arch
             else:
                 self.arch_filepath = os.path.join(conf_abs_dir, arch)
         # set optional save_state
-        arch_ext = utils.get_arch_ext(self.all_options['wrapper_archiver'])
+        arch_ext = utils.get_arch_ext(self.all_options.get('wrapper_archiver'))
-        self.save_filename = os.path.join(conf_abs_dir, conf_base + '_save' +
+        if arch_ext:
-                                          arch_ext)
+            self.save_filename = os.path.join(conf_abs_dir, conf_base +
+                                              '_save' + arch_ext)
 
     def _copy_conf(self):
         """copy provided configuration as Config.fs-uae"""
@@ -143,6 +147,9 @@ class Base(object):
         """
         Get the saves from emulator and store it where configuration is placed
         """
+        if self.all_options.get('wrapper_save_state', '0') != '1':
+            return True
+
         os.chdir(self.dir)
         save_path = self._get_saves_dir()
         if not save_path:
@@ -165,6 +172,9 @@ class Base(object):
         """
         Put the saves (if exists) to the temp directory.
         """
+        if self.all_options.get('wrapper_save_state', '0') != '1':
+            return True
+
         if not os.path.exists(self.save_filename):
             return True
 
@@ -208,6 +218,9 @@ class Base(object):
                              "`wrapper' option.\n")
             return False
 
+        if self.all_options.get('wrapper_save_state', '0') == '0':
+            return True
+
         if 'wrapper_archiver' not in self.all_options:
             sys.stderr.write("Configuration lacks of required "
                              "`wrapper_archiver' option.\n")

fs_uae_wrapper/cd32.py

@@ -34,7 +34,6 @@ class CD32(base.Base):
         if not self._validate_options():
             return False
 
-        self._set_assets_paths()
         if not self._extract():
             return False
 
@@ -46,7 +45,10 @@ class CD32(base.Base):
         if kick_opts:
             self.fsuae_options.update(kick_opts)
 
-        if self._run_emulator(self.fsuae_options.list()):
+        if not self._run_emulator(self.fsuae_options.list()):
+            return False
+
+        if self._get_saves_dir():
             return self._save_save()
 
         return True

setup.py

@@ -7,7 +7,7 @@ from distutils.core import setup
 
 setup(name='fs-uae-wrapper',
       packages=['fs_uae_wrapper'],
-      version='0.4',
+      version='0.5',
       description='Automate archives and state for fs-uae',
       author='Roman Dobosz',
       author_email='gryf73@gmail.com',

tests/test_archive.py

@@ -26,35 +26,43 @@ class TestArchive(TestCase):
         except OSError:
             pass
 
-    def test_validate_options(self):
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_validate_options(self, which):
+        which.return_value = 'unrar'
 
         arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(arch._validate_options())
+        arch.all_options = {'wrapper': 'archive'}
 
         arch.all_options['wrapper'] = 'archive'
         self.assertFalse(arch._validate_options())
 
-        arch.all_options['wrapper_archive'] = 'fake.tgz'
+        arch.all_options['wrapper_archive'] = 'rar'
-        self.assertFalse(arch._validate_options())
-
-        arch.all_options['wrapper_archiver'] = 'rar'
         self.assertTrue(arch._validate_options())
 
     @mock.patch('tempfile.mkdtemp')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('fs_uae_wrapper.archive.Archive._make_archive')
+    @mock.patch('fs_uae_wrapper.base.Base._save_save')
+    @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
     @mock.patch('fs_uae_wrapper.base.Base._run_emulator')
     @mock.patch('fs_uae_wrapper.base.Base._kickstart_option')
     @mock.patch('fs_uae_wrapper.base.Base._copy_conf')
     @mock.patch('fs_uae_wrapper.base.Base._load_save')
     @mock.patch('fs_uae_wrapper.base.Base._extract')
-    def test_run(self, extr, load, copy, kick, run, march, mkdtemp):
+    def test_run(self, extract, load_save, copy_conf, kick_option,
+                 run_emulator, get_save_dir, save_state, make_arch, which,
+                 mkdtemp):
 
-        extr.return_value = False
+        extract.return_value = False
-        load.return_value = False
+        load_save.return_value = False
-        copy.return_value = False
+        copy_conf.return_value = False
-        kick.return_value = False
+        kick_option.return_value = False
-        run.return_value = False
+        run_emulator.return_value = False
-        march.return_value = False
+        get_save_dir.return_value = False
+        save_state.return_value = False
+        make_arch.return_value = False
+        which.return_value = 'rar'
 
         arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(arch.run())
@@ -65,23 +73,29 @@ class TestArchive(TestCase):
 
         self.assertFalse(arch.run())
 
-        extr.return_value = True
+        extract.return_value = True
         self.assertFalse(arch.run())
 
-        load.return_value = True
+        load_save.return_value = True
         self.assertFalse(arch.run())
 
-        copy.return_value = True
+        copy_conf.return_value = True
         self.assertFalse(arch.run())
 
-        kick.return_value = {'foo': 'bar'}
+        kick_option.return_value = {'foo': 'bar'}
         self.assertFalse(arch.run())
         self.assertDictEqual(arch.fsuae_options, {'foo': 'bar'})
 
-        run.return_value = True
+        run_emulator.return_value = True
         self.assertFalse(arch.run())
 
-        march.return_value = True
+        get_save_dir.return_value = True
+        self.assertFalse(arch.run())
+
+        save_state.return_value = True
+        self.assertFalse(arch.run())
+
+        make_arch.return_value = True
         self.assertTrue(arch.run())
 
     @mock.patch('os.rename')

tests/test_base.py

@@ -146,21 +146,27 @@ class TestBase(TestCase):
     @mock.patch('fs_uae_wrapper.utils.create_archive')
     def test_save_save(self, carch, saves_dir):
 
-        bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
+        os.chdir(self.confdir)
+
+        bobj = base.Base('myconf.fs-uae', utils.CmdOption(), {})
         bobj.dir = self.dirname
-        bobj.save_filename = 'foobar_save.7z'
+        bobj.save_filename = os.path.join(self.confdir, 'myconf_save.7z')
-        saves_dir.bobj.save_filenamereturn_value = None
+
+        saves_dir.return_value = None
         carch.return_value = True
 
-        self.assertTrue(bobj._save_save())
+        self.assertTrue(bobj._save_save(),
+                        'there is assumption, that wrapper_save_state is'
+                        ' false by default. Here it was true.')
+
+        bobj.all_options['wrapper_save_state'] = '1'
+        self.assertTrue(bobj._save_save(),
+                        'unexpected save_state directory found')
 
         saves_dir.return_value = bobj.save_filename
-        os.chdir(self.confdir)
         with open(bobj.save_filename, 'w') as fobj:
             fobj.write('asd')
 
-        self.assertTrue(bobj._save_save())
-
         os.mkdir(os.path.join(self.dirname, 'fs-uae-save'))
         self.assertTrue(bobj._save_save())
 
@@ -175,6 +181,12 @@ class TestBase(TestCase):
         bobj.save_filename = "foobar_save.7z"
         earch.return_value = 0
 
+        # By default there would be no save state persistence
+        self.assertTrue(bobj._load_save())
+
+        # set wrapper_save_state option, so we can proceed with test
+        bobj.all_options['wrapper_save_state'] = '1'
+
         # fail to load save is not fatal
         self.assertTrue(bobj._load_save())
 
@@ -218,6 +230,9 @@ class TestBase(TestCase):
         os.mkdir(path)
         self.assertEqual(bobj._get_saves_dir(), 'saves')
 
+        bobj.all_options['save_states_dir'] = '$CONFIG/saves/'
+        self.assertEqual(bobj._get_saves_dir(), 'saves')
+
     @mock.patch('fs_uae_wrapper.path.which')
     def test_validate_options(self, which):
 
@@ -229,18 +244,31 @@ class TestBase(TestCase):
         self.assertFalse(bobj._validate_options())
 
         bobj.all_options = {'wrapper': 'dummy'}
-        self.assertFalse(bobj._validate_options())
+        self.assertTrue(bobj._validate_options())
 
         bobj.all_options = {'wrapper': 'dummy',
                             'wrapper_archiver': 'myarchiver'}
+        self.assertTrue(bobj._validate_options())
+
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1',
+                            'wrapper_archiver': 'myarchiver'}
         self.assertFalse(bobj._validate_options())
 
         which.return_value = '7z'
         bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1'}
+        self.assertFalse(bobj._validate_options())
+
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1',
                             'wrapper_archiver': '7z'}
         self.assertTrue(bobj._validate_options())
 
-    def test_run_clean(self):
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_run_clean(self, which):
+
+        which.return_value = 'rar'
 
         bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
         bobj.all_options = {}

tests/test_cd32.py

@@ -11,7 +11,10 @@ from fs_uae_wrapper import utils
 
 class TestCD32(TestCase):
 
-    def test_validate_options(self):
+    @mock.patch('fs_uae_wrapper.path.which')
+    def test_validate_options(self, which):
+
+        which.return_value = 'rar'
 
         acd32 = cd32.CD32('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(acd32._validate_options())
@@ -20,26 +23,28 @@ class TestCD32(TestCase):
         self.assertFalse(acd32._validate_options())
 
         acd32.all_options['wrapper_archive'] = 'fake.tgz'
-        self.assertFalse(acd32._validate_options())
-
-        acd32.all_options['wrapper_archiver'] = 'rar'
         self.assertTrue(acd32._validate_options())
 
     @mock.patch('tempfile.mkdtemp')
+    @mock.patch('fs_uae_wrapper.path.which')
     @mock.patch('fs_uae_wrapper.base.Base._save_save')
+    @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
     @mock.patch('fs_uae_wrapper.base.Base._run_emulator')
     @mock.patch('fs_uae_wrapper.base.Base._kickstart_option')
-    @mock.patch('fs_uae_wrapper.base.Base._load_save')
     @mock.patch('fs_uae_wrapper.base.Base._copy_conf')
+    @mock.patch('fs_uae_wrapper.base.Base._load_save')
     @mock.patch('fs_uae_wrapper.base.Base._extract')
-    def test_run(self, extr, cconf, lsave, kick, runemul, ssave, mkdtemp):
+    def test_run(self, extract, load_save, copy_conf, kick_option,
+                 run_emulator, get_save_dir, save_state, which, mkdtemp):
 
-        extr.return_value = False
+        extract.return_value = False
-        cconf.return_value = False
+        copy_conf.return_value = False
-        lsave.return_value = False
+        load_save.return_value = False
-        kick.return_value = {}
+        kick_option.return_value = {}
-        runemul.return_value = False
+        run_emulator.return_value = False
-        ssave.return_value = False
+        get_save_dir.return_value = False
+        save_state.return_value = False
+        which.return_value = 'unrar'
 
         acd32 = cd32.CD32('Config.fs-uae', utils.CmdOption(), {})
         self.assertFalse(acd32.run())
@@ -50,21 +55,24 @@ class TestCD32(TestCase):
 
         self.assertFalse(acd32.run())
 
-        extr.return_value = True
+        extract.return_value = True
         self.assertFalse(acd32.run())
 
-        cconf.return_value = True
+        copy_conf.return_value = True
         self.assertFalse(acd32.run())
 
-        lsave.return_value = True
+        load_save.return_value = True
-        self.assertTrue(acd32.run())
+        self.assertFalse(acd32.run())
 
-        kick.return_value = {'foo': 'bar'}
+        kick_option.return_value = {'foo': 'bar'}
-        self.assertTrue(acd32.run())
+        self.assertFalse(acd32.run())
         self.assertDictEqual(acd32.fsuae_options, {'foo': 'bar'})
 
-        runemul.return_value = True
+        run_emulator.return_value = True
+        self.assertTrue(acd32.run())
+
+        get_save_dir.return_value = True
         self.assertFalse(acd32.run())
 
-        ssave.return_value = True
+        save_state.return_value = True
         self.assertTrue(acd32.run())