Example #1
0
        [Ignore] //UNDONE: getting assertion
        public void TestPublicResxFileCodeGeneratorMethod()
        {
            string filePath                  = @"C:\temp\dummy.resx";
            string expectedClassName         = System.IO.Path.GetFileNameWithoutExtension(filePath);
            IVsSingleFileGenerator generator = CreatePublicResxFileCodeGenerator();

            Assert.IsNotNull(generator);

            string generatedCode = GenerateCode(generator, filePath);

            Assert.IsTrue(generatedCode.Contains(String.Format("Public Class {0}", expectedClassName)));
        }
Example #2
0
        private static string GenerateCode(IVsSingleFileGenerator generator, string filePath)
        {
            uint pcbOutput;

            IntPtr[] outputFileContents = new IntPtr[1];

            ((Microsoft.VisualStudio.OLE.Interop.IObjectWithSite)generator).SetSite(new ResxSingleFileGeneratorSite(EnvDTE.CodeModelLanguageConstants.vsCMLanguageVB));
            generator.Generate(filePath, CreateDummyResourceFile(), "", outputFileContents, out pcbOutput, null);

            byte[] data = new byte[pcbOutput];
            System.Runtime.InteropServices.Marshal.Copy(outputFileContents[0], data, 0, (int)pcbOutput);
            return(System.Text.Encoding.UTF8.GetString(data));
        }
        private void TestGenerate <G>(string language,
                                      out int hr,
                                      out IntPtr[] fileContents,
                                      out uint bytesOutput,
                                      out System.CodeDom.CodeCompileUnit compileUnit,
                                      out System.CodeDom.CodeTypeDeclaration typeDeclaration)
            where G : Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGeneratorBase, new()
        {
            SettingsSingleFileGeneratorSite site = new SettingsSingleFileGeneratorSite(language);
            string inputFile = site.DefaultSettingsFilePath;

            Mock <G> generatorMock = new Mock <G>();

            System.CodeDom.CodeCompileUnit     actualCompileUnit     = null;
            System.CodeDom.CodeTypeDeclaration actualTypeDeclaration = null;

            generatorMock.Implement("GetProjectRootNamespace", "MyLittleNamespace");
            generatorMock.Implement("AddRequiredReferences", new object[] { (Shell.Interop.IVsGeneratorProgress)null });
            generatorMock.Implement("OnCompileUnitCreated",
                                    new object[] { MockConstraint.IsAnything <System.CodeDom.CodeCompileUnit>(), MockConstraint.IsAnything <System.CodeDom.CodeTypeDeclaration>() },
                                    delegate(object obj, System.Reflection.MethodInfo method, object[] arguments)
            {
                actualCompileUnit     = (System.CodeDom.CodeCompileUnit)arguments[0];
                actualTypeDeclaration = (System.CodeDom.CodeTypeDeclaration)arguments[1];
                return(null);
            });

            IVsSingleFileGenerator generator = generatorMock.Instance;

            ((Microsoft.VisualStudio.OLE.Interop.IObjectWithSite)generator).SetSite(site);

            fileContents = new IntPtr[] { new IntPtr() };
            bytesOutput  = 0;
            hr           = generator.Generate(inputFile, "", "", fileContents, out bytesOutput, null);

            compileUnit     = actualCompileUnit;
            typeDeclaration = actualTypeDeclaration;
        }
        /// <summary>
        /// Creates an instance of the single file generator requested
        /// </summary>
        /// <param name="progId">prog id of the generator to be created. For e.g HKLM\SOFTWARE\Microsoft\VisualStudio\9.0Exp\Generators\[prjfacguid]\[wszProgId]</param>
        /// <param name="generatesDesignTimeSource">GeneratesDesignTimeSource key value</param>
        /// <param name="generatesSharedDesignTimeSource">GeneratesSharedDesignTimeSource key value</param>
        /// <param name="useTempPEFlag">UseDesignTimeCompilationFlag key value</param>
        /// <param name="generate">IVsSingleFileGenerator interface</param>
        /// <returns>S_OK if succesful</returns>
        public virtual int CreateGeneratorInstance(string progId, out int generatesDesignTimeSource, out int generatesSharedDesignTimeSource, out int useTempPEFlag, out IVsSingleFileGenerator generate)
        {
            Guid genGuid;

            ErrorHandler.ThrowOnFailure(this.GetGeneratorInformation(progId, out generatesDesignTimeSource, out generatesSharedDesignTimeSource, out useTempPEFlag, out genGuid));

            //Create the single file generator and pass it out. Check to see if it is in the cache
            if (!this.generatorsMap.ContainsKey(progId) || ((this.generatorsMap[progId]).Generator == null))
            {
                Guid   riid        = VSConstants.IID_IUnknown;
                uint   dwClsCtx    = (uint)CLSCTX.CLSCTX_INPROC_SERVER;
                IntPtr genIUnknown = IntPtr.Zero;
                //create a new one.
                ErrorHandler.ThrowOnFailure(this.LocalRegistry.CreateInstance(genGuid, null, ref riid, dwClsCtx, out genIUnknown));
                if (genIUnknown != IntPtr.Zero)
                {
                    try
                    {
                        object generator = Marshal.GetObjectForIUnknown(genIUnknown);
                        //Build the generator meta data object and cache it.
                        GeneratorMetaData genData = new GeneratorMetaData();
                        genData.GeneratesDesignTimeSource       = generatesDesignTimeSource;
                        genData.GeneratesSharedDesignTimeSource = generatesSharedDesignTimeSource;
                        genData.UseDesignTimeCompilationFlag    = useTempPEFlag;
                        genData.GeneratorClsid     = genGuid;
                        genData.Generator          = generator;
                        this.generatorsMap[progId] = genData;
                    }
                    finally
                    {
                        Marshal.Release(genIUnknown);
                    }
                }
            }

            generate = (this.generatorsMap[progId]).Generator as IVsSingleFileGenerator;

            return(VSConstants.S_OK);
        }
        /// <summary>
        /// Creates an instance of the single file generator requested
        /// </summary>
        /// <param name="progId">prog id of the generator to be created. For e.g HKLM\SOFTWARE\Microsoft\VisualStudio\9.0Exp\Generators\[prjfacguid]\[wszProgId]</param>
        /// <param name="generatesDesignTimeSource">GeneratesDesignTimeSource key value</param>
        /// <param name="generatesSharedDesignTimeSource">GeneratesSharedDesignTimeSource key value</param>
        /// <param name="useTempPEFlag">UseDesignTimeCompilationFlag key value</param>
        /// <param name="generate">IVsSingleFileGenerator interface</param>
        /// <returns>S_OK if succesful</returns>
        public virtual int CreateGeneratorInstance(string progId, out int generatesDesignTimeSource, out int generatesSharedDesignTimeSource, out int useTempPEFlag, out IVsSingleFileGenerator generate)
        {
            Guid genGuid;
            ErrorHandler.ThrowOnFailure(this.GetGeneratorInformation(progId, out generatesDesignTimeSource, out generatesSharedDesignTimeSource, out useTempPEFlag, out genGuid));

            //Create the single file generator and pass it out. Check to see if it is in the cache
            if(!this.generatorsMap.ContainsKey(progId) || ((this.generatorsMap[progId]).Generator == null))
            {
                Guid riid = VSConstants.IID_IUnknown;
                uint dwClsCtx = (uint)CLSCTX.CLSCTX_INPROC_SERVER;
                IntPtr genIUnknown = IntPtr.Zero;
                //create a new one.
                ErrorHandler.ThrowOnFailure(this.LocalRegistry.CreateInstance(genGuid, null, ref riid, dwClsCtx, out genIUnknown));
                if(genIUnknown != IntPtr.Zero)
                {
                    try
                    {
                        object generator = Marshal.GetObjectForIUnknown(genIUnknown);
                        //Build the generator meta data object and cache it.
                        GeneratorMetaData genData = new GeneratorMetaData();
                        genData.GeneratesDesignTimeSource = generatesDesignTimeSource;
                        genData.GeneratesSharedDesignTimeSource = generatesSharedDesignTimeSource;
                        genData.UseDesignTimeCompilationFlag = useTempPEFlag;
                        genData.GeneratorClsid = genGuid;
                        genData.Generator = generator;
                        this.generatorsMap[progId] = genData;
                    }
                    finally
                    {
                        Marshal.Release(genIUnknown);
                    }
                }
            }

            generate = (this.generatorsMap[progId]).Generator as IVsSingleFileGenerator;

            return VSConstants.S_OK;
        }
        public static int Main(string[] args)
        {
            // Validate the argument.
            if (args == null)
            {
                throw new ArgumentNullException(nameof(args));
            }

            // These are the parameters that are parsed out of the command line.
            string inputFilePath   = string.Empty;
            string outputFileName  = string.Empty;
            string targetNamespace = "DefaultNamespace";

            try
            {
                // The command line parser is driven by different states that are triggered by the flags read.  Unless a flag has been parsed, the command line
                // parser assumes that it's reading the file name from the command line.
                ArgumentState argumentState = ArgumentState.InputFileName;

                // Parse the command line for arguments.
                foreach (string argument in args)
                {
                    // Use the dictionary to transition from one state to the next based on the input parameters.
                    ArgumentState nextArgumentState;
                    if (Program.ArgumentStates.TryGetValue(argument, out nextArgumentState))
                    {
                        argumentState = nextArgumentState;
                        continue;
                    }

                    // The parsing state will determine which variable is read next.
                    switch (argumentState)
                    {
                    case ArgumentState.InputFileName:

                        // Expand the environment variables so that paths don't need to be absolute.
                        inputFilePath = Environment.ExpandEnvironmentVariables(argument);

                        // The output name defaults to the input file name with a new extension.
                        outputFileName = $"{Path.GetFileNameWithoutExtension(inputFilePath)}.cs";

                        break;

                    case ArgumentState.OutputFileName:

                        // Expand the environment variables so that paths don't need to be absolute.
                        outputFileName = Environment.ExpandEnvironmentVariables(argument);
                        break;

                    case ArgumentState.TargetNamespace:

                        // This is the namespace that is used to create the target data model.
                        targetNamespace = argument;
                        break;
                    }

                    // The default state is to look for the input file name on the command line.
                    argumentState = ArgumentState.InputFileName;
                }

                // This will read the input XML schema into a large buffer.
                string fileContents;
                using (StreamReader streamReader = new StreamReader(inputFilePath))
                {
                    fileContents = streamReader.ReadToEnd();
                }

                // This next step simulates the calling convention used by a custom tool, which is to say it uses unmanaged code.  The progress indicator is used
                // to provide feedback, to either the IDE or the command line, about how far along the compilation is.  Note that the calling interface is from
                // unmanaged-code to managed code, the way you would expect the IDE to call the generator, so we create an unmanaged buffer pointer for the results.
                IntPtr[]  buffer = new IntPtr[1];
                uint      bufferSize;
                Generator generator = new Generator();
                IVsSingleFileGenerator ivsSingleFileGenerator = generator as IVsSingleFileGenerator;
                ivsSingleFileGenerator.Generate(inputFilePath, fileContents, targetNamespace, buffer, out bufferSize, null);

                // Once the buffer of source code is generated, it is copied back out of the unmanaged buffers and written to the output file.
                byte[] outputBuffer = new byte[bufferSize];
                Marshal.Copy(buffer[0], outputBuffer, 0, Convert.ToInt32(bufferSize));
                using (StreamWriter streamWriter = new StreamWriter(outputFileName))
                {
                    streamWriter.Write(Encoding.UTF8.GetString(outputBuffer));
                }
            }
            catch (ArgumentException argumentException)
            {
                // This will catch any generic errors and dump them to the console.
                Console.WriteLine(argumentException.Message);
            }

            // The execution at this point was a success.
            return(0);
        }
