Skip to content

GitLab

Commit af571a61 authored by BlackAngle233's avatar BlackAngle233
Browse files

212

parent 1d9b5391
Hide whitespace changes
Inline Side-by-side
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/ProjectGeneration/GUIDProvider.cs
View file @ af571a61
using System;
namespace Packages.Rider.Editor {
class GUIDProvider : IGUIDGenerator
{
public string ProjectGuid(string projectName, string assemblyName)
{
return SolutionGuidGenerator.GuidForProject(projectName + assemblyName);
}
public string SolutionGuid(string projectName, string extension)
{
return SolutionGuidGenerator.GuidForSolution(projectName, extension); // GetExtensionOfSourceFiles(assembly.sourceFiles)
}
}
}
using System;
namespace Packages.Rider.Editor {
class GUIDProvider : IGUIDGenerator
{
public string ProjectGuid(string projectName, string assemblyName)
{
return SolutionGuidGenerator.GuidForProject(projectName + assemblyName);
}
public string SolutionGuid(string projectName, string extension)
{
return SolutionGuidGenerator.GuidForSolution(projectName, extension); // GetExtensionOfSourceFiles(assembly.sourceFiles)
}
}
}
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/ProjectGeneration/GUIDProvider.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: 8cfde1a59fb35574189691a9de1df93b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: 8cfde1a59fb35574189691a9de1df93b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/ProjectGeneration/ProjectGeneration.cs
View file @ af571a61
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Packages.Rider.Editor.Util;
using UnityEditor;
using UnityEditor.Compilation;
using UnityEditor.PackageManager;
using UnityEditorInternal;
using UnityEngine;
namespace Packages.Rider.Editor
{
public interface IGenerator
{
bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles);
void Sync();
bool HasSolutionBeenGenerated();
string SolutionFile();
string ProjectDirectory { get; }
void GenerateAll(bool generateAll);
}
public interface IFileIO
{
bool Exists(string fileName);
string ReadAllText(string fileName);
void WriteAllText(string fileName, string content);
}
public interface IGUIDGenerator
{
string ProjectGuid(string projectName, string assemblyName);
string SolutionGuid(string projectName, string extension);
}
public interface IAssemblyNameProvider
{
string GetAssemblyNameFromScriptPath(string path);
IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution);
IEnumerable<string> GetAllAssetPaths();
UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath);
ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories);
}
class AssemblyNameProvider : IAssemblyNameProvider
{
public string GetAssemblyNameFromScriptPath(string path)
{
return CompilationPipeline.GetAssemblyNameFromScriptPath(path);
}
public IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution)
{
return CompilationPipeline.GetAssemblies()
.Where(i => 0 < i.sourceFiles.Length && i.sourceFiles.Any(shouldFileBePartOfSolution));
}
public IEnumerable<string> GetAllAssetPaths()
{
return AssetDatabase.GetAllAssetPaths();
}
public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath)
{
return UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath);
}
public ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories)
{
return CompilationPipeline.ParseResponseFile(
responseFilePath,
projectDirectory,
systemReferenceDirectories
);
}
}
public class ProjectGeneration : IGenerator
{
enum ScriptingLanguage
{
None,
CSharp
}
public static readonly string MSBuildNamespaceUri = "http://schemas.microsoft.com/developer/msbuild/2003";
/// <summary>
/// Map source extensions to ScriptingLanguages
/// </summary>
static readonly Dictionary<string, ScriptingLanguage> k_BuiltinSupportedExtensions =
new Dictionary<string, ScriptingLanguage>
{
{"cs", ScriptingLanguage.CSharp},
{"uxml", ScriptingLanguage.None},
{"uss", ScriptingLanguage.None},
{"shader", ScriptingLanguage.None},
{"compute", ScriptingLanguage.None},
{"cginc", ScriptingLanguage.None},
{"hlsl", ScriptingLanguage.None},
{"glslinc", ScriptingLanguage.None},
{"template", ScriptingLanguage.None},
{"raytrace", ScriptingLanguage.None}
};
string m_SolutionProjectEntryTemplate = string.Join(Environment.NewLine,
@"Project(""{{{0}}}"") = ""{1}"", ""{2}"", ""{{{3}}}""",
@"EndProject").Replace(" ", "\t");
string m_SolutionProjectConfigurationTemplate = string.Join(Environment.NewLine,
@" {{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU",
@" {{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU",
@" {{{0}}}.Release|Any CPU.ActiveCfg = Release|Any CPU",
@" {{{0}}}.Release|Any CPU.Build.0 = Release|Any CPU").Replace(" ", "\t");
static readonly string[] k_ReimportSyncExtensions = {".dll", ".asmdef"};
/// <summary>
/// Map ScriptingLanguages to project extensions
/// </summary>
/*static readonly Dictionary<ScriptingLanguage, string> k_ProjectExtensions = new Dictionary<ScriptingLanguage, string>
{
{ ScriptingLanguage.CSharp, ".csproj" },
{ ScriptingLanguage.None, ".csproj" },
};*/
static readonly Regex k_ScriptReferenceExpression = new Regex(
@"^Library.ScriptAssemblies.(?<dllname>(?<project>.*)\.dll$)",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
string[] m_ProjectSupportedExtensions = new string[0];
bool m_ShouldGenerateAll;
public string ProjectDirectory { get; }
public void GenerateAll(bool generateAll)
{
m_ShouldGenerateAll = generateAll;
}
readonly string m_ProjectName;
readonly IAssemblyNameProvider m_AssemblyNameProvider;
readonly IFileIO m_FileIOProvider;
readonly IGUIDGenerator m_GUIDGenerator;
internal static bool isRiderProjectGeneration; // workaround to https://github.cds.internal.unity3d.com/unity/com.unity.ide.rider/issues/28
const string k_ToolsVersion = "4.0";
const string k_ProductVersion = "10.0.20506";
const string k_BaseDirectory = ".";
const string k_TargetFrameworkVersion = "v4.7.1";
const string k_TargetLanguageVersion = "latest";
static readonly Regex scriptReferenceExpression = new Regex(
@"^Library.ScriptAssemblies.(?<dllname>(?<project>.*)\.dll$)",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
public ProjectGeneration() : this(Directory.GetParent(Application.dataPath).FullName)
{
}
public ProjectGeneration(string tempDirectory) : this(tempDirectory, new AssemblyNameProvider(), new FileIOProvider(), new GUIDProvider())
{
}
public ProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIoProvider, IGUIDGenerator guidGenerator)
{
ProjectDirectory = tempDirectory.Replace('\\', '/');
m_ProjectName = Path.GetFileName(ProjectDirectory);
m_AssemblyNameProvider = assemblyNameProvider;
m_FileIOProvider = fileIoProvider;
m_GUIDGenerator = guidGenerator;
}
/// <summary>
/// Syncs the scripting solution if any affected files are relevant.
/// </summary>
/// <returns>
/// Whether the solution was synced.
/// </returns>
/// <param name='affectedFiles'>
/// A set of files whose status has changed
/// </param>
/// <param name="reimportedFiles">
/// A set of files that got reimported
/// </param>
public bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
{
SetupProjectSupportedExtensions();
if (HasFilesBeenModified(affectedFiles, reimportedFiles))
{
Sync();
return true;
}
return false;
}
bool HasFilesBeenModified(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
{
return affectedFiles.Any(ShouldFileBePartOfSolution) || reimportedFiles.Any(ShouldSyncOnReimportedAsset);
}
static bool ShouldSyncOnReimportedAsset(string asset)
{
return k_ReimportSyncExtensions.Contains(new FileInfo(asset).Extension);
}
public void Sync()
{
SetupProjectSupportedExtensions();
var types = GetAssetPostprocessorTypes();
isRiderProjectGeneration = true;
bool externalCodeAlreadyGeneratedProjects = OnPreGeneratingCSProjectFiles(types);
isRiderProjectGeneration = false;
if (!externalCodeAlreadyGeneratedProjects)
{
GenerateAndWriteSolutionAndProjects(types);
}
OnGeneratedCSProjectFiles(types);
}
public bool HasSolutionBeenGenerated()
{
return m_FileIOProvider.Exists(SolutionFile());
}
void SetupProjectSupportedExtensions()
{
m_ProjectSupportedExtensions = EditorSettings.projectGenerationUserExtensions;
}
bool ShouldFileBePartOfSolution(string file)
{
string extension = Path.GetExtension(file);
// Exclude files coming from packages except if they are internalized.
if (!m_ShouldGenerateAll && IsInternalizedPackagePath(file))
{
return false;
}
// Dll's are not scripts but still need to be included..
if (extension == ".dll")
return true;
if (file.ToLower().EndsWith(".asmdef"))
return true;
return IsSupportedExtension(extension);
}
bool IsSupportedExtension(string extension)
{
extension = extension.TrimStart('.');
if (k_BuiltinSupportedExtensions.ContainsKey(extension))
return true;
if (m_ProjectSupportedExtensions.Contains(extension))
return true;
return false;
}
static ScriptingLanguage ScriptingLanguageFor(Assembly island)
{
return ScriptingLanguageFor(GetExtensionOfSourceFiles(island.sourceFiles));
}
static string GetExtensionOfSourceFiles(string[] files)
{
return files.Length > 0 ? GetExtensionOfSourceFile(files[0]) : "NA";
}
static string GetExtensionOfSourceFile(string file)
{
var ext = Path.GetExtension(file).ToLower();
ext = ext.Substring(1); //strip dot
return ext;
}
static ScriptingLanguage ScriptingLanguageFor(string extension)
{
return k_BuiltinSupportedExtensions.TryGetValue(extension.TrimStart('.'), out var result)
? result
: ScriptingLanguage.None;
}
public void GenerateAndWriteSolutionAndProjects(Type[] types)
{
// Only synchronize islands that have associated source files and ones that we actually want in the project.
// This also filters out DLLs coming from .asmdef files in packages.
var assemblies = m_AssemblyNameProvider.GetAssemblies(ShouldFileBePartOfSolution);
var allAssetProjectParts = GenerateAllAssetProjectParts();
var monoIslands = assemblies.ToList();
SyncSolution(monoIslands, types);
var allProjectIslands = RelevantIslandsForMode(monoIslands).ToList();
foreach (Assembly assembly in allProjectIslands)
{
var responseFileData = ParseResponseFileData(assembly);
SyncProject(assembly, allAssetProjectParts, responseFileData, allProjectIslands, types);
}
}
IEnumerable<ResponseFileData> ParseResponseFileData(Assembly assembly)
{
var systemReferenceDirectories =
CompilationPipeline.GetSystemAssemblyDirectories(assembly.compilerOptions.ApiCompatibilityLevel);
Dictionary<string, ResponseFileData> responseFilesData = assembly.compilerOptions.ResponseFiles.ToDictionary(
x => x, x => m_AssemblyNameProvider.ParseResponseFile(
x,
ProjectDirectory,
systemReferenceDirectories
));
Dictionary<string, ResponseFileData> responseFilesWithErrors = responseFilesData.Where(x => x.Value.Errors.Any())
.ToDictionary(x => x.Key, x => x.Value);
if (responseFilesWithErrors.Any())
{
foreach (var error in responseFilesWithErrors)
foreach (var valueError in error.Value.Errors)
{
Debug.LogError($"{error.Key} Parse Error : {valueError}");
}
}
return responseFilesData.Select(x => x.Value);
}
Dictionary<string, string> GenerateAllAssetProjectParts()
{
Dictionary<string, StringBuilder> stringBuilders = new Dictionary<string, StringBuilder>();
foreach (string asset in m_AssemblyNameProvider.GetAllAssetPaths())
{
// Exclude files coming from packages except if they are internalized.
if (!m_ShouldGenerateAll && IsInternalizedPackagePath(asset))
{
continue;
}
string extension = Path.GetExtension(asset);
if (IsSupportedExtension(extension) && ScriptingLanguage.None == ScriptingLanguageFor(extension))
{
// Find assembly the asset belongs to by adding script extension and using compilation pipeline.
var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset + ".cs");
if (string.IsNullOrEmpty(assemblyName))
{
continue;
}
assemblyName = FileSystemUtil.FileNameWithoutExtension(assemblyName);
if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder))
{
projectBuilder = new StringBuilder();
stringBuilders[assemblyName] = projectBuilder;
}
projectBuilder.Append(" <None Include=\"").Append(EscapedRelativePathFor(asset)).Append("\" />")
.Append(Environment.NewLine);
}
}
var result = new Dictionary<string, string>();
foreach (var entry in stringBuilders)
result[entry.Key] = entry.Value.ToString();
return result;
}
bool IsInternalizedPackagePath(string file)
{
if (string.IsNullOrWhiteSpace(file))
{
return false;
}
var packageInfo = m_AssemblyNameProvider.FindForAssetPath(file);
if (packageInfo == null)
{
return false;
}
var packageSource = packageInfo.source;
return packageSource != PackageSource.Embedded && packageSource != PackageSource.Local;
}
void SyncProject(
Assembly island,
Dictionary<string, string> allAssetsProjectParts,
IEnumerable<ResponseFileData> responseFilesData,
List<Assembly> allProjectIslands,
Type[] types)
{
SyncProjectFileIfNotChanged(ProjectFile(island),
ProjectText(island, allAssetsProjectParts, responseFilesData.ToList(), allProjectIslands), types);
}
void SyncProjectFileIfNotChanged(string path, string newContents, Type[] types)
{
if (Path.GetExtension(path) == ".csproj")
{
newContents = OnGeneratedCSProject(path, newContents, types);
}
SyncFileIfNotChanged(path, newContents);
}
void SyncSolutionFileIfNotChanged(string path, string newContents, Type[] types)
{
newContents = OnGeneratedSlnSolution(path, newContents, types);
SyncFileIfNotChanged(path, newContents);
}
static List<Type> SafeGetTypes(System.Reflection.Assembly a)
{
List<Type> ret;
try
{
ret = a.GetTypes().ToList();
}
catch (System.Reflection.ReflectionTypeLoadException rtl)
{
ret = rtl.Types.ToList();
}
catch (Exception)
{
return new List<Type>();
}
return ret.Where(r => r != null).ToList();
}
static void OnGeneratedCSProjectFiles(Type[] types)
{
var args = new object[0];
foreach (var type in types)
{
var method = type.GetMethod("OnGeneratedCSProjectFiles",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
method.Invoke(null, args);
}
}
public static Type[] GetAssetPostprocessorTypes()
{
return TypeCache.GetTypesDerivedFrom<AssetPostprocessor>().ToArray(); // doesn't find types from EditorPlugin, which is fine
}
static bool OnPreGeneratingCSProjectFiles(Type[] types)
{
bool result = false;
foreach (var type in types)
{
var args = new object[0];
var method = type.GetMethod("OnPreGeneratingCSProjectFiles",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(bool))
{
result |= (bool) returnValue;
}
}
return result;
}
static string OnGeneratedCSProject(string path, string content, Type[] types)
{
foreach (var type in types)
{
var args = new[] {path, content};
var method = type.GetMethod("OnGeneratedCSProject",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(string))
{
content = (string) returnValue;
}
}
return content;
}
static string OnGeneratedSlnSolution(string path, string content, Type[] types)
{
foreach (var type in types)
{
var args = new[] {path, content};
var method = type.GetMethod("OnGeneratedSlnSolution",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(string))
{
content = (string) returnValue;
}
}
return content;
}
void SyncFileIfNotChanged(string filename, string newContents)
{
try
{
if (m_FileIOProvider.Exists(filename) && newContents == m_FileIOProvider.ReadAllText(filename))
{
return;
}
}
catch (Exception exception)
{
Debug.LogException(exception);
}
m_FileIOProvider.WriteAllText(filename, newContents);
}
string ProjectText(Assembly assembly,
Dictionary<string, string> allAssetsProjectParts,
List<ResponseFileData> responseFilesData,
List<Assembly> allProjectIslands)
{
var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData));
var references = new List<string>();
var projectReferences = new List<Match>();
foreach (string file in assembly.sourceFiles)
{
if (!ShouldFileBePartOfSolution(file))
continue;
var extension = Path.GetExtension(file).ToLower();
var fullFile = EscapedRelativePathFor(file);
if (".dll" != extension)
{
projectBuilder.Append(" <Compile Include=\"").Append(fullFile).Append("\" />").Append(Environment.NewLine);
}
else
{
references.Add(fullFile);
}
}
// Append additional non-script files that should be included in project generation.
if (allAssetsProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject))
projectBuilder.Append(additionalAssetsForProject);
var islandRefs = references.Union(assembly.allReferences);
foreach (string reference in islandRefs)
{
if (reference.EndsWith("/UnityEditor.dll", StringComparison.Ordinal)
|| reference.EndsWith("/UnityEngine.dll", StringComparison.Ordinal)
|| reference.EndsWith("\\UnityEditor.dll", StringComparison.Ordinal)
|| reference.EndsWith("\\UnityEngine.dll", StringComparison.Ordinal))
continue;
var match = k_ScriptReferenceExpression.Match(reference);
if (match.Success)
{
// assume csharp language
// Add a reference to a project except if it's a reference to a script assembly
// that we are not generating a project for. This will be the case for assemblies
// coming from .assembly.json files in non-internalized packages.
var dllName = match.Groups["dllname"].Value;
if (allProjectIslands.Any(i => Path.GetFileName(i.outputPath) == dllName))
{
projectReferences.Add(match);
continue;
}
}
string fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(ProjectDirectory, reference);
AppendReference(fullReference, projectBuilder);
}
var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r));
foreach (var reference in responseRefs)
{
AppendReference(reference, projectBuilder);
}
if (0 < projectReferences.Count)
{
projectBuilder.AppendLine(" </ItemGroup>");
projectBuilder.AppendLine(" <ItemGroup>");
foreach (Match reference in projectReferences)
{
var referencedProject = reference.Groups["project"].Value;
projectBuilder.Append(" <ProjectReference Include=\"").Append(referencedProject)
.Append(GetProjectExtension()).Append("\">").Append(Environment.NewLine);
projectBuilder
.Append(" <Project>{")
.Append(m_GUIDGenerator.ProjectGuid(m_ProjectName, reference.Groups["project"].Value))
.Append("}</Project>")
.Append(Environment.NewLine);
projectBuilder.Append(" <Name>").Append(referencedProject).Append("</Name>").Append(Environment.NewLine);
projectBuilder.AppendLine(" </ProjectReference>");
}
}
projectBuilder.Append(ProjectFooter());
return projectBuilder.ToString();
}
static void AppendReference(string fullReference, StringBuilder projectBuilder)
{
//replace \ with / and \\ with /
var escapedFullPath = SecurityElement.Escape(fullReference);
escapedFullPath = escapedFullPath.Replace("\\\\", "/").Replace("\\", "/");
projectBuilder.Append(" <Reference Include=\"").Append(FileSystemUtil.FileNameWithoutExtension(escapedFullPath))
.Append("\">").Append(Environment.NewLine);
projectBuilder.Append(" <HintPath>").Append(escapedFullPath).Append("</HintPath>").Append(Environment.NewLine);
projectBuilder.Append(" </Reference>").Append(Environment.NewLine);
}
public string ProjectFile(Assembly assembly)
{
return Path.Combine(ProjectDirectory, $"{assembly.name}.csproj");
}
public string SolutionFile()
{
return Path.Combine(ProjectDirectory, $"{m_ProjectName}.sln");
}
string ProjectHeader(
Assembly assembly,
List<ResponseFileData> responseFilesData
)
{
var otherResponseFilesData = GetOtherArgumentsFromResponseFilesData(responseFilesData);
var arguments = new object[]
{
k_ToolsVersion, k_ProductVersion, m_GUIDGenerator.ProjectGuid(m_ProjectName, assembly.name),
InternalEditorUtility.GetEngineAssemblyPath(),
InternalEditorUtility.GetEditorAssemblyPath(),
string.Join(";",
new[] {"DEBUG", "TRACE"}.Concat(EditorUserBuildSettings.activeScriptCompilationDefines).Concat(assembly.defines)
.Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
MSBuildNamespaceUri,
assembly.name,
EditorSettings.projectGenerationRootNamespace,
k_TargetFrameworkVersion,
GenerateLangVersion(otherResponseFilesData["langversion"]),
k_BaseDirectory,
assembly.compilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
GenerateNoWarn(otherResponseFilesData["nowarn"].Distinct().ToArray()),
GenerateAnalyserItemGroup(otherResponseFilesData["analyzer"].Concat(otherResponseFilesData["a"]).SelectMany(x=>x.Split(';')).Distinct().ToArray()),
GenerateAnalyserAdditionalFiles(otherResponseFilesData["additionalfile"].SelectMany(x=>x.Split(';')).Distinct().ToArray()),
GenerateAnalyserRuleSet(otherResponseFilesData["ruleset"].Distinct().ToArray()),
GenerateWarningLevel(otherResponseFilesData["warn"].Concat(otherResponseFilesData["w"]).Distinct()),
GenerateWarningAsError(otherResponseFilesData["warnaserror"]),
GenerateDocumentationFile(otherResponseFilesData["doc"])
};
try
{
return string.Format(GetProjectHeaderTemplate(), arguments);
}
catch (Exception)
{
throw new NotSupportedException(
"Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " +
arguments.Length);
}
}
private string GenerateDocumentationFile(IEnumerable<string> paths)
{
if (!paths.Any())
return String.Empty;
return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $" <DocumentationFile>{a}</DocumentationFile>"))}";
}
private string GenerateWarningAsError(IEnumerable<string> enumerable)
{
string returnValue = String.Empty;
bool allWarningsAsErrors = false;
List<string> warningIds = new List<string>();
foreach (string s in enumerable)
{
if (s == "+") allWarningsAsErrors = true;
else if (s == "-") allWarningsAsErrors = false;
else
{
warningIds.Add(s);
}
}
returnValue += $@" <TreatWarningsAsErrors>{allWarningsAsErrors}</TreatWarningsAsErrors>";
if (warningIds.Any())
{
returnValue += $"{Environment.NewLine} <WarningsAsErrors>{string.Join(";", warningIds)}</WarningsAsErrors>";
}
return $"{Environment.NewLine}{returnValue}";
}
private string GenerateWarningLevel(IEnumerable<string> warningLevel)
{
var level = warningLevel.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(level))
return level;
return 4.ToString();
}
static string GetSolutionText()
{
return string.Join(Environment.NewLine,
@"",
@"Microsoft Visual Studio Solution File, Format Version {0}",
@"# Visual Studio {1}",
@"{2}",
@"Global",
@" GlobalSection(SolutionConfigurationPlatforms) = preSolution",
@" Debug|Any CPU = Debug|Any CPU",
@" Release|Any CPU = Release|Any CPU",
@" EndGlobalSection",
@" GlobalSection(ProjectConfigurationPlatforms) = postSolution",
@"{3}",
@" EndGlobalSection",
@" GlobalSection(SolutionProperties) = preSolution",
@" HideSolutionNode = FALSE",
@" EndGlobalSection",
@"EndGlobal",
@"").Replace(" ", "\t");
}
static string GetProjectFooterTemplate()
{
return string.Join(Environment.NewLine,
@" </ItemGroup>",
@" <Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />",
@" <!-- To modify your build process, add your task inside one of the targets below and uncomment it. ",
@" Other similar extension points exist, see Microsoft.Common.targets.",
@" <Target Name=""BeforeBuild"">",
@" </Target>",
@" <Target Name=""AfterBuild"">",
@" </Target>",
@" -->",
@"</Project>",
@"");
}
static string GetProjectHeaderTemplate()
{
var header = new[]
{
@"<?xml version=""1.0"" encoding=""utf-8""?>",
@"<Project ToolsVersion=""{0}"" DefaultTargets=""Build"" xmlns=""{6}"">",
@" <PropertyGroup>",
@" <LangVersion>{10}</LangVersion>",
@" <_TargetFrameworkDirectories>non_empty_path_generated_by_unity.rider.package</_TargetFrameworkDirectories>",
@" <_FullFrameworkReferenceAssemblyPaths>non_empty_path_generated_by_unity.rider.package</_FullFrameworkReferenceAssemblyPaths>",
@" <DisableHandlePackageFileConflicts>true</DisableHandlePackageFileConflicts>{16}",
@" </PropertyGroup>",
@" <PropertyGroup>",
@" <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>",
@" <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>",
@" <ProductVersion>{1}</ProductVersion>",
@" <SchemaVersion>2.0</SchemaVersion>",
@" <RootNamespace>{8}</RootNamespace>",
@" <ProjectGuid>{{{2}}}</ProjectGuid>",
@" <OutputType>Library</OutputType>",
@" <AppDesignerFolder>Properties</AppDesignerFolder>",
@" <AssemblyName>{7}</AssemblyName>",
@" <TargetFrameworkVersion>{9}</TargetFrameworkVersion>",
@" <FileAlignment>512</FileAlignment>",
@" <BaseDirectory>{11}</BaseDirectory>",
@" </PropertyGroup>",
@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "">",
@" <DebugSymbols>true</DebugSymbols>",
@" <DebugType>full</DebugType>",
@" <Optimize>false</Optimize>",
@" <OutputPath>Temp\bin\Debug\</OutputPath>",
@" <DefineConstants>{5}</DefineConstants>",
@" <ErrorReport>prompt</ErrorReport>",
@" <WarningLevel>{17}</WarningLevel>",
@" <NoWarn>0169{13}</NoWarn>",
@" <AllowUnsafeBlocks>{12}</AllowUnsafeBlocks>{18}{19}",
@" </PropertyGroup>",
@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "">",
@" <DebugType>pdbonly</DebugType>",
@" <Optimize>true</Optimize>",
@" <OutputPath>Temp\bin\Release\</OutputPath>",
@" <ErrorReport>prompt</ErrorReport>",
@" <WarningLevel>{17}</WarningLevel>",
@" <NoWarn>0169{13}</NoWarn>",
@" <AllowUnsafeBlocks>{12}</AllowUnsafeBlocks>{18}{19}",
@" </PropertyGroup>"
};
var forceExplicitReferences = new[]
{
@" <PropertyGroup>",
@" <NoConfig>true</NoConfig>",
@" <NoStdLib>true</NoStdLib>",
@" <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>",
@" <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>",
@" <ImplicitlyExpandDesignTimeFacades>false</ImplicitlyExpandDesignTimeFacades>",
@" </PropertyGroup>"
};
var itemGroupStart = new[]
{
@" <ItemGroup>"
};
var footer = new[]
{
@" <Reference Include=""UnityEngine"">",
@" <HintPath>{3}</HintPath>",
@" </Reference>",
@" <Reference Include=""UnityEditor"">",
@" <HintPath>{4}</HintPath>",
@" </Reference>",
@" </ItemGroup>{14}{15}",
@" <ItemGroup>",
@""
};
var pieces = header.Concat(forceExplicitReferences).Concat(itemGroupStart).Concat(footer).ToArray();
return string.Join(Environment.NewLine, pieces);
}
void SyncSolution(IEnumerable<Assembly> islands, Type[] types)
{
SyncSolutionFileIfNotChanged(SolutionFile(), SolutionText(islands), types);
}
string SolutionText(IEnumerable<Assembly> islands)
{
var fileversion = "11.00";
var vsversion = "2010";
var relevantIslands = RelevantIslandsForMode(islands);
string projectEntries = GetProjectEntries(relevantIslands);
string projectConfigurations = string.Join(Environment.NewLine,
relevantIslands.Select(i => GetProjectActiveConfigurations(m_GUIDGenerator.ProjectGuid(m_ProjectName, i.name))).ToArray());
return string.Format(GetSolutionText(), fileversion, vsversion, projectEntries, projectConfigurations);
}
private static string GenerateAnalyserItemGroup(string[] paths)
{
// <ItemGroup>
// <Analyzer Include="..\packages\Comments_analyser.1.0.6626.21356\analyzers\dotnet\cs\Comments_analyser.dll" />
// <Analyzer Include="..\packages\UnityEngineAnalyzer.1.0.0.0\analyzers\dotnet\cs\UnityEngineAnalyzer.dll" />
// </ItemGroup>
if (!paths.Any())
return string.Empty;
var analyserBuilder = new StringBuilder();
analyserBuilder.AppendLine(" <ItemGroup>");
foreach (var path in paths)
{
analyserBuilder.AppendLine($" <Analyzer Include=\"{path}\" />");
}
analyserBuilder.AppendLine(" </ItemGroup>");
return analyserBuilder.ToString();
}
private static ILookup<string, string> GetOtherArgumentsFromResponseFilesData(List<ResponseFileData> responseFilesData)
{
var paths = responseFilesData.SelectMany(x =>
{
return x.OtherArguments
.Where(a => a.StartsWith("/") || a.StartsWith("-"))
.Select(b =>
{
var index = b.IndexOf(":", StringComparison.Ordinal);
if (index > 0 && b.Length > index)
{
var key = b.Substring(1, index - 1);
return new KeyValuePair<string, string>(key, b.Substring(index + 1));
}
const string warnaserror = "warnaserror";
if (b.Substring(1).StartsWith(warnaserror))
{
return new KeyValuePair<string,string>(warnaserror, b.Substring(warnaserror.Length+ 1) );
}
return default;
});
})
.Distinct()
.ToLookup(o => o.Key, pair => pair.Value);
return paths;
}
private string GenerateLangVersion(IEnumerable<string> langVersionList)
{
var langVersion = langVersionList.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(langVersion))
return langVersion;
return k_TargetLanguageVersion;
}
private static string GenerateAnalyserRuleSet(string[] paths)
{
//<CodeAnalysisRuleSet>..\path\to\myrules.ruleset</CodeAnalysisRuleSet>
if (!paths.Any())
return string.Empty;
return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $" <CodeAnalysisRuleSet>{a}</CodeAnalysisRuleSet>"))}";
}
private static string GenerateAnalyserAdditionalFiles(string[] paths)
{
if (!paths.Any())
return string.Empty;
var analyserBuilder = new StringBuilder();
analyserBuilder.AppendLine(" <ItemGroup>");
foreach (var path in paths)
{
analyserBuilder.AppendLine($" <AdditionalFiles Include=\"{path}\" />");
}
analyserBuilder.AppendLine(" </ItemGroup>");
return analyserBuilder.ToString();
}
private static string GenerateNoWarn(string[] codes)
{
if (!codes.Any())
return string.Empty;
return $",{string.Join(",", codes)}";
}
static IEnumerable<Assembly> RelevantIslandsForMode(IEnumerable<Assembly> islands)
{
IEnumerable<Assembly> relevantIslands = islands.Where(i => ScriptingLanguage.CSharp == ScriptingLanguageFor(i));
return relevantIslands;
}
/// <summary>
/// Get a Project("{guid}") = "MyProject", "MyProject.unityproj", "{projectguid}"
/// entry for each relevant language
/// </summary>
string GetProjectEntries(IEnumerable<Assembly> islands)
{
var projectEntries = islands.Select(i => string.Format(
m_SolutionProjectEntryTemplate,
m_GUIDGenerator.SolutionGuid(m_ProjectName, GetExtensionOfSourceFiles(i.sourceFiles)),
i.name,
Path.GetFileName(ProjectFile(i)),
m_GUIDGenerator.ProjectGuid(m_ProjectName, i.name)
));
return string.Join(Environment.NewLine, projectEntries.ToArray());
}
/// <summary>
/// Generate the active configuration string for a given project guid
/// </summary>
string GetProjectActiveConfigurations(string projectGuid)
{
return string.Format(
m_SolutionProjectConfigurationTemplate,
projectGuid);
}
string EscapedRelativePathFor(string file)
{
var projectDir = ProjectDirectory.Replace('/', '\\');
file = file.Replace('/', '\\');
var path = SkipPathPrefix(file, projectDir);
var packageInfo = m_AssemblyNameProvider.FindForAssetPath(path.Replace('\\', '/'));
if (packageInfo != null)
{
// We have to normalize the path, because the PackageManagerRemapper assumes
// dir seperators will be os specific.
var absolutePath = Path.GetFullPath(NormalizePath(path)).Replace('/', '\\');
path = SkipPathPrefix(absolutePath, projectDir);
}
return SecurityElement.Escape(path);
}
static string SkipPathPrefix(string path, string prefix)
{
if (path.Replace("\\", "/").StartsWith($"{prefix}/"))
return path.Substring(prefix.Length + 1);
return path;
}
static string NormalizePath(string path)
{
if (Path.DirectorySeparatorChar == '\\')
return path.Replace('/', Path.DirectorySeparatorChar);
return path.Replace('\\', Path.DirectorySeparatorChar);
}
static string ProjectFooter()
{
return GetProjectFooterTemplate();
}
static string GetProjectExtension()
{
return ".csproj";
}
}
public static class SolutionGuidGenerator
{
public static string GuidForProject(string projectName)
{
return ComputeGuidHashFor(projectName + "salt");
}
public static string GuidForSolution(string projectName, string sourceFileExtension)
{
if (sourceFileExtension.ToLower() == "cs")
// GUID for a C# class library: http://www.codeproject.com/Reference/720512/List-of-Visual-Studio-Project-Type-GUIDs
return "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC";
return ComputeGuidHashFor(projectName);
}
static string ComputeGuidHashFor(string input)
{
var hash = MD5.Create().ComputeHash(Encoding.Default.GetBytes(input));
return HashAsGuid(HashToString(hash));
}
static string HashAsGuid(string hash)
{
var guid = hash.Substring(0, 8) + "-" + hash.Substring(8, 4) + "-" + hash.Substring(12, 4) + "-" +
hash.Substring(16, 4) + "-" + hash.Substring(20, 12);
return guid.ToUpper();
}
static string HashToString(byte[] bs)
{
var sb = new StringBuilder();
foreach (byte b in bs)
sb.Append(b.ToString("x2"));
return sb.ToString();
}
}
}
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Packages.Rider.Editor.Util;
using UnityEditor;
using UnityEditor.Compilation;
using UnityEditor.PackageManager;
using UnityEditorInternal;
using UnityEngine;
namespace Packages.Rider.Editor
{
public interface IGenerator
{
bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles);
void Sync();
bool HasSolutionBeenGenerated();
string SolutionFile();
string ProjectDirectory { get; }
void GenerateAll(bool generateAll);
}
public interface IFileIO
{
bool Exists(string fileName);
string ReadAllText(string fileName);
void WriteAllText(string fileName, string content);
}
public interface IGUIDGenerator
{
string ProjectGuid(string projectName, string assemblyName);
string SolutionGuid(string projectName, string extension);
}
public interface IAssemblyNameProvider
{
string GetAssemblyNameFromScriptPath(string path);
IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution);
IEnumerable<string> GetAllAssetPaths();
UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath);
ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories);
}
class AssemblyNameProvider : IAssemblyNameProvider
{
public string GetAssemblyNameFromScriptPath(string path)
{
return CompilationPipeline.GetAssemblyNameFromScriptPath(path);
}
public IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution)
{
return CompilationPipeline.GetAssemblies()
.Where(i => 0 < i.sourceFiles.Length && i.sourceFiles.Any(shouldFileBePartOfSolution));
}
public IEnumerable<string> GetAllAssetPaths()
{
return AssetDatabase.GetAllAssetPaths();
}
public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath)
{
return UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath);
}
public ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories)
{
return CompilationPipeline.ParseResponseFile(
responseFilePath,
projectDirectory,
systemReferenceDirectories
);
}
}
public class ProjectGeneration : IGenerator
{
enum ScriptingLanguage
{
None,
CSharp
}
public static readonly string MSBuildNamespaceUri = "http://schemas.microsoft.com/developer/msbuild/2003";
/// <summary>
/// Map source extensions to ScriptingLanguages
/// </summary>
static readonly Dictionary<string, ScriptingLanguage> k_BuiltinSupportedExtensions =
new Dictionary<string, ScriptingLanguage>
{
{"cs", ScriptingLanguage.CSharp},
{"uxml", ScriptingLanguage.None},
{"uss", ScriptingLanguage.None},
{"shader", ScriptingLanguage.None},
{"compute", ScriptingLanguage.None},
{"cginc", ScriptingLanguage.None},
{"hlsl", ScriptingLanguage.None},
{"glslinc", ScriptingLanguage.None},
{"template", ScriptingLanguage.None},
{"raytrace", ScriptingLanguage.None}
};
string m_SolutionProjectEntryTemplate = string.Join(Environment.NewLine,
@"Project(""{{{0}}}"") = ""{1}"", ""{2}"", ""{{{3}}}""",
@"EndProject").Replace(" ", "\t");
string m_SolutionProjectConfigurationTemplate = string.Join(Environment.NewLine,
@" {{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU",
@" {{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU",
@" {{{0}}}.Release|Any CPU.ActiveCfg = Release|Any CPU",
@" {{{0}}}.Release|Any CPU.Build.0 = Release|Any CPU").Replace(" ", "\t");
static readonly string[] k_ReimportSyncExtensions = {".dll", ".asmdef"};
/// <summary>
/// Map ScriptingLanguages to project extensions
/// </summary>
/*static readonly Dictionary<ScriptingLanguage, string> k_ProjectExtensions = new Dictionary<ScriptingLanguage, string>
{
{ ScriptingLanguage.CSharp, ".csproj" },
{ ScriptingLanguage.None, ".csproj" },
};*/
static readonly Regex k_ScriptReferenceExpression = new Regex(
@"^Library.ScriptAssemblies.(?<dllname>(?<project>.*)\.dll$)",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
string[] m_ProjectSupportedExtensions = new string[0];
bool m_ShouldGenerateAll;
public string ProjectDirectory { get; }
public void GenerateAll(bool generateAll)
{
m_ShouldGenerateAll = generateAll;
}
readonly string m_ProjectName;
readonly IAssemblyNameProvider m_AssemblyNameProvider;
readonly IFileIO m_FileIOProvider;
readonly IGUIDGenerator m_GUIDGenerator;
internal static bool isRiderProjectGeneration; // workaround to https://github.cds.internal.unity3d.com/unity/com.unity.ide.rider/issues/28
const string k_ToolsVersion = "4.0";
const string k_ProductVersion = "10.0.20506";
const string k_BaseDirectory = ".";
const string k_TargetFrameworkVersion = "v4.7.1";
const string k_TargetLanguageVersion = "latest";
static readonly Regex scriptReferenceExpression = new Regex(
@"^Library.ScriptAssemblies.(?<dllname>(?<project>.*)\.dll$)",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
public ProjectGeneration() : this(Directory.GetParent(Application.dataPath).FullName)
{
}
public ProjectGeneration(string tempDirectory) : this(tempDirectory, new AssemblyNameProvider(), new FileIOProvider(), new GUIDProvider())
{
}
public ProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIoProvider, IGUIDGenerator guidGenerator)
{
ProjectDirectory = tempDirectory.Replace('\\', '/');
m_ProjectName = Path.GetFileName(ProjectDirectory);
m_AssemblyNameProvider = assemblyNameProvider;
m_FileIOProvider = fileIoProvider;
m_GUIDGenerator = guidGenerator;
}
/// <summary>
/// Syncs the scripting solution if any affected files are relevant.
/// </summary>
/// <returns>
/// Whether the solution was synced.
/// </returns>
/// <param name='affectedFiles'>
/// A set of files whose status has changed
/// </param>
/// <param name="reimportedFiles">
/// A set of files that got reimported
/// </param>
public bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
{
SetupProjectSupportedExtensions();
if (HasFilesBeenModified(affectedFiles, reimportedFiles))
{
Sync();
return true;
}
return false;
}
bool HasFilesBeenModified(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
{
return affectedFiles.Any(ShouldFileBePartOfSolution) || reimportedFiles.Any(ShouldSyncOnReimportedAsset);
}
static bool ShouldSyncOnReimportedAsset(string asset)
{
return k_ReimportSyncExtensions.Contains(new FileInfo(asset).Extension);
}
public void Sync()
{
SetupProjectSupportedExtensions();
var types = GetAssetPostprocessorTypes();
isRiderProjectGeneration = true;
bool externalCodeAlreadyGeneratedProjects = OnPreGeneratingCSProjectFiles(types);
isRiderProjectGeneration = false;
if (!externalCodeAlreadyGeneratedProjects)
{
GenerateAndWriteSolutionAndProjects(types);
}
OnGeneratedCSProjectFiles(types);
}
public bool HasSolutionBeenGenerated()
{
return m_FileIOProvider.Exists(SolutionFile());
}
void SetupProjectSupportedExtensions()
{
m_ProjectSupportedExtensions = EditorSettings.projectGenerationUserExtensions;
}
bool ShouldFileBePartOfSolution(string file)
{
string extension = Path.GetExtension(file);
// Exclude files coming from packages except if they are internalized.
if (!m_ShouldGenerateAll && IsInternalizedPackagePath(file))
{
return false;
}
// Dll's are not scripts but still need to be included..
if (extension == ".dll")
return true;
if (file.ToLower().EndsWith(".asmdef"))
return true;
return IsSupportedExtension(extension);
}
bool IsSupportedExtension(string extension)
{
extension = extension.TrimStart('.');
if (k_BuiltinSupportedExtensions.ContainsKey(extension))
return true;
if (m_ProjectSupportedExtensions.Contains(extension))
return true;
return false;
}
static ScriptingLanguage ScriptingLanguageFor(Assembly island)
{
return ScriptingLanguageFor(GetExtensionOfSourceFiles(island.sourceFiles));
}
static string GetExtensionOfSourceFiles(string[] files)
{
return files.Length > 0 ? GetExtensionOfSourceFile(files[0]) : "NA";
}
static string GetExtensionOfSourceFile(string file)
{
var ext = Path.GetExtension(file).ToLower();
ext = ext.Substring(1); //strip dot
return ext;
}
static ScriptingLanguage ScriptingLanguageFor(string extension)
{
return k_BuiltinSupportedExtensions.TryGetValue(extension.TrimStart('.'), out var result)
? result
: ScriptingLanguage.None;
}
public void GenerateAndWriteSolutionAndProjects(Type[] types)
{
// Only synchronize islands that have associated source files and ones that we actually want in the project.
// This also filters out DLLs coming from .asmdef files in packages.
var assemblies = m_AssemblyNameProvider.GetAssemblies(ShouldFileBePartOfSolution);
var allAssetProjectParts = GenerateAllAssetProjectParts();
var monoIslands = assemblies.ToList();
SyncSolution(monoIslands, types);
var allProjectIslands = RelevantIslandsForMode(monoIslands).ToList();
foreach (Assembly assembly in allProjectIslands)
{
var responseFileData = ParseResponseFileData(assembly);
SyncProject(assembly, allAssetProjectParts, responseFileData, allProjectIslands, types);
}
}
IEnumerable<ResponseFileData> ParseResponseFileData(Assembly assembly)
{
var systemReferenceDirectories =
CompilationPipeline.GetSystemAssemblyDirectories(assembly.compilerOptions.ApiCompatibilityLevel);
Dictionary<string, ResponseFileData> responseFilesData = assembly.compilerOptions.ResponseFiles.ToDictionary(
x => x, x => m_AssemblyNameProvider.ParseResponseFile(
x,
ProjectDirectory,
systemReferenceDirectories
));
Dictionary<string, ResponseFileData> responseFilesWithErrors = responseFilesData.Where(x => x.Value.Errors.Any())
.ToDictionary(x => x.Key, x => x.Value);
if (responseFilesWithErrors.Any())
{
foreach (var error in responseFilesWithErrors)
foreach (var valueError in error.Value.Errors)
{
Debug.LogError($"{error.Key} Parse Error : {valueError}");
}
}
return responseFilesData.Select(x => x.Value);
}
Dictionary<string, string> GenerateAllAssetProjectParts()
{
Dictionary<string, StringBuilder> stringBuilders = new Dictionary<string, StringBuilder>();
foreach (string asset in m_AssemblyNameProvider.GetAllAssetPaths())
{
// Exclude files coming from packages except if they are internalized.
if (!m_ShouldGenerateAll && IsInternalizedPackagePath(asset))
{
continue;
}
string extension = Path.GetExtension(asset);
if (IsSupportedExtension(extension) && ScriptingLanguage.None == ScriptingLanguageFor(extension))
{
// Find assembly the asset belongs to by adding script extension and using compilation pipeline.
var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset + ".cs");
if (string.IsNullOrEmpty(assemblyName))
{
continue;
}
assemblyName = FileSystemUtil.FileNameWithoutExtension(assemblyName);
if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder))
{
projectBuilder = new StringBuilder();
stringBuilders[assemblyName] = projectBuilder;
}
projectBuilder.Append(" <None Include=\"").Append(EscapedRelativePathFor(asset)).Append("\" />")
.Append(Environment.NewLine);
}
}
var result = new Dictionary<string, string>();
foreach (var entry in stringBuilders)
result[entry.Key] = entry.Value.ToString();
return result;
}
bool IsInternalizedPackagePath(string file)
{
if (string.IsNullOrWhiteSpace(file))
{
return false;
}
var packageInfo = m_AssemblyNameProvider.FindForAssetPath(file);
if (packageInfo == null)
{
return false;
}
var packageSource = packageInfo.source;
return packageSource != PackageSource.Embedded && packageSource != PackageSource.Local;
}
void SyncProject(
Assembly island,
Dictionary<string, string> allAssetsProjectParts,
IEnumerable<ResponseFileData> responseFilesData,
List<Assembly> allProjectIslands,
Type[] types)
{
SyncProjectFileIfNotChanged(ProjectFile(island),
ProjectText(island, allAssetsProjectParts, responseFilesData.ToList(), allProjectIslands), types);
}
void SyncProjectFileIfNotChanged(string path, string newContents, Type[] types)
{
if (Path.GetExtension(path) == ".csproj")
{
newContents = OnGeneratedCSProject(path, newContents, types);
}
SyncFileIfNotChanged(path, newContents);
}
void SyncSolutionFileIfNotChanged(string path, string newContents, Type[] types)
{
newContents = OnGeneratedSlnSolution(path, newContents, types);
SyncFileIfNotChanged(path, newContents);
}
static List<Type> SafeGetTypes(System.Reflection.Assembly a)
{
List<Type> ret;
try
{
ret = a.GetTypes().ToList();
}
catch (System.Reflection.ReflectionTypeLoadException rtl)
{
ret = rtl.Types.ToList();
}
catch (Exception)
{
return new List<Type>();
}
return ret.Where(r => r != null).ToList();
}
static void OnGeneratedCSProjectFiles(Type[] types)
{
var args = new object[0];
foreach (var type in types)
{
var method = type.GetMethod("OnGeneratedCSProjectFiles",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
method.Invoke(null, args);
}
}
public static Type[] GetAssetPostprocessorTypes()
{
return TypeCache.GetTypesDerivedFrom<AssetPostprocessor>().ToArray(); // doesn't find types from EditorPlugin, which is fine
}
static bool OnPreGeneratingCSProjectFiles(Type[] types)
{
bool result = false;
foreach (var type in types)
{
var args = new object[0];
var method = type.GetMethod("OnPreGeneratingCSProjectFiles",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(bool))
{
result |= (bool) returnValue;
}
}
return result;
}
static string OnGeneratedCSProject(string path, string content, Type[] types)
{
foreach (var type in types)
{
var args = new[] {path, content};
var method = type.GetMethod("OnGeneratedCSProject",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(string))
{
content = (string) returnValue;
}
}
return content;
}
static string OnGeneratedSlnSolution(string path, string content, Type[] types)
{
foreach (var type in types)
{
var args = new[] {path, content};
var method = type.GetMethod("OnGeneratedSlnSolution",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(string))
{
content = (string) returnValue;
}
}
return content;
}
void SyncFileIfNotChanged(string filename, string newContents)
{
try
{
if (m_FileIOProvider.Exists(filename) && newContents == m_FileIOProvider.ReadAllText(filename))
{
return;
}
}
catch (Exception exception)
{
Debug.LogException(exception);
}
m_FileIOProvider.WriteAllText(filename, newContents);
}
string ProjectText(Assembly assembly,
Dictionary<string, string> allAssetsProjectParts,
List<ResponseFileData> responseFilesData,
List<Assembly> allProjectIslands)
{
var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData));
var references = new List<string>();
var projectReferences = new List<Match>();
foreach (string file in assembly.sourceFiles)
{
if (!ShouldFileBePartOfSolution(file))
continue;
var extension = Path.GetExtension(file).ToLower();
var fullFile = EscapedRelativePathFor(file);
if (".dll" != extension)
{
projectBuilder.Append(" <Compile Include=\"").Append(fullFile).Append("\" />").Append(Environment.NewLine);
}
else
{
references.Add(fullFile);
}
}
// Append additional non-script files that should be included in project generation.
if (allAssetsProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject))
projectBuilder.Append(additionalAssetsForProject);
var islandRefs = references.Union(assembly.allReferences);
foreach (string reference in islandRefs)
{
if (reference.EndsWith("/UnityEditor.dll", StringComparison.Ordinal)
|| reference.EndsWith("/UnityEngine.dll", StringComparison.Ordinal)
|| reference.EndsWith("\\UnityEditor.dll", StringComparison.Ordinal)
|| reference.EndsWith("\\UnityEngine.dll", StringComparison.Ordinal))
continue;
var match = k_ScriptReferenceExpression.Match(reference);
if (match.Success)
{
// assume csharp language
// Add a reference to a project except if it's a reference to a script assembly
// that we are not generating a project for. This will be the case for assemblies
// coming from .assembly.json files in non-internalized packages.
var dllName = match.Groups["dllname"].Value;
if (allProjectIslands.Any(i => Path.GetFileName(i.outputPath) == dllName))
{
projectReferences.Add(match);
continue;
}
}
string fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(ProjectDirectory, reference);
AppendReference(fullReference, projectBuilder);
}
var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r));
foreach (var reference in responseRefs)
{
AppendReference(reference, projectBuilder);
}
if (0 < projectReferences.Count)
{
projectBuilder.AppendLine(" </ItemGroup>");
projectBuilder.AppendLine(" <ItemGroup>");
foreach (Match reference in projectReferences)
{
var referencedProject = reference.Groups["project"].Value;
projectBuilder.Append(" <ProjectReference Include=\"").Append(referencedProject)
.Append(GetProjectExtension()).Append("\">").Append(Environment.NewLine);
projectBuilder
.Append(" <Project>{")
.Append(m_GUIDGenerator.ProjectGuid(m_ProjectName, reference.Groups["project"].Value))
.Append("}</Project>")
.Append(Environment.NewLine);
projectBuilder.Append(" <Name>").Append(referencedProject).Append("</Name>").Append(Environment.NewLine);
projectBuilder.AppendLine(" </ProjectReference>");
}
}
projectBuilder.Append(ProjectFooter());
return projectBuilder.ToString();
}
static void AppendReference(string fullReference, StringBuilder projectBuilder)
{
//replace \ with / and \\ with /
var escapedFullPath = SecurityElement.Escape(fullReference);
escapedFullPath = escapedFullPath.Replace("\\\\", "/").Replace("\\", "/");
projectBuilder.Append(" <Reference Include=\"").Append(FileSystemUtil.FileNameWithoutExtension(escapedFullPath))
.Append("\">").Append(Environment.NewLine);
projectBuilder.Append(" <HintPath>").Append(escapedFullPath).Append("</HintPath>").Append(Environment.NewLine);
projectBuilder.Append(" </Reference>").Append(Environment.NewLine);
}
public string ProjectFile(Assembly assembly)
{
return Path.Combine(ProjectDirectory, $"{assembly.name}.csproj");
}
public string SolutionFile()
{
return Path.Combine(ProjectDirectory, $"{m_ProjectName}.sln");
}
string ProjectHeader(
Assembly assembly,
List<ResponseFileData> responseFilesData
)
{
var otherResponseFilesData = GetOtherArgumentsFromResponseFilesData(responseFilesData);
var arguments = new object[]
{
k_ToolsVersion, k_ProductVersion, m_GUIDGenerator.ProjectGuid(m_ProjectName, assembly.name),
InternalEditorUtility.GetEngineAssemblyPath(),
InternalEditorUtility.GetEditorAssemblyPath(),
string.Join(";",
new[] {"DEBUG", "TRACE"}.Concat(EditorUserBuildSettings.activeScriptCompilationDefines).Concat(assembly.defines)
.Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
MSBuildNamespaceUri,
assembly.name,
EditorSettings.projectGenerationRootNamespace,
k_TargetFrameworkVersion,
GenerateLangVersion(otherResponseFilesData["langversion"]),
k_BaseDirectory,
assembly.compilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
GenerateNoWarn(otherResponseFilesData["nowarn"].Distinct().ToArray()),
GenerateAnalyserItemGroup(otherResponseFilesData["analyzer"].Concat(otherResponseFilesData["a"]).SelectMany(x=>x.Split(';')).Distinct().ToArray()),
GenerateAnalyserAdditionalFiles(otherResponseFilesData["additionalfile"].SelectMany(x=>x.Split(';')).Distinct().ToArray()),
GenerateAnalyserRuleSet(otherResponseFilesData["ruleset"].Distinct().ToArray()),
GenerateWarningLevel(otherResponseFilesData["warn"].Concat(otherResponseFilesData["w"]).Distinct()),
GenerateWarningAsError(otherResponseFilesData["warnaserror"]),
GenerateDocumentationFile(otherResponseFilesData["doc"])
};
try
{
return string.Format(GetProjectHeaderTemplate(), arguments);
}
catch (Exception)
{
throw new NotSupportedException(
"Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " +
arguments.Length);
}
}
private string GenerateDocumentationFile(IEnumerable<string> paths)
{
if (!paths.Any())
return String.Empty;
return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $" <DocumentationFile>{a}</DocumentationFile>"))}";
}
private string GenerateWarningAsError(IEnumerable<string> enumerable)
{
string returnValue = String.Empty;
bool allWarningsAsErrors = false;
List<string> warningIds = new List<string>();
foreach (string s in enumerable)
{
if (s == "+") allWarningsAsErrors = true;
else if (s == "-") allWarningsAsErrors = false;
else
{
warningIds.Add(s);
}
}
returnValue += $@" <TreatWarningsAsErrors>{allWarningsAsErrors}</TreatWarningsAsErrors>";
if (warningIds.Any())
{
returnValue += $"{Environment.NewLine} <WarningsAsErrors>{string.Join(";", warningIds)}</WarningsAsErrors>";
}
return $"{Environment.NewLine}{returnValue}";
}
private string GenerateWarningLevel(IEnumerable<string> warningLevel)
{
var level = warningLevel.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(level))
return level;
return 4.ToString();
}
static string GetSolutionText()
{
return string.Join(Environment.NewLine,
@"",
@"Microsoft Visual Studio Solution File, Format Version {0}",
@"# Visual Studio {1}",
@"{2}",
@"Global",
@" GlobalSection(SolutionConfigurationPlatforms) = preSolution",
@" Debug|Any CPU = Debug|Any CPU",
@" Release|Any CPU = Release|Any CPU",
@" EndGlobalSection",
@" GlobalSection(ProjectConfigurationPlatforms) = postSolution",
@"{3}",
@" EndGlobalSection",
@" GlobalSection(SolutionProperties) = preSolution",
@" HideSolutionNode = FALSE",
@" EndGlobalSection",
@"EndGlobal",
@"").Replace(" ", "\t");
}
static string GetProjectFooterTemplate()
{
return string.Join(Environment.NewLine,
@" </ItemGroup>",
@" <Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />",
@" <!-- To modify your build process, add your task inside one of the targets below and uncomment it. ",
@" Other similar extension points exist, see Microsoft.Common.targets.",
@" <Target Name=""BeforeBuild"">",
@" </Target>",
@" <Target Name=""AfterBuild"">",
@" </Target>",
@" -->",
@"</Project>",
@"");
}
static string GetProjectHeaderTemplate()
{
var header = new[]
{
@"<?xml version=""1.0"" encoding=""utf-8""?>",
@"<Project ToolsVersion=""{0}"" DefaultTargets=""Build"" xmlns=""{6}"">",
@" <PropertyGroup>",
@" <LangVersion>{10}</LangVersion>",
@" <_TargetFrameworkDirectories>non_empty_path_generated_by_unity.rider.package</_TargetFrameworkDirectories>",
@" <_FullFrameworkReferenceAssemblyPaths>non_empty_path_generated_by_unity.rider.package</_FullFrameworkReferenceAssemblyPaths>",
@" <DisableHandlePackageFileConflicts>true</DisableHandlePackageFileConflicts>{16}",
@" </PropertyGroup>",
@" <PropertyGroup>",
@" <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>",
@" <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>",
@" <ProductVersion>{1}</ProductVersion>",
@" <SchemaVersion>2.0</SchemaVersion>",
@" <RootNamespace>{8}</RootNamespace>",
@" <ProjectGuid>{{{2}}}</ProjectGuid>",
@" <OutputType>Library</OutputType>",
@" <AppDesignerFolder>Properties</AppDesignerFolder>",
@" <AssemblyName>{7}</AssemblyName>",
@" <TargetFrameworkVersion>{9}</TargetFrameworkVersion>",
@" <FileAlignment>512</FileAlignment>",
@" <BaseDirectory>{11}</BaseDirectory>",
@" </PropertyGroup>",
@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "">",
@" <DebugSymbols>true</DebugSymbols>",
@" <DebugType>full</DebugType>",
@" <Optimize>false</Optimize>",
@" <OutputPath>Temp\bin\Debug\</OutputPath>",
@" <DefineConstants>{5}</DefineConstants>",
@" <ErrorReport>prompt</ErrorReport>",
@" <WarningLevel>{17}</WarningLevel>",
@" <NoWarn>0169{13}</NoWarn>",
@" <AllowUnsafeBlocks>{12}</AllowUnsafeBlocks>{18}{19}",
@" </PropertyGroup>",
@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "">",
@" <DebugType>pdbonly</DebugType>",
@" <Optimize>true</Optimize>",
@" <OutputPath>Temp\bin\Release\</OutputPath>",
@" <ErrorReport>prompt</ErrorReport>",
@" <WarningLevel>{17}</WarningLevel>",
@" <NoWarn>0169{13}</NoWarn>",
@" <AllowUnsafeBlocks>{12}</AllowUnsafeBlocks>{18}{19}",
@" </PropertyGroup>"
};
var forceExplicitReferences = new[]
{
@" <PropertyGroup>",
@" <NoConfig>true</NoConfig>",
@" <NoStdLib>true</NoStdLib>",
@" <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>",
@" <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>",
@" <ImplicitlyExpandDesignTimeFacades>false</ImplicitlyExpandDesignTimeFacades>",
@" </PropertyGroup>"
};
var itemGroupStart = new[]
{
@" <ItemGroup>"
};
var footer = new[]
{
@" <Reference Include=""UnityEngine"">",
@" <HintPath>{3}</HintPath>",
@" </Reference>",
@" <Reference Include=""UnityEditor"">",
@" <HintPath>{4}</HintPath>",
@" </Reference>",
@" </ItemGroup>{14}{15}",
@" <ItemGroup>",
@""
};
var pieces = header.Concat(forceExplicitReferences).Concat(itemGroupStart).Concat(footer).ToArray();
return string.Join(Environment.NewLine, pieces);
}
void SyncSolution(IEnumerable<Assembly> islands, Type[] types)
{
SyncSolutionFileIfNotChanged(SolutionFile(), SolutionText(islands), types);
}
string SolutionText(IEnumerable<Assembly> islands)
{
var fileversion = "11.00";
var vsversion = "2010";
var relevantIslands = RelevantIslandsForMode(islands);
string projectEntries = GetProjectEntries(relevantIslands);
string projectConfigurations = string.Join(Environment.NewLine,
relevantIslands.Select(i => GetProjectActiveConfigurations(m_GUIDGenerator.ProjectGuid(m_ProjectName, i.name))).ToArray());
return string.Format(GetSolutionText(), fileversion, vsversion, projectEntries, projectConfigurations);
}
private static string GenerateAnalyserItemGroup(string[] paths)
{
// <ItemGroup>
// <Analyzer Include="..\packages\Comments_analyser.1.0.6626.21356\analyzers\dotnet\cs\Comments_analyser.dll" />
// <Analyzer Include="..\packages\UnityEngineAnalyzer.1.0.0.0\analyzers\dotnet\cs\UnityEngineAnalyzer.dll" />
// </ItemGroup>
if (!paths.Any())
return string.Empty;
var analyserBuilder = new StringBuilder();
analyserBuilder.AppendLine(" <ItemGroup>");
foreach (var path in paths)
{
analyserBuilder.AppendLine($" <Analyzer Include=\"{path}\" />");
}
analyserBuilder.AppendLine(" </ItemGroup>");
return analyserBuilder.ToString();
}
private static ILookup<string, string> GetOtherArgumentsFromResponseFilesData(List<ResponseFileData> responseFilesData)
{
var paths = responseFilesData.SelectMany(x =>
{
return x.OtherArguments
.Where(a => a.StartsWith("/") || a.StartsWith("-"))
.Select(b =>
{
var index = b.IndexOf(":", StringComparison.Ordinal);
if (index > 0 && b.Length > index)
{
var key = b.Substring(1, index - 1);
return new KeyValuePair<string, string>(key, b.Substring(index + 1));
}
const string warnaserror = "warnaserror";
if (b.Substring(1).StartsWith(warnaserror))
{
return new KeyValuePair<string,string>(warnaserror, b.Substring(warnaserror.Length+ 1) );
}
return default;
});
})
.Distinct()
.ToLookup(o => o.Key, pair => pair.Value);
return paths;
}
private string GenerateLangVersion(IEnumerable<string> langVersionList)
{
var langVersion = langVersionList.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(langVersion))
return langVersion;
return k_TargetLanguageVersion;
}
private static string GenerateAnalyserRuleSet(string[] paths)
{
//<CodeAnalysisRuleSet>..\path\to\myrules.ruleset</CodeAnalysisRuleSet>
if (!paths.Any())
return string.Empty;
return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $" <CodeAnalysisRuleSet>{a}</CodeAnalysisRuleSet>"))}";
}
private static string GenerateAnalyserAdditionalFiles(string[] paths)
{
if (!paths.Any())
return string.Empty;
var analyserBuilder = new StringBuilder();
analyserBuilder.AppendLine(" <ItemGroup>");
foreach (var path in paths)
{
analyserBuilder.AppendLine($" <AdditionalFiles Include=\"{path}\" />");
}
analyserBuilder.AppendLine(" </ItemGroup>");
return analyserBuilder.ToString();
}
private static string GenerateNoWarn(string[] codes)
{
if (!codes.Any())
return string.Empty;
return $",{string.Join(",", codes)}";
}
static IEnumerable<Assembly> RelevantIslandsForMode(IEnumerable<Assembly> islands)
{
IEnumerable<Assembly> relevantIslands = islands.Where(i => ScriptingLanguage.CSharp == ScriptingLanguageFor(i));
return relevantIslands;
}
/// <summary>
/// Get a Project("{guid}") = "MyProject", "MyProject.unityproj", "{projectguid}"
/// entry for each relevant language
/// </summary>
string GetProjectEntries(IEnumerable<Assembly> islands)
{
var projectEntries = islands.Select(i => string.Format(
m_SolutionProjectEntryTemplate,
m_GUIDGenerator.SolutionGuid(m_ProjectName, GetExtensionOfSourceFiles(i.sourceFiles)),
i.name,
Path.GetFileName(ProjectFile(i)),
m_GUIDGenerator.ProjectGuid(m_ProjectName, i.name)
));
return string.Join(Environment.NewLine, projectEntries.ToArray());
}
/// <summary>
/// Generate the active configuration string for a given project guid
/// </summary>
string GetProjectActiveConfigurations(string projectGuid)
{
return string.Format(
m_SolutionProjectConfigurationTemplate,
projectGuid);
}
string EscapedRelativePathFor(string file)
{
var projectDir = ProjectDirectory.Replace('/', '\\');
file = file.Replace('/', '\\');
var path = SkipPathPrefix(file, projectDir);
var packageInfo = m_AssemblyNameProvider.FindForAssetPath(path.Replace('\\', '/'));
if (packageInfo != null)
{
// We have to normalize the path, because the PackageManagerRemapper assumes
// dir seperators will be os specific.
var absolutePath = Path.GetFullPath(NormalizePath(path)).Replace('/', '\\');
path = SkipPathPrefix(absolutePath, projectDir);
}
return SecurityElement.Escape(path);
}
static string SkipPathPrefix(string path, string prefix)
{
if (path.Replace("\\", "/").StartsWith($"{prefix}/"))
return path.Substring(prefix.Length + 1);
return path;
}
static string NormalizePath(string path)
{
if (Path.DirectorySeparatorChar == '\\')
return path.Replace('/', Path.DirectorySeparatorChar);
return path.Replace('\\', Path.DirectorySeparatorChar);
}
static string ProjectFooter()
{
return GetProjectFooterTemplate();
}
static string GetProjectExtension()
{
return ".csproj";
}
}
public static class SolutionGuidGenerator
{
public static string GuidForProject(string projectName)
{
return ComputeGuidHashFor(projectName + "salt");
}
public static string GuidForSolution(string projectName, string sourceFileExtension)
{
if (sourceFileExtension.ToLower() == "cs")
// GUID for a C# class library: http://www.codeproject.com/Reference/720512/List-of-Visual-Studio-Project-Type-GUIDs
return "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC";
return ComputeGuidHashFor(projectName);
}
static string ComputeGuidHashFor(string input)
{
var hash = MD5.Create().ComputeHash(Encoding.Default.GetBytes(input));
return HashAsGuid(HashToString(hash));
}
static string HashAsGuid(string hash)
{
var guid = hash.Substring(0, 8) + "-" + hash.Substring(8, 4) + "-" + hash.Substring(12, 4) + "-" +
hash.Substring(16, 4) + "-" + hash.Substring(20, 12);
return guid.ToUpper();
}
static string HashToString(byte[] bs)
{
var sb = new StringBuilder();
foreach (byte b in bs)
sb.Append(b.ToString("x2"));
return sb.ToString();
}
}
}
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/ProjectGeneration/ProjectGeneration.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: 7078f19173ceac84fb9e29b9f6175201
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: 7078f19173ceac84fb9e29b9f6175201
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/RiderInitializer.cs
View file @ af571a61
using System;
using System.IO;
using UnityEngine;
using Debug = UnityEngine.Debug;
namespace Packages.Rider.Editor
{
internal class RiderInitializer
{
public void Initialize(string editorPath)
{
var assembly = EditorPluginInterop.EditorPluginAssembly;
if (EditorPluginInterop.EditorPluginIsLoadedFromAssets(assembly))
{
Debug.LogError($"Please delete {assembly.Location}. Unity 2019.2+ loads it directly from Rider installation. To disable this, open Rider's settings, search and uncheck 'Automatically install and update Rider's Unity editor plugin'.");
return;
}
var dllName = "JetBrains.Rider.Unity.Editor.Plugin.Full.Repacked.dll";
var relPath = "../../plugins/rider-unity/EditorPlugin";
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
relPath = "Contents/plugins/rider-unity/EditorPlugin";
var dllFile = new FileInfo(Path.Combine(Path.Combine(editorPath, relPath), dllName));
if (dllFile.Exists)
{
var bytes = File.ReadAllBytes(dllFile.FullName);
assembly = AppDomain.CurrentDomain.Load(bytes); // doesn't lock assembly on disk
// assembly = AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(dllFile.FullName)); // use this for external source debug
EditorPluginInterop.InitEntryPoint(assembly);
}
else
{
Debug.Log($"Unable to find Rider EditorPlugin {dllFile.FullName} for Unity ");
}
}
}
}
using System;
using System.IO;
using UnityEngine;
using Debug = UnityEngine.Debug;
namespace Packages.Rider.Editor
{
internal class RiderInitializer
{
public void Initialize(string editorPath)
{
var assembly = EditorPluginInterop.EditorPluginAssembly;
if (EditorPluginInterop.EditorPluginIsLoadedFromAssets(assembly))
{
Debug.LogError($"Please delete {assembly.Location}. Unity 2019.2+ loads it directly from Rider installation. To disable this, open Rider's settings, search and uncheck 'Automatically install and update Rider's Unity editor plugin'.");
return;
}
var dllName = "JetBrains.Rider.Unity.Editor.Plugin.Full.Repacked.dll";
var relPath = "../../plugins/rider-unity/EditorPlugin";
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
relPath = "Contents/plugins/rider-unity/EditorPlugin";
var dllFile = new FileInfo(Path.Combine(Path.Combine(editorPath, relPath), dllName));
if (dllFile.Exists)
{
var bytes = File.ReadAllBytes(dllFile.FullName);
assembly = AppDomain.CurrentDomain.Load(bytes); // doesn't lock assembly on disk
// assembly = AppDomain.CurrentDomain.Load(AssemblyName.GetAssemblyName(dllFile.FullName)); // use this for external source debug
EditorPluginInterop.InitEntryPoint(assembly);
}
else
{
Debug.Log($"Unable to find Rider EditorPlugin {dllFile.FullName} for Unity ");
}
}
}
}
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/RiderInitializer.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: f5a0cc9645f0e2d4fb816156dcf3f4dd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: f5a0cc9645f0e2d4fb816156dcf3f4dd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/RiderScriptEditor.cs
View file @ af571a61
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using Packages.Rider.Editor.Util;
using Unity.CodeEditor;
using UnityEditor;
using UnityEngine;
using Debug = UnityEngine.Debug;
namespace Packages.Rider.Editor
{
[InitializeOnLoad]
public class RiderScriptEditor : IExternalCodeEditor
{
IDiscovery m_Discoverability;
IGenerator m_ProjectGeneration;
RiderInitializer m_Initiliazer = new RiderInitializer();
static RiderScriptEditor()
{
try
{
var projectGeneration = new ProjectGeneration();
var editor = new RiderScriptEditor(new Discovery(), projectGeneration);
CodeEditor.Register(editor);
var path = GetEditorRealPath(CodeEditor.CurrentEditorInstallation);
if (IsRiderInstallation(path))
{
if (!RiderScriptEditorData.instance.InitializedOnce)
{
var installations = editor.Installations;
// is toolbox and outdated - update
if (installations.Any() && RiderPathLocator.IsToolbox(path) && installations.All(a => a.Path != path))
{
var toolboxInstallations = installations.Where(a => a.Name.Contains("(JetBrains Toolbox)")).ToArray();
if (toolboxInstallations.Any())
{
var newEditor = toolboxInstallations.Last().Path;
CodeEditor.SetExternalScriptEditor(newEditor);
path = newEditor;
}
else
{
var newEditor = installations.Last().Path;
CodeEditor.SetExternalScriptEditor(newEditor);
path = newEditor;
}
}
// exists, is non toolbox and outdated - notify
if (installations.Any() && FileSystemUtil.EditorPathExists(path) && installations.All(a => a.Path != path))
{
var newEditorName = installations.Last().Name;
Debug.LogWarning($"Consider updating External Editor in Unity to Rider {newEditorName}.");
}
ShowWarningOnUnexpectedScriptEditor(path);
RiderScriptEditorData.instance.InitializedOnce = true;
}
if (!FileSystemUtil.EditorPathExists(path)) // previously used rider was removed
{
var installations = editor.Installations;
if (installations.Any())
{
var newEditor = installations.Last().Path;
CodeEditor.SetExternalScriptEditor(newEditor);
path = newEditor;
}
}
RiderScriptEditorData.instance.Init();
editor.CreateSolutionIfDoesntExist();
if (RiderScriptEditorData.instance.shouldLoadEditorPlugin)
{
editor.m_Initiliazer.Initialize(path);
}
InitProjectFilesWatcher();
}
}
catch (Exception e)
{
Debug.LogException(e);
}
}
private static void ShowWarningOnUnexpectedScriptEditor(string path)
{
// Show warning, when Unity was started from Rider, but external editor is different https://github.com/JetBrains/resharper-unity/issues/1127
var args = Environment.GetCommandLineArgs();
var commandlineParser = new CommandLineParser(args);
if (commandlineParser.Options.ContainsKey("-riderPath"))
{
var originRiderPath = commandlineParser.Options["-riderPath"];
var originRealPath = GetEditorRealPath(originRiderPath);
var originVersion = RiderPathLocator.GetBuildNumber(originRealPath);
var version = RiderPathLocator.GetBuildNumber(path);
if (originVersion != string.Empty && originVersion != version)
{
Debug.LogWarning("Unity was started by a version of Rider that is not the current default external editor. Advanced integration features cannot be enabled.");
Debug.Log($"Unity was started by Rider {originVersion}, but external editor is set to: {path}");
}
}
}
private static void InitProjectFilesWatcher()
{
var watcher = new FileSystemWatcher();
watcher.Path = Directory.GetCurrentDirectory();
watcher.NotifyFilter = NotifyFilters.LastWrite; //Watch for changes in LastWrite times
watcher.Filter = "*.*";
// Add event handlers.
watcher.Changed += OnChanged;
watcher.Created += OnChanged;
watcher.EnableRaisingEvents = true; // Begin watching.
AppDomain.CurrentDomain.DomainUnload += (EventHandler) ((_, __) =>
{
watcher.Dispose();
});
}
private static void OnChanged(object sender, FileSystemEventArgs e)
{
var extension = Path.GetExtension(e.FullPath);
if (extension == ".sln" || extension == ".csproj")
RiderScriptEditorData.instance.HasChanges = true;
}
internal static string GetEditorRealPath(string path)
{
if (string.IsNullOrEmpty(path))
{
return path;
}
if (!FileSystemUtil.EditorPathExists(path))
return path;
if (SystemInfo.operatingSystemFamily != OperatingSystemFamily.Windows)
{
var realPath = FileSystemUtil.GetFinalPathName(path);
// case of snap installation
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.Linux)
{
if (new FileInfo(path).Name.ToLowerInvariant() == "rider" &&
new FileInfo(realPath).Name.ToLowerInvariant() == "snap")
{
var snapInstallPath = "/snap/rider/current/bin/rider.sh";
if (new FileInfo(snapInstallPath).Exists)
return snapInstallPath;
}
}
// in case of symlink
return realPath;
}
return path;
}
const string unity_generate_all = "unity_generate_all_csproj";
public RiderScriptEditor(IDiscovery discovery, IGenerator projectGeneration)
{
m_Discoverability = discovery;
m_ProjectGeneration = projectGeneration;
}
private static string[] defaultExtensions
{
get
{
var customExtensions = new[] {"json", "asmdef", "log", "xaml"};
return EditorSettings.projectGenerationBuiltinExtensions.Concat(EditorSettings.projectGenerationUserExtensions)
.Concat(customExtensions).Distinct().ToArray();
}
}
private static string[] HandledExtensions
{
get
{
return HandledExtensionsString.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.TrimStart('.', '*'))
.ToArray();
}
}
private static string HandledExtensionsString
{
get { return EditorPrefs.GetString("Rider_UserExtensions", string.Join(";", defaultExtensions));}
set { EditorPrefs.SetString("Rider_UserExtensions", value); }
}
private static bool SupportsExtension(string path)
{
var extension = Path.GetExtension(path);
if (string.IsNullOrEmpty(extension))
return false;
return HandledExtensions.Contains(extension.TrimStart('.'));
}
public void OnGUI()
{
var prevGenerate = EditorPrefs.GetBool(unity_generate_all, false);
var generateAll = EditorGUILayout.Toggle("Generate all .csproj files.", prevGenerate);
if (generateAll != prevGenerate)
{
EditorPrefs.SetBool(unity_generate_all, generateAll);
}
m_ProjectGeneration.GenerateAll(generateAll);
if (RiderScriptEditorData.instance.shouldLoadEditorPlugin)
{
HandledExtensionsString = EditorGUILayout.TextField(new GUIContent("Extensions handled: "), HandledExtensionsString);
}
}
public void SyncIfNeeded(string[] addedFiles, string[] deletedFiles, string[] movedFiles, string[] movedFromFiles,
string[] importedFiles)
{
m_ProjectGeneration.SyncIfNeeded(addedFiles.Union(deletedFiles).Union(movedFiles).Union(movedFromFiles),
importedFiles);
}
public void SyncAll()
{
AssetDatabase.Refresh();
if (RiderScriptEditorData.instance.HasChanges)
{
m_ProjectGeneration.Sync();
RiderScriptEditorData.instance.HasChanges = false;
}
}
public void Initialize(string editorInstallationPath) // is called each time ExternalEditor is changed
{
RiderScriptEditorData.instance.Invalidate(editorInstallationPath);
m_ProjectGeneration.Sync(); // regenerate csproj and sln for new editor
}
public bool OpenProject(string path, int line, int column)
{
if (path != "" && !SupportsExtension(path)) // Assets - Open C# Project passes empty path here
{
return false;
}
if (path == "" && SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
{
// there is a bug in DllImplementation - use package implementation here instead https://github.cds.internal.unity3d.com/unity/com.unity.ide.rider/issues/21
return OpenOSXApp(path, line, column);
}
if (!IsUnityScript(path))
{
var fastOpenResult = EditorPluginInterop.OpenFileDllImplementation(path, line, column);
if (fastOpenResult)
return true;
}
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
{
return OpenOSXApp(path, line, column);
}
var solution = GetSolutionFile(path); // TODO: If solution file doesn't exist resync.
solution = solution == "" ? "" : $"\"{solution}\"";
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = CodeEditor.CurrentEditorInstallation,
Arguments = $"{solution} -l {line} \"{path}\"",
UseShellExecute = true,
}
};
process.Start();
return true;
}
private bool OpenOSXApp(string path, int line, int column)
{
var solution = GetSolutionFile(path); // TODO: If solution file doesn't exist resync.
solution = solution == "" ? "" : $"\"{solution}\"";
var pathArguments = path == "" ? "" : $"-l {line} \"{path}\"";
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = "open",
Arguments = $"-n \"{CodeEditor.CurrentEditorInstallation}\" --args {solution} {pathArguments}",
CreateNoWindow = true,
UseShellExecute = true,
}
};
process.Start();
return true;
}
private string GetSolutionFile(string path)
{
if (IsUnityScript(path))
{
return Path.Combine(GetBaseUnityDeveloperFolder(), "Projects/CSharp/Unity.CSharpProjects.gen.sln");
}
var solutionFile = m_ProjectGeneration.SolutionFile();
if (File.Exists(solutionFile))
{
return solutionFile;
}
return "";
}
static bool IsUnityScript(string path)
{
if (UnityEditor.Unsupported.IsDeveloperBuild())
{
var baseFolder = GetBaseUnityDeveloperFolder().Replace("\\", "/");
var lowerPath = path.ToLowerInvariant().Replace("\\", "/");
if (lowerPath.Contains((baseFolder + "/Runtime").ToLowerInvariant())
|| lowerPath.Contains((baseFolder + "/Editor").ToLowerInvariant()))
{
return true;
}
}
return false;
}
static string GetBaseUnityDeveloperFolder()
{
return Directory.GetParent(EditorApplication.applicationPath).Parent.Parent.FullName;
}
public bool TryGetInstallationForPath(string editorPath, out CodeEditor.Installation installation)
{
if (FileSystemUtil.EditorPathExists(editorPath) && IsRiderInstallation(editorPath))
{
var info = new RiderPathLocator.RiderInfo(editorPath, false);
installation = new CodeEditor.Installation
{
Name = info.Presentation,
Path = info.Path
};
return true;
}
installation = default;
return false;
}
public static bool IsRiderInstallation(string path)
{
if (IsAssetImportWorkerProcess())
return false;
if (string.IsNullOrEmpty(path))
{
return false;
}
var fileInfo = new FileInfo(path);
var filename = fileInfo.Name.ToLowerInvariant();
return filename.StartsWith("rider", StringComparison.Ordinal);
}
private static bool IsAssetImportWorkerProcess()
{
#if UNITY_2019_3_OR_NEWER
return UnityEditor.Experimental.AssetDatabaseExperimental.IsAssetImportWorkerProcess();
#else
return false;
#endif
}
public static string CurrentEditor // works fast, doesn't validate if executable really exists
=> EditorPrefs.GetString("kScriptsDefaultApp");
public CodeEditor.Installation[] Installations => m_Discoverability.PathCallback();
public void CreateSolutionIfDoesntExist()
{
if (!m_ProjectGeneration.HasSolutionBeenGenerated())
{
m_ProjectGeneration.Sync();
}
}
}
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using Packages.Rider.Editor.Util;
using Unity.CodeEditor;
using UnityEditor;
using UnityEngine;
using Debug = UnityEngine.Debug;
namespace Packages.Rider.Editor
{
[InitializeOnLoad]
public class RiderScriptEditor : IExternalCodeEditor
{
IDiscovery m_Discoverability;
IGenerator m_ProjectGeneration;
RiderInitializer m_Initiliazer = new RiderInitializer();
static RiderScriptEditor()
{
try
{
var projectGeneration = new ProjectGeneration();
var editor = new RiderScriptEditor(new Discovery(), projectGeneration);
CodeEditor.Register(editor);
var path = GetEditorRealPath(CodeEditor.CurrentEditorInstallation);
if (IsRiderInstallation(path))
{
if (!RiderScriptEditorData.instance.InitializedOnce)
{
var installations = editor.Installations;
// is toolbox and outdated - update
if (installations.Any() && RiderPathLocator.IsToolbox(path) && installations.All(a => a.Path != path))
{
var toolboxInstallations = installations.Where(a => a.Name.Contains("(JetBrains Toolbox)")).ToArray();
if (toolboxInstallations.Any())
{
var newEditor = toolboxInstallations.Last().Path;
CodeEditor.SetExternalScriptEditor(newEditor);
path = newEditor;
}
else
{
var newEditor = installations.Last().Path;
CodeEditor.SetExternalScriptEditor(newEditor);
path = newEditor;
}
}
// exists, is non toolbox and outdated - notify
if (installations.Any() && FileSystemUtil.EditorPathExists(path) && installations.All(a => a.Path != path))
{
var newEditorName = installations.Last().Name;
Debug.LogWarning($"Consider updating External Editor in Unity to Rider {newEditorName}.");
}
ShowWarningOnUnexpectedScriptEditor(path);
RiderScriptEditorData.instance.InitializedOnce = true;
}
if (!FileSystemUtil.EditorPathExists(path)) // previously used rider was removed
{
var installations = editor.Installations;
if (installations.Any())
{
var newEditor = installations.Last().Path;
CodeEditor.SetExternalScriptEditor(newEditor);
path = newEditor;
}
}
RiderScriptEditorData.instance.Init();
editor.CreateSolutionIfDoesntExist();
if (RiderScriptEditorData.instance.shouldLoadEditorPlugin)
{
editor.m_Initiliazer.Initialize(path);
}
InitProjectFilesWatcher();
}
}
catch (Exception e)
{
Debug.LogException(e);
}
}
private static void ShowWarningOnUnexpectedScriptEditor(string path)
{
// Show warning, when Unity was started from Rider, but external editor is different https://github.com/JetBrains/resharper-unity/issues/1127
var args = Environment.GetCommandLineArgs();
var commandlineParser = new CommandLineParser(args);
if (commandlineParser.Options.ContainsKey("-riderPath"))
{
var originRiderPath = commandlineParser.Options["-riderPath"];
var originRealPath = GetEditorRealPath(originRiderPath);
var originVersion = RiderPathLocator.GetBuildNumber(originRealPath);
var version = RiderPathLocator.GetBuildNumber(path);
if (originVersion != string.Empty && originVersion != version)
{
Debug.LogWarning("Unity was started by a version of Rider that is not the current default external editor. Advanced integration features cannot be enabled.");
Debug.Log($"Unity was started by Rider {originVersion}, but external editor is set to: {path}");
}
}
}
private static void InitProjectFilesWatcher()
{
var watcher = new FileSystemWatcher();
watcher.Path = Directory.GetCurrentDirectory();
watcher.NotifyFilter = NotifyFilters.LastWrite; //Watch for changes in LastWrite times
watcher.Filter = "*.*";
// Add event handlers.
watcher.Changed += OnChanged;
watcher.Created += OnChanged;
watcher.EnableRaisingEvents = true; // Begin watching.
AppDomain.CurrentDomain.DomainUnload += (EventHandler) ((_, __) =>
{
watcher.Dispose();
});
}
private static void OnChanged(object sender, FileSystemEventArgs e)
{
var extension = Path.GetExtension(e.FullPath);
if (extension == ".sln" || extension == ".csproj")
RiderScriptEditorData.instance.HasChanges = true;
}
internal static string GetEditorRealPath(string path)
{
if (string.IsNullOrEmpty(path))
{
return path;
}
if (!FileSystemUtil.EditorPathExists(path))
return path;
if (SystemInfo.operatingSystemFamily != OperatingSystemFamily.Windows)
{
var realPath = FileSystemUtil.GetFinalPathName(path);
// case of snap installation
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.Linux)
{
if (new FileInfo(path).Name.ToLowerInvariant() == "rider" &&
new FileInfo(realPath).Name.ToLowerInvariant() == "snap")
{
var snapInstallPath = "/snap/rider/current/bin/rider.sh";
if (new FileInfo(snapInstallPath).Exists)
return snapInstallPath;
}
}
// in case of symlink
return realPath;
}
return path;
}
const string unity_generate_all = "unity_generate_all_csproj";
public RiderScriptEditor(IDiscovery discovery, IGenerator projectGeneration)
{
m_Discoverability = discovery;
m_ProjectGeneration = projectGeneration;
}
private static string[] defaultExtensions
{
get
{
var customExtensions = new[] {"json", "asmdef", "log", "xaml"};
return EditorSettings.projectGenerationBuiltinExtensions.Concat(EditorSettings.projectGenerationUserExtensions)
.Concat(customExtensions).Distinct().ToArray();
}
}
private static string[] HandledExtensions
{
get
{
return HandledExtensionsString.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.TrimStart('.', '*'))
.ToArray();
}
}
private static string HandledExtensionsString
{
get { return EditorPrefs.GetString("Rider_UserExtensions", string.Join(";", defaultExtensions));}
set { EditorPrefs.SetString("Rider_UserExtensions", value); }
}
private static bool SupportsExtension(string path)
{
var extension = Path.GetExtension(path);
if (string.IsNullOrEmpty(extension))
return false;
return HandledExtensions.Contains(extension.TrimStart('.'));
}
public void OnGUI()
{
var prevGenerate = EditorPrefs.GetBool(unity_generate_all, false);
var generateAll = EditorGUILayout.Toggle("Generate all .csproj files.", prevGenerate);
if (generateAll != prevGenerate)
{
EditorPrefs.SetBool(unity_generate_all, generateAll);
}
m_ProjectGeneration.GenerateAll(generateAll);
if (RiderScriptEditorData.instance.shouldLoadEditorPlugin)
{
HandledExtensionsString = EditorGUILayout.TextField(new GUIContent("Extensions handled: "), HandledExtensionsString);
}
}
public void SyncIfNeeded(string[] addedFiles, string[] deletedFiles, string[] movedFiles, string[] movedFromFiles,
string[] importedFiles)
{
m_ProjectGeneration.SyncIfNeeded(addedFiles.Union(deletedFiles).Union(movedFiles).Union(movedFromFiles),
importedFiles);
}
public void SyncAll()
{
AssetDatabase.Refresh();
if (RiderScriptEditorData.instance.HasChanges)
{
m_ProjectGeneration.Sync();
RiderScriptEditorData.instance.HasChanges = false;
}
}
public void Initialize(string editorInstallationPath) // is called each time ExternalEditor is changed
{
RiderScriptEditorData.instance.Invalidate(editorInstallationPath);
m_ProjectGeneration.Sync(); // regenerate csproj and sln for new editor
}
public bool OpenProject(string path, int line, int column)
{
if (path != "" && !SupportsExtension(path)) // Assets - Open C# Project passes empty path here
{
return false;
}
if (path == "" && SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
{
// there is a bug in DllImplementation - use package implementation here instead https://github.cds.internal.unity3d.com/unity/com.unity.ide.rider/issues/21
return OpenOSXApp(path, line, column);
}
if (!IsUnityScript(path))
{
var fastOpenResult = EditorPluginInterop.OpenFileDllImplementation(path, line, column);
if (fastOpenResult)
return true;
}
if (SystemInfo.operatingSystemFamily == OperatingSystemFamily.MacOSX)
{
return OpenOSXApp(path, line, column);
}
var solution = GetSolutionFile(path); // TODO: If solution file doesn't exist resync.
solution = solution == "" ? "" : $"\"{solution}\"";
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = CodeEditor.CurrentEditorInstallation,
Arguments = $"{solution} -l {line} \"{path}\"",
UseShellExecute = true,
}
};
process.Start();
return true;
}
private bool OpenOSXApp(string path, int line, int column)
{
var solution = GetSolutionFile(path); // TODO: If solution file doesn't exist resync.
solution = solution == "" ? "" : $"\"{solution}\"";
var pathArguments = path == "" ? "" : $"-l {line} \"{path}\"";
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = "open",
Arguments = $"-n \"{CodeEditor.CurrentEditorInstallation}\" --args {solution} {pathArguments}",
CreateNoWindow = true,
UseShellExecute = true,
}
};
process.Start();
return true;
}
private string GetSolutionFile(string path)
{
if (IsUnityScript(path))
{
return Path.Combine(GetBaseUnityDeveloperFolder(), "Projects/CSharp/Unity.CSharpProjects.gen.sln");
}
var solutionFile = m_ProjectGeneration.SolutionFile();
if (File.Exists(solutionFile))
{
return solutionFile;
}
return "";
}
static bool IsUnityScript(string path)
{
if (UnityEditor.Unsupported.IsDeveloperBuild())
{
var baseFolder = GetBaseUnityDeveloperFolder().Replace("\\", "/");
var lowerPath = path.ToLowerInvariant().Replace("\\", "/");
if (lowerPath.Contains((baseFolder + "/Runtime").ToLowerInvariant())
|| lowerPath.Contains((baseFolder + "/Editor").ToLowerInvariant()))
{
return true;
}
}
return false;
}
static string GetBaseUnityDeveloperFolder()
{
return Directory.GetParent(EditorApplication.applicationPath).Parent.Parent.FullName;
}
public bool TryGetInstallationForPath(string editorPath, out CodeEditor.Installation installation)
{
if (FileSystemUtil.EditorPathExists(editorPath) && IsRiderInstallation(editorPath))
{
var info = new RiderPathLocator.RiderInfo(editorPath, false);
installation = new CodeEditor.Installation
{
Name = info.Presentation,
Path = info.Path
};
return true;
}
installation = default;
return false;
}
public static bool IsRiderInstallation(string path)
{
if (IsAssetImportWorkerProcess())
return false;
if (string.IsNullOrEmpty(path))
{
return false;
}
var fileInfo = new FileInfo(path);
var filename = fileInfo.Name.ToLowerInvariant();
return filename.StartsWith("rider", StringComparison.Ordinal);
}
private static bool IsAssetImportWorkerProcess()
{
#if UNITY_2019_3_OR_NEWER
return UnityEditor.Experimental.AssetDatabaseExperimental.IsAssetImportWorkerProcess();
#else
return false;
#endif
}
public static string CurrentEditor // works fast, doesn't validate if executable really exists
=> EditorPrefs.GetString("kScriptsDefaultApp");
public CodeEditor.Installation[] Installations => m_Discoverability.PathCallback();
public void CreateSolutionIfDoesntExist()
{
if (!m_ProjectGeneration.HasSolutionBeenGenerated())
{
m_ProjectGeneration.Sync();
}
}
}
}
\ No newline at end of file
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/RiderScriptEditor.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: c4095d72f77fbb64ea39b8b3ca246622
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: c4095d72f77fbb64ea39b8b3ca246622
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/RiderScriptEditorData.cs
View file @ af571a61
using System;
using UnityEditor;
using UnityEngine;
namespace Packages.Rider.Editor
{
public class RiderScriptEditorData : ScriptableSingleton<RiderScriptEditorData>
{
[SerializeField] internal bool HasChanges = true; // sln/csproj files were changed
[SerializeField] internal bool shouldLoadEditorPlugin;
[SerializeField] internal bool InitializedOnce;
[SerializeField] internal string currentEditorVersion;
public void Init()
{
if (string.IsNullOrEmpty(currentEditorVersion))
Invalidate(RiderScriptEditor.CurrentEditor);
}
public void Invalidate(string editorInstallationPath)
{
currentEditorVersion = RiderPathLocator.GetBuildNumber(editorInstallationPath);
if (!Version.TryParse(currentEditorVersion, out var version))
shouldLoadEditorPlugin = false;
shouldLoadEditorPlugin = version >= new Version("191.7141.156");
}
}
using System;
using UnityEditor;
using UnityEngine;
namespace Packages.Rider.Editor
{
public class RiderScriptEditorData : ScriptableSingleton<RiderScriptEditorData>
{
[SerializeField] internal bool HasChanges = true; // sln/csproj files were changed
[SerializeField] internal bool shouldLoadEditorPlugin;
[SerializeField] internal bool InitializedOnce;
[SerializeField] internal string currentEditorVersion;
public void Init()
{
if (string.IsNullOrEmpty(currentEditorVersion))
Invalidate(RiderScriptEditor.CurrentEditor);
}
public void Invalidate(string editorInstallationPath)
{
currentEditorVersion = RiderPathLocator.GetBuildNumber(editorInstallationPath);
if (!Version.TryParse(currentEditorVersion, out var version))
shouldLoadEditorPlugin = false;
shouldLoadEditorPlugin = version >= new Version("191.7141.156");
}
}
}
\ No newline at end of file
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/RiderScriptEditorData.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: f079e3afd077fb94fa2bda74d6409499
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: f079e3afd077fb94fa2bda74d6409499
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting.meta
View file @ af571a61
fileFormatVersion: 2
guid: a52391bc44c477f40a547ed4ef3b9560
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: a52391bc44c477f40a547ed4ef3b9560
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/CallbackData.cs
View file @ af571a61
using System;
using System.Collections.Generic;
using JetBrains.Annotations;
using UnityEditor;
namespace Packages.Rider.Editor.UnitTesting
{
public class CallbackData : ScriptableSingleton<CallbackData>
{
public bool isRider;
[UsedImplicitly] public static event EventHandler Changed = (sender, args) => { };
internal void RaiseChangedEvent()
{
Changed(null, EventArgs.Empty);
}
public List<TestEvent> events = new List<TestEvent>();
[UsedImplicitly]
public void Clear()
{
events.Clear();
}
}
using System;
using System.Collections.Generic;
using JetBrains.Annotations;
using UnityEditor;
namespace Packages.Rider.Editor.UnitTesting
{
public class CallbackData : ScriptableSingleton<CallbackData>
{
public bool isRider;
[UsedImplicitly] public static event EventHandler Changed = (sender, args) => { };
internal void RaiseChangedEvent()
{
Changed(null, EventArgs.Empty);
}
public List<TestEvent> events = new List<TestEvent>();
[UsedImplicitly]
public void Clear()
{
events.Clear();
}
}
}
\ No newline at end of file
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/CallbackData.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: 010246a07de7cb34185a2a7b1c1fad59
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: 010246a07de7cb34185a2a7b1c1fad59
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/CallbackInitializer.cs
View file @ af571a61
#if TEST_FRAMEWORK
using UnityEditor;
using UnityEditor.TestTools.TestRunner.Api;
using UnityEngine;
namespace Packages.Rider.Editor.UnitTesting
{
[InitializeOnLoad]
internal static class CallbackInitializer
{
static CallbackInitializer()
{
if (CallbackData.instance.isRider)
ScriptableObject.CreateInstance<TestRunnerApi>().RegisterCallbacks(ScriptableObject.CreateInstance<TestsCallback>(), 0);
}
}
}
#if TEST_FRAMEWORK
using UnityEditor;
using UnityEditor.TestTools.TestRunner.Api;
using UnityEngine;
namespace Packages.Rider.Editor.UnitTesting
{
[InitializeOnLoad]
internal static class CallbackInitializer
{
static CallbackInitializer()
{
if (CallbackData.instance.isRider)
ScriptableObject.CreateInstance<TestRunnerApi>().RegisterCallbacks(ScriptableObject.CreateInstance<TestsCallback>(), 0);
}
}
}
#endif
\ No newline at end of file
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/CallbackInitializer.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: aa1c6b1a353ab464782fc1e7c051eb02
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: aa1c6b1a353ab464782fc1e7c051eb02
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/RiderTestRunner.cs
View file @ af571a61
using JetBrains.Annotations;
using UnityEngine;
#if TEST_FRAMEWORK
using UnityEditor;
using UnityEditor.TestTools.TestRunner.Api;
#endif
namespace Packages.Rider.Editor.UnitTesting
{
public static class RiderTestRunner
{
#if TEST_FRAMEWORK
private static readonly TestsCallback Callback = ScriptableObject.CreateInstance<TestsCallback>();
#endif
[UsedImplicitly]
public static void RunTests(int testMode, string[] assemblyNames, string[] testNames, string[] categoryNames, string[] groupNames, int? buildTarget)
{
#if !TEST_FRAMEWORK
Debug.LogError("Update Test Framework package to v.1.1.1+ to run tests from Rider.");
#else
CallbackData.instance.isRider = true;
var api = ScriptableObject.CreateInstance<TestRunnerApi>();
var settings = new ExecutionSettings();
var filter = new Filter
{
assemblyNames = assemblyNames,
testNames = testNames,
categoryNames = categoryNames,
groupNames = groupNames,
targetPlatform = (BuildTarget?) buildTarget
};
if (testMode > 0) // for future use - test-framework would allow running both Edit and Play test at once
filter.testMode = (TestMode) testMode;
settings.filters = new []{
filter
};
api.Execute(settings);
api.UnregisterCallbacks(Callback); // avoid multiple registrations
api.RegisterCallbacks(Callback); // This can be used to receive information about when the test suite and individual tests starts and stops. Provide this with a scriptable object implementing ICallbacks
#endif
}
}
using JetBrains.Annotations;
using UnityEngine;
#if TEST_FRAMEWORK
using UnityEditor;
using UnityEditor.TestTools.TestRunner.Api;
#endif
namespace Packages.Rider.Editor.UnitTesting
{
public static class RiderTestRunner
{
#if TEST_FRAMEWORK
private static readonly TestsCallback Callback = ScriptableObject.CreateInstance<TestsCallback>();
#endif
[UsedImplicitly]
public static void RunTests(int testMode, string[] assemblyNames, string[] testNames, string[] categoryNames, string[] groupNames, int? buildTarget)
{
#if !TEST_FRAMEWORK
Debug.LogError("Update Test Framework package to v.1.1.1+ to run tests from Rider.");
#else
CallbackData.instance.isRider = true;
var api = ScriptableObject.CreateInstance<TestRunnerApi>();
var settings = new ExecutionSettings();
var filter = new Filter
{
assemblyNames = assemblyNames,
testNames = testNames,
categoryNames = categoryNames,
groupNames = groupNames,
targetPlatform = (BuildTarget?) buildTarget
};
if (testMode > 0) // for future use - test-framework would allow running both Edit and Play test at once
filter.testMode = (TestMode) testMode;
settings.filters = new []{
filter
};
api.Execute(settings);
api.UnregisterCallbacks(Callback); // avoid multiple registrations
api.RegisterCallbacks(Callback); // This can be used to receive information about when the test suite and individual tests starts and stops. Provide this with a scriptable object implementing ICallbacks
#endif
}
}
}
\ No newline at end of file
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/RiderTestRunner.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: 5c3b27069cb3ddf42ba1260eeefcdd1c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: 5c3b27069cb3ddf42ba1260eeefcdd1c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/TestEvent.cs
View file @ af571a61
using System;
using NUnit.Framework.Interfaces;
namespace Packages.Rider.Editor.UnitTesting
{
[Serializable]
public enum EventType { TestStarted, TestFinished, RunFinished }
[Serializable]
public class TestEvent
{
public EventType type;
public string id;
public string assemblyName;
public string output;
public TestStatus testStatus;
public double duration;
public string parentId;
public TestEvent(EventType type, string id, string assemblyName, string output, double duration, TestStatus testStatus, string parentID)
{
this.type = type;
this.id = id;
this.assemblyName = assemblyName;
this.output = output;
this.testStatus = testStatus;
this.duration = duration;
parentId = parentID;
}
}
using System;
using NUnit.Framework.Interfaces;
namespace Packages.Rider.Editor.UnitTesting
{
[Serializable]
public enum EventType { TestStarted, TestFinished, RunFinished }
[Serializable]
public class TestEvent
{
public EventType type;
public string id;
public string assemblyName;
public string output;
public TestStatus testStatus;
public double duration;
public string parentId;
public TestEvent(EventType type, string id, string assemblyName, string output, double duration, TestStatus testStatus, string parentID)
{
this.type = type;
this.id = id;
this.assemblyName = assemblyName;
this.output = output;
this.testStatus = testStatus;
this.duration = duration;
parentId = parentID;
}
}
}
\ No newline at end of file
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/TestEvent.cs.meta
View file @ af571a61
fileFormatVersion: 2
guid: f9413c47b3a14a64e8810ce76d1a6032
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
fileFormatVersion: 2
guid: f9413c47b3a14a64e8810ce76d1a6032
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
MathTec/Library/PackageCache/com.unity.ide.rider@1.1.4/Rider/Editor/UnitTesting/TestsCallback.cs
View file @ af571a61
#if TEST_FRAMEWORK
using System;
using System.Text;
using UnityEditor.TestTools.TestRunner.Api;
using UnityEngine;
namespace Packages.Rider.Editor.UnitTesting
{
public class TestsCallback : ScriptableObject, ICallbacks
{
public void RunFinished(ITestResultAdaptor result)
{
CallbackData.instance.isRider = false;
CallbackData.instance.events.Add(
new TestEvent(EventType.RunFinished, "", "","", 0, ParseTestStatus(result.TestStatus), ""));
CallbackData.instance.RaiseChangedEvent();
}
public void TestStarted(ITestAdaptor result)
{
if (result.Method == null) return;
CallbackData.instance.events.Add(
new TestEvent(EventType.TestStarted, GetUniqueName(result), result.Method.TypeInfo.Assembly.GetName().Name, "", 0, ParseTestStatus(TestStatus.Passed), result.ParentFullName));
CallbackData.instance.RaiseChangedEvent();
}
public void TestFinished(ITestResultAdaptor result)
{
if (result.Test.Method == null) return;
CallbackData.instance.events.Add(
new TestEvent(EventType.TestFinished, GetUniqueName(result.Test), result.Test.Method.TypeInfo.Assembly.GetName().Name, ExtractOutput(result), result.Duration, ParseTestStatus(result.TestStatus), result.Test.ParentFullName));
CallbackData.instance.RaiseChangedEvent();
}
// todo: reimplement JetBrains.Rider.Unity.Editor.AfterUnity56.UnitTesting.TestEventsSender.GetUniqueName
private static string GetUniqueName(ITestAdaptor test)
{
string str = test.FullName;
return str;
}
public void RunStarted(ITestAdaptor testsToRun)
{
}
private static NUnit.Framework.Interfaces.TestStatus ParseTestStatus(TestStatus testStatus)
{
return (NUnit.Framework.Interfaces.TestStatus)Enum.Parse(typeof(NUnit.Framework.Interfaces.TestStatus), testStatus.ToString());
}
private static string ExtractOutput(ITestResultAdaptor testResult)
{
var stringBuilder = new StringBuilder();
if (testResult.Message != null)
{
stringBuilder.AppendLine("Message: ");
stringBuilder.AppendLine(testResult.Message);
}
if (!string.IsNullOrEmpty(testResult.Output))
{
stringBuilder.AppendLine("Output: ");
stringBuilder.AppendLine(testResult.Output);
}
if (!string.IsNullOrEmpty(testResult.StackTrace))
{
stringBuilder.AppendLine("Stacktrace: ");
stringBuilder.AppendLine(testResult.StackTrace);
}
var result = stringBuilder.ToString();
if (result.Length > 0)
return result;
return testResult.Output ?? string.Empty;
}
}
}
#if TEST_FRAMEWORK
using System;
using System.Text;
using UnityEditor.TestTools.TestRunner.Api;
using UnityEngine;
namespace Packages.Rider.Editor.UnitTesting
{
public class TestsCallback : ScriptableObject, ICallbacks
{
public void RunFinished(ITestResultAdaptor result)
{
CallbackData.instance.isRider = false;
CallbackData.instance.events.Add(
new TestEvent(EventType.RunFinished, "", "","", 0, ParseTestStatus(result.TestStatus), ""));
CallbackData.instance.RaiseChangedEvent();
}
public void TestStarted(ITestAdaptor result)
{
if (result.Method == null) return;
CallbackData.instance.events.Add(
new TestEvent(EventType.TestStarted, GetUniqueName(result), result.Method.TypeInfo.Assembly.GetName().Name, "", 0, ParseTestStatus(TestStatus.Passed), result.ParentFullName));
CallbackData.instance.RaiseChangedEvent();
}
public void TestFinished(ITestResultAdaptor result)
{
if (result.Test.Method == null) return;
CallbackData.instance.events.Add(
new TestEvent(EventType.TestFinished, GetUniqueName(result.Test), result.Test.Method.TypeInfo.Assembly.GetName().Name, ExtractOutput(result), result.Duration, ParseTestStatus(result.TestStatus), result.Test.ParentFullName));
CallbackData.instance.RaiseChangedEvent();
}
// todo: reimplement JetBrains.Rider.Unity.Editor.AfterUnity56.UnitTesting.TestEventsSender.GetUniqueName
private static string GetUniqueName(ITestAdaptor test)
{
string str = test.FullName;
return str;
}
public void RunStarted(ITestAdaptor testsToRun)
{
}
private static NUnit.Framework.Interfaces.TestStatus ParseTestStatus(TestStatus testStatus)
{
return (NUnit.Framework.Interfaces.TestStatus)Enum.Parse(typeof(NUnit.Framework.Interfaces.TestStatus), testStatus.ToString());
}
private static string ExtractOutput(ITestResultAdaptor testResult)
{
var stringBuilder = new StringBuilder();
if (testResult.Message != null)
{
stringBuilder.AppendLine("Message: ");
stringBuilder.AppendLine(testResult.Message);
}
if (!string.IsNullOrEmpty(testResult.Output))
{
stringBuilder.AppendLine("Output: ");
stringBuilder.AppendLine(testResult.Output);
}
if (!string.IsNullOrEmpty(testResult.StackTrace))
{
stringBuilder.AppendLine("Stacktrace: ");
stringBuilder.AppendLine(testResult.StackTrace);
}
var result = stringBuilder.ToString();
if (result.Length > 0)
return result;
return testResult.Output ?? string.Empty;
}
}
}
#endif
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment