public static void Extract(Core.ILogger logger, Core.Paths paths, List <string> filePaths, Dictionary <string, Core.Project> projects, Dictionary <string, string> filters, string configPlatform = "Debug|AnyCPU")
{
var skipped = new List <string>();
foreach (var filePath in filePaths)
{
var ext = System.IO.Path.GetExtension(filePath);
if (ext == ".sln")
{
Extract(logger, paths, filePath, projects, filters, configPlatform);
continue;
}
skipped.Add(filePath);
}
filePaths.Clear();
filePaths.AddRange(skipped);
if (filePaths.Count > 0)
{
SetSolutionDir(paths, filePaths[0], string.Empty);
}
ExtractProjects(logger, paths, filePaths, projects, filters, configPlatform);
paths.Remove("$(ProjectDir)");
}
static private void Files(Core.ILogger logger, Core.Paths paths, string fileName, string direc, List <KeyValuePair <string, string> > fileNames, List <string> extensions, List <string> projectExts)
{
var ext = System.IO.Path.GetExtension(fileName);
if (projectExts.Contains(ext))
{
logger.Info("Appended for reading \"{0}\"", fileName);
if (!extensions.Contains(ext))
{
extensions.Add(ext);
}
fileNames.Add(new KeyValuePair <string, string>(fileName, direc));
SetSolutionDir(paths, fileName, direc);
}
else if (ext == ".sln")
{
logger.Info("Reading projects from \"{0}\"", fileName);
direc = System.IO.Path.GetDirectoryName(fileName);
foreach (var name in ReadVisualStudioSolution(logger, fileName))
{
Files(logger, paths, name, direc, fileNames, extensions, projectExts);
}
SetSolutionDir(paths, fileName, direc);
}
}
public static List <string> ReadVisualStudioSolution(Core.ILogger logger, string slnfilename)
{
List <string> projects = new List <string>();
var direc = System.IO.Path.GetDirectoryName(slnfilename);
foreach (var line in System.IO.File.ReadAllLines(slnfilename))
{
if (line.Length <= 10)
{
continue;
}
if (line.Substring(0, 10) != "Project(\"{")
{
continue;
}
var bits = line.Split(',');
var filename = bits[1].Trim().Substring(1);
filename = filename.Substring(0, filename.Length - 1);
var ext = System.IO.Path.GetExtension(filename);
if (ext == ".csproj" || ext == ".shproj" || ext == ".vbproj" || ext == ".vcxproj")
{
projects.Add(System.IO.Path.GetFullPath(System.IO.Path.Combine(direc, filename)));
logger.Info("Appended for reading \"{0}\"", filename);
}
}
return(projects);
}
public Core.Project Extract(Core.ILogger logger, Core.Paths paths, string filePath, Dictionary <string, string> filters, Dictionary <Core.Project, List <string> > dependencies, Dictionary <string, string> mapping)
{
var sourceDirec = paths.Value("SolutionDir");
var proj = this;
var project = new Core.Cpp();
project.IncludeDirectories.AddRange(proj.Includes());
project.CompileDefinitions.AddRange(proj.CompileDefinitions());
if (project.CompileDefinitions.Contains("_CONSOLE"))
{
project.CompileDefinitions.Remove("_CONSOLE");
project.IsExe = true;
}
dependencies[project] = proj.Dependencies();
foreach (var type in new string[] { "ClInclude", "ClCompile" })
{
foreach (var pair2 in proj.Files(false, type, sourceDirec))
{
var fullName = pair2.Key;
var filter = pair2.Value;
logger.Info("Appended \"{0}\"", fullName);
project.FilePaths.Add(fullName);
filters.Add(fullName, filter);
}
}
mapping[filePath] = proj.Name;
return(project);
}
/// <summary>
/// Generate treescheme json for a given type.
/// </summary>
/// <param name="rootAliasTypeName">Fullname of the type to use as the root of the tree</param>
/// <param name="fieldSource">Enum to indicator how to find fields on types</param>
/// <param name="typeIgnorePattern">Optional regex pattern to ignore types</param>
/// <param name="nodeCommentProvider">Optional provider of node-comments</param>
/// <param name="logger">Optional logger for diagnostic output</param>
/// <returns>Json string representing the scheme</returns>
public static string GenerateScheme(
string rootAliasTypeName,
FieldSource fieldSource,
Regex typeIgnorePattern = null,
INodeCommentProvider nodeCommentProvider = null,
Core.ILogger logger = null)
{
try
{
// Gather all the types.
var typeCollection = TypeCollection.Create(AppDomain.CurrentDomain.GetAssemblies(), logger);
// Create mapping context.
var context = Context.Create(
typeCollection,
fieldSource,
typeIgnorePattern,
nodeCommentProvider,
logger);
// Map the tree.
var tree = TreeMapper.MapTree(context, rootAliasTypeName);
// Serialize the scheme.
return(JsonSerializer.ToJson(tree, JsonSerializer.Mode.Pretty));
}
catch (Exception e)
{
logger?.LogCritical($"Failed to generate scheme: {e.Message.ToDistinctLines()}");
return(null);
}
}
private static AssemblyLoadContext CreateLoadContext(string assemblyPath, Core.ILogger logger = null)
{
var validatedPath = ValidateFilePath(assemblyPath, logger);
if (validatedPath == null)
{
return(null);
}
var mainAssemblyName = Path.GetFileNameWithoutExtension(validatedPath);
var builder = new AssemblyLoadContextBuilder();
// Set base directory.
var baseDir = Path.GetDirectoryName(validatedPath);
builder.SetBaseDirectory(baseDir);
logger?.LogTrace($"Base directory: '{baseDir}'");
// Add deps file as a source for finding dependencies.
var depsJsonFile = Path.Combine(baseDir, $"{mainAssemblyName}.deps.json");
if (File.Exists(depsJsonFile))
{
builder.AddDependencyContext(depsJsonFile);
logger?.LogTrace($"Added '{depsJsonFile}' as a deps file dependency");
}
// Add runtimeconfig file as a source for finding dependencies.
var pluginRuntimeConfigFile = Path.Combine(baseDir, $"{mainAssemblyName}.runtimeconfig.json");
builder.TryAddAdditionalProbingPathFromRuntimeConfig(pluginRuntimeConfigFile, includeDevConfig: true, out _);
return(builder.Build());
}
/// <summary>
/// Generate treescheme json file for a given type.
/// </summary>
/// <param name="rootAliasTypeName">Fullname of the type to use as the root of the tree</param>
/// <param name="fieldSource">Enum to indicator how to find fields on types</param>
/// <param name="outputPath">Path to save the output file relative to the Assets directory</param>
/// <param name="typeIgnorePattern">Optional regex pattern to ignore types</param>
/// <param name="nodeCommentProvider">Optional provider of node-comments</param>
/// <param name="logger">Optional logger for diagnostic output</param>
public static void GenerateSchemeToFile(
string rootAliasTypeName,
FieldSource fieldSource,
string outputPath,
Regex typeIgnorePattern = null,
INodeCommentProvider nodeCommentProvider = null,
Core.ILogger logger = null)
{
// Generate the json.
var json = GenerateScheme(
rootAliasTypeName, fieldSource, typeIgnorePattern, nodeCommentProvider, logger);
if (json != null)
{
// Write the file.
try
{
var fullPath = Path.Combine(UnityEngine.Application.dataPath, outputPath);
var outputDir = Path.GetDirectoryName(fullPath);
if (!Directory.Exists(outputDir))
{
logger?.LogDebug($"Creating output directory: '{outputDir}'");
Directory.CreateDirectory(outputDir);
}
File.WriteAllText(fullPath, json);
logger?.LogInformation($"Saved scheme: '{outputPath}'");
}
catch (Exception e)
{
logger?.LogCritical($"Failed to save file: {e.Message.ToDistinctLines()}");
}
}
}
public static void MainFunc(string[] args, Core.ILogger logger)
{
var state = new CMakeParser.State(logger, args[0], (args.Length > 1) ? args[1] : string.Empty, new Core.Paths());
var cmake = Instance(state, logger);
cmake.Read();
}
private static CMakeParser.CMakeLists Instance(CMakeParser.State state, Core.ILogger logger)
{
var lists = new CMakeParser.CMakeLists(state);
var addBinary = new CMakeParser.AddBinary(new AddBinaryHandler(logger));
var binaryCommands = new string[] { "add_executable", "add_library", "catkin_add_gtest" };
foreach (var command in binaryCommands)
{
lists.AddCommand(command, addBinary);
}
var ignore = new CMakeParser.Ignore();
var ignoreCommands = new string[] { "target_link_libraries", "add_dependencies", "add_test", "function", "endfunction", "option", "enable_testing", "configure_file", "find_package", "catkin_package", "install", "project", "string", "message", "cmake_minimum_required", "set_target_properties", "list", "add_custom_command", "add_custom_target", "execute_process", "find_library", "generate_messages", "add_action_files" };
foreach (var command in ignoreCommands)
{
lists.AddCommand(command, ignore);
}
lists.AddCommand("set", new CMakeParser.Set());
lists.AddCommand("file", new CMakeParser.File());
lists.AddCommand("source_group", new CMakeParser.SourceGroup(new SourceGroupHandler(logger)));
lists.AddCommand("include_directories", new CMakeParser.IncludeDirectories());
lists.AddCommand("add_compile_definitions", new CMakeParser.AddCompileDefinitions());
return(lists);
}
private static void ExtractProjects(Core.ILogger logger, Core.Paths paths, List <string> filePaths, Dictionary <string, Core.Project> projects, Dictionary <string, string> filters, string configPlatform)
{
var dependencies = new Dictionary <Core.Project, List <string> >();
var mapping = new Dictionary <string, string>();
foreach (var proj in ExtractProjects(logger, paths, filePaths, configPlatform))
{
if (proj.Value is VCProj vcProj)
{
projects[proj.Value.Name] = vcProj.Extract(logger, paths, proj.Key, filters, dependencies, mapping);
}
else if (proj.Value is NetProj netProj)
{
projects[proj.Value.Name] = netProj.Extract(logger, paths, proj.Key, dependencies, mapping);
}
}
foreach (var dep in dependencies)
{
var proj = dep.Key;
foreach (var filePath in dep.Value)
{
if (mapping.ContainsKey(filePath))
{
proj.Dependencies.Add(mapping[filePath]);
}
}
}
}
public static void MainFunc(string[] args, Core.ILogger logger)
{
logger.Info("Visual Studio solution command line application for creating CMake files");
logger.Info("Copyright (c) 2020 Zebedee Mason");
bool printUsage = false;
if (args.Length == 2 || args.Length == 3)
{
if (!System.IO.File.Exists(args[0]))
{
logger.Info("First argument is not an existing file");
printUsage = true;
}
else if (System.IO.Path.GetExtension(args[0]) != ".sln")
{
logger.Info("First argument is not an sln file");
printUsage = true;
}
if (args.Length == 3 && !System.IO.Directory.Exists(args[2]))
{
logger.Info("Third argument is not an existing directory");
printUsage = true;
}
}
else
{
printUsage = true;
}
if (printUsage)
{
logger.Info("Create CMakeLists.txt files");
logger.Info("Usage:");
logger.Info(" ProjectIO.VisualStudioToCMake.exe <Visual Studio solution> <configuration|platform> [root directory if different from sln file path]");
return;
}
var filePaths = new List <string> {
args[0]
};
var projects = new Dictionary <string, Core.Project>();
var filters = new Dictionary <string, string>();
var paths = new Core.Paths();
VisualStudio.Solution.Extract(logger, paths, filePaths, projects, filters, args[1]);
var rootDirec = System.IO.Path.GetDirectoryName(args[0]);
if (args.Length == 3)
{
rootDirec = args[2];
}
string name = System.IO.Path.GetFileNameWithoutExtension(args[0]);
CMakeProject.Assemble(rootDirec, name, projects);
}
private static IReadOnlyList <Assembly> LoadAssemblyFromName(
AssemblyLoadContext loadContext,
AssemblyName assemblyName,
IEnumerable <string> dependencyDirectories,
Core.ILogger logger = null)
{
// If assembly exists in any of the dependency paths then load it from there.
var dependencyPath = dependencyDirectories.
Select(d =>
{
try
{
return
(Directory.EnumerateFiles(d, $"{assemblyName.Name}.dll", SearchOption.AllDirectories).
FirstOrDefault());
}
catch (Exception)
{
return(null);
}
}).
Where(p => p != null).
FirstOrDefault();
if (!string.IsNullOrEmpty(dependencyPath))
{
return(LoadAssemblyFromPath(loadContext, dependencyPath, dependencyDirectories, logger));
}
// Otherwise load by name from the context.
var output = new List <Assembly>();
try
{
output.Add(loadContext.LoadFromAssemblyName(assemblyName));
logger?.LogTrace($"Loaded assembly: '{output[0].FullName}'");
}
catch (Exception e)
{
if (logger != null)
{
logger?.LogWarning($"Failed to load assembly: {e.Message.ToDistinctLines()}");
}
return(Array.Empty <Assembly>());
}
// Load referenced assemblies.
foreach (var referencedAssemblyName in output[0].GetReferencedAssemblies())
{
if (!IsAssemblyLoaded(referencedAssemblyName))
{
output.AddRange(
LoadAssemblyFromName(loadContext, referencedAssemblyName, dependencyDirectories, logger));
}
}
return(output);
}
/// <summary>
/// Initializes a new instance of the <see cref="Application"/> class.
/// </summary>
/// <param name="logger">Optional logger to use during execution</param>
public Application(ILogger <Application> logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = new LoggerAdapter(logger);
}
public Proj(Core.ILogger logger, string path, Core.Paths paths, string configPlatform)
{
_logger = logger;
_filePath = path;
_paths = paths;
_configPlatform = configPlatform;
_xml = new XMLUtils(path);
_paths.Add("ProjectDir", System.IO.Path.GetDirectoryName(_filePath));
}
public State(State state)
{
Variables = state.Variables.ToDictionary(entry => entry.Key, entry => entry.Value);
Properties = state.Properties.ToDictionary(entry => entry.Key, entry => entry.Value);
Switches = state.Switches.ToDictionary(entry => entry.Key, entry => entry.Value);
IncludeDirectories = state.IncludeDirectories.ToList();
CompileDefinitions = state.CompileDefinitions.ToList();
_logger = state._logger;
_paths = state._paths;
}
private static void Extract(Core.ILogger logger, Core.Paths paths, string solutionPath, Dictionary <string, Core.Project> projects, Dictionary <string, string> filters, string configPlatform)
{
logger.Info("Reading projects from \"{0}\"", solutionPath);
var direc = System.IO.Path.GetDirectoryName(solutionPath);
SetSolutionDir(paths, solutionPath, direc);
var filePaths = ReadVisualStudioSolution(logger, solutionPath);
ExtractProjects(logger, paths, filePaths, projects, filters, configPlatform);
}
public static string Extract(Core.ILogger logger, Core.Paths paths, List <string> filePaths, Dictionary <string, Core.Project> projects, Dictionary <string, string> filters)
{
string lists = string.Empty;
string cache = string.Empty;
foreach (var filePath in filePaths)
{
if (lists.Length == 0 && System.IO.Path.GetFileName(filePath) == "CMakeLists.txt")
{
lists = filePath;
}
if (cache.Length == 0 && System.IO.Path.GetFileName(filePath) == "CMakeCache.txt")
{
cache = filePath;
}
}
if (lists.Length == 0)
{
return("solution");
}
logger.Info("Appended for reading \"{0}\"", lists);
var sourceDirec = System.IO.Path.GetDirectoryName(lists);
paths.Add("PROJECT_SOURCE_DIR", sourceDirec);
filePaths.Remove(lists);
var binaryDirec = string.Empty;
if (cache.Length != 0)
{
binaryDirec = System.IO.Path.GetDirectoryName(cache);
paths.Add("PROJECT_BINARY_DIR", binaryDirec);
filePaths.Remove(cache);
}
logger.Info("Reading CMake");
var state = new State(logger, sourceDirec, binaryDirec, paths);
state.ReadCache(cache);
var builder = Instance(state, projects, filters, logger);
builder.Read();
if (state.Variables.ContainsKey("${CMAKE_PROJECT_NAME}"))
{
return(state.Variables["${CMAKE_PROJECT_NAME}"]);
}
return("solution");
}
public DocumentDbReadModelRepository(
IDocumentDbSettings settings,
IReliableReadWriteDocumentClientFactory clientFactory,
Core.ILogger logger,
ITelemetryLogger telemetryLogger)
{
Settings = settings;
ClientFactory = clientFactory;
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
_telemetryLogger = telemetryLogger;
}
public override Core.Project Extract(Core.ILogger logger, Core.Paths paths, string filePath, Dictionary <Core.Project, List <string> > dependencies, Dictionary <string, string> mapping)
{
var proj = this;
var project = new Core.VBasic();
dependencies[project] = proj.Dependencies();
proj.Compiles(project.FilePaths, logger, paths);
mapping[filePath] = proj.Name;
return(project);
}
public State(Core.ILogger logger, string sourceDirec, string binaryDirec, Core.Paths paths)
{
Variables["${PROJECT_SOURCE_DIR}"] = sourceDirec;
Variables["${PROJECT_BINARY_DIR}"] = binaryDirec;
Variables["${CMAKE_CURRENT_LIST_DIR}"] = "${PROJECT_SOURCE_DIR}";
Variables["${CMAKE_CURRENT_SOURCE_DIR}"] = "${PROJECT_SOURCE_DIR}";
Variables["${CMAKE_CURRENT_BINARY_DIR}"] = "${PROJECT_BINARY_DIR}";
Switches["WIN32"] = true;
Switches["UNIX"] = false;
_logger = logger;
_paths = paths;
}
private IEnumerable <IDnlibDef> InjectType(ModuleDef m, Core.ILogger l, params TypeDefUser[] types)
{
List <IDnlibDef> ret = new List <IDnlibDef>();
foreach (TypeDefUser type in types)
{
m.Types.Add(type);
l.Debug("Added attribute " + type);
ret.AddRange(InjectHelper.Inject(type, type, m));
}
return(ret);
}
public void DotNetCompiles(Proj project, List <string> files, Core.ILogger logger, Core.Paths filePath)
{
var list = Compiles("Compile");
var direc = System.IO.Path.GetDirectoryName(project.FilePath);
filePath.Add("ProjectDir", direc);
foreach (var link in list)
{
var trimmed = link;
trimmed = trimmed.Replace("$(MSBuildThisFileDirectory)", direc + "\\");
var file = filePath.RemoveAliases(trimmed);
if (!System.IO.Path.IsPathRooted(file))
{
file = System.IO.Path.Combine(direc, trimmed);
}
if (file.Contains("*"))
{
var directory = System.IO.Path.GetDirectoryName(file);
var pattern = System.IO.Path.GetFileName(file);
try
{
foreach (var name in System.IO.Directory.GetFiles(directory, pattern))
{
logger.Info("Appended \"{0}\"", name);
files.Add(name);
}
}
catch
{
}
}
else if (file.Length > 0)
{
if (!System.IO.File.Exists(file))
{
logger.Warn("Cannot find \"{0}\"", file);
continue;
}
logger.Info("Appended \"{0}\"", file);
files.Add(file);
}
}
filePath.Remove("ProjectDir");
}
private static IEnumerable <IDnlibDef> InjectType(ModuleDef m, Core.ILogger l, params Type[] types)
{
List <IDnlibDef> ret = new List <IDnlibDef>();
foreach (TypeDef type in types.Select(RuntimeHelper.GetType))
{
var newType = new TypeDefUser(DefaultNamespace, type.Name);
m.Types.Add(newType);
l.Debug("Added type " + newType);
ret.Add(newType);
ret.AddRange(InjectHelper.Inject(type, newType, m));
}
return(ret);
}
public static Dictionary <string, Proj> ExtractProjects(Core.ILogger logger, Core.Paths paths, List <string> filePaths, string configPlatform = "Debug|AnyCPU")
{
var projects = new Dictionary <string, Proj>();
var skipped = new List <string>();
foreach (var filePath in filePaths)
{
var ext = System.IO.Path.GetExtension(filePath);
if (ext == ".vcxproj")
{
logger.Info("Appended for reading \"{0}\"", filePath);
logger.Info("Reading Visual C++");
var proj = new VCProj(logger, filePath, paths, configPlatform);
projects[filePath] = proj;
continue;
}
if (ext == ".csproj")
{
var proj = new CSProj(logger, filePath, paths, configPlatform);
projects[filePath] = proj;
continue;
}
if (ext == ".shproj")
{
var proj = new SHProj(logger, filePath, paths, configPlatform);
projects[filePath] = proj;
continue;
}
if (ext == ".vbproj")
{
var proj = new VBProj(logger, filePath, paths, configPlatform);
projects[filePath] = proj;
continue;
}
skipped.Add(filePath);
}
filePaths.Clear();
filePaths.AddRange(skipped);
return(projects);
}
/// <summary>
/// Attempt to load a <see cref="ITypeCollection"/> from a Assembly path.
/// </summary>
/// <param name="assemblyPath">Path to the assembly file</param>
/// <param name="dependencyDirectories">List of directories to search for dependant assemblies</param>
/// <param name="logger">Optional logger to provide diagnostic output</param>
/// <returns><see cref="ITypeCollection"/> if successfull otherwise null</returns>
internal static ITypeCollection TryLoad(
string assemblyPath,
IEnumerable <string> dependencyDirectories,
Core.ILogger logger = null)
{
if (assemblyPath == null)
{
throw new ArgumentNullException(nameof(assemblyPath));
}
if (dependencyDirectories == null)
{
throw new ArgumentNullException(nameof(dependencyDirectories));
}
// Verify that dependency paths exists.
foreach (var dependencyDirectory in dependencyDirectories)
{
if (!Directory.Exists(dependencyDirectory))
{
logger?.LogCritical($"Dependency directory '{dependencyDirectory}' cannot be found");
return(null);
}
}
// Create load context.
var loadContext = CreateLoadContext(assemblyPath, logger);
if (loadContext == null)
{
return(null);
}
// Load assemblies.
var assemblies = LoadAssemblyFromPath(loadContext, assemblyPath, dependencyDirectories, logger);
logger?.LogDebug($"Loaded {assemblies.Count} assemblies");
// Load types.
var typeCollection = TypeCollection.Create(assemblies, logger);
logger?.LogDebug($"Loaded {typeCollection.TypeCount} types");
return(typeCollection);
}
private static IReadOnlyList <Assembly> LoadAssemblyFromPath(
AssemblyLoadContext loadContext,
string path,
IEnumerable <string> dependencyDirectories,
Core.ILogger logger = null)
{
// Validate path.
var validatedPath = ValidateFilePath(path, logger);
if (validatedPath == null)
{
return(Array.Empty <Assembly>());
}
// Load assembly.
var output = new List <Assembly>();
try
{
output.Add(loadContext.LoadFromAssemblyPath(validatedPath));
logger?.LogTrace($"Loaded assembly: '{output[0].FullName}'");
}
catch (Exception e)
{
if (logger != null)
{
logger?.LogWarning($"Failed to load assembly: {e.Message.ToDistinctLines()}");
}
return(Array.Empty <Assembly>());
}
// Load referenced assemblies.
foreach (var referencedAssemblyName in output[0].GetReferencedAssemblies())
{
if (!IsAssemblyLoaded(referencedAssemblyName))
{
output.AddRange(
LoadAssemblyFromName(loadContext, referencedAssemblyName, dependencyDirectories, logger));
}
}
return(output);
}
private static string ValidateFilePath(string path, Core.ILogger logger = null)
{
// Determine full-path.
string fullPath;
try
{
fullPath = Path.GetFullPath(path);
}
catch
{
logger?.LogCritical($"Unable to determine absolute path for: '{path}'");
return(null);
}
// Validate file existence.
if (!File.Exists(fullPath))
{
logger?.LogCritical($"No file found at path: '{fullPath}'");
return(null);
}
return(fullPath);
}
public void Setup(ViewRegistry registry, Core.ILogger logger)
{
if (logger == null)
{
logger = new NullLogger();
}
_logger = logger;
foreach (TypeBinding bindingData in registry.Bindings)
{
Type type = Type.GetType(bindingData.TypeName);
if (type == null)
{
_logger.LogError(string.Format(
"Could not get type for qualified name '{0}'",
bindingData.TypeName
));
continue;
}
var binding = new Binding();
binding.Targets.AddRange(bindingData.Targets);
_bindings.Add(type, binding);
}
}
private static void MainFunc(string[] args, Core.ILogger logger)
{
logger.Info("VStoVS command line application for creating a Visual Studio solution from a Visual Studio solution!");
logger.Info("Copyright (c) 2020 Zebedee Mason");
bool printUsage = false;
if (args.Length > 3)
{
if (!System.IO.Directory.Exists(args[0]))
{
logger.Info("First argument is not an output directory");
printUsage = true;
}
else if (!System.IO.Directory.Exists(args[1]))
{
logger.Info("Second argument is not a template directory");
printUsage = true;
}
else if (System.IO.Path.GetExtension(args[2]) != ".sln" && System.IO.File.Exists(args[2]))
{
logger.Info("Third argument is not an existing sln file");
printUsage = true;
}
else
{
foreach (var fileName in VisualStudio.Writer.Templates)
{
if (!System.IO.File.Exists(System.IO.Path.Combine(args[1], fileName)))
{
logger.Info(string.Format("Second argument is not a directory containing {0}", fileName));
printUsage = true;
}
}
}
}
else
{
printUsage = true;
}
if (printUsage)
{
logger.Info("Create a Visual Studio solution");
logger.Info("Usage:");
logger.Info(" ProjectIO.VStoVS.exe <output directory> <template directory> <Visual Studio solution> <configuration|platform>");
return;
}
var filePaths = new List <string> {
args[2]
};
var projects = new Dictionary <string, Core.Project>();
var filters = new Dictionary <string, string>();
var paths = new Core.Paths();
VisualStudio.Solution.Extract(logger, paths, filePaths, projects, filters, args[3]);
var solutionName = System.IO.Path.GetFileNameWithoutExtension(args[2]);
var solution = new VisualStudio.Writer(projects, filters);
solution.Write(solutionName, args[0], args[1]);
}
public static void Extract(Core.ILogger logger, Core.Paths paths, string filePath, Dictionary <string, Core.Project> projects, Dictionary <Core.Project, List <string> > dependencies, Dictionary <string, string> mapping, string configPlatform)
{
var proj = new VBProj(logger, filePath, paths, configPlatform);
projects[proj.Name] = proj.Extract(logger, paths, filePath, dependencies, mapping);
}
