Initial implementation of template subsystem

Author: bclothier

Rubberduck.Core/Templates/ITemplate.cs

@@ -0,0 +1,12 @@
+namespace Rubberduck.Templates
+{
+    public interface ITemplate
+    {
+        string Name { get; }
+        bool IsUserDefined { get; }
+        string Caption { get; }
+        string Description { get; }
+        string Read();
+        void Write(string content);
+    }
+}

Rubberduck.Core/Templates/Template.cs

@@ -0,0 +1,69 @@
+namespace Rubberduck.Templates
+{
+    /// <remarks>
+    /// Template can be either built-in or user-defined. For a built-in template, the
+    /// metadata should be stored in the <see cref="Rubberduck.Resources.Templates"/>
+    /// resource, with specific entries, currently Name, Caption, Description and Code.
+    /// Due to the fact that we cannot strong-type the reference to the resource entries
+    /// the class has unit tests to validate that the crucial elements are present in the
+    /// resource to guard against runtime errors/unexpected behavior due to missing/malformed
+    /// entries in the resources. 
+    /// </remarks>
+    public class Template : ITemplate
+    {
+        private readonly ITemplateFileHandler _handler;
+        public Template(string name, ITemplateFileHandler handler)
+        {
+            _handler = handler;
+
+            Name = name;
+            IsUserDefined = VerifyIfUserDefined(name);
+
+            if (IsUserDefined)
+            {
+                //TODO: Devise a way for users to define their captions/descriptions simply
+                Caption = Name;
+                Description = Name;
+            }
+            else
+            {
+                VerifyFile(name, handler);
+                (Caption, Description) = GetBuiltInMetaData(name);
+            }
+        }
+
+        public string Name { get; }
+        public bool IsUserDefined { get; }
+        public string Caption { get; }
+        public string Description { get; }
+
+        public string Read() => _handler.Read();
+        
+        public void Write(string content) => _handler.Write(content);
+
+        private static bool VerifyIfUserDefined(string name)
+        {
+            var builtInName = Resources.Templates.ResourceManager.GetString(name + "_Name");
+            return builtInName == null || builtInName != name;
+        }
+
+        private static void VerifyFile(string name, ITemplateFileHandler handler)
+        {
+            if (handler.Exists)
+            {
+                return;
+            }
+
+            var content = Resources.Templates.ResourceManager.GetString(name + "_Code");
+            handler.Write(content);
+        }
+
+        private static (string caption, string description) GetBuiltInMetaData(string name)
+        {
+            var caption = Resources.Templates.ResourceManager.GetString(name + "_Caption");
+            var description = Resources.Templates.ResourceManager.GetString(name + "_Description");
+
+            return (caption, description);
+        }
+    }
+}

Rubberduck.Core/Templates/TemplateFileHandler.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Rubberduck.SettingsProvider;
+
+namespace Rubberduck.Templates
+{
+    public interface ITemplateFileHandlerProvider
+    {
+        ITemplateFileHandler CreateTemplateFileHandler(string templateName);
+        IEnumerable<string> GetTemplateNames();
+    }
+
+    public class TemplateFileHandlerProvider : ITemplateFileHandlerProvider
+    {
+        private readonly string _rootPath;
+
+        public TemplateFileHandlerProvider(IPersistancePathProvider pathProvider)
+        {
+            _rootPath = pathProvider.DataFolderPath("Templates");
+        }
+
+        public ITemplateFileHandler CreateTemplateFileHandler(string templateName)
+        {
+            if (!Directory.Exists(_rootPath))
+            {
+                Directory.CreateDirectory(_rootPath);
+            }
+
+            var fullPath = Path.Combine(_rootPath, templateName);
+            if (!Directory.Exists(Path.GetDirectoryName(fullPath)))
+            {
+                throw new InvalidOperationException("Cannot provide a path for where the parent directory do not exist");
+            }
+            return  new TemplateFileHandler(fullPath);
+        }
+
+        public IEnumerable<string> GetTemplateNames()
+        {
+            var info = new DirectoryInfo(_rootPath);
+            return info.GetFiles().Select(file => file.Name).ToList();
+        }
+    }
+
+    public interface ITemplateFileHandler
+    {
+        bool Exists { get; }
+        string Read();
+        void Write(string content);
+    }
+    
+    public class TemplateFileHandler : ITemplateFileHandler
+    {
+        private readonly string _fullPath;
+
+        public TemplateFileHandler(string fullPath)
+        {
+            _fullPath = fullPath + (fullPath.EndsWith(".rdt") ? string.Empty : ".rdt");
+        }
+
+        public bool Exists => File.Exists(_fullPath);
+
+        public string Read()
+        {
+            return Exists ? File.ReadAllText(_fullPath) : null;
+        }
+
+        public void Write(string content)
+        {
+            File.WriteAllText(_fullPath, content);
+        }
+    }
+}

