Merge lp:~adam-rpconnelly/dbversion/archive-properties into lp:dbversion

[Adam Connelly]

Added support for storing properties inside the file and zip archives.

=== added file 'samples/classic-sample.zip'
Binary files samples/classic-sample.zip	1970-01-01 00:00:00 +0000 and samples/classic-sample.zip	2011-09-04 10:36:23 +0000 differ
=== modified file 'src/DatabaseVersion.Console/DatabaseVersion.Console.csproj'
--- src/DatabaseVersion.Console/DatabaseVersion.Console.csproj	2011-09-04 10:36:23 +0000
+++ src/DatabaseVersion.Console/DatabaseVersion.Console.csproj	2011-09-04 10:36:23 +0000
@@ -22,7 +22,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <Commandlineparameters>-c "Server=localhost;Database=library;User ID=adam;Password=adam;" -a /home/adam/bzr/dbversion/settings/samples/classic-sample</Commandlineparameters>
+    <Commandlineparameters>-c "Server=localhost;Database=library;User ID=adam;Password=adam;" -a /home/adam/bzr/dbversion/archive-properties/samples/classic-sample.zip</Commandlineparameters>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
     <PlatformTarget>x86</PlatformTarget>

=== modified file 'src/DatabaseVersion.Console/Program.cs'
--- src/DatabaseVersion.Console/Program.cs	2011-09-04 10:36:23 +0000
+++ src/DatabaseVersion.Console/Program.cs	2011-09-04 10:36:23 +0000
@@ -1,3 +1,5 @@
+using dbversion.Archives;
+
 namespace dbversion.Console
 {
     using System;
@@ -26,20 +28,41 @@
 
             try
             {
+                var archive = GetArchive(arguments, container);
                 var propertyService = container.GetExportedValue<IPropertyService>();
                 propertyService.SetDefaultProperties();
                 MergeSavedProperties(container, propertyService);
+                propertyService.Merge(archive.Properties);
                 OverwritePropertiesFromArguments(propertyService, arguments);
 
-                creator.LoadArchive(arguments.Archive);
-                creator.Create(arguments.Version, new ConsoleTaskExecuter());
-            } catch (VersionNotFoundException e)
-            {
-                System.Console.WriteLine(e.Message);
-            } catch (TaskExecutionException e)
-            {
-                System.Console.WriteLine(e.Message);
-            }
+                creator.Create(archive, arguments.Version, new ConsoleTaskExecuter());
+            }
+            catch (VersionNotFoundException e)
+            {
+                System.Console.WriteLine(e.Message);
+            }
+            catch (TaskExecutionException e)
+            {
+                System.Console.WriteLine(e.Message);
+            }
+        }
+
+        private static IDatabaseArchive GetArchive(Arguments arguments, CompositionContainer container)
+        {
+            IDatabaseArchiveFactory archiveFactory = GetArchiveFactory(arguments.Archive, container);
+            if (archiveFactory == null)
+            {
+                throw new InvalidOperationException("Unknown archive type");
+            }
+
+            return archiveFactory.Create(arguments.Archive);
+        }
+
+        private static IDatabaseArchiveFactory GetArchiveFactory(string archivePath, CompositionContainer container)
+        {
+            var archiveFactories = container.GetExportedValues<IDatabaseArchiveFactory>();
+            // TODO: Throw UnknownArchiveTypeException if no handlers found
+            return archiveFactories.First(f => f.CanCreate(archivePath));
         }
 
         private static Arguments ParseArguments(ref string[] args)
@@ -84,9 +107,6 @@
 
         private static void OverwritePropertiesFromArguments(IPropertyService propertyService, Arguments arguments)
         {
-//            propertyService.Add(new Property { Key = "hibernate.connection.provider", Value = "NHibernate.Connection.DriverConnectionProvider" });
-//            propertyService.Add(new Property { Key = "hibernate.connection.driver_class", Value = "NHibernate.Driver.SqlClientDriver" });
-//            propertyService.Add(new Property { Key = "hibernate.dialect", Value = "NHibernate.Dialect.MsSql2008Dialect" });
             propertyService.Add(new Property { Key = "hibernate.connection.connection_string", Value = arguments.ConnectionString });
         }
 

