public TreeNode AddProjectNode(TreeNode motherNode, IProject project)
{
ProjectNode projectNode = new ProjectNode(project);
projectNode.AddTo(motherNode);
ReferenceFolder referenceFolderNode = new ReferenceFolder(project);
referenceFolderNode.AddTo(projectNode);
//TagManagerNode tagManagerNode = new TagManagerNode(project);
//tagManagerNode.AddTo(projectNode);
//
// TagListFileNode tagListFileNode = new TagListFileNode(TagManager.FullFileName, FileNodeStatus.InProject);
// tagListFileNode.AddTo(projectNode);
// TagGroupNode tagGroupNode = new TagGroupNode(project);
// tagGroupNode.AddTo(projectNode);
// AimTagGroupFolderNode aimTagGroupFolderNode = new AimTagGroupFolderNode(project);
// aimTagGroupFolderNode.AddTo(projectNode);
//
// SecurityNode securityNode = new SecurityNode(project);
// securityNode.AddTo(projectNode);
//DriverFolderNode driverFolderNode = new DriverFolderNode(project);
//driverFolderNode.AddTo(projectNode);
motherNode.TreeView.MouseDoubleClick += new MouseEventHandler(TreeView_MouseDoubleClick);
return projectNode;
}
/// <summary>
/// Watch Loom projects to update the configuration
/// </summary>
/// <param name="project"></param>
static public void Monitor(IProject project)
{
if (updater == null && project != null)
{
updater = new System.Timers.Timer();
updater.Interval = 200;
updater.SynchronizingObject = PluginCore.PluginBase.MainForm as System.Windows.Forms.Form;
updater.Elapsed += updater_Elapsed;
updater.AutoReset = false;
}
proj = null;
StopWatcher();
if (project is LoomProject)
{
proj = project as LoomProject;
proj.ProjectUpdating += new ProjectUpdatingHandler(proj_ProjectUpdating);
proj_ProjectUpdating(proj);
if (lastProject != proj.ProjectPath)
{
lastProject = proj.ProjectPath;
AutoInit(proj);
}
}
else lastProject = null;
}
private SpecFlowProject CreateSpecFlowProjectFrom(IProject project)
{
var specFlowProject = new SpecFlowProject();
specFlowProject.ProjectSettings.ProjectFolder = project.Directory;
specFlowProject.ProjectSettings.ProjectName = project.Name;
specFlowProject.ProjectSettings.AssemblyName = project.AssemblyName;
specFlowProject.ProjectSettings.DefaultNamespace = project.RootNamespace;
var generatorConfig = specFlowProject.Configuration.GeneratorConfiguration;
foreach (var projectFile in project.Items.OfType<FileProjectItem>().Where(IsFeatureOrAppConfigFile))
{
string extension = Path.GetExtension(projectFile.FileName);
if (extension != null && extension.Equals(".feature", StringComparison.InvariantCultureIgnoreCase))
{
string fileName = FileUtilities.GetRelativePath(projectFile.FileName, project.Directory);
var featureFile = new FeatureFileInput(fileName);
specFlowProject.FeatureFiles.Add(featureFile);
}
if (extension != null && extension.Equals(".config", StringComparison.InvariantCultureIgnoreCase))
{
string configContent = File.ReadAllText(projectFile.FileName);
GeneratorConfigurationReader.UpdateConfigFromFileContent(generatorConfig, configContent);
}
}
return specFlowProject;
}
public bool IsFileAValidModification(IFileInfo file, IProject baseProject, IProject sourceProject, List<string> warnings, List<FileReleaseInfo> releases)
{
if (FileIsDeletedItem(file))
return false;
if (FileIsSharedResx(file))
{
var baseFile = baseProject.Drive.GetFileInfo(file.Url);
var sourceFile = sourceProject.Drive.GetFileInfo(file.Url);
ResxDifferences changes = ResxDiffMerge.CompareResxFiles(sourceFile, baseFile);
if (changes.None)
return false;
}
if (FileIsRelationship(file))
{
Guid sourceId = GetModelItemIdFromFile(file);
if (sourceId == Guid.Empty)
return true;
OrmRelationship baseRelationship = FindRelationshipInBaseById(sourceId, baseProject);
if (baseRelationship != null)
{
var sourceRelationship = sourceProject.Get<OrmRelationship>(file.Url);
var diffMerge = new ObjectDiffMerge();
var changes = diffMerge.CompareObjects(sourceRelationship, baseRelationship);
if (!changes.All(change => RelationshipChangeCanBeIgnored(change)))
warnings.Add(string.Format("{0} is an existing SalesLogix relationship that was renamed and also modified. This file will need to be manually merged.", file.Url));
return false;
}
}
return true;
}
public IPsiModule GetPrimaryPsiModule(IProject project)
{
var solution = project.GetSolution();
var psiServices = solution.GetPsiServices();
var modules = psiServices.Modules;
return modules.GetPrimaryPsiModule(project, TargetFrameworkId.Default);
}
public void Explore(IProject project, IMetadataAssembly assembly, UnitTestElementConsumer consumer)
{
if (!assembly.ReferencedAssembliesNames.Any(x => String.Equals(
x.Name,
typeof(It).Assembly.GetName().Name,
StringComparison.InvariantCultureIgnoreCase)))
{
return;
}
assembly.GetTypes().Where(type => type.IsContext()).ForEach(type =>
{
var contextElement = _factories.Contexts.CreateContext(project,assembly.Location.FullPath, type);
consumer(contextElement);
type
.GetSpecifications()
.ForEach(x => consumer(_factories.ContextSpecifications.CreateContextSpecification(contextElement, x)));
type.GetBehaviors().ForEach(x =>
{
var behaviorElement = _factories.Behaviors.CreateBehavior(contextElement, x);
consumer(behaviorElement);
_factories.BehaviorSpecifications
.CreateBehaviorSpecificationsFromBehavior(behaviorElement, x)
.ForEach(y => consumer(y));
});
});
}
public static void Reparse(IProject project, bool initReferences, bool parseCode)
{
if (jobs == null)
return; // do nothing if service wasn't initialized (e.g. some unit tests)
ParseProjectContent pc = ParserService.GetProjectContent(project) as ParseProjectContent;
if (pc != null) {
if (initReferences) {
lock (reParse1) {
if (!reParse1.Contains(pc)) {
LoggingService.Debug("Enqueue for reinitializing references: " + project);
reParse1.Add(pc);
jobs.AddJob(new JobTask(pm => ReInitializeReferences(pc, pm),
GetLoadReferenceTaskTitle(project.Name),
10
));
}
}
}
if (parseCode) {
lock (reParse2) {
if (!reParse2.Contains(pc)) {
LoggingService.Debug("Enqueue for reparsing code: " + project);
reParse2.Add(pc);
jobs.AddJob(new JobTask(pm => ReparseCode(pc, pm),
GetParseTaskTitle(project.Name),
pc.GetInitializationWorkAmount()
));
}
}
}
jobs.StartRunningIfRequired();
}
}
public ProjectNode(IProject project)
{
if (project == null)
throw new ArgumentNullException("project");
sortOrder = 1;
this.ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/ProjectNode";
this.project = project;
Text = project.Name;
if (project.IsReadOnly) {
Text += StringParser.Parse(" (${res:Global.ReadOnly})");
}
autoClearNodes = false;
if (project is MissingProject) {
OpenedImage = ClosedImage = "ProjectBrowser.MissingProject";
this.ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/MissingProjectNode";
} else if (project is ErrorProject) {
OpenedImage = ClosedImage = "ProjectBrowser.ProjectWarning";
this.ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/UnknownProjectNode";
} else {
OpenedImage = ClosedImage = IconService.GetImageForProjectType(project.Language);
}
Tag = project;
if (project.ParentSolution != null) {
project.ParentSolution.StartupProjectChanged += OnStartupProjectChanged;
OnStartupProjectChanged(null, null);
}
}
public static ContextSpecificationElement GetOrCreateContextSpecification(MSpecUnitTestProvider provider,
IUnitTestElementManager manager,
PsiModuleManager psiModuleManager,
CacheManager cacheManager,
IProject project,
ContextElement context,
ProjectModelElementEnvoy projectEnvoy,
IClrTypeName declaringTypeName,
string fieldName,
bool isIgnored)
{
var id = ContextSpecificationElement.CreateId(context, fieldName);
var contextSpecification = manager.GetElementById(project, id) as ContextSpecificationElement;
if (contextSpecification != null)
{
contextSpecification.Parent = context;
contextSpecification.State = UnitTestElementState.Valid;
return contextSpecification;
}
return new ContextSpecificationElement(provider,
psiModuleManager,
cacheManager,
context,
projectEnvoy,
declaringTypeName,
fieldName,
isIgnored);
}
public void ProjectsReturnsSingleItemContainingProjectPassedToConstructor()
{
List<IProject> projects = new List<IProject>(selectedTests.Projects);
IProject[] expectedProjects = new IProject[] { project };
Assert.AreEqual(expectedProjects, projects);
}
public TextTemplatingAssemblyPathResolver(IProject project)
: this(
project,
new TextTemplatingAssemblyParserService(),
new TextTemplatingPathResolver())
{
}
public void ExploreAssembly(IProject project,
IMetadataAssembly assembly,
UnitTestElementConsumer consumer,
ManualResetEvent exitEvent)
{
ExploreAssembly(project, assembly, consumer);
}
public ParseInformation Parse(FileName fileName, ITextSource fileContent, bool fullParseInformationRequested,
IProject parentProject, CancellationToken cancellationToken)
{
var csharpProject = parentProject as CSharpProject;
CSharpParser parser = new CSharpParser(csharpProject != null ? csharpProject.CompilerSettings : null);
parser.GenerateTypeSystemMode = !fullParseInformationRequested;
SyntaxTree cu = parser.Parse(fileContent, fileName);
cu.Freeze();
CSharpUnresolvedFile file = cu.ToTypeSystem();
ParseInformation parseInfo;
if (fullParseInformationRequested)
parseInfo = new CSharpFullParseInformation(file, fileContent.Version, cu);
else
parseInfo = new ParseInformation(file, fileContent.Version, fullParseInformationRequested);
IDocument document = fileContent as IDocument;
AddCommentTags(cu, parseInfo.TagComments, fileContent, parseInfo.FileName, ref document);
if (fullParseInformationRequested) {
if (document == null)
document = new ReadOnlyDocument(fileContent, parseInfo.FileName);
((CSharpFullParseInformation)parseInfo).newFoldings = CreateNewFoldings(cu, document);
}
return parseInfo;
}
public ContextElement GetOrCreateContext(string assemblyPath,
IProject project,
IClrTypeName typeName,
string subject,
ICollection<string> tags,
bool isIgnored)
{
var id = ContextElement.CreateId(subject, typeName.FullName, tags);
var contextElement = _manager.GetElementById(project, id) as ContextElement;
if (contextElement != null)
{
contextElement.State = UnitTestElementState.Valid;
return contextElement;
}
return new ContextElement(_provider,
_psiModuleManager,
_cacheManager,
new ProjectModelElementEnvoy(project),
typeName,
assemblyPath,
subject,
tags,
isIgnored);
}
public IProject AddProject(IProject project)
{
_projects.Add(project);
project.ProjectId = _projects.Count();
return project;
}
public TreeNode AddProjectNode(TreeNode motherNode, IProject project)
{
FSharpProjectNode prjNode = new FSharpProjectNode(project);
prjNode.AddTo(motherNode);
new ReferenceFolder(project).AddTo(prjNode);
return prjNode;
}
public override bool Accepts(IProject project)
{
if (!project.IsProjectReferencingNancyRazorViewEngine())
return false;
return Language == ProjectLanguage.UNKNOWN || Language == project.ProjectProperties.DefaultLanguage;
}
public void SaveProject(IProject project, string location)
{
this.project = project;
CreateDirectoryStructure(project.ResourceTree, location);
settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
Formatting = Formatting.Indented,
};
var rootFile = new JsonRootProject();
rootFile.Version = SpecificVersion;
ExportSprites(location);
ExportScripts(location);
// Export icon
var icoFileName = Path.Combine(location, "app.ico");
File.WriteAllBytes(icoFileName, project.Settings.IconData);
// Write project file
var rootFileName = Path.Combine(location, "project.json");
File.WriteAllText(rootFileName, JsonConvert.SerializeObject(rootFile, settings));
}
public void SelectedTestsHasOneProject()
{
IProject[] expectedProjects = new IProject[] { project };
var actualProjects = selectedTests.Projects.ToArray();
Assert.AreEqual(expectedProjects, actualProjects);
}
public void Execute(IProject project, bool debug)
{
//PythonCompilerParameters parameters = (PythonCompilerParameters) project.ActiveConfiguration;
//FileUtilityService fileUtilityService = (FileUtilityService) ServiceManager.GetService (typeof (FileUtilityService));
string files = "";
foreach (ProjectFile finfo in project.ProjectFiles) {
if (finfo.Subtype != Subtype.Directory) {
switch (finfo.BuildAction) {
case BuildAction.Compile:
files += String.Format ("{0} ", finfo.Name);
break;
}
}
}
Console.WriteLine (files);
string fullCommand = String.Format ("-e \"IronPythonConsole {0};read -p 'press any key to continue...' -n1\"", files);
ProcessStartInfo psi = new ProcessStartInfo ("xterm", fullCommand);
//psi.WorkingDirectory = Path.GetDirectoryName (exe);
psi.UseShellExecute = false;
Process p = Process.Start (psi);
p.WaitForExit ();
}
public override void Init( IProject project, IDependencyManager dependencies, IBuildAggregator aggregator )
{
base.Init( project, dependencies, aggregator );
Model model = project.Model;
EntityClass quotes = new EntityClass();
quotes.Name = "QuoteOfTheDay";
quotes.Visibility = "public";
EntityField id = new EntityField();
id.Name = "id";
id.IsPreview = true;
id.IsPrimaryKey = true;
id.Type = IntrinsicTypes.Create("System.Int32");
quotes.Fields.Add(id);
EntityField quote = new EntityField();
quote.Name = "quote";
quote.Represents = true;
quote.IsPreview = true;
quote.Type = IntrinsicTypes.Create( "System.String" );
quote.IsRequired = true;
quote.MaxSize = 1000;
quotes.Fields.Add(quote);
model.Add(quotes);
}
public CustomToolContext(IProject project, IProgressMonitor progressMonitor)
{
if (project == null)
throw new ArgumentNullException("project");
this.project = project;
this.ProgressMonitor = progressMonitor;
}
void CreateTypeScriptContextIfProjectHasTypeScriptFiles(IProject project)
{
var typeScriptProject = new TypeScriptProject(project);
if (typeScriptProject.HasTypeScriptFiles()) {
contextProvider.CreateProjectContext(typeScriptProject);
}
}
public static TestProject CreateTestProjectWithTestClassAndSingleTestMethod(IProject project,
string className,
string methodName)
{
string[] methodNames = new string[] { methodName };
return CreateTestProjectWithTestClassTestMethods(project, className, methodNames);
}
public ProjectContentContainer(MSBuildBasedProject project, IProjectContent initialProjectContent)
{
if (project == null)
throw new ArgumentNullException("project");
this.project = project;
this.projectContent = initialProjectContent.SetAssemblyName(project.AssemblyName).SetLocation(project.OutputAssemblyFullPath);
this.assemblyModel = (IUpdateableAssemblyModel)project.AssemblyModel;
this.assemblyModel.AssemblyName = this.projectContent.AssemblyName;
this.assemblyModel.FullAssemblyName = this.projectContent.FullAssemblyName;
this.cacheFileName = GetCacheFileName(project.FileName);
SD.ProjectService.ProjectItemAdded += OnProjectItemAdded;
SD.ProjectService.ProjectItemRemoved += OnProjectItemRemoved;
SD.AssemblyParserService.AssemblyRefreshed += OnAssemblyRefreshed;
List<FileName> filesToParse = new List<FileName>();
foreach (var file in project.Items.OfType<FileProjectItem>()) {
if (IsParseableFile(file)) {
var fileName = file.FileName;
parserService.AddOwnerProject(fileName, project, startAsyncParse: false, isLinkedFile: file.IsLink);
filesToParse.Add(fileName);
}
}
SD.ParserService.LoadSolutionProjectsThread.AddJob(
monitor => Initialize(monitor, filesToParse),
"Loading " + project.Name + "...", filesToParse.Count + LoadingReferencesWorkAmount);
}
public Folder(IProject project, string name)
{
this._project = project;
this._name = name;
this._items = new List<IItem>();
this._folders = new List<IFolder>();
}
void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper)
{
options = new TestablePackageManagementOptions();
options.PackagesDirectory = "packages";
repositoryPaths = new SolutionPackageRepositoryPath(project, options);
var pathResolver = new DefaultPackagePathResolver(repositoryPaths.PackageRepositoryPath);
fakeFileSystem = new FakeFileSystem();
fakeFeedSourceRepository = new FakePackageRepository();
fakeSolutionSharedRepository = packageRefRepositoryHelper.FakeSharedSourceRepository;
fakePackageOperationResolverFactory = new FakePackageOperationResolverFactory();
var fakeSolutionPackageRepository = new FakeSolutionPackageRepository();
fakeSolutionPackageRepository.FileSystem = fakeFileSystem;
fakeSolutionPackageRepository.PackagePathResolver = pathResolver;
fakeSolutionPackageRepository.FakeSharedRepository = fakeSolutionSharedRepository;
packageManager = new SharpDevelopPackageManager(fakeFeedSourceRepository,
packageRefRepositoryHelper.FakeProjectSystem,
fakeSolutionPackageRepository,
fakePackageOperationResolverFactory);
}
public ContextElement GetOrCreateContext(string assemblyPath,
IProject project,
IClrTypeName typeName,
string subject,
ICollection<string> tags,
bool isIgnored)
{
var id = ContextElement.CreateId(_elementIdFactory, _provider, project, subject, typeName.FullName, tags);
var contextElement = this._manager.GetElementById(id) as ContextElement;
if (contextElement != null)
{
contextElement.State = UnitTestElementState.Valid;
contextElement.AssemblyLocation = assemblyPath;
return contextElement;
}
return new ContextElement(this._provider,
this._psiModuleManager,
this._cacheManager,
id,
new ProjectModelElementEnvoy(project),
typeName,
assemblyPath,
subject,
tags,
isIgnored,
_categoryFactory);
}
public BehaviorSpecificationFactory(MSpecUnitTestProvider provider, IProject project, ProjectModelElementEnvoy projectEnvoy)
{
#endif
_provider = provider;
_project = project;
_projectEnvoy = projectEnvoy;
}
private DateTime? GetLaunchedDate(IProject project)
{
var submittedDate = GetSubmittedDate(project.SubmittedDate);
var developmentTime = GetDevelopmentTime(project.DevelopmentTime);
return GetLaunchedDate(submittedDate, developmentTime);
}
public override ITemplate CreateTemplateInstance(IProject project, IList <IDTOModel> models)
{
return(new MappingProfileTemplate(project, models));
}
private ITemplate CreateTemplateInstance(IProject project, IServiceModel serviceModel, IOperationModel operationModel)
{
return(new ServiceCallHandlerImplementationTemplate(project, serviceModel, operationModel));
}
public MSpecTestProject(ITestSolution parentSolution, IProject project)
: base(project)
{
}
void UnresolvedUnityReferencesTracker.IHandler.OnReferenceAdded(IProject unityProject)
{
myShellLocks.ExecuteOrQueueReadLockEx(myLifetime, "UnityPluginInstaller.UnresolvedReferenceAdded", () => InstallPluginIfRequired(new[] { unityProject }));
}
public void OnReferenceAdded(IProject unityProject, Lifetime projectLifetime)
{
}
public override ITemplate CreateTemplateInstance(IProject project, IServiceModel model)
{
return(new WebApiControllerTemplate(project, model));
}
internal override void Init()
{
#region
// Следим за другими утилитами, что б поддерживать кеш задач в валидном состоянии
Utility.Projects.OnDelete += ProjectsUtility_OnDelete;
// Удаляем из кеша все задачи удаленного пользователя
Utility.Boards.OnRemoveUserFromBoard += BoardsUtility_OnRemoveUserFromBoard;
// Обновляем цвета у задач
Utility.Boards.OnUpdateColor +=
(s, e) =>
{
IBoardsColor color = e.Data;
HashSet <ITask> cache = GetTasksCache(color.BoardId);
if (cache != null)
{
using (new UpdateLock(color.BoardId))
{
ITask[] tasks = cache
.Where(x => x.ColorId == color.Id)
.ToArray();
foreach (var item in tasks)
{
item.ColorHEX = color.Color;
item.ColorPosition = color.Position;
item.ColorName = color.Name;
}
}
}
};
Utility.Boards.OnDeleteColor +=
(s, e) =>
{
IBoardsColor color = e.Data;
var key = GetAllTasksKey(color.BoardId);
Cache.Clear(key);
};
#endregion
#region Обновляем имена проектов в задачах
Utility.Projects.OnUpdate.Add(
(sender, e) =>
{
IProject project = e.Data;
TaskFilter filter = CreateFilter(project.BoardId);
filter.ProjectIds = new[] { project.Id };
List <ITask> tasks = Get(filter);
tasks.ForEach(x => x.ProjectName = project.Name);
});
#endregion
#region Обновляем имена статусов в задачах
Utility.Statuses.OnUpdate.Add(
(sender, e) =>
{
ITasksStatus status = e.Data;
TaskFilter filter = CreateFilter(status.BoardId);
filter.Statuses = new[] { status.Id };
List <ITask> tasks = Get(filter);
tasks.ForEach(
x =>
{
x.TaskStatusName = status.Name;
x.TaskStatusPosition = status.Position;
});
});
#endregion
#region При удалении статуса чистим кеш доски
Utility.Statuses.OnDelete.Add(
(sender, e) =>
{
ITasksStatus status = e.Data;
var key = Cache.GetKeys(CacheKey.Status, status.Id);
Cache.Clear(key);
key = GetAllTasksKey(status.BoardId);
Cache.Clear(key);
});
#endregion
#region Обновление исполнителя
Utility.Users.OnUpdate.Add(
(sender, e) =>
{
IUser user = e.NewData;
Repository.Tasks.UpdateExecutor(user);
List <IBoard> boards = Utility.Boards.GetByUser(user.Id);
foreach (var board in boards)
{
var cache = GetTasksCache(board.Id);
if (cache != null)
{
using (new UpdateLock(board.Id))
{
foreach (ITask task in cache.Where(x => x.ExecutorUserId == user.Id))
{
task.ExecutorEmail = user.EMail;
task.ExecutorNick = user.Nick;
}
}
}
}
});
#endregion
// TODO: протестить лики из-за подписок
}
public override void RemoveReference(IProject project)
{
References.Remove(project);
}
public FSharpProjectNode(IProject project) : base(project)
{
}
public override int CompareTo(IProject other)
{
return(Name.CompareTo(other.Name));
}
public abstract Task InstallAsync(IConsole console, IProject project);
public override void AddReference(IProject project)
{
References.InsertSorted(project);
}
public abstract IList <object> GetConfigurationPages(IProject project);
public async Task <bool> Build(IConsole console, IProject project, string label = "", IEnumerable <string> defines = null)
{
await InstallAsync(console, project);
if (!ValidateToolchainExecutables(console))
{
return(false);
}
console.Clear();
var preBuildCommands = (project as IStandardProject).PreBuildCommands;
var postBuildCommands = (project as IStandardProject).PostBuildCommands;
bool result = true;
if (preBuildCommands.Count > 0)
{
console.WriteLine("Pre-Build Commands:");
result = ExecuteCommands(console, project, preBuildCommands);
}
console.WriteLine("Starting Build...");
terminateBuild = !result;
SetFileCount(project as IStandardProject);
buildCount = 0;
var compiledProjects = new List <CompileResult>();
List <Definition> injectedDefines = new List <Definition>();
if (defines != null)
{
foreach (var define in defines)
{
var injectableDefinition = new Definition()
{
Global = true, Value = define
};
(project as IStandardProject).Defines.Add(injectableDefinition);
injectedDefines.Add(injectableDefinition);
}
}
if (!terminateBuild)
{
await CompileProject(console, project as IStandardProject, project as IStandardProject, compiledProjects);
if (!terminateBuild)
{
await WaitForCompileJobs();
foreach (var compiledReference in compiledProjects)
{
result = compiledReference.ExitCode == 0;
if (!result)
{
break;
}
}
if (result)
{
var linkedReferences = new CompileResult();
linkedReferences.Project = project as IStandardProject;
foreach (var compiledProject in compiledProjects)
{
if (compiledProject.Project.Location != project.Location)
{
var linkResult = Link(console, project as IStandardProject, compiledProject, linkedReferences);
}
else
{
linkedReferences.ObjectLocations = compiledProject.ObjectLocations;
linkedReferences.NumberOfObjectsCompiled = compiledProject.NumberOfObjectsCompiled;
var linkResult = Link(console, project as IStandardProject, linkedReferences, linkedReferences, label);
console.WriteLine();
if (postBuildCommands.Count > 0)
{
console.WriteLine("Post-Build Commands:");
bool succeess = ExecuteCommands(console, project, postBuildCommands);
if (!succeess)
{
result = false;
break;
}
}
}
if (linkedReferences.ExitCode != 0)
{
result = false;
break;
}
}
}
ClearBuildFlags(project as IStandardProject);
}
}
console.WriteLine();
if (terminateBuild)
{
result = false;
}
if (result)
{
console.WriteLine("Build Successful");
}
else
{
console.WriteLine("Build Failed");
}
foreach (var define in injectedDefines)
{
(project as IStandardProject).Defines.Remove(define);
}
project.Save();
return(result);
}
/// <summary>
/// Purges the specified project.
/// </summary>
/// <param name="project">The project.</param>
/// <remarks></remarks>
public override void Purge(IProject project)
{
_realScProvider.Purge(project);
}
public abstract bool CanHandle(IProject project);
private IEnumerable <IProjectFilePackageReference> ParsePackageReferences(IProject project)
{
return(_parser.ParsePackageReferences(project).ToList());
}
public PreProcessingDirective[] GetPreprocessorDefines(IProject project)
{
return(EmptyArray <PreProcessingDirective> .Instance);
}
public DomainEntitySpecificationTemplate(Class model, IProject project)
: base(Identifier, project, model)
{
}
/// <summary>
/// Initializes the specified project.
/// </summary>
/// <param name="project">The project.</param>
/// <remarks></remarks>
public override void Initialize(IProject project)
{
_realScProvider.Initialize(project);
}
public ProjectConfigurationEventArgs(IProject project, string configuration)
{
this.configuration = configuration;
this.project = project;
}
protected override ITestRunner CreateTestRunner(IProject project)
{
return(Context.RegisteredTestFrameworks.CreateTestRunner(project));
}
/// <inheritdoc />
public void AddProject(IProject project)
{
_projectList.Add(project);
}
public static void ExtractInterface(IClass c)
{
ExtractInterfaceOptions extractInterface = new ExtractInterfaceOptions(c);
using (ExtractInterfaceDialog eid = new ExtractInterfaceDialog()) {
extractInterface = eid.ShowDialog(extractInterface);
if (extractInterface.IsCancelled)
{
return;
}
// do rename
/*
* MessageService.ShowMessageFormatted("Extracting interface",
* @"Extracting {0} [{1}] from {2} into {3}",
* extractInterface.NewInterfaceName,
* extractInterface.FullyQualifiedName,
* extractInterface.ClassEntity.Name,
* extractInterface.NewFileName
* );
* ` */
}
string newInterfaceFileName = Path.Combine(Path.GetDirectoryName(c.CompilationUnit.FileName),
extractInterface.NewFileName);
if (File.Exists(newInterfaceFileName))
{
int confirmReplace = MessageService.ShowCustomDialog("Extract Interface",
newInterfaceFileName + " already exists!",
0,
1,
"${res:Global.ReplaceButtonText}",
"${res:Global.AbortButtonText}");
if (confirmReplace != 0)
{
return;
}
}
LanguageProperties language = c.ProjectContent.Language;
string classFileName = c.CompilationUnit.FileName;
string existingClassCode = ParserService.GetParseableFileContent(classFileName).Text;
// build the new interface...
string newInterfaceCode = language.RefactoringProvider.GenerateInterfaceForClass(extractInterface.NewInterfaceName,
existingClassCode,
extractInterface.ChosenMembers,
c, extractInterface.IncludeComments);
if (newInterfaceCode == null)
{
return;
}
// ...dump it to a file...
IViewContent viewContent = FileService.GetOpenFile(newInterfaceFileName);
ITextEditorProvider editable = viewContent as ITextEditorProvider;
if (viewContent != null && editable != null)
{
// simply update it
editable.TextEditor.Document.Text = newInterfaceCode;
viewContent.PrimaryFile.SaveToDisk();
}
else
{
// create it
viewContent = FileService.NewFile(newInterfaceFileName, newInterfaceCode);
viewContent.PrimaryFile.SaveToDisk(newInterfaceFileName);
// ... and add it to the project
IProject project = (IProject)c.ProjectContent.Project;
if (project != null)
{
FileProjectItem projectItem = new FileProjectItem(project, ItemType.Compile);
projectItem.FileName = newInterfaceFileName;
ProjectService.AddProjectItem(project, projectItem);
FileService.FireFileCreated(newInterfaceFileName, false);
project.Save();
ProjectBrowserPad.RefreshViewAsync();
}
}
ICompilationUnit newCompilationUnit = ParserService.ParseFile(newInterfaceFileName).CompilationUnit;
IClass newInterfaceDef = newCompilationUnit.Classes[0];
// finally, add the interface to the base types of the class that we're extracting from
if (extractInterface.AddInterfaceToClass)
{
string modifiedClassCode = language.RefactoringProvider.AddBaseTypeToClass(existingClassCode, c, newInterfaceDef);
if (modifiedClassCode == null)
{
return;
}
// TODO: replacing the whole text is not an option, we would loose all breakpoints/bookmarks.
viewContent = FileService.OpenFile(classFileName);
editable = viewContent as ITextEditorProvider;
if (editable == null)
{
return;
}
editable.TextEditor.Document.Text = modifiedClassCode;
}
}
public ProjectController(IProject project)
{
_project = project;
}
private static void AdaptElementPaths(Dictionary <String, String> filesMoved, String musicDir, String soundsDir, IProject project)
{
if (project == null)
{
return;
}
FileLists lists = new FileLists();
IList <IFileElement> elements = lists.GetAllFiles(project);
foreach (IFileElement element in elements)
{
String basePath = element.SoundFileType == SoundFileType.Music ? musicDir : soundsDir;
String currentPath = System.IO.Path.Combine(basePath, element.FilePath);
if (filesMoved.ContainsKey(currentPath))
{
String newPath = filesMoved[currentPath];
if (newPath.StartsWith(basePath, StringComparison.InvariantCultureIgnoreCase))
{
element.FilePath = newPath.Substring(basePath.Length + 1);
}
}
}
}
/// <summary>
/// 关闭工程
/// </summary>
/// <param name="project"></param>
public static void CloseProject(IProject project)
{
}
protected BaseMacroExecuteClass(IDataEngine dataengine, IMacroFactory macroFactory, IOutputEngine outputengine, IProject project, IConfiguration configuration) : base(dataengine, macroFactory, outputengine, project, configuration)
{
}
/// <summary>
/// 保存工程
/// </summary>
/// <param name="project"></param>
public static void SaveProject(IProject project)
{
}
/// <summary>
/// 保存工程子项
/// </summary>
/// <param name="project"></param>
/// <param name="projectItem"></param>
private static void SaveProjectItem(IProject project, ProjectItem projectItem)
{
}
