Exemple #1
0
        /// <summary>
        /// Based on our current token, determine how much of it should be replaced
        /// </summary>
        /// <param name="intellisenseData"></param>
        /// <param name="tokenStart"></param>
        /// <param name="tokenEnd"></param>
        /// <param name="validNames"></param>
        /// <returns></returns>
        internal static int GetReplacementLength(IntellisenseData.IntellisenseData intellisenseData, int tokenStart, int tokenEnd, IEnumerable <string> validNames)
        {
            Contracts.AssertValue(intellisenseData);
            Contracts.Assert(tokenStart <= intellisenseData.CursorPos);
            Contracts.Assert(intellisenseData.CursorPos <= tokenEnd);
            Contracts.Assert(tokenEnd <= intellisenseData.Script.Length);
            Contracts.AssertAllNonEmpty(validNames);

            int cursorPos = intellisenseData.CursorPos;

            // If the cursor is at the start of a token, then do not replace anything
            if (tokenStart == intellisenseData.CursorPos)
            {
                return(0);
            }

            string forwardOverwrittenText = intellisenseData.Script.Substring(cursorPos, tokenEnd - cursorPos);

            foreach (var validName in validNames)
            {
                Contracts.AssertNonEmpty(validName);

                if (validName == forwardOverwrittenText)
                {
                    return(cursorPos - tokenStart);   // If the remaining text of the token is a valid name, we shouldn't overwrite it
                }
            }

            return(tokenEnd - tokenStart);
        }
Exemple #2
0
        public static ErrorResource Reassemble(Dictionary <string, Dictionary <int, string> > members)
        {
            Contracts.AssertAllNonEmpty(members.Keys);
            Contracts.AssertAllValues(members.Values);

            var errorResource = new ErrorResource();

            // Reassemble link 2-part resources first
            // They need to match up. Because these resources are loaded for almost all tests,
            // The asserts here will fail during unit tests if they're incorrectly defined
            if (members.TryGetValue(LinkTag, out var linkValues))
            {
                members.TryGetValue(LinkTagUrlTag, out var urls).Verify();
                Contracts.Assert(linkValues.Count == urls.Count);

                foreach (var kvp in linkValues)
                {
                    urls.TryGetValue(kvp.Key, out var correspondingUrl).Verify();
                    errorResource.HelpLinks.Add(new ErrorHelpLink(kvp.Value, correspondingUrl));
                }
                members.Remove(LinkTag);
                members.Remove(LinkTagUrlTag);
            }


            foreach (var tag in members)
            {
                if (!errorResource.TagToValues.ContainsKey(tag.Key))
                {
                    errorResource.TagToValues[tag.Key] = new List <string>();
                }

                foreach (var value in tag.Value.OrderBy(kvp => kvp.Key).Select(kvp => kvp.Value))
                {
                    errorResource.TagToValues[tag.Key].Add(value);
                }
            }

            return(errorResource);
        }