=== modified file 'src/DatabaseVersion.Tests/Archives/File/FileDatabaseArchiveTests.cs'
--- src/DatabaseVersion.Tests/Archives/File/FileDatabaseArchiveTests.cs	2011-08-29 18:40:26 +0000
+++ src/DatabaseVersion.Tests/Archives/File/FileDatabaseArchiveTests.cs	2011-09-04 10:36:23 +0000
@@ -14,6 +14,8 @@
     using Moq;
     using dbversion.Archives;
     using dbversion.Version;
+    using dbversion.Property;
+    using dbversion.Utils;
 
     public class FileDatabaseArchiveTests : IDisposable
     {
@@ -84,16 +86,16 @@
 
             DatabaseVersion version1 = new DatabaseVersion(new NumericVersion(1), "_1" + Path.DirectorySeparatorChar + "database.xml", null);
             DatabaseVersion version2 = new DatabaseVersion(new NumericVersion(2), "_2" + Path.DirectorySeparatorChar + "database.xml", null);
-			
+
             this.manifestReader.Setup(
                 m => m.Read(It.IsAny<Stream>(), 
-				string.Format("{1}{0}{2}{0}{3}", Path.DirectorySeparatorChar, this.testDirectory.FullName, "_1", "database.xml"),
-				It.IsAny<IDatabaseArchive>()))
+                string.Format("{1}{0}{2}{0}{3}", Path.DirectorySeparatorChar, this.testDirectory.FullName, "_1", "database.xml"),
+                It.IsAny<IDatabaseArchive>()))
                 .Returns(version1);
             this.manifestReader.Setup(
-				m => m.Read(It.IsAny<Stream>(),
+                m => m.Read(It.IsAny<Stream>(),
                 string.Format("{1}{0}{2}{0}{3}", Path.DirectorySeparatorChar, this.testDirectory.FullName, "_2", "database.xml"),
-				It.IsAny<IDatabaseArchive>()))
+            It.IsAny<IDatabaseArchive>()))
                 .Returns(version2);
 
             FileDatabaseArchive archive = new FileDatabaseArchive(testDirectory.FullName, this.manifestReader.Object);
@@ -105,7 +107,69 @@
             Assert.Contains(version1, versions);
             Assert.Contains(version2, versions);
         }
