AvalonEdit FoldingStrategy by Indent (Python)

Question

Has someone ever tried to create a FoldingStrategy by the indent level? Like for the programming language python.

BraceFoldingStrategy is no problem because you have a fixed start and end tag. Has someone a idea to create this for tab indents?

zaknotzach · Accepted Answer

Here is a mostly-functional solution. I don't have time to test all possibilities but with a few of my python scripts I had sitting around (which admittedly are well-formatted) it behaved well. I put some notes in about making it so that it shows the line contents when it's collapsed. Basically just buffer the start line and then put that on the stack with the start index in a Tuple or something.

I am sure that this code won't handle many cases with comments correctly. That's something you will have to test and tweak for. The code is relatively naive, so you may also want to add checks for keywords instead of just the "if it has a colon it is a new folding start" logic. Also, it is done in a more complicated iterating through characters way because of my experience with folding previously. I have tried other "easier" methods like running regex checks on the lines and that can be very, very slow.

Finally, you may want to actually use the error offset thing instead of just bailing as I have done. That should be pretty easy to add in.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ICSharpCode.AvalonEdit.Highlighting;
using ICSharpCode.AvalonEdit.Highlighting.Xshd;
using ICSharpCode.AvalonEdit.Rendering;
using ICSharpCode.AvalonEdit.Document;
using ICSharpCode.AvalonEdit.Folding;
using System.Text.RegularExpressions;

namespace Foo.languages
{
    public class TabFoldingStrategy : AbstractFoldingStrategy
    {
        // How many spaces == one tab
        private const int SpacesInTab = 4;

        /// 
        /// Creates a new TabFoldingStrategy.
        /// 
        public TabFoldingStrategy() {
        }

        /// 
        /// Create s for the specified document.
        /// 
        public override IEnumerable CreateNewFoldings(TextDocument document, out int firstErrorOffset)
        {
            firstErrorOffset = -1;
            return CreateNewFoldingsByLine(document);
        }

        /// 
        /// Create s for the specified document.
        /// 
        public IEnumerable CreateNewFoldingsByLine(ITextSource document)
        {
            List newFoldings = new List();

            if (document == null || (document as TextDocument).LineCount <= 1)
            {
                return newFoldings;
            }

            //Can keep track of offset ourself and from testing it seems to be accurate
            int offsetTracker = 0;

            // Keep track of start points since things nest
            Stack startOffsets = new Stack();

            StringBuilder lineBuffer = new StringBuilder();


            foreach (DocumentLine line in (document as TextDocument).Lines)
            {
                if (offsetTracker >= document.TextLength)
                {
                    break;
                }

                lineBuffer.Clear();


                // First task is to get the line and figure out the spacing in front of it
                int spaceCounter = 0;
                bool foundText = false;
                bool foundColon = false;
                //for (int i = 0; i < line.Length; i++)
                int i = 0;
                //TODO buffer the characters so you can have the line contents on the stack too for the folding name (display text)
                while (i < line.Length && !(foundText && foundColon))
                {
                    char c = document.GetCharAt(offsetTracker + i);

                    switch (c)
                    {
                        case ' ': // spaces count as one
                            if (!foundText) {
                                spaceCounter++;
                            }
                            break;
                        case '	': // Tabs count as N
                            if (!foundText) {
                                spaceCounter += SpacesInTab;
                            }
                            break;
                        case ':': // Tabs count as N
                            foundColon = true;
                            break;
                        default: // anything else means we encountered not spaces or tabs, so keep making the line but stop counting
                            foundText = true;
                            break;
                    }
                    i++;
                }

                // before we continue, we need to make sure its a correct multiple
                int remainder = spaceCounter % SpacesInTab;
                if (remainder > 0)
                {
                    // Some tabbing isn't correct. ignore this line for folding purposes.
                    // This may break all foldings below that, but it's a complex problem to address.
                    continue;
                }

                // Now we need to figure out if this line is a new folding by checking its tabing
                // relative to the current stack count. Convert into virtual tabs and compare to stack level
                int numTabs = spaceCounter / SpacesInTab; // we know this will be an int because of the above check
                if (numTabs >= startOffsets.Count && foundText && foundColon)
                {
                    // we are starting a new folding
                    startOffsets.Push(offsetTracker);

                }
                else // numtabs < offsets
                {
                    // we know that this is the end of a folding. It could be the end of multiple foldings. So pop until it matches.
                    while (numTabs < startOffsets.Count)
                    {
                        int foldingStart = startOffsets.Pop();
                        NewFolding tempFolding = new NewFolding();
                        //tempFolding.Name = < could add logic here, possibly by tracking key words when starting the folding, to control what is shown when it's folded >
                        tempFolding.StartOffset = foldingStart;
                        tempFolding.EndOffset = offsetTracker - 2; 
                        newFoldings.Add(tempFolding);
                    }
                }


                // Increment tracker. Much faster than getting it from the line
                offsetTracker += line.TotalLength;
            }

            // Complete last foldings
            while (startOffsets.Count > 0)
            {
                int foldingStart = startOffsets.Pop();
                NewFolding tempFolding = new NewFolding();
                //tempFolding.Name = < could add logic here, possibly by tracking key words when starting the folding, to control what is shown when it's folded >
                tempFolding.StartOffset = foldingStart;
                tempFolding.EndOffset = offsetTracker;
                newFoldings.Add(tempFolding);
            }

            newFoldings.Sort((a, b) => (a.StartOffset.CompareTo(b.StartOffset)));
            return newFoldings;
        }

    }

}

AvalonEdit FoldingStrategy by Indent (Python)

Answers (2)

Related Questions