Move repositories to indexed cache and tracking collection

Author: shana

src/GitHub.App/SampleData/SampleViewModels.cs

@@ -332,7 +332,7 @@ public class RepositoryCloneViewModelDesigner : BaseViewModel, IRepositoryCloneV
     {
         public RepositoryCloneViewModelDesigner()
         {
-            var repositories = new ReactiveList<IRepositoryModel>
+            Repositories = new ObservableCollection<IRepositoryModel>
             {
                 RepositoryModelDesigner.Create("encourage", "haacked"),
                 RepositoryModelDesigner.Create("haacked.com", "haacked"),
@@ -346,10 +346,6 @@ public RepositoryCloneViewModelDesigner()
 
             BrowseForDirectory = ReactiveCommand.Create();
 
-            FilteredRepositories = repositories.CreateDerivedCollection(
-                x => x
-            );
-
             BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(this.WhenAny(x => x.BaseRepositoryPath, x => x.Value))
                 .IfNullOrEmpty("Please enter a repository path")
                 .IfTrue(x => x.Length > 200, "Path too long")
@@ -365,7 +361,7 @@ public IReactiveCommand<Unit> CloneCommand
 
         public IRepositoryModel SelectedRepository { get; set; }
 
-        public IReactiveDerivedList<IRepositoryModel> FilteredRepositories
+        public ObservableCollection<IRepositoryModel> Repositories
         {
             get;
             private set;

src/GitHub.App/ViewModels/RepositoryCloneViewModel.cs

@@ -19,6 +19,8 @@
 using NullGuard;
 using ReactiveUI;
 using Rothko;
+using System.Collections.ObjectModel;
+using GitHub.Collections;
 
 namespace GitHub.ViewModels
 {
@@ -28,14 +30,12 @@ public class RepositoryCloneViewModel : BaseViewModel, IRepositoryCloneViewModel
     {
         static readonly Logger log = LogManager.GetCurrentClassLogger();
 
-        readonly IRepositoryHost repositoryHost;
         readonly IRepositoryCloneService cloneService;
         readonly IOperatingSystem operatingSystem;
         readonly INotificationService notificationService;
         readonly IUsageTracker usageTracker;
-        readonly IReactiveCommand<IReadOnlyList<IRepositoryModel>> loadRepositoriesCommand;
         readonly ReactiveCommand<object> browseForDirectoryCommand = ReactiveCommand.Create();
-        readonly ObservableAsPropertyHelper<bool> isLoading;
+        bool isLoading;
         readonly ObservableAsPropertyHelper<bool> noRepositoriesFound;
         readonly ObservableAsPropertyHelper<bool> canClone;
         string baseRepositoryPath;
@@ -58,34 +58,39 @@ public RepositoryCloneViewModel(
             INotificationService notificationService,
             IUsageTracker usageTracker)
         {
-            this.repositoryHost = repositoryHost;
             this.cloneService = cloneService;
             this.operatingSystem = operatingSystem;
             this.notificationService = notificationService;
             this.usageTracker = usageTracker;
 
             Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
-            Repositories = new ReactiveList<IRepositoryModel>();
-            loadRepositoriesCommand = ReactiveCommand.CreateAsyncObservable(OnLoadRepositories);
-            isLoading = this.WhenAny(x => x.LoadingFailed, x => x.Value)
-                .CombineLatest(loadRepositoriesCommand.IsExecuting, (failed, loading) => !failed && loading)
-                .ToProperty(this, x => x.IsLoading);
-            loadRepositoriesCommand.Subscribe(Repositories.AddRange);
+
+            var col = new TrackingCollection<IRepositoryModel>(filter: FilterRepository);
+            col = repositoryHost.ModelService.GetRepositories(col) as TrackingCollection<IRepositoryModel>;
+            col.OriginalCompleted.Subscribe(
+                _ => {}
+                , ex =>
+                    {
+                        LoadingFailed = true;
+                        log.Error("Error while loading repositories", ex);
+                    },
+                () => IsLoading = false
+            );
+            col.Subscribe(_ => IsLoading = true, () => {});
+
+            Repositories = col;
+
             filterTextIsEnabled = this.WhenAny(x => x.Repositories.Count, x => x.Value > 0)
                 .ToProperty(this, x => x.FilterTextIsEnabled);
+
             noRepositoriesFound = this.WhenAny(x => x.FilterTextIsEnabled, x => x.IsLoading, x => x.LoadingFailed
                 , (any, loading, failed) => !any.Value && !loading.Value && !failed.Value)
                 .ToProperty(this, x => x.NoRepositoriesFound);
 
-            var filterResetSignal = this.WhenAny(x => x.FilterText, x => x.Value)
+            this.WhenAny(x => x.FilterText, x => x.Value)
                 .DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
-                .Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler);
-
-            FilteredRepositories = Repositories.CreateDerivedCollection(
-                x => x,
-                filter: FilterRepository,
-                signalReset: filterResetSignal
-            );
+                .Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler)
+                .Subscribe(_ => col.Filter = FilterRepository);
 
             var baseRepositoryPath = this.WhenAny(
                 x => x.BaseRepositoryPath,
@@ -112,18 +117,7 @@ public RepositoryCloneViewModel(
             BaseRepositoryPath = cloneService.DefaultClonePath;
         }
 
-        IObservable<IReadOnlyList<IRepositoryModel>> OnLoadRepositories(object value)
-        {
-            return repositoryHost.ModelService.GetRepositories()
-                .Catch<IReadOnlyList<IRepositoryModel>, Exception>(ex =>
-                {
-                    log.Error("Error while loading repositories", ex);
-                    return Observable.Start(() => LoadingFailed = true, RxApp.MainThreadScheduler)
-                        .Select(_ => new IRepositoryModel[] { });
-                });
-        }
-       
-        bool FilterRepository(IRepositoryModel repo)
+        bool FilterRepository(IRepositoryModel repo, int position, IList<IRepositoryModel> list)
         {
             if (string.IsNullOrWhiteSpace(FilterText))
                 return true;
@@ -177,6 +171,34 @@ bool IsAlreadyRepoAtPath(string path)
             return isAlreadyRepoAtPath;
         }
 
+        IObservable<Unit> ShowBrowseForDirectoryDialog()
+        {
+            return Observable.Start(() =>
+            {
+                // We store this in a local variable to prevent it changing underneath us while the
+                // folder dialog is open.
+                var localBaseRepositoryPath = BaseRepositoryPath;
+                var browseResult = operatingSystem.Dialog.BrowseForDirectory(localBaseRepositoryPath, Resources.BrowseForDirectory);
+
+                if (!browseResult.Success)
+                    return;
+
+                var directory = browseResult.DirectoryPath ?? localBaseRepositoryPath;
+
+                try
+                {
+                    BaseRepositoryPath = directory;
+                }
+                catch (Exception e)
+                {
+                    // TODO: We really should limit this to exceptions we know how to handle.
+                    log.Error(string.Format(CultureInfo.InvariantCulture,
+                        "Failed to set base repository path.{0}localBaseRepositoryPath = \"{1}\"{0}BaseRepositoryPath = \"{2}\"{0}Chosen directory = \"{3}\"",
+                        System.Environment.NewLine, localBaseRepositoryPath ?? "(null)", BaseRepositoryPath ?? "(null)", directory ?? "(null)"), e);
+                }
+            }, RxApp.MainThreadScheduler);
+        }
+
         /// <summary>
         /// Path to clone repositories into
         /// </summary>
@@ -192,26 +214,16 @@ public string BaseRepositoryPath
         /// </summary>
         public IReactiveCommand<Unit> CloneCommand { get; private set; }
 
-        IReactiveList<IRepositoryModel> repositories;
+        ObservableCollection<IRepositoryModel> repositories;
         /// <summary>
         /// List of repositories as returned by the server
         /// </summary>
-        public IReactiveList<IRepositoryModel> Repositories
+        public ObservableCollection<IRepositoryModel> Repositories
         {
             get { return repositories; }
             private set { this.RaiseAndSetIfChanged(ref repositories, value); }
         }
 
-        IReactiveDerivedList<IRepositoryModel> filteredRepositories;
-        /// <summary>
-        /// List of repositories as filtered by user
-        /// </summary>
-        public IReactiveDerivedList<IRepositoryModel> FilteredRepositories
-        {
-            get { return filteredRepositories; }
-            private set { this.RaiseAndSetIfChanged(ref filteredRepositories, value); }
-        }
-
         IRepositoryModel selectedRepository;
         /// <summary>
         /// Selected repository to clone
@@ -244,12 +256,8 @@ public string FilterText
 
         public bool IsLoading
         {
-            get { return isLoading.Value; }
-        }
-
-        public IReactiveCommand<IReadOnlyList<IRepositoryModel>> LoadRepositoriesCommand
-        {
-            get { return loadRepositoriesCommand; }
+            get { return isLoading; }
+            private set { this.RaiseAndSetIfChanged(ref isLoading, value); }
         }
 
         public bool LoadingFailed
@@ -278,33 +286,5 @@ public ReactivePropertyValidator<string> BaseRepositoryPathValidator
             get;
             private set;
         }
-
-        IObservable<Unit> ShowBrowseForDirectoryDialog()
-        {
-            return Observable.Start(() =>
-            {
-                // We store this in a local variable to prevent it changing underneath us while the
-                // folder dialog is open.
-                var localBaseRepositoryPath = BaseRepositoryPath;
-                var browseResult = operatingSystem.Dialog.BrowseForDirectory(localBaseRepositoryPath, Resources.BrowseForDirectory);
-
-                if (!browseResult.Success)
-                    return;
-
-                var directory = browseResult.DirectoryPath ?? localBaseRepositoryPath;
-
-                try
-                {
-                    BaseRepositoryPath = directory;
-                }
-                catch (Exception e)
-                {
-                    // TODO: We really should limit this to exceptions we know how to handle.
-                    log.Error(string.Format(CultureInfo.InvariantCulture,
-                        "Failed to set base repository path.{0}localBaseRepositoryPath = \"{1}\"{0}BaseRepositoryPath = \"{2}\"{0}Chosen directory = \"{3}\"",
-                        System.Environment.NewLine, localBaseRepositoryPath ?? "(null)", BaseRepositoryPath ?? "(null)", directory ?? "(null)"), e);
-                }
-            }, RxApp.MainThreadScheduler);
-        }
     }
 }

src/GitHub.Exports.Reactive/Collections/ITrackingCollection.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Reactive;
 
 namespace GitHub.Collections
@@ -15,7 +17,10 @@ namespace GitHub.Collections
     /// for T
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public interface ITrackingCollection<T> : IDisposable, IList<T> where T : ICopyable<T>
+    public interface ITrackingCollection<T> : IDisposable,
+        INotifyCollectionChanged, INotifyPropertyChanged,
+        IList<T>, ICollection<T>, IEnumerable<T>
+        where T : ICopyable<T>
     {
         /// <summary>
         /// Sets up an observable as source for the collection.
@@ -55,7 +60,6 @@ public interface ITrackingCollection<T> : IDisposable, IList<T> where T : ICopya
         /// How long to delay between processing incoming items
         /// </summary>
         TimeSpan ProcessingDelay { get; set; }
-        event NotifyCollectionChangedEventHandler CollectionChanged;
         IObservable<Unit> OriginalCompleted { get; }
     }
 }

src/GitHub.Exports.Reactive/Collections/TrackingCollection.cs

@@ -152,7 +152,7 @@ enum TheAction
 
         bool originalSourceIsCompleted;
         bool signalOriginalSourceCompletion;
-        readonly Subject<Unit> originalSourceCompleted = new Subject<Unit>();
+        ReplaySubject<Unit> originalSourceCompleted;
         public IObservable<Unit> OriginalCompleted => originalSourceCompleted;
 
         TimeSpan requestedDelay;
@@ -214,15 +214,33 @@ public IObservable<T> Listen(IObservable<T> obs)
             // to the cache queue, and signal that data is available
             // for processing
             dataPump = obs
+                .Catch<T, Exception>(ex =>
+                {
+                    originalSourceCompleted.OnError(ex);
+                    return Observable.Throw<T>(ex);
+                })
                 .Do(data =>
                 {
                     cache.Enqueue(new ActionData(data));
                     signalHaveData.OnNext(Unit.Default);
                 })
                 .Finally(() =>
                 {
+                    if (disposed)
+                        return;
+
                     originalSourceIsCompleted = true;
-                    signalOriginalSourceCompletion = true;
+                    if (!cache.IsEmpty)
+                    {
+                        signalOriginalSourceCompletion = true;
+                    }
+                    else
+                    {
+                        originalSourceCompleted.OnNext(Unit.Default);
+                        originalSourceCompleted.OnCompleted();
+                        signalNeedData.OnCompleted();
+                        signalHaveData.OnCompleted();
+                    }
                 })
                 .Publish();
 
@@ -275,6 +293,7 @@ public IObservable<T> Listen(IObservable<T> obs)
                         {
                             signalOriginalSourceCompletion = false;
                             originalSourceCompleted.OnNext(Unit.Default);
+                            originalSourceCompleted.OnCompleted();
                         }
                     }
                     else
@@ -1086,6 +1105,7 @@ void Reset()
             disposables.Add(signalHaveData);
             signalNeedData = new Subject<Unit>();
             disposables.Add(signalNeedData);
+            originalSourceCompleted = new ReplaySubject<Unit>();
 
             resetting = false;
         }