-		
+
+        [Fact]
+        public void ShouldLoadPropertiesFromPropertiesFile()
+        {
+            // Arrange
+            this.testDirectory = FileUtil.CreateTempDirectory();
+
+            PropertyCollection expectedProperties = new PropertyCollection();
+            expectedProperties.Properties.Add(new Property { Key = "property1", Value = "property1.value" });
+            expectedProperties.Properties.Add(new Property { Key = "property2", Value = "property2.value" });
+
+            using (FileStream stream = new FileStream(Path.Combine(this.testDirectory.FullName, PropertyService.PropertyFileName), FileMode.Create))
+            {
+                XmlSerializer.Serialize(expectedProperties).CopyTo(stream);
+            }
+
+            var archive = new FileDatabaseArchive(this.testDirectory.FullName, this.manifestReader.Object);
+
+            // Act
+            var properties = archive.Properties;
+
+            // Assert
+            Assert.Equal("property1.value", properties.Single(p => p.Key == "property1").Value);
+            Assert.Equal("property2.value", properties.Single(p => p.Key == "property2").Value);
+        }
+
+        [Fact]
+        public void ShouldReturnEmptyPropertiesIfNoPropertiesFileExists()
+        {
+            // Arrange
+            this.testDirectory = FileUtil.CreateTempDirectory();
+
+            var archive = new FileDatabaseArchive(this.testDirectory.FullName, this.manifestReader.Object);
+
+            // Act
+            var properties = archive.Properties;
+
+            // Assert
+            Assert.Empty(properties);
+        }
+
+        [Fact]
+        public void ShouldReturnEmptyPropertiesIfNoPropertiesExistInFile()
+        {
+            // Arrange
+            this.testDirectory = FileUtil.CreateTempDirectory();
+
+            PropertyCollection expectedProperties = new PropertyCollection();
+
+            using (FileStream stream = new FileStream(Path.Combine(this.testDirectory.FullName, PropertyService.PropertyFileName), FileMode.Create))
+            {
+                XmlSerializer.Serialize(expectedProperties).CopyTo(stream);
+            }
+
+            var archive = new FileDatabaseArchive(this.testDirectory.FullName, this.manifestReader.Object);
+
+            // Act
+            var properties = archive.Properties;
+
+            // Assert
+            Assert.Empty(properties);
+        }
+
         public void Dispose()
         {
             if (this.testDirectory != null)

=== modified file 'src/DatabaseVersion.Tests/Archives/Zip/ZipDatabaseArchiveTests.cs'
--- src/DatabaseVersion.Tests/Archives/Zip/ZipDatabaseArchiveTests.cs	2011-08-29 18:40:26 +0000
+++ src/DatabaseVersion.Tests/Archives/Zip/ZipDatabaseArchiveTests.cs	2011-09-04 10:36:23 +0000
@@ -1,15 +1,21 @@
 namespace dbversion.Tests.Archives.Zip
 {
-    using Xunit;
-    using Ionic.Zip;
-    using Moq;
-    using dbversion.Manifests;
-    using dbversion.Archives.Zip;
     using System.IO;
     using System.Linq;
+
+    using dbversion.Archives;
+    using dbversion.Archives.Zip;
+    using dbversion.Manifests;
     using dbversion.Tests.Utils;
-    using dbversion.Archives;
+    using dbversion.Utils;
     using dbversion.Version;
+    using dbversion.Property;
+
+    using Ionic.Zip;
+
+    using Moq;
+
+    using Xunit;
 
     public class ZipDatabaseArchiveTests
     {
@@ -37,5 +43,55 @@
                 Assert.Equal(2, archive.Versions.Count());
             }
         }
+
+        [Fact]
+        public void ShouldLoadPropertiesFromArchive()
+        {
+            // Arrange
+            string path = Path.GetTempFileName();
+            using (var zipFile = new ZipFile())
+            {
+                var tempDir = FileUtil.CreateTempDirectory();
+                var propertiesFileName = Path.Combine(tempDir.FullName, "properties.xml");
+                using (var stream = File.Create(propertiesFileName))
+                {
+                    var propertyCollection = new PropertyCollection();
+                    propertyCollection.Properties.Add(new Property { Key = "property1", Value = "property1.value" });
+                    propertyCollection.Properties.Add(new Property { Key = "property2", Value = "property2.value" });
+                    XmlSerializer.Serialize(propertyCollection).CopyTo(stream);
+                }
+
+                zipFile.AddFile(propertiesFileName, "/");
+                zipFile.Save(path);
+            }
+
+            var archive = new ZipDatabaseArchive(path, new Mock<ManifestReader>().Object);
+
+            // Act
+            var properties = archive.Properties;
+
+            // Assert
+            Assert.Equal("property1.value", properties.Single(p => p.Key == "property1").Value);
+            Assert.Equal("property2.value", properties.Single(p => p.Key == "property2").Value);
+        }
+
+        [Fact]
+        public void ShouldHaveEmptyPropertiesIfNoPropertiesFileExists()
+        {
+            // Arrange
+            string path = Path.GetTempFileName();
+            using (var zipFile = new ZipFile())
+            {
+                zipFile.Save(path);
+            }
+
+            var archive = new ZipDatabaseArchive(path, new Mock<ManifestReader>().Object);
+
+            // Act
+            var properties = archive.Properties;
+
+            // Assert
+            Assert.Empty(properties);
+        }
     }
 }

=== modified file 'src/DatabaseVersion.sln'
--- src/DatabaseVersion.sln	2011-09-04 10:36:23 +0000
+++ src/DatabaseVersion.sln	2011-09-04 10:36:23 +0000
@@ -71,6 +71,7 @@
 		$2.WhileBraceForcement = AddBraces
 		$2.UsingBraceForcement = AddBraces
 		$2.FixedBraceForcement = AddBraces
+		$2.PlaceElseOnNewLine = True
 		$2.BeforeMethodDeclarationParentheses = False
 		$2.BeforeMethodCallParentheses = False
 		$2.BeforeConstructorDeclarationParentheses = False

=== modified file 'src/DatabaseVersion/Archives/File/FileDatabaseArchive.cs'
--- src/DatabaseVersion/Archives/File/FileDatabaseArchive.cs	2011-08-29 18:40:26 +0000
+++ src/DatabaseVersion/Archives/File/FileDatabaseArchive.cs	2011-09-04 10:36:23 +0000
@@ -8,6 +8,8 @@
     using System.ComponentModel.Composition;
     
     using dbversion.Manifests;
