/// <summary>
        /// Reorganizes the specified document.
        /// </summary>
        /// <param name="document">The document for reorganizing.</param>
        internal void Reorganize(Document document)
        {
            if (!_codeReorganizationAvailabilityLogic.CanReorganize(document, true))
            {
                return;
            }

            new UndoTransactionHelper(_package, $"CodeMaid Reorganize for '{document.Name}'").Run(
                delegate
            {
                OutputWindowHelper.DiagnosticWriteLine($"CodeReorganizationManager.Reorganize started for '{document.FullName}'");
                _package.IDE.StatusBar.Text = $"CodeMaid is reorganizing '{document.Name}'...";

                // Retrieve all relevant code items (excluding using statements).
                var rawCodeItems = _codeModelManager.RetrieveAllCodeItems(document).Where(x => !(x is CodeItemUsingStatement));

                // Build the code tree based on the current file sort order.
                var codeItems = new SetCodeItems(rawCodeItems);
                var codeTree  = CodeTreeBuilder.RetrieveCodeTree(new CodeTreeRequest(document, codeItems, CodeSortOrder.File));

                // Recursively reorganize the code tree.
                RecursivelyReorganize(codeTree);

                _package.IDE.StatusBar.Text = $"CodeMaid reorganized '{document.Name}'.";
                OutputWindowHelper.DiagnosticWriteLine($"CodeReorganizationManager.Reorganize completed for '{document.FullName}'");
            });
        }
Example #2
0
        public void AddLiteralChunk_AddsChunkToCodeTree_IfPreviousChunkWasNotLiteral()
        {
            // Arrange
            var spanFactory = SpanFactory.CreateCsHtml();
            var codeSpan    = spanFactory.Code("int a = 10;")
                              .AsStatement()
                              .Builder.Build();
            var literalSpan = spanFactory.Markup("<p>").Builder.Build();
            var builder     = new CodeTreeBuilder();

            // Act
            builder.AddStatementChunk("int a = 10;", codeSpan);
            builder.AddLiteralChunk("<p>", literalSpan);

            // Assert
            var chunks = builder.CodeTree.Chunks;

            Assert.Equal(2, chunks.Count);
            var statementChunk = Assert.IsType <StatementChunk>(chunks[0]);

            Assert.Equal("int a = 10;", statementChunk.Code);
            Assert.Same(codeSpan, statementChunk.Association);
            var literalChunk = Assert.IsType <LiteralChunk>(chunks[1]);

            Assert.Equal("<p>", literalChunk.Text);
            Assert.Same(literalSpan, literalChunk.Association);
        }
 public CodeGeneratorContext(RazorEngineHost host,
                             string className,
                             string rootNamespace,
                             string sourceFile,
                             bool shouldGenerateLinePragmas)
 {
     CodeTreeBuilder = new CodeTreeBuilder();
     Host = host;
     SourceFile = shouldGenerateLinePragmas ? sourceFile : null;
     RootNamespace = rootNamespace;
     ClassName = className;
 }
Example #4
0
 public CodeGeneratorContext(RazorEngineHost host,
                             string className,
                             string rootNamespace,
                             string sourceFile,
                             bool shouldGenerateLinePragmas)
 {
     CodeTreeBuilder = new CodeTreeBuilder();
     Host            = host;
     SourceFile      = shouldGenerateLinePragmas ? sourceFile : null;
     RootNamespace   = rootNamespace;
     ClassName       = className;
 }
Example #5
0
        public void AddLiteralChunk_AddsChunkToCodeTree()
        {
            // Arrange
            var spanFactory = SpanFactory.CreateCsHtml();
            var previousSpan = spanFactory.EmptyHtml().Builder.Build();
            var builder = new CodeTreeBuilder();

            // Act
            builder.AddLiteralChunk("some text", previousSpan);

            // Assert
            var chunk = Assert.Single(builder.CodeTree.Chunks);
            var literalChunk = Assert.IsType<LiteralChunk>(chunk);
            Assert.Equal("some text", literalChunk.Text);
            Assert.Same(previousSpan, literalChunk.Association);
        }
Example #6
0
        public void AddLiteralChunk_AddsChunkToCodeTree()
        {
            // Arrange
            var spanFactory  = SpanFactory.CreateCsHtml();
            var previousSpan = spanFactory.EmptyHtml().Builder.Build();
            var builder      = new CodeTreeBuilder();

            // Act
            builder.AddLiteralChunk("some text", previousSpan);

            // Assert
            var chunk        = Assert.Single(builder.CodeTree.Chunks);
            var literalChunk = Assert.IsType <LiteralChunk>(chunk);

            Assert.Equal("some text", literalChunk.Text);
            Assert.Same(previousSpan, literalChunk.Association);
        }