src/GitHub.Exports.Reactive/Services/IModelService.cs

@@ -16,11 +16,10 @@ public interface IModelService : IDisposable
         IObservable<AccountCacheItem> GetUserFromCache();
         IObservable<Unit> InsertUser(AccountCacheItem user);
         IObservable<IReadOnlyList<IAccount>> GetAccounts();
-        IObservable<IReadOnlyList<IRepositoryModel>> GetRepositories();
         IObservable<LicenseItem> GetLicenses();
         IObservable<GitIgnoreItem> GetGitIgnoreTemplates();
-        ITrackingCollection<IPullRequestModel> GetPullRequests(ISimpleRepositoryModel repo,
-            ITrackingCollection<IPullRequestModel> collection = null);
+        ITrackingCollection<IPullRequestModel> GetPullRequests(ISimpleRepositoryModel repo, ITrackingCollection<IPullRequestModel> collection);
         IObservable<Unit> InvalidateAll();
+        ITrackingCollection<IRepositoryModel> GetRepositories(ITrackingCollection<IRepositoryModel> collection);
     }
 }

src/GitHub.Exports.Reactive/ViewModels/IRepositoryCloneViewModel.cs

@@ -2,6 +2,7 @@
 using System.Reactive;
 using GitHub.Models;
 using ReactiveUI;
+using System.Collections.ObjectModel;
 
 namespace GitHub.ViewModels
 {
@@ -10,11 +11,6 @@ namespace GitHub.ViewModels
     /// </summary>
     public interface IRepositoryCloneViewModel : IViewModel, IRepositoryCreationTarget
     {
-        /// <summary>
-        /// Command to load the repositories.
-        /// </summary>
-        IReactiveCommand<IReadOnlyList<IRepositoryModel>> LoadRepositoriesCommand { get; }
-
         /// <summary>
         /// Command to clone the currently selected repository.
         /// </summary>
@@ -23,7 +19,7 @@ public interface IRepositoryCloneViewModel : IViewModel, IRepositoryCreationTarg
         /// <summary>
         /// The list of repositories the current user may clone from the specified host.
         /// </summary>
-        IReactiveDerivedList<IRepositoryModel> FilteredRepositories { get; }
+        ObservableCollection<IRepositoryModel> Repositories { get; }
 
         IRepositoryModel SelectedRepository { get; set; }