+    using dbversion.Property;
+    using dbversion.Utils;
     using dbversion.Version;
 
     /// <summary>
@@ -34,6 +36,7 @@
             this.ArchivePath = archivePath;
             this.manifestReader = manifestReader;
             this.ParseManifests();
+            this.LoadProperties();
         }
 
         /// <summary>
@@ -56,6 +59,12 @@
             private set;
         }
 
+        public IEnumerable<Property> Properties
+        {
+            get;
+            private set;
+        }
+
         /// <summary>
         /// Gets the file at the specified path from the archive.
         /// </summary>
@@ -117,5 +126,22 @@
             string filePath = Path.Combine(manifestFile.Directory.Name, scriptFileName);
             return filePath;
         }
+
+        private void LoadProperties()
+        {
+            FileInfo propertiesFile = new FileInfo(Path.Combine(this.ArchivePath, PropertyService.PropertyFileName));
+            if (propertiesFile.Exists)
+            {
+                using (var stream = propertiesFile.OpenRead())
+                {
+                    var propertyCollection = XmlSerializer.DeSerialize<PropertyCollection>(stream);
+                    this.Properties = propertyCollection.Properties;
+                }
+            }
+            else
+            {
+                this.Properties = Enumerable.Empty<Property>();
+            }
+        }
     }
 }

=== modified file 'src/DatabaseVersion/Archives/IDatabaseArchive.cs'
--- src/DatabaseVersion/Archives/IDatabaseArchive.cs	2011-08-29 18:40:26 +0000
+++ src/DatabaseVersion/Archives/IDatabaseArchive.cs	2011-09-04 10:36:23 +0000
@@ -6,6 +6,7 @@
     using System.Text;
     using System.IO;
 
+    using dbversion.Property;
     using dbversion.Version;
     
     /// <summary>
@@ -24,6 +25,14 @@
         IEnumerable<IDatabaseVersion> Versions { get; }
 
         /// <summary>
+        /// Gets the properties stored in the archive.
+        /// </summary>
+        /// <value>
+        /// The properties.
+        /// </value>
+        IEnumerable<Property> Properties { get; }
+
+        /// <summary>
         /// Gets the file at the specified path.
         /// </summary>
         /// <param name="path">The path relative to the root of the archive.</param>

