Add Typed ServiceVolume Models With Custom Collection (#191)

* Changes Volumes property from List<string> to ServiceVolumeCollection,
   which implements both IList<string> and IList<ServiceVolume>.

   This allows both patterns to work:
   - foreach (string v in service.Volumes) - backwards compatible
   - foreach (var v in service.Volumes) - typed access (ServiceVolume)
   - string x = service.Volumes[0] - implicit conversion
   - ServiceVolume y = service.Volumes[0] - typed access

   Note: This is a minor breaking change for code using 'var' with volumes,
   as the inferred type changes from string to ServiceVolume.

* fix formatting issue
update complex example

* Keep class per file

* Define PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE_EX

* Simplify deserializer

* Simplify serializer

---------

Co-authored-by: aus-design-web-mobile <aus-design-web-mobile@users.noreply.github.com>
Co-authored-by: Jan Trejbal <jan@trejbal.land>

Author: aus-design-web-mobile

src/DockerComposeBuilder.Examples.Complex/Program.cs

@@ -26,6 +26,7 @@
     .WithImage("mysql:5.7")
     .WithNetworks(network1)
     .WithExposed("3306")
+    .WithVolumes("mysql-data:/var/lib/mysql")
     .WithEnvironment(mb =>
     {
         mb.Add("MYSQL_ROOT_PASSWORD", dbPass);
@@ -62,6 +63,21 @@
     {
         Target = 83,
     })
+    .WithVolumes(
+        new ServiceVolume
+        {
+            Type = "bind",
+            Source = "./wp-content",
+            Target = "/var/www/html/wp-content"
+        },
+        new ServiceVolume
+        {
+            Type = "volume",
+            Source = "wp-uploads",
+            Target = "/var/www/html/wp-content/uploads",
+            ReadOnly = false
+        }
+    )
     .WithEnvironment(mb =>
     {
         mb.Add("WORDPRESS_DB_HOST", $"{mysql.Name}:3306");

src/DockerComposeBuilder.Tests/ComposeBuilderTests.cs

@@ -1,5 +1,6 @@
 using DockerComposeBuilder.Builders;
 using DockerComposeBuilder.Extensions;
+using DockerComposeBuilder.Model.Services;
 using DockerComposeBuilder.Model.Services.BuildArguments;
 using System.Collections.Generic;
 using Xunit;
@@ -320,7 +321,7 @@ public void DeserializeWithPortRangesTest()
     }
 
     [Fact]
-    public void DeserializeWithVolumesTest()
+    public void DeserializeWithVolumesShortSyntaxTest()
     {
         var yaml = // language=yaml
             """
@@ -341,7 +342,157 @@ public void DeserializeWithVolumesTest()
         var appService = compose.Services["app"];
         Assert.NotNull(appService.Volumes);
         Assert.Equal(2, appService.Volumes.Count);
+
+        // Works as string (backwards compatible via implicit conversion)
         Assert.Equal("./data:/app/data", appService.Volumes[0]);
         Assert.Equal("cache:/app/cache", appService.Volumes[1]);
+
+        // Also works as ServiceVolume (typed access)
+        ServiceVolume firstVolume = appService.Volumes[0];
+        Assert.Equal("./data:/app/data", firstVolume.ShortSyntax);
+    }
+
+    [Fact]
+    public void DeserializeWithVolumesLongSyntaxTest()
+    {
+        var yaml = // language=yaml
+            """
+            version: "3.8"
+            services:
+              app:
+                image: myapp:latest
+                volumes:
+                  - type: bind
+                    source: ./data
+                    target: /app/data
+                    read_only: true
+                  - type: volume
+                    source: cache
+                    target: /app/cache
+            volumes:
+              cache:
+            """;
+
+        var compose = ComposeExtensions.Deserialize(yaml);
+
+        Assert.NotNull(compose.Services);
+        var appService = compose.Services["app"];
+        Assert.NotNull(appService.Volumes);
+        Assert.Equal(2, appService.Volumes.Count);
+
+        Assert.Equal("bind", appService.Volumes[0].Type);
+        Assert.Equal("./data", appService.Volumes[0].Source);
+        Assert.Equal("/app/data", appService.Volumes[0].Target);
+        Assert.True(appService.Volumes[0].ReadOnly);
+
+        Assert.Equal("volume", appService.Volumes[1].Type);
+        Assert.Equal("cache", appService.Volumes[1].Source);
+        Assert.Equal("/app/cache", appService.Volumes[1].Target);
+        Assert.Null(appService.Volumes[1].ReadOnly);
+    }
+
+    [Fact]
+    public void VolumesSupportsForEachWithStringTest()
+    {
+        var compose = Builder.MakeCompose()
+            .WithServices(
+                Builder.MakeService("app")
+                    .WithImage("myapp:latest")
+                    .WithVolumes("./data:/app/data", "cache:/app/cache")
+                    .Build()
+            )
+            .Build();
+
+        var appService = compose.Services!["app"];
+        var volumeStrings = new List<string>();
+
+        // This is the backwards-compatible pattern that must work
+        foreach (string v in appService.Volumes!)
+        {
+            volumeStrings.Add(v);
+        }
+
+        Assert.Equal(2, volumeStrings.Count);
+        Assert.Equal("./data:/app/data", volumeStrings[0]);
+        Assert.Equal("cache:/app/cache", volumeStrings[1]);
+    }
+
+    [Fact]
+    public void SerializeWithVolumesShortSyntaxTest()
+    {
+        var compose = Builder.MakeCompose()
+            .WithServices(
+                Builder.MakeService("app")
+                    .WithImage("myapp:latest")
+                    .WithVolumes("./data:/app/data", "cache:/app/cache")
+                    .Build()
+            )
+            .Build();
+
+        var result = compose.Serialize();
+
+        Assert.Equal(
+            // language=yaml
+            """
+            version: "3.8"
+            services:
+              app:
+                image: "myapp:latest"
+                volumes:
+                - "./data:/app/data"
+                - "cache:/app/cache"
+
+            """,
+            result
+        );
+    }
+
+    [Fact]
+    public void SerializeWithVolumesLongSyntaxTest()
+    {
+        var compose = Builder.MakeCompose()
+            .WithServices(
+                Builder.MakeService("app")
+                    .WithImage("myapp:latest")
+                    .WithVolumes(
+                        new ServiceVolume
+                        {
+                            Type = "bind",
+                            Source = "./data",
+                            Target = "/app/data",
+                            ReadOnly = true
+                        },
+                        new ServiceVolume
+                        {
+                            Type = "volume",
+                            Source = "cache",
+                            Target = "/app/cache"
+                        }
+                    )
+                    .Build()
+            )
+            .Build();
+
+        var result = compose.Serialize();
+
+        Assert.Equal(
+            // language=yaml
+            """
+            version: "3.8"
+            services:
+              app:
+                image: "myapp:latest"
+                volumes:
+                - type: "bind"
+                  source: "./data"
+                  target: "/app/data"
+                  read_only: true
+                - type: "volume"
+                  source: "cache"
+                  target: "/app/cache"
+
+            """,
+            result
+        );
     }
 }

src/DockerComposeBuilder.sln.DotSettings

@@ -1,5 +1,6 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_RAW_LITERAL_STRING/@EntryValue">INDENT</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EUnitTestFramework_002EMigrations_002EEnableDisabledProvidersMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/UnitTesting/DisabledProviders/=Testing_0020Platform/@EntryIndexedValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/UnitTesting/DisabledProviders/=VsTest/@EntryIndexedValue">True</s:Boolean>

src/DockerComposeBuilder/Builders/ServiceBuilder.cs

@@ -219,12 +219,19 @@ public SwarmServiceBuilder WithSwarm()
 
     public ServiceBuilder WithVolumes(params string[] volumes)
     {
-        if (WorkingObject.Volumes == null)
-        {
-            WorkingObject.Volumes = new List<string>();
-        }
+        WorkingObject.Volumes ??= new ServiceVolumeCollection();
+
+        WorkingObject.Volumes.AddRange(volumes);
+
+        return this;
+    }
+
+    public ServiceBuilder WithVolumes(params ServiceVolume[] volumes)
+    {
+        WorkingObject.Volumes ??= new ServiceVolumeCollection();
 
         WorkingObject.Volumes.AddRange(volumes);
+
         return this;
     }
 

src/DockerComposeBuilder/Converters/ServiceVolumeCollectionConverter.cs

@@ -0,0 +1,54 @@
+using DockerComposeBuilder.Model.Services;
+using System;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace DockerComposeBuilder.Converters;
+
+public class ServiceVolumeCollectionConverter : IYamlTypeConverter
+{
+    private readonly ServiceVolumeConverter _itemConverter = new();
+
+    public bool Accepts(Type type) => typeof(ServiceVolumeCollection).IsAssignableFrom(type);
+
+    public object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
+    {
+        if (parser.Current is not SequenceStart)
+        {
+            return null;
+        }
+
+        parser.MoveNext();
+        var collection = new ServiceVolumeCollection();
+
+        while (parser.Current is not SequenceEnd)
+        {
+            var item = _itemConverter.ReadYaml(parser, typeof(ServiceVolume), rootDeserializer);
+            if (item is ServiceVolume volume)
+            {
+                collection.Add(volume);
+            }
+        }
+
+        parser.MoveNext();
+        return collection;
+    }
+
+    public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
+    {
+        if (value is not ServiceVolumeCollection collection)
+        {
+            return;
+        }
+
+        emitter.Emit(new SequenceStart(AnchorName.Empty, TagName.Empty, false, SequenceStyle.Block));
+
+        foreach (var item in collection)
+        {
+            _itemConverter.WriteYaml(emitter, item, typeof(ServiceVolume), serializer);
+        }
+
+        emitter.Emit(new SequenceEnd());
+    }
+}

src/DockerComposeBuilder/Converters/ServiceVolumeConverter.cs

@@ -0,0 +1,45 @@
+using DockerComposeBuilder.Model.Services;
+using System;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace DockerComposeBuilder.Converters;
+
+public class ServiceVolumeConverter : IYamlTypeConverter
+{
+    public bool Accepts(Type type) => typeof(ServiceVolume).IsAssignableFrom(type);
+
+    public object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
+    {
+        if (parser.Current is Scalar scalar)
+        {
+            var value = scalar.Value;
+            parser.MoveNext();
+            return ServiceVolume.FromShortSyntax(value);
+        }
+
+        if (parser.Current is MappingStart)
+        {
+            return rootDeserializer(typeof(ServiceVolume));
+        }
+
+        parser.MoveNext();
+        return null;
+    }
+
+    public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
+    {
+        if (value is ServiceVolume serviceVolume)
+        {
+            if (serviceVolume.ShortSyntax != null)
+            {
+                emitter.Emit(new Scalar(AnchorName.Empty, TagName.Empty, serviceVolume.ShortSyntax, ScalarStyle.DoubleQuoted, true, false));
+            }
+            else
+            {
+                serializer(value, type);
+            }
+        }
+    }
+}

src/DockerComposeBuilder/Extensions/ComposeExtensions.cs

@@ -15,6 +15,7 @@ string lineEndings
         .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull)
         .WithTypeConverter(new YamlValueCollectionConverter())
         .WithTypeConverter(new PublishedPortConverter())
+        .WithTypeConverter(new ServiceVolumeCollectionConverter())
         .WithNamingConvention(UnderscoredNamingConvention.Instance)
         .WithEventEmitter(nextEmitter => new FlowStyleStringSequences(nextEmitter))
         .WithEventEmitter(nextEmitter => new FlowStringEnumConverter(nextEmitter))
@@ -36,6 +37,7 @@ public static DeserializerBuilder CreateDeserializerBuilder(
     {
         var builder = new DeserializerBuilder()
             .WithTypeConverter(new PublishedPortConverter())
+            .WithTypeConverter(new ServiceVolumeCollectionConverter())
             .WithNamingConvention(UnderscoredNamingConvention.Instance);
 
         if (ignoreUnmatchedProperties)

src/DockerComposeBuilder/Model/Service.cs

@@ -41,7 +41,7 @@ public class Service : IObject
     public IDictionary<string, string?>? Environment { get; set; }
 
     [YamlMember(Alias = "volumes")]
-    public List<string>? Volumes { get; set; }
+    public ServiceVolumeCollection? Volumes { get; set; }
 
     [YamlMember(Alias = "ports")]
     public List<Port>? Ports { get; set; }