Rubberduck.Core/Templates/TemplateProvider.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace Rubberduck.Templates
+{
+    public interface ITemplateProvider
+    {
+        ITemplate Load(string templateName);
+        IEnumerable<Template> GetTemplates();
+    }
+
+    public class TemplateProvider : ITemplateProvider
+    {
+        private readonly ITemplateFileHandlerProvider _provider;
+
+        public TemplateProvider(ITemplateFileHandlerProvider provider)
+        {
+            _provider = provider;
+        }
+
+        public ITemplate Load(string templateName)
+        {
+            var handler = _provider.CreateTemplateFileHandler(templateName);
+            return new Template(templateName, handler);
+        }
+
+        private Lazy<IEnumerable<Template>> LazyList => new Lazy<IEnumerable<Template>>(() =>
+        {
+            var list = new List<Template>();
+            var set = Rubberduck.Resources.Templates.ResourceManager.GetResourceSet(CultureInfo.CurrentCulture, true, true);
+
+            foreach (DictionaryEntry entry in set)
+            {
+                var key = (string)entry.Key;
+                var value = (string) entry.Value;
+                if (key.EndsWith("_Name"))
+                {
+                    var handler = _provider.CreateTemplateFileHandler(value);
+                    list.Add(new Template(value, handler));
+                }
+            }
+
+            foreach (var templateName in _provider.GetTemplateNames())
+            {
+                if (list.Any(e => e.Name == templateName))
+                {
+                    continue;
+                }
+
+                var handler = _provider.CreateTemplateFileHandler(templateName);
+                list.Add(new Template(templateName, handler));
+            }
+
+            return list;
+        });
+
+        public IEnumerable<Template> GetTemplates() => LazyList.Value;
+    }
+}

Rubberduck.Core/UI/CodeExplorer/Commands/AddTemplateCommand.cs

@@ -0,0 +1,46 @@
+using NLog;
+using Rubberduck.Navigation.CodeExplorer;
+using Rubberduck.Templates;
+using Rubberduck.UI.Command;
+using Rubberduck.VBEditor.SafeComWrappers;
+
+namespace Rubberduck.UI.CodeExplorer.Commands
+{
+    public class AddTemplateCommand : CommandBase
+    {
+        private readonly ITemplateProvider _provider;
+        private readonly AddComponentCommand _addComponentCommand;
+
+        public AddTemplateCommand(ITemplateProvider provider, AddComponentCommand addComponentCommand) : base(LogManager.GetCurrentClassLogger())
+        {
+            _provider = provider;
+            _addComponentCommand = addComponentCommand;
+        }
+
+        protected override bool EvaluateCanExecute(object parameter)
+        {
+            var data = ((string templateName, CodeExplorerItemViewModel model)) parameter;
+            return _addComponentCommand.CanAddComponent(data.model,
+                new[]
+                {
+                    ProjectType.HostProject, ProjectType.StandAlone, ProjectType.StandardExe, ProjectType.ActiveXExe
+                });
+        }
+
+        protected override void OnExecute(object parameter)
+        {
+            var data = ((string templateName, CodeExplorerItemViewModel model)) parameter;
+            if (string.IsNullOrWhiteSpace(data.templateName))
+            {
+                return;
+            }
+
+            var moduleText = GetTemplate(data.templateName);
+            _addComponentCommand.AddComponent(data.model, moduleText);        }
+
+        private string GetTemplate(string name)
+        {
+            return _provider.Load(name).Read();
+        }
+    }
+}

Rubberduck.Core/UI/Converters/TemplateCommandParameterToTupleConverter.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using Rubberduck.Navigation.CodeExplorer;
+
+namespace Rubberduck.UI.Converters
+{
+    public class TemplateCommandParameterToTupleConverter : IMultiValueConverter
+    {
+        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+        {
+            (string templateName, CodeExplorerItemViewModel model) data = (
+                values[0] as string,
+                values[1] as CodeExplorerItemViewModel);
+            return data;
+        }
+
+        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
+        {
+            var data = ((string templateName, CodeExplorerItemViewModel model))value;
+            return new[] {(object) data.templateName, data.model};
+        }
+    }
+}

Rubberduck.Main/Root/RubberduckIoCInstaller.cs

@@ -89,7 +89,6 @@ public void Install(IWindsorContainer container, IConfigurationStore store)
             container.Register(Component.For<Version>()
                      .UsingFactoryMethod(() => Assembly.GetExecutingAssembly().GetName().Version)
                      .LifestyleSingleton());
-
             container.Register(Component.For<IProjectsProvider, IProjectsRepository>()
                 .ImplementedBy<ProjectsRepository>()
                 .LifestyleSingleton());

Rubberduck.Resources/Rubberduck.Resources.csproj

@@ -10,6 +10,19 @@
   <ItemGroup>
     <Resource Include="**\*.png" />
     <Resource Include="**\*.bmp" />
-    <Resource Include="**\*.txt" />
+    <Resource Include="**\*.txt" Exclude="$(IntermediateOutputPath)\**" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Update="Templates.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Templates.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Update="Templates.resx">
+      <Generator>PublicResXFileCodeGenerator</Generator>
+      <LastGenOutput>Templates.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
   </ItemGroup>
 </Project>