Example #7
0
        ///////// <summary>
        ///////// Get the index of the specified dimension or time dimension
        ///////// </summary>
        ///////// <param name="component">
        ///////// The dimension or time dimension
        ///////// </param>
        ///////// <returns>
        ///////// The index of the dimension or time dimension or -1 if it is not found
        ///////// </returns>
        //////public int GetComponentIndex(ComponentBean component)
        //////{
        //////    int idx;
        //////    if (!this._componentIndex.TryGetValue(component, out idx))
        //////    {
        //////        idx = -1;
        //////    }

        //////    return idx;
        //////}

        /// <summary>
        /// Gets the current component is retrieved from <see cref="CriteriaComponentIdx"/>
        /// </summary>
        /// <returns>
        /// The current component is retrieved from <see cref="CriteriaComponentIdx"/>
        /// </returns>
        public CodeTreeBuilder GetCurrentCodeTree()
        {
            CodeTreeBuilder codeTree = null;

            if (this._criteriaComponentIdx > -1)
            {
                foreach (KeyValuePair <IComponent, int> kv in this._componentIndex)
                {
                    if (kv.Value == this._criteriaComponentIdx)
                    {
                        codeTree = this.GetCodeTree(kv.Key);
                        break;
                    }
                }
            }

            return(codeTree);
        }
Example #8
0
        public void AddLiteralChunk_AppendsToPreviousChunk_IfChunkWasLiteral()
        {
            // Arrange
            var spanFactory  = SpanFactory.CreateCsHtml();
            var previousSpan = spanFactory.Markup("<a>").Builder.Build();
            var newSpan      = spanFactory.Markup("<p>").Builder.Build();
            var builder      = new CodeTreeBuilder();

            // Act
            builder.AddLiteralChunk("<a>", previousSpan);
            builder.AddLiteralChunk("<p>", newSpan);

            // Assert
            var chunk        = Assert.Single(builder.CodeTree.Chunks);
            var literalChunk = Assert.IsType <LiteralChunk>(chunk);

            Assert.Equal("<a><p>", literalChunk.Text);
            var span = Assert.IsType <Span>(literalChunk.Association);

            Assert.Equal(previousSpan.Symbols.Concat(newSpan.Symbols), span.Symbols);
        }
Example #9
0
        public void AddRemoveTagHelperChunk_AddsChunkToTopLevelCodeTree()
        {
            // Arrange
            var spanFactory = SpanFactory.CreateCsHtml();
            var builder = new CodeTreeBuilder();
            var block = new ExpressionBlock();
            var removeTagHelperDirective = spanFactory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ");

            // Act
            builder.StartChunkBlock<ExpressionBlockChunk>(block);
            builder.AddRemoveTagHelperChunk("some text", removeTagHelperDirective);
            builder.EndChunkBlock();

            // Assert
            Assert.Equal(2, builder.CodeTree.Chunks.Count);

            var chunkBlock = Assert.IsType<ExpressionBlockChunk>(builder.CodeTree.Chunks.First());
            Assert.Empty(chunkBlock.Children);

            var removeTagHelperChunk = Assert.IsType<RemoveTagHelperChunk>(builder.CodeTree.Chunks.Last());
            Assert.Equal(removeTagHelperChunk.LookupText, "some text");
        }
Example #10
0
        /// <summary>
        /// Reorganizes the specified document.
        /// </summary>
        /// <param name="document">The document for reorganizing.</param>
        /// <param name="isAutoSave">A flag indicating if occurring due to auto-save.</param>
        internal void Reorganize(Document document, bool isAutoSave)
        {
            if (!CanReorganize(document))
            {
                return;
            }

            _undoTransactionHelper.Run(
                () => !(isAutoSave && Settings.Default.General_SkipUndoTransactionsDuringAutoCleanupOnSave),
                delegate
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    string.Format("CodeReorderManager.Reorganize started for '{0}'", document.FullName));

                _package.IDE.StatusBar.Text = string.Format("CodeMaid is reorganizing '{0}'...", document.Name);

                // Retrieve all relevant code items (excluding using statements).
                var rawCodeItems = _codeModelManager.RetrieveAllCodeItems(document).Where(x => !(x is CodeItemUsingStatement));

                // Build the code tree based on the current file layout.
                var codeItems = new SetCodeItems(rawCodeItems);
                var codeTree  = CodeTreeBuilder.RetrieveCodeTree(new CodeTreeRequest(document, codeItems, TreeLayoutMode.FileLayout));

                // Recursively reorganize the code tree.
                RecursivelyReorganize(codeTree);

                _package.IDE.StatusBar.Text = string.Format("CodeMaid reorganized '{0}'.", document.Name);

                OutputWindowHelper.DiagnosticWriteLine(
                    string.Format("CodeReorderManager.Reorganize completed for '{0}'", document.FullName));
            },
                delegate(Exception ex)
            {
                OutputWindowHelper.ExceptionWriteLine(
                    string.Format("Stopped reorganizing '{0}'", document.Name), ex);
                _package.IDE.StatusBar.Text = string.Format("CodeMaid stopped reorganizing '{0}'.  See output window for more details.", document.Name);
            });
        }
        /// <summary>
        /// Reorganizes the specified document.
        /// </summary>
        /// <param name="document">The document for reorganizing.</param>
        internal void Reorganize(Document document)
        {
            if (!_codeReorganizationAvailabilityLogic.CanReorganize(document))
            {
                return;
            }

            _undoTransactionHelper.Run(
                delegate
            {
                OutputWindowHelper.DiagnosticWriteLine(
                    string.Format("CodeReorganizationManager.Reorganize started for '{0}'", document.FullName));

                _package.IDE.StatusBar.Text = string.Format("CodeMaid is reorganizing '{0}'...", document.Name);

                // Retrieve all relevant code items (excluding using statements).
                var rawCodeItems = _codeModelManager.RetrieveAllCodeItems(document).Where(x => !(x is CodeItemUsingStatement));

                // Build the code tree based on the current file sort order.
                var codeItems = new SetCodeItems(rawCodeItems);
                var codeTree  = CodeTreeBuilder.RetrieveCodeTree(new CodeTreeRequest(document, codeItems, CodeSortOrder.File));

                // Recursively reorganize the code tree.
                RecursivelyReorganize(codeTree);

                _package.IDE.StatusBar.Text = string.Format("CodeMaid reorganized '{0}'.", document.Name);

                OutputWindowHelper.DiagnosticWriteLine(
                    string.Format("CodeReorganizationManager.Reorganize completed for '{0}'", document.FullName));
            },
                delegate(Exception ex)
            {
                OutputWindowHelper.ExceptionWriteLine(
                    string.Format("Stopped reorganizing '{0}'", document.Name), ex);
                _package.IDE.StatusBar.Text = string.Format("CodeMaid stopped reorganizing '{0}'.  See output window for more details.", document.Name);
            });
        }