=== modified file 'src/DatabaseVersion/Archives/Zip/ZipDatabaseArchive.cs'
--- src/DatabaseVersion/Archives/Zip/ZipDatabaseArchive.cs	2011-08-29 18:40:26 +0000
+++ src/DatabaseVersion/Archives/Zip/ZipDatabaseArchive.cs	2011-09-04 10:36:23 +0000
@@ -1,23 +1,47 @@
 namespace dbversion.Archives.Zip
 {
-    using Ionic.Zip;
+    using System;
     using System.IO;
     using System.Linq;
     using System.ComponentModel.Composition;
     using System.Collections.Generic;
 
     using dbversion.Manifests;
+    using dbversion.Property;
+    using dbversion.Utils;
     using dbversion.Version;
 
+    using Ionic.Zip;
+
+    /// <summary>
+    /// A database archive that stores its files in a zip file.
+    /// </summary>
     [Export(typeof(IDatabaseArchive))]
     public class ZipDatabaseArchive : IDatabaseArchive
     {
         #region Fields
+
+        /// <summary>
+        /// The manifest reader.
+        /// </summary>
         private readonly IManifestReader manifestReader;
+
+        /// <summary>
+        /// The versions contained in the archive.
+        /// </summary>
         private readonly List<IDatabaseVersion> versions = new List<IDatabaseVersion>();
 
         #endregion
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="dbversion.Archives.Zip.ZipDatabaseArchive"/> class.
+        /// </summary>
+        /// <param name='path'>
+        /// The path to the archive.
+        /// </param>
+        /// <param name='manifestReader'>
+        /// The manifest reader.
+        /// </param>
         public ZipDatabaseArchive(string path, IManifestReader manifestReader)
         {
             Validate.NotEmpty(() => path);
@@ -26,26 +50,57 @@
             this.ArchivePath = path;
             this.manifestReader = manifestReader;
 
-            using (ZipFile zipfile = new ZipFile(path))
+            using (ZipFile zipFile = new ZipFile(path))
             {
-                foreach (ZipEntry entry in zipfile.Where(e => e.FileName.EndsWith("database.xml")))
-                {
-                    this.ParseManifest(entry);
-                }
+                this.ParseManifests(zipFile);
+                this.LoadProperties(zipFile);
             }
         }
 
+        /// <summary>
+        /// Gets the archive path.
+        /// </summary>
+        /// <value>
+        /// The archive path.
+        /// </value>
         public string ArchivePath
         {
             get;
             private set;
         }
 
-        public System.Collections.Generic.IEnumerable<IDatabaseVersion> Versions
+        /// <summary>
+        /// Gets the versions contained in the archive.
+        /// </summary>
+        /// <value>
+        /// The versions.
+        /// </value>
+        public IEnumerable<IDatabaseVersion> Versions
         {
             get { return this.versions; }
         }
 
+        /// <summary>
+        /// Gets the properties set in the archive.
+        /// </summary>
+        /// <value>
+        /// The properties.
+        /// </value>
+        public IEnumerable<Property> Properties
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gets the specified file from the archive.
+        /// </summary>
+        /// <param name='path'>
+        /// The path to the file.
+        /// </param>
+        /// <returns>
+        /// The file or null if the file does not exist.
+        /// </returns>
         public System.IO.Stream GetFile(string path)
         {
             using (ZipFile zipFile = new ZipFile(this.ArchivePath))
@@ -65,11 +120,58 @@
             return null;
         }
 
+        /// <summary>
+        /// Returns whether the archive contains the specified version.
+        /// </summary>
+        /// <param name='version'>
+        /// The version to look for.
+        /// </param>
+        /// <returns>
+        /// true if the archive contains the version, false otherwise.
+        /// </returns>
         public bool ContainsVersion(object version)
         {
             return this.Versions.FirstOrDefault(v => object.Equals(v.Version, version)) != null;
         }
 
+        /// <summary>
+        /// Gets the script path.
+        /// </summary>
+        /// <param name='manifestPath'>
+        /// The manifest path.
+        /// </param>
+        /// <param name='scriptFileName'>
+        /// The script file name.
+        /// </param>
+        /// <returns>
+        /// The script path.
+        /// </returns>
+        public string GetScriptPath(string manifestPath, string scriptFileName)
+        {
+            string filePath = Path.Combine(Path.GetDirectoryName(manifestPath), scriptFileName);
+            return filePath.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        }
+
+        /// <summary>
+        /// Parses the manifests contained in the zip file.
+        /// </summary>
+        /// <param name='zipFile'>
+        /// The zip file.
+        /// </param>
+        private void ParseManifests(ZipFile zipFile)
+        {
+            foreach (ZipEntry entry in zipFile.Where(e => e.FileName.EndsWith("database.xml")))
+            {
+                this.ParseManifest(entry);
+            }
+        }
+
+        /// <summary>
+        /// Parses the manifest.
+        /// </summary>
+        /// <param name='entry'>
+        /// The zip entry containing the manifest.
+        /// </param>
         private void ParseManifest(ZipEntry entry)
         {
             MemoryStream stream = new MemoryStream();
@@ -80,10 +182,23 @@
             this.versions.Add(this.manifestReader.Read(stream, entry.FileName, this));
         }
 
-        public string GetScriptPath(string manifestPath, string scriptFileName)
+        /// <summary>
+        /// Loads the properties.
+        /// </summary>
+        /// <param name='zipFile'>
+        /// The zip file to load the properties from.
+        /// </param>
+        private void LoadProperties(ZipFile zipFile)
         {
-            string filePath = Path.Combine(Path.GetDirectoryName(manifestPath), scriptFileName);
-            return filePath.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+            if (zipFile.ContainsEntry(PropertyService.PropertyFileName))
+            {
+                var propertiesFile = zipFile.Single(p => p.FileName == PropertyService.PropertyFileName);
+                this.Properties = XmlSerializer.DeSerialize<PropertyCollection>(propertiesFile.OpenReader()).Properties;
+            }
+            else
+            {
+                this.Properties = Enumerable.Empty<Property>();
+            }
         }
     }
 }

=== modified file 'src/DatabaseVersion/DatabaseCreator.cs'
--- src/DatabaseVersion/DatabaseCreator.cs	2011-09-04 10:36:23 +0000
+++ src/DatabaseVersion/DatabaseCreator.cs	2011-09-04 10:36:23 +0000
@@ -46,15 +46,9 @@
             set;
         }
 
-        public IDatabaseArchive Archive
-        {
-            get;
-            private set;
-        }
-
-        public void Create(string version)
-        {
-            this.Create(version, new SimpleTaskExecuter());
+        public void Create(IDatabaseArchive archive, string version)
+        {
+            this.Create(archive, version, new SimpleTaskExecuter());
         }
 
         /// <summary>
@@ -67,7 +61,7 @@
         /// <exception cref="TaskExecutionException">
         /// Thrown if an error occurs while executing one of the tasks in the archive.
         /// </exception>
-        public void Create(string version, ITaskExecuter executer)
+        public void Create(IDatabaseArchive archive, string version, ITaskExecuter executer)
         {
             using (var sessionFactory = this.SessionFactoryProvider.CreateSessionFactory())
             {
@@ -89,21 +83,22 @@
                         object targetVersion;
                         if (string.IsNullOrEmpty(version))
                         {
-                            targetVersion = this.Archive.Versions
+                            targetVersion = archive.Versions
                                 .OrderByDescending(v => v.Version, this.VersionProvider.GetComparer())
                                 .First()
                                 .Version;
-                        } else
+                        }
+                        else
                         {
                             targetVersion = this.VersionProvider.CreateVersion(version);
                         }
 
-                        if (!this.Archive.ContainsVersion(targetVersion))
+                        if (!archive.ContainsVersion(targetVersion))
                         {
                             throw new Version.VersionNotFoundException(targetVersion);
                         }
 
-                        this.AddTasksToExecuter(executer, currentVersion, targetVersion);
+                        this.AddTasksToExecuter(archive, executer, currentVersion, targetVersion);
 
                         executer.ExecuteTasks(session);
 
@@ -113,20 +108,9 @@
             }
         }
 
-        public void LoadArchive(string archivePath)
-        {
-            IDatabaseArchiveFactory archiveFactory = this.GetArchiveFactory(archivePath);
-            if (archiveFactory == null)
-            {
-                throw new InvalidOperationException("Unknown archive type");
-            }
-
-            this.Archive = archiveFactory.Create(archivePath);
-        }
-
-        private void AddTasksToExecuter(ITaskExecuter executer, VersionBase currentVersion, object targetVersion)
-        {
-            IEnumerable<IDatabaseVersion > versionsToExecute = this.Archive.Versions
+        private void AddTasksToExecuter(IDatabaseArchive archive, ITaskExecuter executer, VersionBase currentVersion, object targetVersion)
+        {
+            IEnumerable<IDatabaseVersion > versionsToExecute = archive.Versions
                 .OrderBy(v => v.Version, this.VersionProvider.GetComparer())
                 .Where(
                     v =>
@@ -147,7 +131,8 @@
                             executer.AddTask(task);
                             currentVersion.AddTask(task);
                         }
-                    } else
+                    }
+                    else
                     {
                         executer.AddTask(task);
                         v.Version.AddTask(task);
@@ -159,18 +144,13 @@
                     if (updating)
                     {
                         executer.AddTask(new InsertVersionTask(this.VersionProvider, currentVersion));
-                    } else
+                    }
+                    else
                     {
                         executer.AddTask(new InsertVersionTask(this.VersionProvider, v.Version));
                     }
                 }
             }
         }
-
-        private IDatabaseArchiveFactory GetArchiveFactory(string archivePath)
-        {
-            // TODO: Throw UnknownArchiveTypeException if no handlers found
-            return this.ArchiveFactories.First(f => f.CanCreate(archivePath));
-        }
     }
 }

=== modified file 'src/DatabaseVersion/Property/PropertyService.cs'
--- src/DatabaseVersion/Property/PropertyService.cs	2011-09-04 10:36:23 +0000
+++ src/DatabaseVersion/Property/PropertyService.cs	2011-09-04 10:36:23 +0000
@@ -11,6 +11,11 @@
     public class PropertyService : IPropertyService
     {
         /// <summary>
+        /// The name of the properties file.
+        /// </summary>
+        public const string PropertyFileName = "properties.xml";
+
+        /// <summary>
         /// The properties.
         /// </summary>
         private readonly Dictionary<string, Property> properties = new Dictionary<string, Property>();