public SolutionTreeNode(ISolutionAssemblyList solutionAssemblyList)
{
if (solutionAssemblyList == null)
throw new ArgumentNullException("solutionAssemblyList");
this.solutionAssemblyList = solutionAssemblyList;
this.solution = solutionAssemblyList.Solution;
}
public TestableSolutionPackageRepository (
ISolution solution,
IMonoDevelopPackageRepositoryFactory repositoryFactory,
PackageManagementOptions options)
: base (solution, repositoryFactory, options)
{
}
public CheckReadyStatusModule(ISolution solution)
{
Post["/checkreadystatus"] = x =>
{
return Response.AsJson(solution.Loaded);
};
}
public void Execute(ISolution solution, ITextControl textControl)
{
// TODO extract add attribute to another class
// method name IDeclaredParameter AddDeclaredParameter()
if (missedParameterError.Descriptor.IsAttribute)
{
IDocument document = textControl.Document;
using (ModificationCookie cookie = document.EnsureWritable())
{
int navigationOffset = -1;
try
{
CommandProcessor.Instance.BeginCommand("TextControl:AddAttribute");
string toInsert = " " + this.missedParameterError.Descriptor.Name + "=\"\"";
document.InsertText(this.headerNameRange.TextRange.EndOffset, toInsert);
navigationOffset = (this.headerNameRange.TextRange.EndOffset + toInsert.Length) - 1;
}
finally
{
CommandProcessor.Instance.EndCommand();
}
if (navigationOffset != -1)
{
textControl.CaretModel.MoveTo(navigationOffset, TextControlScrollType.MAKE_VISIBLE);
// todo run Completion Action
}
}
}
else
{
Assert.Fail();
}
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
ITreeNode element = Utils.GetElementAtCaret(solution, textControl);
IBlock containingBlock = element.GetContainingNode<IBlock>(true);
if (containingBlock != null)
{
//// CSharpFormatterHelper.FormatterInstance.Format(containingBlock);
ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter;
codeFormatter.Format(containingBlock);
new LayoutRules().CurlyBracketsForMultiLineStatementsMustNotShareLine(containingBlock);
}
else
{
IFieldDeclaration fieldDeclarationNode = element.GetContainingNode<IFieldDeclaration>(true);
if (fieldDeclarationNode != null)
{
//// CSharpFormatterHelper.FormatterInstance.Format(fieldDeclarationNode);
ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter;
codeFormatter.Format(fieldDeclarationNode);
new LayoutRules().CurlyBracketsForMultiLineStatementsMustNotShareLine(fieldDeclarationNode);
}
}
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
string documentation = this.DocumentRange.GetText();
Regex regEx = new Regex("(((///[ ^ ] *)))|((///))");
documentation = regEx.Replace(documentation, "/// ");
textControl.Document.ReplaceText(this.DocumentRange.TextRange, documentation);
}
/// <summary>
/// Creates a new instance of the <see cref="WindowsFileImporter"/> class.
/// </summary>
public WindowsFileImporter(ISolution solution, IUriReferenceService uriService, IProductElement currentElement, string targetPath)
{
this.solution = solution;
this.uriService = uriService;
this.currentElement = currentElement;
this.targetPath = targetPath;
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
IElement element = Utils.GetElementAtCaret(solution, textControl);
if (element == null)
{
return;
}
IUsingListNode usingList = element.GetContainingElement(typeof(IUsingListNode), false) as IUsingListNode;
if (usingList == null)
{
return;
}
ICSharpFile file = Utils.GetCSharpFile(solution, textControl);
// This violation will only run if there are some using statements and definately at least 1 namespace
// so [0] index will always be OK.
ICSharpNamespaceDeclaration firstNamespace = file.NamespaceDeclarations[0];
foreach (IUsingDirectiveNode usingDirectiveNode in usingList.Imports)
{
firstNamespace.AddImportBefore(usingDirectiveNode, null);
file.RemoveImport(usingDirectiveNode);
}
}
public override async Task<IProject> Generate(ISolution solution, string name)
{
var shell = IoC.Get<IShell>();
var project = await base.Generate(solution, name);
project.ToolChain = shell.ToolChains.FirstOrDefault(tc => tc is LocalGCCToolchain);
project.ToolChain.ProvisionSettings(project);
project.Debugger = shell.Debuggers.FirstOrDefault(db => db is LocalDebugAdaptor);
var code = new StringBuilder();
code.AppendLine("#include <stdio.h>");
code.AppendLine();
code.AppendLine("int main (void)");
code.AppendLine("{");
code.AppendLine(" printf(\"Hello World\");");
code.AppendLine(" return 0;");
code.AppendLine("}");
code.AppendLine();
await SourceFile.Create(project, "main.cpp", code.ToString());
project.Save();
return project;
}
public IPackageInitializationScripts CreatePackageInitializationScripts(
ISolution solution)
{
var repository = new SolutionPackageRepository(solution);
var scriptFactory = new PackageScriptFactory();
return new PackageInitializationScripts(repository, scriptFactory);
}
public void Initialize()
{
this.solutionEvents = new SolutionEvents(VsIdeTestHostContext.ServiceProvider);
this.solution = VsIdeTestHostContext.ServiceProvider.GetService<ISolution>();
this.solution.CreateInstance(Path.GetTempPath(), Path.GetFileName(Path.GetRandomFileName()));
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
ICSharpFile file = Utils.GetCSharpFile(solution, textControl);
// Fixes SA1639
DocumentationRules.InsertFileHeaderSummary(file);
}
public SolutionPackageRepository(ISolution solution)
: this(
solution,
new SharpDevelopPackageRepositoryFactory(),
PackageManagementServices.Options)
{
}
internal CorrectAllSignaturesInSolution(ISolution solution, SyntaxNode declaration,
IEnumerable<Tuple<int, int>> mappings)
{
this.solution = solution;
this.declaration = declaration;
this.mappings = mappings;
}
protected override Action<ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
if (_invocationExpression.ArgumentList.Arguments.Count == 4)
{
_invocationExpression.RemoveArgument(_invocationExpression.ArgumentList.Arguments[3]);
var argument = Provider.ElementFactory.CreateArgument(ParameterKind.VALUE, Provider.ElementFactory.CreateExpression("false"));
_invocationExpression.AddArgumentAfter(argument, _invocationExpression.ArgumentList.Arguments[2]);
}
else
{
if (_invocationExpression.ArgumentList.Arguments.Count == 1)
{
var argument = Provider.ElementFactory.CreateArgument(ParameterKind.VALUE, Provider.ElementFactory.CreateExpression("default($0)", PropertyDeclaration.Type));
_invocationExpression.AddArgumentAfter(argument, _invocationExpression.ArgumentList.Arguments[0]);
}
if (_invocationExpression.ArgumentList.Arguments.Count == 2)
{
var argument = Provider.ElementFactory.CreateArgument(ParameterKind.VALUE, Provider.ElementFactory.CreateExpression("null"));
_invocationExpression.AddArgumentAfter(argument, _invocationExpression.ArgumentList.Arguments[1]);
}
if (_invocationExpression.ArgumentList.Arguments.Count == 3)
{
var argument = Provider.ElementFactory.CreateArgument(ParameterKind.VALUE, Provider.ElementFactory.CreateExpression("false"));
_invocationExpression.AddArgumentAfter(argument, _invocationExpression.ArgumentList.Arguments[2]);
}
}
return null;
}
protected override Action<ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
ITypeDeclaration typeDeclaration = GetTargetTypeDeclaration(_highlighting.DeclaredTypeUsage);
if (typeDeclaration == null)
return null;
MemberSignature signature = CreateTransformTextSignature(typeDeclaration);
TypeTarget target = CreateTarget(typeDeclaration);
var context = new CreateMethodDeclarationContext {
AccessRights = AccessRights.PUBLIC,
ExecuteTemplateOverMemberBody = false,
ExecuteTemplateOverName = false,
ExecuteTemplateOverParameters = false,
ExecuteTemplateOverReturnType = false,
IsAbstract = true,
IsStatic = false,
MethodSignatures = new[] { signature },
MethodName = T4CSharpCodeGenerator.TransformTextMethodName,
SourceReferenceExpressionReference = null,
Target = target,
};
IntentionResult intentionResult = MethodDeclarationBuilder.Create(context);
intentionResult.ExecuteTemplate();
return null;
}
public SolutionPackageRepositoryPath (
ISolution solution,
PackageManagementOptions options)
{
this.solution = solution;
PackageRepositoryPath = GetSolutionPackageRepositoryPath (options);
}
public Bootstrapper(ISolution solution, IFileSystem fileSystem, bool verbose)
{
_fileSystem = fileSystem;
_solution = solution;
_verbose = verbose;
JsonSettings.MaxJsonLength = int.MaxValue;
}
/// <inheritdoc />
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
IDeclaration declaration = Utils.GetTypeClosestToTextControl<IDeclaration>(solution, textControl);
// Fixes SA1604, 1605
new DocumentationRules().InsertMissingSummaryElement(declaration);
}
void CreateSolution(string fileName)
{
solution = MockRepository.GenerateStrictMock<ISolution>();
var file = FileName.Create(fileName);
solution.Stub(s => s.FileName).Return(file);
solution.Stub(s => s.Directory).Return(file.GetParentDirectory());
}
public ZenCodingEngine(ISolution solution)
{
ScriptEngine engine = Python.CreateEngine();
ScriptScope scope = engine.CreateScope();
string folder = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
var searchPaths = new List<string>(engine.GetSearchPaths())
{
Path.Combine(folder, "zencoding"), Path.Combine(folder, "sys")
};
engine.SetSearchPaths(searchPaths);
var code = new StringBuilder()
.AppendLine("import zen_settings")
.AppendLine("import zen_core")
.AppendLine("from zen_core import *")
.AppendLine("from zen_settings import zen_settings")
.AppendFormat("zen_core.insertion_point = '{0}'", InsertionPoint)
.AppendLine()
.AppendFormat("zen_settings['variables']['indentation'] = '{0}'", GlobalFormatSettingsHelper.GetService(solution).GetSettingsForLanguage(PsiLanguageType.ANY).GetIndentStr())
.AppendLine()
.AppendFormat("zen_core.newline = '{0}'", Regex.Escape(Environment.NewLine))
.AppendLine();
ScriptSource source = engine.CreateScriptSourceFromString(code.ToString(), SourceCodeKind.Statements);
source.Execute(scope);
expandAbbr = engine.GetVariable<Func<string, string, string>>(scope, "expand_abbreviation");
PadString = engine.GetVariable<Func<string, int, string>>(scope, "pad_string");
findAbbrInLine = engine.GetVariable<Func<string, int, PythonTuple>>(scope, "find_abbr_in_line");
wrapWithAbbr = engine.GetVariable<Func<string, string, string, string>>(scope, "wrap_with_abbreviation");
}
public static IUnitTestElement ReadFromXml(XmlElement parent, IUnitTestElement parentElement, MSpecUnitTestProvider provider, ISolution solution
#if RESHARPER_61
, IUnitTestElementManager manager, PsiModuleManager psiModuleManager, CacheManager cacheManager
#endif
)
{
var projectId = parent.GetAttribute("projectId");
var project = ProjectUtil.FindProjectElementByPersistentID(solution, projectId) as IProject;
if (project == null)
{
return null;
}
var context = parentElement as ContextElement;
if (context == null)
{
return null;
}
var typeName = parent.GetAttribute("typeName");
var methodName = parent.GetAttribute("methodName");
var isIgnored = bool.Parse(parent.GetAttribute("isIgnored"));
return ContextSpecificationFactory.GetOrCreateContextSpecification(provider,
#if RESHARPER_61
manager, psiModuleManager, cacheManager,
#endif
project, context, ProjectModelElementEnvoy.Create(project), new ClrTypeName(typeName), methodName, EmptyArray<string>.Instance, isIgnored);
}
MonitoredSolution FindMonitoredSolution (ISolution solutionToMatch)
{
if (monitoredSolutions.Count == 1)
return monitoredSolutions [0];
return monitoredSolutions.FirstOrDefault (monitoredSolution => monitoredSolution.Solution.FileName == solutionToMatch.FileName);
}
public static IUnitTestElement ReadFromXml(XmlElement parent, IUnitTestElement parentElement, MSpecUnitTestProvider provider, ISolution solution
#if RESHARPER_61
, IUnitTestElementManager manager, PsiModuleManager psiModuleManager, CacheManager cacheManager
#endif
)
{
var projectId = parent.GetAttribute("projectId");
var project = ProjectUtil.FindProjectElementByPersistentID(solution, projectId) as IProject;
if (project == null)
{
return null;
}
var behavior = parentElement as BehaviorElement;
if (behavior == null)
{
return null;
}
var typeName = parent.GetAttribute("typeName");
var methodName = parent.GetAttribute("methodName");
var isIgnored = bool.Parse(parent.GetAttribute("isIgnored"));
return BehaviorSpecificationFactory.GetOrCreateBehaviorSpecification(provider,
#if RESHARPER_61
manager, psiModuleManager, cacheManager,
#endif
project, behavior, ProjectModelElementEnvoy.Create(project), typeName, methodName, isIgnored);
}
/// <summary>
/// Executes QuickFix or ContextAction. Returns post-execute method.
/// </summary>
/// <param name="solution">The solution.</param>
/// <param name="progress">The progress.</param>
/// <returns>Action to execute after document and PSI transaction finish. Use to open TextControls, navigate caret, etc.</returns>
protected override Action<ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var model = this.GetModel();
if (model == null)
{
return null;
}
var code = model.Method.GetText();
if (string.IsNullOrEmpty(code))
{
return null;
}
var typeMember = this.provider.ElementFactory.CreateTypeMemberDeclaration(code);
var classDeclaration = model.ContainingType as IClassLikeDeclaration;
if (classDeclaration == null)
{
return null;
}
var memberDeclaration = typeMember as IClassMemberDeclaration;
Debug.Assert(memberDeclaration != null, "memberDeclaration != null");
var result = classDeclaration.AddClassMemberDeclarationBefore(memberDeclaration, model.Method);
FormattingUtils.Format(result);
return null;
}
/// <summary>
/// Executes action. Called after Update, that set <c>ActionPresentation.Enabled</c> to true.
/// </summary>
/// <param name="solution">The solution.</param>
/// <param name="context">The context.</param>
protected override void Execute(ISolution solution, IDataContext context)
{
if (!context.CheckAllNotNull(DataConstants.SOLUTION)) {
return;
}
ITextControl textControl = context.GetData(DataConstants.TEXT_CONTROL);
if (textControl == null) {
return;
}
IElement element = GetElementAtCaret(context);
if (element == null) {
return;
}
var enumDeclaration = element.ToTreeNode().Parent as IEnumDeclaration;
if (enumDeclaration == null) {
return;
}
using (ModificationCookie cookie = textControl.Document.EnsureWritable()) {
if (cookie.EnsureWritableResult != EnsureWritableResult.SUCCESS) {
return;
}
using (CommandCookie.Create("Context Action Sort Enum By Name")) {
PsiManager.GetInstance(solution).DoTransaction(delegate { Execute(solution, enumDeclaration); });
}
}
}
/// <summary>
/// Loads the specified solution.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
public void LoadChanges(ISolution solution)
{
this.solution = solution;
var locations = RecentFilesManager.GetInstance(solution).EditLocations;
var count = 0;
foreach (var locationInfo in locations)
{
var projectFile = locationInfo.ProjectFile;
var project = projectFile.GetProject();
var solutionName = project.GetSolution().Name;
var fileName = projectFile.Location.ConvertToRelativePath(project.Location).FullPath;
int line;
int position;
int selectionStart;
int selectionLength;
if (EditorManager.GetInstance(solution).IsOpenedInTextControl(projectFile))
{
var textControl = EditorManager.GetInstance(solution).TryGetTextControl(projectFile);
if (textControl == null)
{
return;
}
var documentText = textControl.Document.GetText();
ReadText(new StringReader(documentText), locationInfo.CaretOffset, out line, out position, out selectionStart, out selectionLength);
}
else
{
ReadFile(projectFile, locationInfo.CaretOffset, out line, out position, out selectionStart, out selectionLength);
}
var labelText = "<" + solutionName + ">\\" + fileName + " (Ln " + line + ", Col " + position + ")";
var l = new Selection
{
Text = labelText,
SelectionStart = selectionStart,
SelectionLength = selectionLength,
};
this.Listbox.Items.Add(l);
count++;
if (count >= 25)
{
break;
}
}
if (this.Listbox.Items.Count > 0)
{
this.Listbox.SelectedIndex = 0;
}
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
ICSharpFile file = Utils.GetCSharpFile(solution, textControl);
IRangeMarker marker = this.DocumentRange.CreateRangeMarker();
file.ArrangeThisQualifier(marker);
}
protected override Action<ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
var methodDeclaration = _highlighting.MethodDeclaration;
methodDeclaration.SetExtern(true);
methodDeclaration.SetStatic(true);
return null;
}
public RenameHandler(ISolution solution, BufferParser bufferParser, OmniSharpConfiguration config, FindUsagesHandler findUsagesHandler)
{
_solution = solution;
_bufferParser = bufferParser;
_findUsagesHandler = findUsagesHandler;
_config = config;
}
public override void Accept(
ITextControl textControl, DocumentRange nameRange,
LookupItemInsertType insertType, Suffix suffix, ISolution solution, bool keepCaretStill)
{
var psiServices = solution.GetPsiServices();
var updateMethodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl);
if (UpdateExistingMethod(updateMethodDeclaration, psiServices))
{
return;
}
var isCoroutine = updateMethodDeclaration?.TypeUsage is IUserTypeUsage userTypeUsage &&
userTypeUsage.ScalarTypeName?.ShortName == "IEnumerator";
var fixedNameRange = nameRange.SetStartTo(Info.MemberReplaceRanges.InsertRange.StartOffset);
var memberRange = Info.MemberReplaceRanges.GetAcceptRange(fixedNameRange, insertType);
// Insert a dummy method declaration, as text, which means the PSI is reparsed. This will remove empty type
// usages and merge leading attributes into a method declaration, such that we can copy them and replace
// them once the declared element has expanded. This also fixes up the case where the type usage picks up
// the attribute of the next code construct as an array specifier. E.g. `OnAni{caret} [SerializeField]`
using (WriteLockCookie.Create())
{
textControl.Document.ReplaceText(memberRange, "void Foo(){}");
}
psiServices.Files.CommitAllDocuments();
var methodDeclaration = TextControlToPsi.GetElement <IMethodDeclaration>(solution, textControl);
if (methodDeclaration == null)
{
return;
}
var methodDeclarationCopy = methodDeclaration.Copy();
var nodesBeforeCopyRange = NodesBeforeMethodHeader(methodDeclarationCopy);
using (new PsiTransactionCookie(psiServices, DefaultAction.Commit, "RemoveInsertedDeclaration"))
using (WriteLockCookie.Create())
{
LowLevelModificationUtil.DeleteChild(methodDeclaration);
}
var classDeclaration = TextControlToPsi.GetElement <IClassLikeDeclaration>(solution, textControl);
Assertion.AssertNotNull(classDeclaration, "classDeclaration != null");
var factory = CSharpElementFactory.GetInstance(classDeclaration);
GenerateCodeWorkflowBase.ExecuteNonInteractive(
GeneratorUnityKinds.UnityEventFunctions, solution, textControl, methodDeclaration.Language,
configureContext: context =>
{
// Note that the generated code will use the access rights, if specified. However, if they haven't
// been specified (NONE) or they are the default for methods (PRIVATE), the generated code will be
// whatever the current code style setting is - implicit or explicit
var knownTypesCache = solution.GetComponent <KnownTypesCache>();
var declaredElement = myEventFunction.CreateDeclaration(factory, knownTypesCache, classDeclaration,
myAccessRights, makeCoroutine: isCoroutine)
.DeclaredElement.NotNull("declaredElement != null");
context.InputElements.Clear();
context.InputElements.Add(new GeneratorDeclaredElement(declaredElement));
},
onCompleted: context =>
{
if (nodesBeforeCopyRange.IsEmpty)
{
return;
}
foreach (var outputElement in context.OutputElements)
{
if (outputElement is GeneratorDeclarationElement declarationElement)
{
using (new PsiTransactionCookie(psiServices, DefaultAction.Commit, "BringBackAttributes"))
using (WriteLockCookie.Create())
{
var newDeclaration = declarationElement.Declaration;
ModificationUtil.AddChildRangeAfter(newDeclaration, anchor: null, nodesBeforeCopyRange);
}
return;
}
}
});
ITreeRange NodesBeforeMethodHeader(IMethodDeclaration declaration)
{
var firstNode = declaration.ModifiersList ?? declaration.TypeUsage as ITreeNode;
var smthBeforeTypeUsage = firstNode?.PrevSibling;
if (smthBeforeTypeUsage == null)
{
return(TreeRange.Empty);
}
return(new TreeRange(declaration.FirstChild, smthBeforeTypeUsage));
}
}
public void SetUp()
{
Solution = new FakeSolution(@"c:\test\fake.sln");
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution _, IProgressIndicator __)
{
Highlighting.MethodDeclaration.RemoveParameterDeclaration(Highlighting.ParameterDeclaration);
return(null);
}
public ProjectReference(ISolution solution, string projectTitle, Guid projectGuid)
{
_solution = solution;
_projectTitle = projectTitle;
_projectGuid = projectGuid;
}
public AddReferenceHandler(ISolution solution, IAddReferenceProcessorFactory addReferenceProcessorFactory)
{
_solution = solution;
_addReferenceProcessorFactory = addReferenceProcessorFactory;
}
public UnityAssetRiderUsageGroupingProjectItemProvider(ISolution solution, ProjectModelIcons projectModelIcons, IconHost iconHost)
{
mySolution = solution;
myProjectModelIcons = projectModelIcons;
myIconHost = iconHost;
}
public abstract IProject Load(ISolution solution, string filePath);
internal SolutionItem(ISolution f, IEnumerable <IDependentItemRef> projects)
{
_solution = f;
_projects = projects;
}
public UnityPluginDetector(ISolution solution, ILogger logger)
{
mySolution = solution;
myLogger = logger;
}
/// <summary>
/// Creates a new <see cref="SolutionDependencyContext"/>, possibly for a different subset of projects
/// of the <see cref="Solutions"/> than the default set (all projects except build projects).
/// </summary>
/// <param name="m">The monitor to use.</param>
/// <param name="traceGraphDetails">True to trace the details of the input and output (sorted) graphs.</param>
/// <param name="projectFilter">
/// Optional project filter.
/// By default all projects are considered except build projects (see <see cref="Solution.BuildProject"/>).
/// </param>
/// <returns>The context or null on error.</returns>
public SolutionDependencyContext CreateDependencyContext(IActivityMonitor m, bool traceGraphDetails, Func <IProject, bool> projectFilter = null)
{
if (projectFilter == null)
{
projectFilter = p => !p.IsBuildProject;
}
var sortables = new Dictionary <ISolution, SolutionItem>();
foreach (var s in _solutions)
{
// The Solution contains its Projects.
var children = s.Projects.Where(p => projectFilter(p)).Select(p => _projects[p]);
var sItem = new SolutionItem(s, children);
sortables.Add(s, sItem);
}
var options = new DependencySorterOptions();
if (traceGraphDetails)
{
options.HookInput = i => i.Debug(m);
options.HookOutput = i => i.Debug(m);
}
IDependencySorterResult result = DependencySorter.OrderItems(m, sortables.Values, null, options);
if (!result.IsComplete)
{
result.LogError(m);
return(new SolutionDependencyContext(this, result, GetBuildProjectInfo(m)));
}
// Building the list of SolutionDependencyContext.DependencyRow.
var table = result.SortedItems
// 1 - Selects solutions along with their ordered index.
.Where(sorted => sorted.GroupForHead == null && sorted.Item is SolutionItem)
.Select(sorted =>
(
Solution: (Solution)sorted.StartValue,
// The projects from this solution that reference packages that are
// produced by local solutions have a direct requires to a Package
// that has a local Project.
// 2 - First Map: LocalRefs is a set of value tuple (Project Origin, Package Target).
LocalRefs: sorted.Children
.Select(c => (SProject: c, Project: (Project)c.StartValue))
.SelectMany(c => c.SProject.DirectRequires
.Select(r => r.Item)
.OfType <LocalPackageItem>()
.Select(package => (Origin: c.Project, Target: package))
)))
// 3 - Second Map: Expands the LocalRefs.
.SelectMany(s => s.LocalRefs.Any()
? s.LocalRefs.Select(r => new DependentSolution.Row
(
s.Solution,
r.Origin,
r.Target.Project
))
: new[] { new DependentSolution.Row(s.Solution, null, null) }
)
.ToList();
// Now that the table of SolutionDependencyContext.DependencyRow is built, use it to compute the
// pure solution dependency graph.
//
var index = new Dictionary <object, DependentSolution>();
ISolution current = null;
var depSolutions = new DependentSolution[sortables.Count];
int idx = 0;
foreach (var r in table)
{
if (current != r.Solution)
{
current = r.Solution;
var newDependent = new DependentSolution(current, table, s => index[s]);
depSolutions[idx++] = newDependent;
index.Add(current.Name, newDependent);
index.Add(current, newDependent);
}
}
Array.Sort(depSolutions, (d1, d2) =>
{
int cmp = d1.Rank - d2.Rank;
if (cmp == 0)
{
cmp = d1.Solution.Name.CompareTo(d2.Solution.Name);
}
return(cmp);
});
for (int i = 0; i < depSolutions.Length; ++i)
{
depSolutions[i].Index = i;
}
return(new SolutionDependencyContext(this, index, result, table, depSolutions, GetBuildProjectInfo(m)));
}
public Result Optimize(
int maxSteps,
float criteria,
Func <ISolution> initialSolution,
int runs = 1,
int evalsPerSolution = 1)
{
int evaluations = 0;
BestEvaluation = float.NaN;
BestSolution = null;
// Perform algorithm runs
for (int i = 0; i < runs; i++)
{
BestSolutionInRun = null;
// For current run, get an initial solution
CurrentSolution = initialSolution();
CurrentEvaluation = evaluate(CurrentSolution);
evaluations++;
BestSolutionInRun = CurrentSolution;
BestEvaluationInRun = CurrentEvaluation;
// Perform a run of the algorithm
for (int j = 0; j < maxSteps; j++)
{
// Find random neighbor
ISolution neighborSolution = findNeighbor(CurrentSolution);
float neighborEvaluation = 0;
// Evaluate neighbor
for (int k = 0; k < evalsPerSolution; k++)
{
neighborEvaluation += evaluate(neighborSolution);
evaluations++;
}
neighborEvaluation = neighborEvaluation / evalsPerSolution;
// Select solution (either keep current solution or
// select neighbor solution)
if (select(neighborEvaluation, CurrentEvaluation))
{
CurrentSolution = neighborSolution;
CurrentEvaluation = neighborEvaluation;
if (compare(CurrentEvaluation, BestEvaluationInRun))
{
BestSolutionInRun = CurrentSolution;
BestEvaluationInRun = CurrentEvaluation;
}
}
// If we reached the criteria, break loop
if (compare(CurrentEvaluation, criteria))
{
break;
}
}
// Is last run's best solution better than the best solution
// found so far in all runs?
if (compare(BestEvaluationInRun, BestEvaluation) ||
BestSolution == null)
{
BestSolution = BestSolutionInRun;
BestEvaluation = BestEvaluationInRun;
}
}
return(new Result(BestSolution, BestEvaluation, evaluations));
}
void ImportRemoved(object sender, DotNetProjectImportEventArgs e)
{
solutionContainingProjectBuildersToDispose = e.Project.ParentSolution;
}
public RenameHandler(ISolution solution, BufferParser bufferParser)
{
_solution = solution;
_bufferParser = bufferParser;
_findUsagesHandler = new FindUsagesHandler(bufferParser, solution);
}
private static IDataContext CreateDataContext(IComponentContainer componentContainer, ISolution solution, ITextControl control)
{
var actionManager = componentContainer.GetComponent <IActionManager>();
var dataRules = DataRules
.AddRule("Test", ProjectModelDataConstants.SOLUTION, x => solution)
.AddRule("Test", TextControlDataConstants.TEXT_CONTROL, x => control)
.AddRule("Test", DocumentModelDataConstants.DOCUMENT, x => control.Document)
.AddRule("Test", DocumentModelDataConstants.EDITOR_CONTEXT, x => new DocumentEditorContext(new DocumentOffset(control.Document, control.Caret.Position.Value.ToDocOffset())));
return(actionManager.DataContexts.CreateWithDataRules(control.Lifetime, dataRules));
}
/// <summary>
/// The execute transaction inner.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="textControl">
/// The text control.
/// </param>
public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
{
ICSharpFile file = Utils.GetCSharpFile(solution, textControl);
new DocumentationRules().InsertCopyrightText(file);
}
public override ILexerFactory GetMixedLexerFactory(ISolution solution, IBuffer buffer, IPsiSourceFile sourceFile = null)
{
var service = GherkinLanguage.Instance.LanguageService();
return(service?.GetPrimaryLexerFactory());
}
public static bool HasUnityReference([NotNull] this ISolution solution)
{
var tracker = solution.GetComponent <UnityReferencesTracker>();
return(tracker.HasUnityReference.Value);
}
public ISolutionPackageRepository CreateSolutionPackageRepository(ISolution solution)
{
return(new SolutionPackageRepository(solution, repositoryFactory, options));
}
public ProviderCustomOptionsControl GetCustomOptionsControl(ISolution solution)
{
return(null);
}
public ISolutionPackageRepository CreateSolutionPackageRepository(ISolution solution)
{
SolutionPassedToCreateSolutionPackageRepository = solution;
return(FakeSolutionPackageRepository);
}
public Examiner(ISolution solution)
{
Solution = solution;
}
public UnitTestElement Deserialize(ISolution solution, string elementString)
{
throw new NotImplementedException();
}
public void SetUp()
{
_solution = new FakeSolution(@"c:\test\fake.sln");
_fs = new MockFileSystem();
}
public void ExploreSolution(ISolution solution, UnitTestElementConsumer consumer)
{
}
public string GetPresentation(ISolution solution, IDeclaredElement declaredElement, bool prefabImport)
{
return($"x: {X}, y: {Y}");
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
AttributeUtil.AddAttributeToSingleDeclaration(myClassDeclaration, KnownTypes.RequireComponent,
new[] { new AttributeValue(myType) }, null, myClassDeclaration.GetPsiModule(), myFactory, true);
return(null);
}
public ISolution Apply(ISolution solution, int configuration)
{
return(Apply(solution, Configurations[configuration]));
}
public string GetFullPresentation(ISolution solution, IDeclaredElement declaredElement, bool prefabImport)
{
return(GetPresentation(solution, declaredElement, prefabImport));
}
public abstract ISolution Apply(ISolution solution, Configuration configuration);
public bool Navigate(ISolution solution, PopupWindowContextSource windowContext, bool transferFocus,
TabOptions tabOptions = TabOptions.Default)
{
return(solution.GetComponent <UnityAssetOccurrenceNavigator>().Navigate(solution, DeclaredElementPointer, AttachedElementLocation));
}