Example #12
0
        public void AddRemoveTagHelperChunk_AddsChunkToTopLevelCodeTree()
        {
            // Arrange
            var spanFactory = SpanFactory.CreateCsHtml();
            var builder     = new CodeTreeBuilder();
            var block       = new ExpressionBlock();
            var removeTagHelperDirective = spanFactory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ");

            // Act
            builder.StartChunkBlock <ExpressionBlockChunk>(block);
            builder.AddRemoveTagHelperChunk("some text", removeTagHelperDirective);
            builder.EndChunkBlock();

            // Assert
            Assert.Equal(2, builder.CodeTree.Chunks.Count);

            var chunkBlock = Assert.IsType <ExpressionBlockChunk>(builder.CodeTree.Chunks.First());

            Assert.Empty(chunkBlock.Children);

            var removeTagHelperChunk = Assert.IsType <RemoveTagHelperChunk>(builder.CodeTree.Chunks.Last());

            Assert.Equal(removeTagHelperChunk.LookupText, "some text");
        }
Example #13
0
        public void AddLiteralChunk_AppendsToPreviousChunk_IfChunkWasLiteral()
        {
            // Arrange
            var spanFactory = SpanFactory.CreateCsHtml();
            var previousSpan = spanFactory.Markup("<a>").Builder.Build();
            var newSpan = spanFactory.Markup("<p>").Builder.Build();
            var builder = new CodeTreeBuilder();

            // Act
            builder.AddLiteralChunk("<a>", previousSpan);
            builder.AddLiteralChunk("<p>", newSpan);

            // Assert
            var chunk = Assert.Single(builder.CodeTree.Chunks);
            var literalChunk = Assert.IsType<LiteralChunk>(chunk);
            Assert.Equal("<a><p>", literalChunk.Text);
            var span = Assert.IsType<Span>(literalChunk.Association);
            Assert.Equal(previousSpan.Symbols.Concat(newSpan.Symbols), span.Symbols);
        }
Example #14
0
        public void AddLiteralChunk_AddsChunkToCodeTree_IfPreviousChunkWasNotLiteral()
        {
            // Arrange
            var spanFactory = SpanFactory.CreateCsHtml();
            var codeSpan = spanFactory.Code("int a = 10;")
                                      .AsStatement()
                                      .Builder.Build();
            var literalSpan = spanFactory.Markup("<p>").Builder.Build();
            var builder = new CodeTreeBuilder();

            // Act
            builder.AddStatementChunk("int a = 10;", codeSpan);
            builder.AddLiteralChunk("<p>", literalSpan);

            // Assert
            var chunks = builder.CodeTree.Chunks;
            Assert.Equal(2, chunks.Count);
            var statementChunk = Assert.IsType<StatementChunk>(chunks[0]);
            Assert.Equal("int a = 10;", statementChunk.Code);
            Assert.Same(codeSpan, statementChunk.Association);
            var literalChunk = Assert.IsType<LiteralChunk>(chunks[1]);
            Assert.Equal("<p>", literalChunk.Text);
            Assert.Same(literalSpan, literalChunk.Association);
        }