Adding missing advisors

Author: StanleyGoldman

src/GitHub.UI/Helpers/AutoCompleteAdvisor.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel.Composition;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Reactive.Linq;
+using GitHub.UI;
+using NLog;
+
+namespace GitHub.Helpers
+{
+    [Export(typeof(IAutoCompleteAdvisor))]
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class AutoCompleteAdvisor : IAutoCompleteAdvisor
+    {
+        const int SuggestionCount = 5; // The number of suggestions we'll provide. github.com does 5.
+
+        static readonly Logger log = LogManager.GetCurrentClassLogger();
+        readonly Lazy<Dictionary<string, IAutoCompleteSource>> prefixSourceMap;
+
+        [ImportingConstructor]
+        public AutoCompleteAdvisor([ImportMany]IEnumerable<IAutoCompleteSource> autocompleteSources)
+        {
+            prefixSourceMap = new Lazy<Dictionary<string, IAutoCompleteSource>>(
+                () => autocompleteSources.ToDictionary(s => s.Prefix, s => s));
+        }
+
+        public IObservable<AutoCompleteResult> GetAutoCompletionSuggestions(string text, int caretPosition)
+        {
+            Ensure.ArgumentNotNull("text", text);
+
+            if (caretPosition < 0 || caretPosition > text.Length)
+            {
+                string error = String.Format(CultureInfo.InvariantCulture,
+                    "The CaretPosition '{0}', is not in the range of '0' and the text length '{1}' for the text '{2}'",
+                    caretPosition,
+                    text.Length,
+                    text);
+
+                // We need to be alerted when this happens because it should never happen.
+                // But it apparently did happen in production.
+                Debug.Fail(error);
+                log.Error(error);
+                return Observable.Empty<AutoCompleteResult>();
+            }
+            var tokenAndSource = PrefixSourceMap
+                .Select(kvp => new {Source = kvp.Value, Token = ParseAutoCompletionToken(text, caretPosition, kvp.Key)})
+                .FirstOrDefault(s => s.Token != null);
+
+            if (tokenAndSource == null)
+            {
+                return Observable.Return(AutoCompleteResult.Empty);
+            }
+
+            return tokenAndSource.Source.GetSuggestions()
+                .Select(suggestion => new
+                {
+                    suggestion,
+                    rank = suggestion.GetSortRank(tokenAndSource.Token.SearchSearchPrefix)
+                })
+                .Where(suggestion => suggestion.rank > -1)
+                .ToList()
+                .Select(suggestions => suggestions
+                    .OrderByDescending(s => s.rank)
+                    .ThenBy(s => s.suggestion.Name)
+                    .Take(SuggestionCount)
+                    .Select(s => s.suggestion)
+                    .ToList())
+                .Select(suggestions => new AutoCompleteResult(tokenAndSource.Token.Offset,
+                    new ReadOnlyCollection<AutoCompleteSuggestion>(suggestions)))
+                .Catch<AutoCompleteResult, Exception>(e =>
+                {
+                    log.Info(e);
+                    return Observable.Return(AutoCompleteResult.Empty);
+                });
+        }
+
+        [SuppressMessage("Microsoft.Usage", "CA2233:OperationsShouldNotOverflow", MessageId = "caretPosition-1"
+            , Justification = "We ensure the argument is greater than -1 so it can't overflow")]
+        public static AutoCompletionToken ParseAutoCompletionToken(string text, int caretPosition, string triggerPrefix)
+        {
+            Ensure.ArgumentNotNull("text", text);
+            Ensure.ArgumentInRange(caretPosition, 0, text.Length, "caretPosition");
+            if (caretPosition == 0 || text.Length == 0) return null;
+
+            // :th     : 1
+            //:th      : 0
+            //Hi :th   : 3
+            int beginningOfWord = text.LastIndexOfAny(new[] { ' ', '\n' }, caretPosition - 1) + 1;
+            string word = text.Substring(beginningOfWord, caretPosition - beginningOfWord);
+            if (!word.StartsWith(triggerPrefix, StringComparison.Ordinal)) return null;
+
+            return new AutoCompletionToken(word.Substring(1), beginningOfWord);
+        }
+
+        Dictionary<string, IAutoCompleteSource> PrefixSourceMap { get { return prefixSourceMap.Value; } }
+    }
+
+    public class AutoCompletionToken
+    {
+        public AutoCompletionToken(string searchPrefix, int offset)
+        {
+            Ensure.ArgumentNotNull(searchPrefix, "searchPrefix");
+            Ensure.ArgumentNonNegative(offset, "offset");
+
+            SearchSearchPrefix = searchPrefix;
+            Offset = offset;
+        }
+
+        /// <summary>
+        /// Used to filter the list of auto complete suggestions to what the user has typed in.
+        /// </summary>
+        public string SearchSearchPrefix { get; private set; }
+        public int Offset { get; private set; }
+    }
+}

src/GitHub.UI/Helpers/EmojiAutoCompleteSource.cs

@@ -0,0 +1,41 @@
+using System;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Windows.Media.Imaging;
+using GitHub.UI;
+
+namespace GitHub.Helpers
+{
+    [Export(typeof(IAutoCompleteSource))]
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class EmojiAutoCompleteSource : IAutoCompleteSource
+    {
+        readonly IEmojiCache emojiCache;
+
+        [ImportingConstructor]
+        public EmojiAutoCompleteSource(IEmojiCache emojiCache)
+        {
+            Ensure.ArgumentNotNull(emojiCache, "emojiCache");
+
+            this.emojiCache = emojiCache;
+        }
+
+        public IObservable<AutoCompleteSuggestion> GetSuggestions()
+        {
+            Func<Uri, IObservable<BitmapSource>> resolveImage = uri =>
+                Observable.Defer(() =>
+                {
+                    var resourcePath = "pack://application:,,,/GitHub;component/" + uri;
+                    return Observable.Return(App.CreateBitmapImage(resourcePath));
+                });
+
+            return emojiCache.GetEmojis()
+                .Where(emoji => !String.IsNullOrEmpty(emoji.Name)) // Just being extra cautious.
+                .Select(emoji => new AutoCompleteSuggestion(emoji.Name, resolveImage(emoji.IconKey), ":", ":"))
+                .ToObservable();
+        }
+
+        public string Prefix { get { return ":"; } }
+    }
+}

src/GitHub.UI/Helpers/IAutoCompleteSource.cs

@@ -0,0 +1,13 @@
+using System;
+using GitHub.UI;
+
+namespace GitHub.Helpers
+{
+    public interface IAutoCompleteSource
+    {
+        IObservable<AutoCompleteSuggestion> GetSuggestions();
+
+        // The prefix used to trigger auto completion.
+        string Prefix { get; }
+    }
+}

src/GitHub.UI/Helpers/IssuesAutoCompleteSource.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Reactive.Linq;
+using GitHub.Cache;
+using GitHub.Models;
+using GitHub.UI;
+using GitHub.ViewModels;
+
+namespace GitHub.Helpers
+{
+    [Export(typeof(IAutoCompleteSource))]
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class IssuesAutoCompleteSource : IAutoCompleteSource
+    {
+        readonly Lazy<IIssuesCache> issuesCache;
+        readonly Lazy<ISourceListViewModel> currentRepositoryState;
+
+        [ImportingConstructor]
+        public IssuesAutoCompleteSource(
+            Lazy<IIssuesCache> issuesCache,
+            Lazy<ISourceListViewModel> currentRepositoryState)
+        {
+            Ensure.ArgumentNotNull(issuesCache, "issuesCache");
+            Ensure.ArgumentNotNull(currentRepositoryState, "currentRepositoryState");
+
+            this.issuesCache = issuesCache;
+            this.currentRepositoryState = currentRepositoryState;
+        }
+
+        public IObservable<AutoCompleteSuggestion> GetSuggestions()
+        {
+            if (CurrentRepository.RepositoryHost == null)
+            {
+                return Observable.Empty<AutoCompleteSuggestion>();
+            }
+
+            return IssuesCache.RetrieveSuggestions(CurrentRepository)
+                .Catch<IReadOnlyList<SuggestionItem>, Exception>(_ => Observable.Empty<IReadOnlyList<SuggestionItem>>())
+                .SelectMany(x => x.ToObservable())
+                .Where(suggestion => !String.IsNullOrEmpty(suggestion.Name)) // Just being extra cautious
+                .Select(suggestion => new IssueAutoCompleteSuggestion(suggestion, Prefix));
+        }
+
+        public string Prefix
+        {
+            get { return "#"; }
+        }
+
+        IIssuesCache IssuesCache { get { return issuesCache.Value; } }
+
+        IRepositoryModel CurrentRepository { get { return currentRepositoryState.Value.SelectedRepository; } }
+
+        class IssueAutoCompleteSuggestion : AutoCompleteSuggestion
+        {
+            // Just needs to be some value before GitHub stored its first issue.
+            static readonly DateTimeOffset lowerBound = new DateTimeOffset(2000, 1, 1, 12, 0, 0, TimeSpan.FromSeconds(0));
+
+            readonly SuggestionItem suggestion;
+            public IssueAutoCompleteSuggestion(SuggestionItem suggestion, string prefix)
+                : base(suggestion.Name, suggestion.Description, prefix)
+            {
+                this.suggestion = suggestion;
+            }
+
+            public override int GetSortRank(string text)
+            {
+                // We need to override the sort rank behavior because when we display issues, we include the prefix
+                // unlike mentions. So we need to account for that in how we do filtering.
+                if (text.Length == 0)
+                {
+                    return (int) ((suggestion.LastModifiedDate ?? lowerBound) - lowerBound).TotalSeconds;
+                }
+                // Name is always "#" followed by issue number.
+                return Name.StartsWith("#" + text, StringComparison.OrdinalIgnoreCase)
+                        ? 1
+                        : DescriptionWords.Any(word => word.StartsWith(text, StringComparison.OrdinalIgnoreCase))
+                            ? 0
+                            : -1;
+            }
+
+            // This is what gets "completed" when you tab.
+            public override string ToString()
+            {
+                return Name;
+            }
+        }
+    }
+}

src/GitHub.UI/Helpers/MentionsAutoCompleteSource.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Reactive.Linq;
+using System.Windows.Media.Imaging;
+using GitHub.Cache;
+using GitHub.Models;
+using GitHub.UI;
+using GitHub.ViewModels;
+
+namespace GitHub.Helpers
+{
+    /// <summary>
+    /// Supplies @mentions auto complete suggestions.
+    /// </summary>
+    [Export(typeof(IAutoCompleteSource))]
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class MentionsAutoCompleteSource : IAutoCompleteSource
+    {
+        readonly Lazy<IMentionsCache> mentionsCache;
+        readonly Lazy<ISourceListViewModel> currentRepositoryState;
+        readonly Lazy<IImageCache> imageCache;
+        readonly IHostAvatarProvider hostAvatarProvider;
+
+        [ImportingConstructor]
+        public MentionsAutoCompleteSource(
+            Lazy<IMentionsCache> mentionsCache,
+            Lazy<ISourceListViewModel> currentRepositoryState,
+            Lazy<IImageCache> imageCache,
+            IHostAvatarProvider hostAvatarProvider)
+        {
+            Ensure.ArgumentNotNull(mentionsCache, "mentionsCache");
+            Ensure.ArgumentNotNull(currentRepositoryState, "currentRepositoryState");
+            Ensure.ArgumentNotNull(imageCache, "imageCache");
+            Ensure.ArgumentNotNull(hostAvatarProvider, "hostAvatarProvider");
+
+            this.mentionsCache = mentionsCache;
+            this.currentRepositoryState = currentRepositoryState;
+            this.imageCache = imageCache;
+            this.hostAvatarProvider = hostAvatarProvider;
+        }
+
+        public IObservable<AutoCompleteSuggestion> GetSuggestions()
+        {
+            if (CurrentRepository.RepositoryHost == null)
+            {
+                return Observable.Empty<AutoCompleteSuggestion>();
+            }
+
+            var avatarProviderKey = CurrentRepository.RepositoryHost.Address.WebUri.ToString();
+            var avatarProvider = hostAvatarProvider.Get(avatarProviderKey);
+
+            Func<Uri, IObservable<BitmapSource>> resolveImage = uri =>
+                Observable.Defer(() => ImageCache
+                    .GetImage(uri)
+                    .Catch<BitmapSource, Exception>(_ => Observable.Return(avatarProvider.DefaultUserBitmapImage))
+                    .StartWith(avatarProvider.DefaultUserBitmapImage));
+
+            return MentionsCache.RetrieveSuggestions(CurrentRepository)
+                .Catch<IReadOnlyList<SuggestionItem>, Exception>(_ => Observable.Empty<IReadOnlyList<SuggestionItem>>())
+                .SelectMany(x => x.ToObservable())
+                .Where(suggestion => !String.IsNullOrEmpty(suggestion.Name)) // Just being extra cautious
+                .Select(suggestion =>
+                    new AutoCompleteSuggestion(suggestion.Name, suggestion.Description, resolveImage(suggestion.IconKey), Prefix));
+        }
+
+        public string Prefix { get { return "@"; } }
+
+        IImageCache ImageCache { get { return imageCache.Value; } }
+
+        IMentionsCache MentionsCache { get { return mentionsCache.Value; } }
+
+        IRepositoryModel CurrentRepository { get { return currentRepositoryState.Value.SelectedRepository; } }
+    }
+}