Example #7
0
 public int CreateGeneratorInstance(string wszProgId, out int pbGeneratesDesignTimeSource, out int pbGeneratesSharedDesignTimeSource, out int pbUseTempPEFlag, out IVsSingleFileGenerator ppGenerate)
 {
     // The only user in the project system does not call this method.
     pbGeneratesDesignTimeSource       = 0;
     pbGeneratesSharedDesignTimeSource = 0;
     pbUseTempPEFlag = 0;
     ppGenerate      = null;
     return(VSConstants.E_NOTIMPL);
 }
 /// <summary>
 /// Initializes a new instance of the
 /// <see cref="GlobalDataSetGenerator"/> class.
 /// </summary>
 public GlobalDataSetGenerator()
 {
     this.msDataSetGenerator     = GetGenerator(MSDataSetGeneratorGuid);
     this.msDataSetGeneratorRN   = (IVsRefactorNotify)this.msDataSetGenerator;
     this.msDataSetGeneratorSite = (IObjectWithSite)this.msDataSetGenerator;
 }
Example #9
0
        public void CheckForIVsSingleFileGenerator()
        {
            IVsSingleFileGenerator sfg = Generator as IVsSingleFileGenerator;

            Assert.IsNotNull(sfg);
        }
Example #10
0
        int IVsSingleFileGeneratorFactory.CreateGeneratorInstance( string wszProgId, out int pbGeneratesDesignTimeSource, out int pbGeneratesSharedDesignTimeSource, out int pbUseTempPEFlag, out IVsSingleFileGenerator ppGenerate )
        {
            int hr = Utility.COM_HResults.S_OK;

            //what are these used for?
            pbGeneratesDesignTimeSource = Utility.Boolean.TRUE;
            pbGeneratesSharedDesignTimeSource = Utility.Boolean.FALSE;
            pbUseTempPEFlag = Utility.Boolean.FALSE;
            ppGenerate = null;

            NameValueCollection coll = ParseGeneratorProgID( ref wszProgId );

            switch(wszProgId)
            {
                case ResXFileCodeGenerator.c_Name:
                    ResXFileCodeGenerator resxGenerator = new ResXFileCodeGenerator(this);
                    ppGenerate = resxGenerator;

                    if(coll != null)
                    {
                        foreach(string name in coll.AllKeys)
                        {
                            string value = coll[name];
                            bool fValue;

                            switch(name.Trim().ToLower())
                            {
                                case "nestedenums":
                                    if(bool.TryParse( value, out fValue ))
                                        resxGenerator.m_fNestedEnums = fValue;
                                    break;
                                case "internal":
                                    if(bool.TryParse( value, out fValue ))
                                        resxGenerator.m_fInternal = fValue;
                                    break;
                                case "mscorlib":
                                    if(bool.TryParse( value, out fValue ))
                                        resxGenerator.m_fMscorlib = fValue;
                                    break;
                            }
                        }
                    }
                    break;
                default:
                    hr = Utility.COM_HResults.E_FAIL;

                    if(m_innerSingleFileGeneratorFactory != null)
                    {
                        hr = m_innerSingleFileGeneratorFactory.CreateGeneratorInstance( wszProgId, out pbGeneratesDesignTimeSource, out pbGeneratesSharedDesignTimeSource, out pbUseTempPEFlag, out ppGenerate );
                    }
                    break;
            }

            return hr;
        }