Merge pull request #8 from coryleach/dev

Added GetFiles

Author: coryleach

README.md

@@ -1,6 +1,6 @@
 <h1 align="center">Gameframe.SaveLoad 👋</h1>
 <p>
-  <img alt="Version" src="https://img.shields.io/badge/version-1.0.4-blue.svg?cacheSeconds=2592000" />
+  <img alt="Version" src="https://img.shields.io/badge/version-1.0.5-blue.svg?cacheSeconds=2592000" />
   <a href="https://twitter.com/Cory Leach">
     <img alt="Twitter: coryleach" src="https://img.shields.io/twitter/follow/coryleach.svg?style=social" target="_blank" />
   </a>
@@ -13,15 +13,15 @@ Serialization helper utility that supports save, load and encryption.
 #### Using UnityPackageManager (for Unity 2019.3 or later)
 Open the package manager window (menu: Window > Package Manager)<br/>
 Select "Add package from git URL...", fill in the pop-up with the following link:<br/>
-https://github.com/coryleach/UnitySaveLoad.git#1.0.4<br/>
+https://github.com/coryleach/UnitySaveLoad.git#1.0.5<br/>
 
 #### Using UnityPackageManager (for Unity 2019.1 or later)
 
 Find the manifest.json file in the Packages folder of your project and edit it to look like this:
 ```js
 {
   "dependencies": {
-    "com.gameframe.saveload": "https://github.com/coryleach/UnitySaveLoad.git#1.0.4",
+    "com.gameframe.saveload": "https://github.com/coryleach/UnitySaveLoad.git#1.0.5",
     ...
   },
 }

Runtime/SaveLoadManager.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using UnityEditor;
 using UnityEngine;
 
 namespace Gameframe.SaveLoad
@@ -75,24 +74,48 @@ public void Save(object obj, string filename, string folder = null)
         }
 
         /// <summary>
-        /// Creat a copy of an object by serializing and deserializing it
+        /// Gets the list of save files that have been created
+        /// </summary>
+        /// <param name="folder">sub folder</param>
+        /// <returns>list of file names (excludes the path)</returns>
+        public string[] GetFiles(string folder = null)
+        {
+            if (string.IsNullOrEmpty(folder))
+            {
+                folder = defaultFolder;
+            }
+            return SaveLoadUtility.GetSavedFiles(folder,baseFolder);
+        }
+
+        /// <summary>
+        /// Creat a copy of an object by serializing and deserializing it.
+        /// Not compatible with unity objects.
         /// </summary>
         /// <param name="obj">object to be copied</param>
         /// <returns>duplicated instance</returns>
         public object Copy(object obj)
         {
+            if (obj is UnityEngine.Object)
+            {
+                throw new ArgumentException("UnityEngine.Object and child types not supported by copy method.");
+            }
             var saveLoadMethod = GetSaveLoadMethod(saveMethod);
             return saveLoadMethod.Copy(obj);
         }
 
         /// <summary>
-        /// Creat a copy of an object by serializing and deserializing it
+        /// Creat a copy of an object by serializing and deserializing it.
+        /// Not compatible with Unity objects.
         /// </summary>
         /// <param name="obj">object to be copied</param>
         /// <typeparam name="T">Type of object to be copied.</typeparam>
         /// <returns>duplicated instance</returns>
         public T Copy<T>(T obj)
         {
+            if (obj is UnityEngine.Object)
+            {
+                throw new ArgumentException("UnityEngine.Object and child types not supported by copy method.");
+            }
             var saveLoadMethod = GetSaveLoadMethod(saveMethod);
             return (T)saveLoadMethod.Copy(obj);
         }
@@ -219,6 +242,17 @@ public bool LoadUnityObjectOverwrite(UnityEngine.Object objectToOverwrite, strin
             JsonUtility.FromJsonOverwrite(savedObj.jsonData,objectToOverwrite);
             return true;
         }
+
+        /// <summary>
+        /// Copies the serializable fields from one UnityEngine.Object to another
+        /// </summary>
+        /// <param name="toCopy">object which should be copied</param>
+        /// <param name="toOverwrite">object onto which copied fields should be written</param>
+        public void CopyUnityObjectOverwrite(UnityEngine.Object toCopy, UnityEngine.Object toOverwrite)
+        {
+            var jsonData = JsonUtility.ToJson(toCopy);
+            JsonUtility.FromJsonOverwrite(jsonData,toOverwrite);
+        }
 
         /// <summary>
         /// JsonSerializedUnityObject

Runtime/SaveLoadUtility.cs

@@ -1,4 +1,6 @@
-using System.IO;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using UnityEngine;
 
 namespace Gameframe.SaveLoad
@@ -66,9 +68,9 @@ public static void Save(object saveObject, ISerializationMethod serializationMet
                 saveFile.Close();
             }
         }
-        
+
         /// <summary>
-        /// 
+        /// Load object from file
         /// </summary>
         /// <param name="objectType"></param>
         /// <param name="serializationMethod"></param>
@@ -98,7 +100,33 @@ public static object Load(System.Type objectType, ISerializationMethod serializa
         }
 
         /// <summary>
-        /// 
+        /// Enumerate files in the save directory
+        /// </summary>
+        /// <param name="folderName">folder containing the save files</param>
+        /// <param name="baseFolderPath">base path to the folder</param>
+        /// <returns>list of file names</returns>
+        public static IEnumerable<string> EnumerateSavedFiles(string folderName = null, string baseFolderPath = null)
+        {
+            var savePath = GetSavePath(folderName,baseFolderPath);
+            foreach ( var file in Directory.EnumerateFiles(savePath,"*",SearchOption.AllDirectories) )
+            {
+                yield return Path.GetFileName(file);
+            }
+        }
+        
+        /// <summary>
+        /// Creates an array list of save files in the given folder and path
+        /// </summary>
+        /// <param name="folderName"></param>
+        /// <param name="baseFolderPath"></param>
+        /// <returns>Array of file names</returns>
+        public static string[] GetSavedFiles(string folderName = null, string baseFolderPath = null)
+        {
+            return EnumerateSavedFiles(folderName, baseFolderPath).ToArray();
+        }
+        
+        /// <summary>
+        /// Check if a saved file exists
         /// </summary>
         /// <param name="filename"></param>
         /// <param name="folderName"></param>
@@ -112,7 +140,7 @@ public static bool Exists(string filename, string folderName = null, string base
         }
 
         /// <summary>
-        /// 
+        /// Delete a savedd file
         /// </summary>
         /// <param name="filename"></param>
         /// <param name="folderName"></param>

Tests/Editor.meta

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using NUnit.Framework;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Gameframe.SaveLoad.Tests
+{
+    public class SaveLoadUtilityTests
+    {
+        private string TestKey = "TestKey";
+        private string TestSalt = "TestSalt";
+        
+        private ISerializationMethod GetSerializationMethod(SerializationMethodType method)
+        {
+            switch (method)
+            {
+                case SerializationMethodType.Default:
+                    return new SerializationMethodUnityJson();
+                case SerializationMethodType.Binary:
+                    return new SerializationMethodBinary();
+                case SerializationMethodType.BinaryEncrypted:
+                    return new SerializationMethodBinaryEncrypted(TestKey,TestSalt);
+                case SerializationMethodType.UnityJson:
+                    return new SerializationMethodUnityJson();
+                case SerializationMethodType.UnityJsonEncrypted:
+                    return new SerializationMethodUnityJsonEncrypted(TestKey,TestSalt);
+                case SerializationMethodType.JsonDotNet:
+                    return new SerializationMethodJsonDotNet();
+                case SerializationMethodType.JsonDotNetEncrypted:
+                    return new SerializationMethodJsonDotNetEncrypted(TestKey,TestSalt);
+                case SerializationMethodType.Custom:
+                    return new SerializationMethodBinary();
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(method), method, null);
+            }
+        }
+        
+        [Serializable]
+        public class SaveLoadTestObject
+        {
+            public string testData;
+        }
+        
+        [Test]
+        public void SaveLoadAndDelete([Values]SerializationMethodType method)
+        {
+            var testSave = new SaveLoadTestObject() {testData = "SaveFileExists"};
+            var serializationMethod = GetSerializationMethod(method);
+            var filename = "TestSave.sav";
+            
+            SaveLoadUtility.Save(testSave,serializationMethod,filename);
+            
+            Assert.IsTrue(SaveLoadUtility.Exists(filename));
+
+            var loadedSave = (SaveLoadTestObject)SaveLoadUtility.Load(typeof(SaveLoadTestObject), serializationMethod, filename);
+            Assert.NotNull(loadedSave);
+            Assert.IsTrue(loadedSave.testData == testSave.testData);
+            
+            SaveLoadUtility.DeleteSavedFile(filename);
+            
+            Assert.IsFalse(SaveLoadUtility.Exists(filename));
+        }
+
+        [Test]
+        public void CanGetFiles_Empty()
+        {
+            var files = SaveLoadUtility.GetSavedFiles();
+            Assert.IsTrue(files.Length == 0);
+        }
+
+        [Test]
+        public void CanGetFiles()
+        {
+            var testSave = new SaveLoadTestObject() {testData = "SaveFileExists"};
+            var serializationMethod = GetSerializationMethod(SerializationMethodType.Binary);
+            var filename = "TestSave.sav";
+            var folder = "TestFolder";
+            
+            SaveLoadUtility.Save(testSave,serializationMethod,filename,folder);
+
+            var files = SaveLoadUtility.GetSavedFiles(folder);
+            Assert.IsTrue(files.Length == 1);
+            
+            //Files should contain a list of names that exactly match the file name used
+            //omits the path of the file
+            Assert.IsTrue(files[0] == filename);
+            
+            SaveLoadUtility.DeleteSavedFile(filename,folder);
+
+            files = SaveLoadUtility.GetSavedFiles();
+            Assert.IsTrue(files.Length == 0);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            var path = SaveLoadUtility.GetSavePath();
+            string[] files = {"TestSave.sav"};
+
+            foreach (var file in files)
+            {
+                var filename = path + file;
+                if (File.Exists(filename))
+                {
+                    File.Delete(filename);
+                }
+            }
+        }
+        
+    }
+
+}
+

Tests/Editor/SaveLoadUtilityTests.cs

@@ -0,0 +1,21 @@
+{
+    "name": "com.gameframe.saveload.editor.tests",
+    "references": [
+        "GUID:b894308b0ac81480cb726cb405d83944",
+        "GUID:0acc523941302664db1f4e527237feb3",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}