protected override void VisitEnum(CodeEnum codeEnum) { if (codeEnum.FullName == _classFullName) { _result = codeEnum.ProjectItem; } }
public ProcessResult Execute(ProcessInfo processInfo, ProjectItem item, TaskExecutionContext context) { var outputFile = context.GeneratePathInWorkingDirectory(item.NameOrType + ".log"); if ((this.Item == null) || (this.Context == null)) { return this.Execute(processInfo, item.Project.Name, item.NameOrType, outputFile); } Assert.AreEqual(this.FileName, processInfo.FileName); var actual = processInfo.Arguments == null ? null : processInfo.Arguments.ToString(); Assert.AreEqual(this.Arguments, actual); Assert.AreEqual(this.WorkingDirectory, processInfo.WorkingDirectory); Assert.AreSame(this.Item, item); Assert.AreEqual(this.Context, context); var fileSystemMock = new Mock<IFileSystem>(); fileSystemMock.Setup(fs => fs.OpenFileForRead(outputFile)).Returns(new MemoryStream()); var result = new ProcessResult( fileSystemMock.Object, outputFile, this.ExitCode, this.TimedOut, this.Failed); return result; }
private static void SetDependentUpon(ProjectItem item, string value) { if (Helpers.ProjectItemContainsProperty(item, "DependentUpon")) { item.Properties.Item("DependentUpon").Value = value; } }
public static void CreateNewProcessOverview(string ProcessName, ProjectItem processFile, ProjectItem diagramFile) { var store = new Store(typeof(CloudCoreArchitectProcessOverviewDomainModel)); var partition = new Partition(store); var result = new SerializationResult(); using (Transaction t = store.TransactionManager.BeginTransaction("create new process overview model")) { try { var processOverviewSerializationHelper = CloudCoreArchitectProcessOverviewSerializationHelper.Instance; Architect.ProcessOverview.Process process = processOverviewSerializationHelper.CreateModelHelper(partition); SetProcessOverviewProperties(ProcessName, process); var diagram = processOverviewSerializationHelper.CreateDiagramHelper(partition, process); processOverviewSerializationHelper.SaveModelAndDiagram(result, process, processFile.FileNames[0], diagram, diagramFile.FileNames[0]); AddAssemblyReference(ProcessName, process); t.Commit(); } catch (Exception ex) { MessageBox.Show(ex.Message); } } }
protected override void VisitClass(CodeClass codeClass) { if (codeClass.FullName == _classFullName) { _result = codeClass.ProjectItem; } }
public static bool VerifyConfiguration(ProjectItem projectItem) { var configProjectItem = SearchService.FindConfigFromModule(projectItem); if (configProjectItem == null) { throw new Exception($"Configuration file not found for module {projectItem.Name}"); } string configText = configProjectItem.ReadAllText(); var moduleText = projectItem.ReadAllText(); var serviceNames = moduleText.Matches(@".GetObject\<(?<element>[^\>]+)\>") .Union(moduleText.Matches(@".GetRuntimeObject\<(?<element>[^\>]+)\>")) .Union(moduleText.Matches(@".RegisterInstance\<(?<element>[^\>]+)\>")); foreach (var serviceName in serviceNames) { var fullName = FindServiceFullName(serviceName); if (!configText.Contains(fullName)) { throw new Exception($"{fullName} not found in the configuration file. Model: {projectItem.Name}"); } } return false; }
public static void RemoveSubItemsAndAssociatedFiles(ProjectItem parentItem) { if (parentItem == null) return; var projectItems = parentItem.ProjectItems.Cast<ProjectItem>(); RemoveSubItemsAndAssociatedFiles(projectItems); }
/// <summary> /// Creates a new instance of <see cref="GenerateAssemblersParams"/>. /// </summary> /// <param name="targetProject">Project where the Assemblers are going to be generated.</param> /// <param name="targetProjectFolder">Project folder where Assemblers are going to be generated. /// Null value indicates to generate at project level.</param> /// <param name="sourceFileHeaderComment">Source File Header Comment (optional).</param> /// <param name="useProjectDefaultNamespace">Indicates if Target Project default namespace is going to be used.</param> /// <param name="sourceNamespace">Namespace used for the Assemblers.</param> /// <param name="classIdentifierUse">Indicates use of identifier in class names.</param> /// <param name="classIdentifierWord">Identifier to use in class names.</param> /// <param name="sourceFileGenerationType">Specifies the Source File Generation Type desired.</param> /// <param name="sourceFileName">Source File Name to use if the Source File Generation Type is OneSourceFile.</param> /// <param name="isServiceReady">Specifies if the DTOs are Service-Ready (this means if they can be serialized or not).</param> /// <param name="dtosNamespace">DTO's namespace.</param> /// <param name="dtosTargetProject">DTO's target Project.</param> /// <param name="edmxProjectItem">EDMX ProjectItem.</param> public GenerateAssemblersParams(Project targetProject, ProjectItem targetProjectFolder, string sourceFileHeaderComment, bool useProjectDefaultNamespace, string sourceNamespace, ClassIdentifierUse classIdentifierUse, string classIdentifierWord, SourceFileGenerationType sourceFileGenerationType, string sourceFileName, bool isServiceReady, string dtosNamespace, Project dtosTargetProject, ProjectItem edmxProjectItem) { this.TargetProject = targetProject; this.TargetProjectFolder = targetProjectFolder; // Indicate target type this.TargetType = (this.TargetProjectFolder == null ? TargetType.Project : TargetType.ProjectFolder); this.SourceFileHeaderComment = sourceFileHeaderComment; this.UseProjectDefaultNamespace = useProjectDefaultNamespace; this.SourceNamespace = sourceNamespace; this.ClassIdentifierUse = classIdentifierUse; this.ClassIdentifierWord = classIdentifierWord; if (this.ClassIdentifierUse == ClassIdentifierUse.None) { this.ClassIdentifierWord = string.Empty; } this.SourceFileGenerationType = sourceFileGenerationType; this.SourceFileName = sourceFileName; this.IsServiceReady = isServiceReady; this.DTOsNamespace = dtosNamespace; this.DTOsTargetProject = dtosTargetProject; this.EDMXProject = edmxProjectItem.ContainingProject; this.EntitiesNamespace = EdmxHelper.GetEntitiesNamespace(edmxProjectItem); }
public static FileCodeModel CreateFileCodeModel(DTE dte, ProjectItem item, CodeDomProvider provider, string fileName) { if (null == item) { throw new ArgumentNullException("item"); } return new CodeDomFileCodeModel(dte, item, provider, fileName); }
public override NameValueItem[] GetNameValueItems(XmlNode node, XmlDocument resdoc, ProjectItem item) { try { List<NameValueItem> nvitems = new List<NameValueItem>(); foreach (XmlNode lobInstance in GetChildsOfType(GetFirstChildOfType(node.ParentNode.ParentNode, "LobSystemInstances"), "LobSystemInstance")) { //we have the Entity in our hand string entityName = node.Attributes["Name"].Value; string entityValue = node.Attributes["Name"].Value; string entityGroup = lobInstance.Attributes["Name"].Value; //LobSystemInstance string entityDescription = node.Attributes["Namespace"].Value; //LobSystemInstance NameValueItem nvitem = new NameValueItem(); nvitem.ItemType = "BCSEntity"; nvitem.Name = entityName; nvitem.Value = entityValue; nvitem.Group = entityGroup; nvitem.Description = entityDescription; nvitems.Add(nvitem); } return nvitems.ToArray(); } catch { } return new NameValueItem[0]; }
private bool ContainsDeployableItem(ProjectItem pitem) { if (pitem != null && pitem.ProjectItems != null) { foreach (ProjectItem childItem in pitem.ProjectItems) { if (childItem.Kind == EnvDTE.Constants.vsProjectItemKindPhysicalFile) { //ok, is file if (ItemIsDeployable(childItem)) { return true; } } else { if (ContainsDeployableItem(childItem)) { return true; } } } } return false; }
public IEnumerable<IStepDefinitionBinding> GetBindingsFromProjectItem(ProjectItem projectItem, out List<ProjectItem> relatedProjectItems) { var bindingProcessor = new IdeBindingSourceProcessor(tracer); relatedProjectItems = new List<ProjectItem>(); ProcessBindingsFromProjectItem(projectItem, bindingProcessor, relatedProjectItems); return bindingProcessor.ReadStepDefinitionBindings(); }
public bool RunFeatures(ProjectItem projectItem, bool debug) { if (IsAllowDebugGeneratedFilesSet(projectItem)) return runnerGateway_CodeBehind.RunFeatures(projectItem, debug); return runnerGateway_TestWindowInvoke.RunFeatures(projectItem, debug); }
bool IgnoreChildProjectItem (ProjectItem item) { if (item != null) { return SeenChildProjectItemBefore (item); } return true; }
public ProjectItemRelationship (ProjectItem parentProjectItem, MD.ProjectItem msbuildProjectItem) { this.ParentProjectItem = parentProjectItem; this.MSBuildProjectItem = msbuildProjectItem; this.Project = (Project)parentProjectItem.ContainingProject; GetRelationship (); }
public override void FixtureSetUp() { base.FixtureSetUp(); project = WebReferenceTestHelper.CreateTestProject("C#"); WebReferencesProjectItem item = new WebReferencesProjectItem(project); item.Include = "Web References\\"; ProjectService.AddProjectItem(project, item); protocol = new DiscoveryClientProtocol(); DiscoveryDocumentReference discoveryRef = new DiscoveryDocumentReference(); discoveryRef.Url = updateFromUrl; protocol.References.Add(discoveryRef); ContractReference contractRef = new ContractReference(); contractRef.Url = "http://localhost/test.asmx?wsdl"; contractRef.ClientProtocol = new DiscoveryClientProtocol(); ServiceDescription desc = new ServiceDescription(); contractRef.ClientProtocol.Documents.Add(contractRef.Url, desc); protocol.References.Add(contractRef); WebReferenceTestHelper.InitializeProjectBindings(); webReference = new Gui.WebReference(project, updateFromUrl, name, proxyNamespace, protocol); webReferencesProjectItem = WebReferenceTestHelper.GetProjectItem(webReference.Items, "Web References\\", ItemType.WebReferences); }
/// <summary> /// Loads XML from the .config file, manipulates it to possibly add an "defaultConnectionFactory" entry /// and then attempts to save the file. /// </summary> /// <remarks> /// If the file cannot be saved then it is not saved and an exception is thrown. Under normal use this should not happen /// because NuGet will have ensured that the file is writable. It would be possible to try to do things like try check out /// the file from source control, but it doesn't seem like this is valuable enough to implement given it will not normally be used. /// </remarks> public virtual void ProcessConfigFile(ProjectItem configItem, IEnumerable<Func<XDocument, bool>> manipulators) { Contract.Requires(configItem != null); var fileName = configItem.FileNames[0]; var config = XDocument.Load(fileName); var fileModified = false; foreach (var manipulator in manipulators) { fileModified = manipulator(config) || fileModified; } if (fileModified) { try { config.Save(fileName); } catch (Exception ex) { throw new IOException(Strings.SaveConnectionFactoryInConfigFailed(fileName), ex); } } }
public void Fill(SolutionBrowserForm parent, string projectType, string objectName, ProjectItem defaultPath = null) { ObjectName.Text = objectName; _parent = parent; _defaultPath = defaultPath; var enumerator = new ProjectEnumerator(); foreach (var project in enumerator.Get(projectType)) { var newNode = new TreeViewItem(); newNode.Header = project.Name; newNode.Tag = project; for (var i = 1; i <= project.ProjectItems.Count; i++) { var expandParent = false; var node = AddChildren(project.ProjectItems.Item(i), out expandParent); if (node != null) { newNode.Items.Add(node); if (expandParent) { newNode.IsExpanded = true; node.IsExpanded = true; } } } Tree.Items.Add(newNode); } }
public static Microsoft.AnalysisServices.BackEnd.DataModelingSandbox GetTabularSandboxFromProjectItem(ProjectItem projectItem, bool openIfNotOpen) { Microsoft.VisualStudio.Project.Automation.OAFileItem project = projectItem as Microsoft.VisualStudio.Project.Automation.OAFileItem; Microsoft.AnalysisServices.VSHost.VSHostManager host = GetVSHostManager(project, openIfNotOpen); if (host == null) return null; return host.Sandbox; }
public DocumentEventArgs(string documentFullPath, ProjectItem projectItem) { this.DocumentFullPath = documentFullPath; this.DocumentFileName = Path.GetFileName(documentFullPath); this.ProjectItem = projectItem; }
public bool RunScenario(ProjectItem projectItem, IScenarioBlock currentScenario, ScenarioOutlineExamplesRow examplesRow, IGherkinFileScope fileScope, bool debug) { var line = currentScenario.KeywordLine; if (examplesRow != null && examplesRow.BlockRelativeLine >= 0) line += examplesRow.BlockRelativeLine; return RunInCurrentContext(VsxHelper.GetFileName(projectItem), debug, line); }
public SProjectItem(ProjectItem item) { this.Name = item.Name; foreach(var c in item.Children) this.Children.Add(SProjectItem.Build(c)); }
public ActionResult Edit(int? id) { if (id == null) { return new HttpStatusCodeResult(HttpStatusCode.BadRequest); } var user = db.UserModels .Include("UserProjectRoles") .Include("UserProjectRoles.Role") .Where(m => m.Id == id).ToList().First(); var userProjectsList = user.UserProjectRoles.ToList(); var projectList = db.Projects.ToList(); var viewmodel = new UserViewModel(); viewmodel.Id = user.Id; viewmodel.Email = user.Email; viewmodel.FirstName = user.FirstName; viewmodel.LastName = user.LastName; viewmodel.IsAdmin = user.Admin; foreach (var item in projectList) { var toAdd = new ProjectItem(); toAdd.ProjectId = item.Id; toAdd.ProjectName = item.Name; toAdd.IsManager = userProjectsList.Where(m => m.ProjectId == item.Id && m.Role.Role1 == "Manager").ToList().Count > 0; toAdd.IsDeveloper = userProjectsList.Where(m => m.ProjectId == item.Id && m.Role.Role1 == "Developer").ToList().Count > 0; toAdd.IsSubmitter = userProjectsList.Where(m => m.ProjectId == item.Id && m.Role.Role1 == "Submitter").ToList().Count > 0; viewmodel.ProjectItems.Add(toAdd); } return View(viewmodel); }
internal static IEnumerable<IntellisenseObject> ProcessFile(ProjectItem item, HashSet<CodeClass> underProcess = null) { if (item.FileCodeModel == null) return null; List<IntellisenseObject> list = new List<IntellisenseObject>(); if (underProcess == null) underProcess = new HashSet<CodeClass>(); foreach (CodeElement element in item.FileCodeModel.CodeElements) { if (element.Kind == vsCMElement.vsCMElementNamespace) { CodeNamespace cn = (CodeNamespace)element; foreach (CodeElement member in cn.Members) { if (ShouldProcess(member)) ProcessElement(member, list, underProcess); } } else if (ShouldProcess(element)) ProcessElement(element, list, underProcess); } return new HashSet<IntellisenseObject>(list); }
internal VSProjectItemManager(DTE2 dte, ProjectItem projectItem, string fileNamePrefix) { this.dte = dte; this.projectItem = projectItem; this.filesAdded = new Dictionary<string, object>(); this.filesCreated = new List<string>(); if (this.projectItem != null) { if (string.IsNullOrEmpty(fileNamePrefix)) { fileNamePrefix = this.GetFileNamePrefix(projectItem.Name); } if (projectItem.FileCount > 0) { try { this.fullFileNamePrefix = Path.GetDirectoryName(projectItem.get_FileNames(0)) + @"\" + fileNamePrefix; } catch (System.ArgumentException) { //vs.Php raise exception } } } }
private void AddCustomToolItemBeforeQueryStatus(object sender, EventArgs e) { OleMenuCommand button = (OleMenuCommand) sender; button.Visible = false; UIHierarchyItem uiItem = GetSelectedItem(); if (uiItem == null) return; _item = uiItem.Object as ProjectItem; if (_item == null) return; if (_item.ContainingProject.Kind != PrjKind.prjKindCSharpProject && _item.ContainingProject.Kind != PrjKind.prjKindVBProject) return; string fullPath = _item.Properties.Item("FullPath").Value.ToString(); string ext = Path.GetExtension(fullPath); if (!ext.Equals(".vsct", StringComparison.OrdinalIgnoreCase)) return; button.Checked = _item.Properties.Item("CustomTool").Value.ToString() == CUSTOM_TOOL_NAME; button.Visible = true; }
public static void InternalExecute(ProjectItem projectItem) { var ctors = new List<CodeFunction>(); foreach (CodeFunction constructor in projectItem.FindContructors().Where(m => m.Parameters.Count > 0)) { var codeElement = constructor.As<CodeElement>(); string ctorText = codeElement.InnerText(); var editPoint = codeElement.AtTheFirstLineAfterTheOpeningBrakect(); bool lineAdded = false; foreach (var param in constructor.Parameters().Reverse()) { if (param.Type.CodeType.Kind != vsCMElement.vsCMElementStruct && !ctorText.Contains($"ArgumentNullException(\"{param.Name}\")")) { lineAdded = true; projectItem.AddLine(editPoint, param.Name.ToCtorNullCheck()); } } if (lineAdded) { ctors.Add(constructor); } } if (ctors.Any()) { if (!projectItem.Contains("using System;")) { projectItem.AddLine(projectItem.FindNameSpace().As<CodeElement>().AtTheFirstLineAfterTheOpeningBrakect(), "using System;"); } } foreach (CodeFunction constructor in projectItem.FindContructors().Where(m => m.Parameters.Count > 0)) { if (string.IsNullOrWhiteSpace(constructor.DocComment)) { AddCommentsToCodeElements.AddDocCommentToCtor(constructor); } var docComment = constructor.DocComment; var codeElement = constructor.As<CodeElement>(); if ((codeElement.Contains("throw new ArgumentNullException") || codeElement.Contains("throw new System.ArgumentNullException")) && (!docComment.Contains(exceptionMessage1) && !docComment.Contains(exceptionMessage2))) { codeElement.AppendToDocComment(exceptionMessage1); } } if (ctors.Any()) { var dte = (DTE)Package.GetGlobalService(typeof(SDTE)); try { dte.ExecuteCommand("Edit.FormatDocument"); } catch { } } }
private CodeDomCodeNamespace vsTopNamespace; // top-level CodeModel namespace #endregion Fields #region Constructors public CodeDomFileCodeModel(DTE dte, ProjectItem parent, CodeDomProvider provider, string filename) : base(dte, filename) { this.parent = parent; this.provider = provider as IMergableProvider; if (provider == null) throw new ArgumentException("provider must implement IMergeableProvider interface"); }
public static IEnumerable<ProjectItem> GetSelfAndChildProjectItems(ProjectItem projectItem) { yield return projectItem; for (int i = 1; i <= projectItem.ProjectItems.Count; i++) { ProjectItem item = null; try { item = projectItem.ProjectItems.Item(i); } catch (Exception ex) { // sometimes we get System.ArgumentException: The parameter is incorrect. (Exception from HRESULT: 0x80070057 (E_INVALIDARG)) // when we open some file in the text editor LogService.LogError(new Exception("Cannot evaluate items in the project!", ex)); } if (item != null) { foreach (var childItem in GetSelfAndChildProjectItems(item)) { yield return childItem; } } } }
private static IEnumerable<string> GetUnsavedModifiedProjectItems(ProjectItem projectItem) { if ((projectItem.ProjectItems != null && projectItem.ProjectItems.Count == 0) && projectItem.SubProject == null) { if (!projectItem.Saved) yield return projectItem.Name; } var projectItems = projectItem.ProjectItems == null ? new List<ProjectItem>() : projectItem.ProjectItems.OfType<ProjectItem>().ToList(); if (projectItem.SubProject != null) { if (!projectItem.SubProject.Saved) yield return projectItem.SubProject.Name; foreach (var subProjectProjectItem in projectItem.SubProject.ProjectItems.OfType<ProjectItem>().SelectMany(GetUnsavedModifiedProjectItems)) { yield return subProjectProjectItem; } } foreach (var pi in projectItems.Where(pi => !pi.Saved)) { yield return pi.Name; } }
private void SetIconIndexes(ProjectItem item, TreeNode node) { switch (item.Kind) { case Constants.vsProjectItemKindPhysicalFolder: // UNDONE: icon resources could be pulled from VS. if (item.Name == "Configuration" || item.Name == "Properties") { node.ImageIndex = 34; node.SelectedImageIndex = 2; } else if (item.Name == "Web References") { node.ImageIndex = 37; node.SelectedImageIndex = 2; } else if (HasProperty(item.Properties, "WebReference")) { node.ImageIndex = 36; node.SelectedImageIndex = 36; } else { node.ImageIndex = 3; node.SelectedImageIndex = 4; } break; case Constants.vsProjectItemKindPhysicalFile: try { // Try to get the dependent property. if (item.Properties.Item("IsDependentFile").Value.ToString() == Boolean.TrueString) { node.ImageIndex = 35; node.SelectedImageIndex = 35; break; } } catch { } switch (Path.GetExtension(item.get_FileNames(1))) { case ".ascx": node.ImageIndex = 5; node.SelectedImageIndex = 5; break; case ".asmx": node.ImageIndex = 6; node.SelectedImageIndex = 6; break; case ".aspx": node.ImageIndex = 7; node.SelectedImageIndex = 7; break; case ".bmp": case ".png": case ".gif": case ".jpg": node.ImageIndex = 8; node.SelectedImageIndex = 8; break; case ".config": node.ImageIndex = 9; node.SelectedImageIndex = 9; break; case ".cs": node.ImageIndex = 11; node.SelectedImageIndex = 11; break; case ".disco": node.ImageIndex = 14; node.SelectedImageIndex = 14; break; case ".html": case ".htm": node.ImageIndex = 15; node.SelectedImageIndex = 15; break; case ".ico": node.ImageIndex = 16; node.SelectedImageIndex = 16; break; case ".js": node.ImageIndex = 18; node.SelectedImageIndex = 18; break; case ".resx": node.ImageIndex = 21; node.SelectedImageIndex = 21; break; case ".wsdl": node.ImageIndex = 23; node.SelectedImageIndex = 23; break; case ".settings": node.ImageIndex = 24; node.SelectedImageIndex = 24; break; case ".css": node.ImageIndex = 25; node.SelectedImageIndex = 25; break; case ".txt": node.ImageIndex = 26; node.SelectedImageIndex = 26; break; case ".vbs": node.ImageIndex = 28; node.SelectedImageIndex = 28; break; case ".wsf": node.ImageIndex = 30; node.SelectedImageIndex = 30; break; case ".xml": node.ImageIndex = 31; node.SelectedImageIndex = 31; break; case ".xsd": node.ImageIndex = 32; node.SelectedImageIndex = 32; break; case ".xsl": node.ImageIndex = 33; node.SelectedImageIndex = 33; break; default: node.ImageIndex = 17; node.SelectedImageIndex = 17; break; } break; default: node.ImageIndex = 11; node.SelectedImageIndex = 11; break; } }
internal static bool TryGetBufferViaExtensions( IServiceProvider serviceProvider, ProjectItem projectItem, string fileContents, Lazy <IModelConversionExtension, IEntityDesignerConversionData>[] converters, Lazy <IModelTransformExtension>[] serializers, out string documentViaExtensions, out List <ExtensionError> errors) { Debug.Assert(serviceProvider != null, "serviceProvider != null"); Debug.Assert(projectItem != null, "projectItem != null"); Debug.Assert(VsUtils.EntityFrameworkSupportedInProject(projectItem.ContainingProject, serviceProvider, false)); Debug.Assert(serializers != null && converters != null, "extensions must not be null"); Debug.Assert(serializers.Any() || converters.Any(), "at least one extension expected"); errors = new List <ExtensionError>(); documentViaExtensions = ""; ModelConversionContextImpl conversionContext = null; ModelTransformContextImpl transformContext = null; try { var targetSchemaVersion = EdmUtils.GetEntityFrameworkVersion(projectItem.ContainingProject, serviceProvider); Debug.Assert(targetSchemaVersion != null, "should not get here for a Misc project"); // get the extension of the file being loaded (might not be EDMX); this API will include the preceding "." var filePath = projectItem.get_FileNames(1); var fileExtension = Path.GetExtension(filePath); XDocument originalDocument = null; // see if we are loading an EDMX file or not, and if we have any converters if (!string.Equals( fileExtension, EntityDesignArtifact.ExtensionEdmx, StringComparison.OrdinalIgnoreCase)) { conversionContext = new ModelConversionContextImpl( projectItem.ContainingProject, projectItem, new FileInfo(filePath), targetSchemaVersion, fileContents); // we aren't loading an EDMX file, so call the extensions who can process this file extension // when this finishes, then output should be a valid EDMX document VSArtifact.DispatchToConversionExtensions(converters, fileExtension, conversionContext, true); // we are done with the non-EDMX extensions so CurrentDocument will be a valid EDMX document // create the serialization context for further extensions to act on transformContext = new ModelTransformContextImpl( projectItem, targetSchemaVersion, conversionContext.CurrentDocument); } else { // we are loading an EDMX file, we can parse file contents into an XDocument try { originalDocument = XDocument.Parse(fileContents, LoadOptions.PreserveWhitespace); transformContext = new ModelTransformContextImpl( projectItem, targetSchemaVersion, originalDocument); } catch (XmlException) { // If there's an error here, don't do anything. We will want to gracefully step out of the extension loading // since the designer itself won't load. } } if (transformContext != null && originalDocument != null) { // now dispatch to those that want to work on EDMX files VSArtifact.DispatchToSerializationExtensions(serializers, transformContext, true); // TODO: this does not seem to be correct if severity is Message or Warning if (transformContext.Errors.Count == 0) { // see if any extension changed things. Note that we need to compare the serialization of // the XDocuments together since the original buffer may have different whitespace after creating the XDocument. // TODO: Why not use XNode.DeepEquals()? string newBufferContents; using (var currentDocWriter = new Utf8StringWriter()) { transformContext.CurrentDocument.Save(currentDocWriter, SaveOptions.None); newBufferContents = currentDocWriter.ToString(); } string originalBufferContents; using (var originalDocWriter = new Utf8StringWriter()) { originalDocument.Save(originalDocWriter, SaveOptions.None); originalBufferContents = originalDocWriter.ToString(); } if (!string.Equals(originalBufferContents, newBufferContents, StringComparison.Ordinal)) { documentViaExtensions = newBufferContents; return(true); } } else { errors.AddRange(transformContext.Errors); return(false); } } } finally { var errorList = ErrorListHelper.GetExtensionErrorList(serviceProvider); errorList.Clear(); // log any errors if (conversionContext != null && conversionContext.Errors.Count > 0) { ErrorListHelper.LogExtensionErrors(conversionContext.Errors, projectItem); } if (transformContext != null && transformContext.Errors.Count > 0) { ErrorListHelper.LogExtensionErrors(transformContext.Errors, projectItem); } } return(false); }
/// <summary> /// Adds the plugins. /// </summary> /// <param name="visualStudioService">The visual studio service.</param> /// <param name="plugins">The plugins.</param> /// <param name="viewModelName">Name of the view model.</param> /// <param name="codeSnippetsPath">The code snippets path.</param> public void AddPlugins( IVisualStudioService visualStudioService, List <Plugin> plugins, string viewModelName, string codeSnippetsPath) { Project coreProject = visualStudioService.CoreProject; this.AddProjectPlugins(coreProject, plugins, "Core", "Core"); this.AddProjectPlugins(visualStudioService.DroidProject, plugins, "Droid", "Droid"); this.AddProjectPlugins(visualStudioService.iOSProject, plugins, "iOS", "Touch"); this.AddProjectPlugins(visualStudioService.WindowsPhoneProject, plugins, "WindowsPhone", "WindowsPhone"); this.AddProjectPlugins(visualStudioService.WindowsStoreProject, plugins, "WindowsStore", "WindowsStore"); this.AddProjectPlugins(visualStudioService.WpfProject, plugins, "Wpf", "Wpf"); if (string.IsNullOrEmpty(viewModelName) == false) { ProjectItem projectItem = coreProject.GetProjectItem(viewModelName); if (projectItem != null) { foreach (Plugin plugin in plugins) { string snippetPath = string.Format(@"{0}\Plugins.{1}.txt", codeSnippetsPath, plugin.FriendlyName); if (File.Exists(snippetPath)) { FileInfo fileInfo = new FileInfo(snippetPath); //// only do if the snippet contains some text :-) if (fileInfo.Length > 0) { string assemblyName = Path.GetFileNameWithoutExtension(plugin.FileName); projectItem.AddUsingStatement("Cirrious.CrossCore"); projectItem.AddUsingStatement(assemblyName); projectItem.InsertMethod(snippetPath); //// tidy up the using statements. projectItem.Save(); projectItem.MoveUsingStatements(); projectItem.Save(); projectItem.SortAndRemoveUsingStatements(); projectItem.Save(); if (projectItem.Document != null) { projectItem.Document.ActiveWindow.Close(); } } } } } } DTE2 dte2 = coreProject.DTE as DTE2; dte2.SaveAll(); }
// This method is only called for item templates, // not for project templates. public void ProjectItemFinishedGenerating(ProjectItem projectItem) { }
// This method is called before opening any item that // has the OpenInEditor attribute. public void BeforeOpeningFile(ProjectItem projectItem) { }
public void RequestAnalysis(string path, string charset, IEnumerable <SonarLanguage> detectedLanguages, IIssueConsumer issueConsumer, ProjectItem projectItem) { bool handled = false; foreach (var language in detectedLanguages) { switch (language) { case SonarLanguage.Javascript: handled = true; daemon.RequestAnalysis(path, charset, "js", null, issueConsumer); break; case SonarLanguage.CFamily: handled = true; CFamily.ProcessFile(daemon, issueConsumer, logger, projectItem, path, charset); break; default: break; } } if (!handled) { logger.WriteLine($"Unsupported content type for {path}"); } }
/// <summary> /// Initializes a new instance of the <see cref="VSMDLuaCodeDomProvider"/> class. /// </summary> /// <param name="projectItem">ProjectItem instance.</param> public VSMDLuaCodeDomProvider(ProjectItem projectItem) { codeDomProvider = new LuaCodeDomProvider(projectItem); }
public BindingFileInfo(ProjectItem projectItem) { ProjectRelativePath = VsxHelper.GetProjectRelativePath(projectItem); LastChangeDate = VsxHelper.GetLastChangeDate(projectItem) ?? DateTime.MinValue; }
public FileModel(SolutionModelBase parent, ProjectItem file) : base(parent) { this.file = file; }
protected override void OnFileBecomesIrrelevant(ProjectItem item, string oldName) { OnFileOutOfScope(item, GetProjectRelativePathWithFileName(item, oldName)); }
public void TestInitialize() { TestEnvironment.CommonTestInitialize(); _projectItem = TestEnvironment.LoadFileIntoProject(@"Data\SortUsingStatements.cs"); }
protected override BindingFileInfo CreateFileInfo(ProjectItem projectItem) { return(new BindingFileInfo(projectItem)); }
/// <summary> /// Initializes a new instance of the <see cref="T:System.Object" /> class. /// </summary> public AnnotationProjectItem(ProjectItem dteProjectItem) : base(dteProjectItem) { }
public void RequestAnalysis(string path, string charset, IEnumerable <AnalysisLanguage> detectedLanguages, IIssueConsumer issueConsumer, ProjectItem projectItem) { // May be called on the UI thread -> unhandled exceptions will crash VS try { analyzerController.ExecuteAnalysis(path, charset, detectedLanguages, issueConsumer, projectItem); } catch (Exception ex) when(!Microsoft.VisualStudio.ErrorHandler.IsCriticalException(ex)) { logger.WriteLine($"Analysis error: {ex.ToString()}"); } }
// <summary> // This method will log errors to the "Extension" Multi-doc error list. // </summary> internal static void LogExtensionErrors(IEnumerable <ExtensionError> errors, ProjectItem projectItem) { if (null == errors) { throw new ArgumentNullException("errors"); } if (null == projectItem) { throw new ArgumentNullException("projectItem"); } if (PackageManager.Package != null) { var hierarchy = VsUtils.GetVsHierarchy(projectItem.ContainingProject, Services.ServiceProvider); var itemId = VsUtils.GetProjectItemId(hierarchy, projectItem); var errorList = GetExtensionErrorList(PackageManager.Package); var errorCount = 0; foreach (var error in errors) { // only display the first 100 errors. VS gets really slow if you try to display more if (errorCount++ > 99) { break; } var category = TaskErrorCategory.Message; if (error.Severity == ExtensionErrorSeverity.Error) { category = TaskErrorCategory.Error; } else if (error.Severity == ExtensionErrorSeverity.Warning) { category = TaskErrorCategory.Warning; } string filePath = null; var fullPathProperty = projectItem.Properties.Item("FullPath"); if (fullPathProperty != null) { filePath = fullPathProperty.Value as String; } if (filePath == null) { filePath = projectItem.Name; } var textSpan = new TextSpan(); textSpan.iStartLine = error.Line; textSpan.iStartIndex = error.Column; textSpan.iEndLine = error.Line; textSpan.iEndIndex = error.Column; errorList.AddItem( EFModelErrorTaskFactory.CreateErrorTask( filePath, error.Message, textSpan, category, hierarchy, itemId, MARKERTYPE.MARKER_OTHER_ERROR)); } } }
public void TestInitialize() { TestEnvironment.CommonTestInitialize(); _projectItem = TestEnvironment.LoadFileIntoProject(@"Data\SortAtBottom.cs"); }
void IWizard.BeforeOpeningFile(ProjectItem projectItem) { }
// <summary> // Logs SchemaErrors to the a special provider for wizard errors. We won't ever clear this provider, // because we have no way to get the wizard errors back. This way, they will persist for the time that // the document is open. This will log errors to the 'Wizard' multi-doc error list. // </summary> internal static void LogWizardErrors(IEnumerable <EdmSchemaError> errors, ProjectItem projectItem) { LogWizardErrors(errors, projectItem, MARKERTYPE.MARKER_COMPILE_ERROR); }
public static IProjectItemAccessor Access(this ProjectItem projectItem) { return(GetterFactory(projectItem)); }
void IWizard.ProjectItemFinishedGenerating(ProjectItem projectItem) { }
public void ProjectItemFinishedGenerating(ProjectItem projectItem) { throw new NotImplementedException(); }
public static IProjectItemPredicator Is(this ProjectItem projectItem) { return(PredicatorFactory(projectItem)); }
public void TestInitialize() { TestEnvironment.CommonTestInitialize(); _projectItem = TestEnvironment.LoadFileIntoProject(@"Data\VisualBasic.vb"); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private async void Execute(object sender, EventArgs e) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); DTE dte = (DTE)await this.ServiceProvider.GetServiceAsync(typeof(DTE)); foreach (SelectedItem item in dte.SelectedItems) { ProjectItem pi = item.ProjectItem; string tarsPath = null; switch (pi.ContainingProject.CodeModel.Language) { case CodeModelLanguageConstants.vsCMLanguageCSharp: tarsPath = this.tars2csPath; break; case CodeModelLanguageConstants.vsCMLanguageVC: break; default: break; } if (tarsPath != null) { string srcFile = pi.FileNames[0]; string tmpFile = Path.GetTempPath() + pi.GetHashCode() + ".tars"; File.Copy(srcFile, tmpFile, true); string targetPath = srcFile + "_"; string path = Path.GetTempPath() + pi.GetHashCode(); if (Directory.Exists(path)) { Directory.Delete(path, true); } Directory.CreateDirectory(path); ProjectItems pis = pi.Collection; try { pis.Item(pi.Name + "_").Delete(); } catch { } if (Directory.Exists(targetPath)) { Directory.Delete(targetPath, true); } pi = pis.AddFolder(pi.Name + "_"); ProcessStartInfo psi = new ProcessStartInfo(tarsPath, $"--base-package= \"{tmpFile}\""); psi.UseShellExecute = false; psi.CreateNoWindow = true; psi.WorkingDirectory = path; psi.RedirectStandardError = true; using (Process p = Process.Start(psi)) { if (p?.WaitForExit(10 * 1000) == true) { IVsOutputWindowPane outputPane = (IVsOutputWindowPane)await this.ServiceProvider.GetServiceAsync(typeof(SVsGeneralOutputWindowPane)); outputPane.OutputString(p.StandardError.ReadToEnd()); //string targetPath = Path.GetDirectoryName(srcFile); this.AddLinks(pi, path, targetPath); } } Directory.Delete(path, true); File.Delete(tmpFile); } } }
public void BeforeOpeningFile(ProjectItem projectItem) { // Method intentionally left empty. }
public void BeforeOpeningFile(ProjectItem projectItem) { throw new NotImplementedException(); }
public void CheckGenerateTypeScriptOutput() { // get the DTE reference... DTE dte = SolutionWorker.GetVisualStudioInstanceOfTypeScriptDefinitionGenerator(); var worker = new SolutionWorker(); worker.ExamineSolution(dte.Solution); var testFiles = new System.Collections.Generic.Dictionary <string, string> { { "SomeEnum.cs", "// ------------------------------------------------------------------------------\n" + "// <auto-generated>\n" + "// This file was generated by TypeScript Definition Generator v2.2.0.0\n" + "// </auto-generated>\n" + "// ------------------------------------------------------------------------------\n" + "export enum SomeEnum {\n" + " This,\n" + " That,\n" + "}\n" }, { "SecondClass.cs", "// ------------------------------------------------------------------------------\n" + "// <auto-generated>\n" + "// This file was generated by TypeScript Definition Generator v2.2.0.0\n" + "// </auto-generated>\n" + "// ------------------------------------------------------------------------------\n" + "import { SomeClass } from \"./SomeClass.generated\";\n" + "import { SomeSomeClass } from \"./SomeSomeClass.generated\";\n" + "export interface SecondClass {\n" + " myProperty: number;\n" + " complex1: SomeClass;\n" + " complex2: SomeSomeClass;\n" + "}\n" }, { "SomeClass.cs", "// ------------------------------------------------------------------------------\n" + "// <auto-generated>\n" + "// This file was generated by TypeScript Definition Generator v2.2.0.0\n" + "// </auto-generated>\n" + "// ------------------------------------------------------------------------------\n" + "import { SomeEnum } from \"./SomeEnum.generated\";\n" + "export interface SomeClass {\n" + " inc1: number;\n" + " some: SomeEnum;\n" + "}\n" }, { "SomeSomeClass.cs", "// ------------------------------------------------------------------------------\n" + "// <auto-generated>\n" + "// This file was generated by TypeScript Definition Generator v2.2.0.0\n" + "// </auto-generated>\n" + "// ------------------------------------------------------------------------------\n" + "import { SomeClass } from \"./SomeClass.generated\";\n" + "export interface SomeSomeClass extends SomeClass {\n" + " inc2: number;\n" + " inc3: number;\n" + " inc4: number;\n" + " inc5: number;\n" + " inc6: string;\n" + " inc7: any;\n" + " inc8: number[];\n" + " inc9: number[];\n" + " inc10: number[];\n" + " inc11: number[];\n" + " inc12: boolean;\n" + " inc13: { [index: string]: number };\n" + " inc14: { [index: string]: number };\n" + "}\n" }, { "ThirdClass.cs", "// ------------------------------------------------------------------------------\n" + "// <auto-generated>\n" + "// This file was generated by TypeScript Definition Generator v2.2.0.0\n" + "// </auto-generated>\n" + "// ------------------------------------------------------------------------------\n" + "import { SomeClass } from \"../SomeClass.generated\";\n" + "import { SomeSomeClass } from \"../SomeSomeClass.generated\";\n" + "export interface ThirdClass {\n" + " myProperty: number;\n" + " complex1: SomeClass;\n" + " complex2: SomeSomeClass;\n" + "}\n" } }; foreach (var testFile in testFiles) { var testFileName = testFile.Key; var expectedFile = testFile.Value; ProjectItem item = worker.GetProjectItem(dte.Solution, testFileName); Assert.NotNull(item, $"Could not find {testFileName}"); Options.SetOptionsOverrides(new OptionsOverride() { CamelCaseEnumerationValues = false, CamelCasePropertyNames = true, CamelCaseTypeNames = false, WebEssentials2015 = false, ClassInsteadOfInterface = false, DeclareModule = false, DefaultModuleName = "Server.Dtos", EOLType = EOLType.LF, IgnoreIntellisense = true, IndentTab = false, IndentTabSize = 2, UseNamespace = true, }); var list = IntellisenseParser.ProcessFile(item).ToList(); var sourceItemPath = item.Properties.Item("FullPath").Value as string; var tsFile = IntellisenseWriter.WriteTypeScript(list, sourceItemPath); Assert.AreEqual(expectedFile, tsFile); } }
public void ProjectItemFinishedGenerating(ProjectItem projectItem) { // Method intentionally left empty. }
private bool SetValue(object currentValue, out object newValue) { if (currentValue != null) { newValue = null; return(false); } DTE dte = this.GetService <DTE>(true); //first we need the xpath, which is needed by the manifest-recipe string manifestXpath = ""; string manifestXpathNamespace = ""; IConfigurationService b = (IConfigurationService)GetService(typeof(IConfigurationService)); Microsoft.Practices.RecipeFramework.Configuration.Recipe recipe = b.CurrentRecipe; if (recipe.HostData.Any.Attributes["XPath"] != null) { manifestXpath = recipe.HostData.Any.Attributes["XPath"].Value; } if (recipe.HostData.Any.Attributes["XPathNamespace"] != null) { manifestXpathNamespace = recipe.HostData.Any.Attributes["XPathNamespace"].Value; } //if file is selected we check, if the xpath can be found in this item //if folder is selected we search in this folder for the elements.xml which contains the xpath if (dte.SelectedItems.Count > 0) { SelectedItem item = dte.SelectedItems.Item(1); ProjectItem selectedItem = null; if (item is ProjectItem) { selectedItem = item as ProjectItem; } else if (item.ProjectItem is ProjectItem) { selectedItem = item.ProjectItem as ProjectItem; } if (selectedItem != null) { if (selectedItem.Kind == EnvDTE.Constants.vsProjectItemKindPhysicalFile) { if (selectedItem.Collection.Parent is ProjectItem) { ProjectItem parentItem = selectedItem.Collection.Parent as ProjectItem; newValue = parentItem; return(true); } } else if (selectedItem.Kind == EnvDTE.Constants.vsProjectItemKindPhysicalFolder) { newValue = selectedItem; return(true); } } } newValue = null; return(false); }
public void _ShouldWorkProperly() { //Arrange // get the DTE reference... DTE dte = SolutionWorker.GetVisualStudioInstanceOfTypeScriptDefinitionGenerator(); var worker = new SolutionWorker(); worker.ExamineSolution(dte.Solution); ProjectItem item = worker.GetProjectItem(dte.Solution, "Class1.cs"); if (item == null) { throw new System.ArgumentNullException(nameof(item), "Class1.cs not found in solution. Close all other instances of Visual Studio!"); } //Act Options.SetOptionsOverrides(new OptionsOverride() { CamelCaseEnumerationValues = false, CamelCasePropertyNames = true, CamelCaseTypeNames = false, WebEssentials2015 = false, ClassInsteadOfInterface = false, DefaultModuleName = "Server.Dtos", UseNamespace = true, DeclareModule = true, IgnoreIntellisense = true, }); var list = IntellisenseParser.ProcessFile(item).ToList(); var sourceItemPath = item.Properties.Item("FullPath").Value as string; var tsFile = IntellisenseWriter.WriteTypeScript(list, sourceItemPath); //Assert Assert.IsNotNull(list); Assert.NotZero(list.Count); Assert.AreEqual("TypeScriptDefinitionGenerator.Tests.Class1", list[0].FullName); Assert.AreEqual("Class1", list[0].Name); Assert.AreEqual(5, list[0].Properties.Count); Assert.AreEqual("IntEnumField", list[0].Properties[1].Name); Assert.AreEqual("IntEnumField", list[0].Properties[1].NameWithOption); Assert.AreEqual(null, list[0].Properties[1].InitExpression); Assert.AreEqual(null, list[0].Properties[1].Summary); Assert.AreEqual("TypeScriptDefinitionGenerator.Tests.IntEnum", list[0].Properties[1].Type.CodeName); Assert.AreNotEqual("any", list[0].Properties[1].Type.TypeScriptName); Assert.AreEqual("TypeScriptDefinitionGenerator.Tests.IntEnum", list[0].Properties[1].Type.TypeScriptName); Assert.AreNotEqual(null, list[0].Properties[1].Type.ClientSideReferenceName); Assert.AreEqual("TypeScriptDefinitionGenerator.Tests.IntEnum", list[0].Properties[1].Type.ClientSideReferenceName); Assert.AreEqual(false, list[0].Properties[1].Type.IsArray); Assert.AreEqual(false, list[0].Properties[1].Type.IsDictionary); Assert.AreEqual(true, list[0].Properties[1].Type.IsKnownType); Assert.AreEqual(false, list[0].Properties[1].Type.IsOptional); Assert.AreEqual("SomeEnumField", list[0].Properties[3].Name); Assert.AreEqual("SomeEnumField", list[0].Properties[3].NameWithOption); Assert.AreEqual(null, list[0].Properties[3].InitExpression); Assert.AreEqual(null, list[0].Properties[3].Summary); Assert.AreEqual("ClassLibrary1.SomeEnum", list[0].Properties[3].Type.CodeName); Assert.AreNotEqual("any", list[0].Properties[3].Type.TypeScriptName); Assert.AreEqual("ClassLibrary1.SomeEnum", list[0].Properties[3].Type.TypeScriptName); Assert.AreNotEqual(null, list[0].Properties[3].Type.ClientSideReferenceName); Assert.AreEqual("ClassLibrary1.SomeEnum", list[0].Properties[3].Type.ClientSideReferenceName); Assert.AreEqual(false, list[0].Properties[3].Type.IsArray); Assert.AreEqual(false, list[0].Properties[3].Type.IsDictionary); Assert.AreEqual(true, list[0].Properties[3].Type.IsKnownType); Assert.AreEqual(false, list[0].Properties[3].Type.IsOptional); Assert.AreEqual("SomeSomeClassField", list[0].Properties[4].Name); Assert.AreEqual("SomeSomeClassField", list[0].Properties[4].NameWithOption); Assert.AreEqual(null, list[0].Properties[4].InitExpression); Assert.AreEqual(null, list[0].Properties[4].Summary); Assert.AreEqual("ClassLibrary1.SomeSomeClass", list[0].Properties[4].Type.CodeName); Assert.AreNotEqual("any", list[0].Properties[4].Type.TypeScriptName); Assert.AreEqual("ClassLibrary1.SomeSomeClass", list[0].Properties[4].Type.TypeScriptName); Assert.AreNotEqual(null, list[0].Properties[4].Type.ClientSideReferenceName); Assert.AreEqual("ClassLibrary1.SomeSomeClass", list[0].Properties[4].Type.ClientSideReferenceName); Assert.AreEqual(false, list[0].Properties[4].Type.IsArray); Assert.AreEqual(false, list[0].Properties[4].Type.IsDictionary); Assert.AreEqual(true, list[0].Properties[4].Type.IsKnownType); Assert.AreEqual(false, list[0].Properties[4].Type.IsOptional); Assert.AreEqual(13, list[0].Properties[4].Type.Shape.Count()); // Inc6 Assert.AreEqual("System.Guid", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc6").Type.CodeName); Assert.AreNotEqual("any", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc6").Type.TypeScriptName); Assert.AreEqual("string", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc6").Type.TypeScriptName); // Inc13 Assert.AreEqual("System.Collections.Generic.Dictionary<string, int>", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc13").Type.CodeName); Assert.AreEqual("System.Collections.Generic.Dictionary", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc13").Type.ClientSideReferenceName); Assert.AreEqual(true, list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc13").Type.IsDictionary); Assert.AreEqual("{ [index: string]: number }", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc13").Type.TypeScriptName); // Inc14 Assert.AreEqual("System.Collections.Generic.IDictionary<string, int>", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc14").Type.CodeName); Assert.AreEqual("System.Collections.Generic.IDictionary", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc14").Type.ClientSideReferenceName); Assert.AreEqual(true, list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc14").Type.IsDictionary); Assert.AreEqual("{ [index: string]: number }", list[0].Properties[4].Type.Shape.First(o => o.Name == "Inc14").Type.TypeScriptName); }