Merge pull request #1343 from reactiveui/develop

+semver: feature

Author: ghuntley

CODE_OF_CONDUCT.md

@@ -35,7 +35,7 @@ This Code of Conduct applies both within project spaces and in public spaces
 when an individual is representing the project or its community.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting a project maintainer at [email protected]. All
+reported by contacting a project maintainer at [email protected]. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. Maintainers are
 obligated to maintain confidentiality with regard to the reporter of an

README.md

@@ -311,26 +311,18 @@ public void ExecutePassesThroughParameter()
         }
 
         [Fact]
-        public void ExecuteExecutesOnTheSpecifiedScheduler()
+        public void ExecuteResultIsDeliveredOnSpecifiedScheduler()
         {
             (new TestScheduler()).With(sched => {
-                var execute = Observables.Unit.Delay(TimeSpan.FromSeconds(1), sched);
+                var execute = Observables.Unit;
                 var fixture = ReactiveCommand.CreateFromObservable(() => execute, outputScheduler: sched);
-                var isExecuting = fixture
-                    .IsExecuting
-                    .CreateCollection();
+                var executed = false;
 
-                fixture.Execute().Subscribe();
-                sched.AdvanceByMs(999);
+                fixture.Execute().Subscribe(_ => executed = true);
 
-                Assert.Equal(2, isExecuting.Count);
-                Assert.False(isExecuting[0]);
-                Assert.True(isExecuting[1]);
-
-                sched.AdvanceByMs(2);
-
-                Assert.Equal(3, isExecuting.Count);
-                Assert.False(isExecuting[2]);
+                Assert.False(executed);
+                sched.AdvanceByMs(1);
+                Assert.True(executed);
             });
         }
 

src/ReactiveUI.Tests/ReactiveCommandTest.cs

@@ -88,7 +88,7 @@ public void ByDefaultViewModelIsReplacedWithViewWhenDeterminingTheServiceName()
                 FooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -106,7 +106,7 @@ public void TheRuntimeTypeOfTheViewModelIsUsedToResolveTheView()
                 object vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result );
             }
         }
 
@@ -125,7 +125,7 @@ public void ViewModelToViewNamingConventionCanBeCustomized()
                 FooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooWithWeirdConvention);
+                Assert.IsType<FooWithWeirdConvention>(result);
             }
         }
 
@@ -143,7 +143,7 @@ public void CanResolveViewFromViewModelClassUsingClassRegistration()
                 FooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -161,7 +161,7 @@ public void CanResolveViewFromViewModelClassUsingInterfaceRegistration()
                 FooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -179,7 +179,7 @@ public void CanResolveViewFromViewModelClassUsingIViewForRegistration()
                 FooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -197,7 +197,7 @@ public void CanResolveViewFromViewModelInterfaceUsingClassRegistration()
                 IFooViewModel vm = new FooViewModelWithWeirdName();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -215,7 +215,7 @@ public void CanResolveViewFromViewModelInterfaceUsingInterfaceRegistration()
                 IFooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -233,7 +233,7 @@ public void CanResolveViewFromViewModelInterfaceUsingIViewForRegistration()
                 IFooViewModel vm = new FooViewModel();
 
                 var result = fixture.ResolveView(vm);
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
             }
         }
 
@@ -255,10 +255,10 @@ public void ContractIsUsedWhenResolvingView()
                 Assert.Null(result);
 
                 result = fixture.ResolveView(vm, "first");
-                Assert.True(result is FooView);
+                Assert.IsType<FooView>(result);
 
                 result = fixture.ResolveView(vm, "second");
-                Assert.True(result is FooWithWeirdConvention);
+                Assert.IsType<FooWithWeirdConvention>(result);
             }
         }
 
@@ -333,4 +333,4 @@ public void AnErrorIsRaisedIfTheCreationOfTheViewFails()
             }
         }
     }
-}
+}

src/ReactiveUI.Tests/ViewLocatorTests.cs

@@ -30,9 +30,22 @@ static ControlFetcherMixin()
             var assm = AppDomain.CurrentDomain.GetAssemblies()[1];
             var resources = assm.GetModules().SelectMany(x => x.GetTypes()).First(x => x.Name == "Resource");
 
-            controlIds = resources.GetNestedType("Id").GetFields()
-                .Where(x => x.FieldType == typeof(int))
-                .ToDictionary(k => k.Name.ToLowerInvariant(), v => (int)v.GetRawConstantValue());
+            try {
+                controlIds = resources.GetNestedType("Id").GetFields()
+                    .Where(x => x.FieldType == typeof(int))
+                    .ToDictionary(k => k.Name.ToLowerInvariant(), v => (int)v.GetRawConstantValue());
+            } catch (ArgumentException argumentException) {
+                var duplicates = resources.GetNestedType("Id").GetFields()
+                                          .Where(x => x.FieldType == typeof(int))
+                                          .GroupBy(k => k.Name.ToLowerInvariant())
+                                          .Where(g => g.Count() > 1)
+                                          .Select(g => "{ " + string.Join(" = ", g.Select(v => v.Name)) + " }");
+
+                if (duplicates.Any())
+                    throw new InvalidOperationException("You're using multiple resource ID's with the same name but with different casings which isn't allowed for WireUpControls: " + string.Join(", ", duplicates), argumentException);
+
+                throw argumentException;
+            }
 
             var type = typeof(ControlFetcherMixin);
             getControlActivity = type.GetMethod("GetControl", new[] { typeof(Activity), typeof(string) });

src/ReactiveUI/Android/ControlFetcherMixin.cs

@@ -1,4 +1,3 @@
-using ReactiveUI;
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
@@ -7,9 +6,8 @@
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
-using System.Runtime.Serialization;
-using System.Text;
 using System.Reflection;
+using System.Runtime.Serialization;
 using Splat;
 
 namespace ReactiveUI
@@ -33,11 +31,16 @@ public static class AutoPersistHelper
         /// Changes to properties not marked with DataMember will not trigger the
         /// object to be saved.
         /// </summary>
-        /// <param name="doPersist">The asynchronous method to call to save the
-        /// object to disk.</param>
-        /// <param name="interval">The interval to save the object on. Note that
-        /// if an object is constantly changing, it is possible that it will never
-        /// be saved.</param>
+        /// <param name="This">
+        /// The reactive object to watch for changes
+        /// </param>
+        /// <param name="doPersist">
+        /// The asynchronous method to call to save the object to disk.
+        /// </param>
+        /// <param name="interval">
+        /// The interval to save the object on. Note that if an object is constantly changing, 
+        /// it is possible that it will never be saved.
+        /// </param>
         /// <returns>A Disposable to disable automatic persistence.</returns>
         public static IDisposable AutoPersist<T>(this T This, Func<T, IObservable<Unit>> doPersist, TimeSpan? interval = null)
             where T : IReactiveObject
@@ -52,13 +55,19 @@ public static IDisposable AutoPersist<T>(this T This, Func<T, IObservable<Unit>>
         /// Changes to properties not marked with DataMember will not trigger the
         /// object to be saved.
         /// </summary>
-        /// <param name="doPersist">The asynchronous method to call to save the
-        /// object to disk.</param>
-        /// <param name="manualSaveSignal">When invoked, the object will be saved
-        /// regardless of whether it has changed.</param>
-        /// <param name="interval">The interval to save the object on. Note that
-        /// if an object is constantly changing, it is possible that it will never
-        /// be saved.</param>
+        /// <param name="This">
+        /// The reactive object to watch for changes
+        /// </param>
+        /// <param name="doPersist">
+        /// The asynchronous method to call to save the object to disk.
+        /// </param>
+        /// <param name="manualSaveSignal">
+        /// When invoked, the object will be saved regardless of whether it has changed.
+        /// </param>
+        /// <param name="interval">
+        /// The interval to save the object on. Note that if an object is constantly changing, 
+        /// it is possible that it will never be saved.
+        /// </param>
         /// <returns>A Disposable to disable automatic persistence.</returns>
         public static IDisposable AutoPersist<T, TDontCare>(this T This, Func<T, IObservable<Unit>> doPersist, IObservable<TDontCare> manualSaveSignal, TimeSpan? interval = null)
             where T : IReactiveObject
@@ -100,11 +109,16 @@ public static IDisposable AutoPersist<T, TDontCare>(this T This, Func<T, IObserv
         /// Apply AutoPersistence to all objects in a collection. Items that are
         /// no longer in the collection won't be persisted anymore.
         /// </summary>
-        /// <param name="doPersist">The asynchronous method to call to save the
-        /// object to disk.</param>
-        /// <param name="interval">The interval to save the object on. Note that
-        /// if an object is constantly changing, it is possible that it will never
-        /// be saved.</param>
+        /// <param name="This">
+        /// The reactive collection to watch for changes
+        /// </param>
+        /// <param name="doPersist">
+        /// The asynchronous method to call to save the object to disk.
+        /// </param>
+        /// <param name="interval">
+        /// The interval to save the object on. Note that if an object is constantly changing, 
+        /// it is possible that it will never be saved.
+        /// </param>
         /// <returns>A Disposable to disable automatic persistence.</returns>
         public static IDisposable AutoPersistCollection<T>(this IReactiveCollection<T> This, Func<T, IObservable<Unit>> doPersist, TimeSpan? interval = null)
             where T : IReactiveObject
@@ -116,13 +130,19 @@ public static IDisposable AutoPersistCollection<T>(this IReactiveCollection<T> T
         /// Apply AutoPersistence to all objects in a collection. Items that are
         /// no longer in the collection won't be persisted anymore.
         /// </summary>
-        /// <param name="doPersist">The asynchronous method to call to save the
-        /// object to disk.</param>
-        /// <param name="manualSaveSignal">When invoked, the object will be saved
-        /// regardless of whether it has changed.</param>
-        /// <param name="interval">The interval to save the object on. Note that
-        /// if an object is constantly changing, it is possible that it will never
-        /// be saved.</param>
+        /// <param name="This">
+        /// The reactive collection to watch for changes
+        /// </param>
+        /// <param name="doPersist">
+        /// The asynchronous method to call to save the object to disk.
+        /// </param>
+        /// <param name="manualSaveSignal">
+        /// When invoked, the object will be saved regardless of whether it has changed.
+        /// </param>
+        /// <param name="interval">
+        /// The interval to save the object on. Note that if an object is constantly changing, 
+        /// it is possible that it will never be saved.
+        /// </param>
         /// <returns>A Disposable to disable automatic persistence.</returns>
         public static IDisposable AutoPersistCollection<T, TDontCare>(this IReactiveCollection<T> This, Func<T, IObservable<Unit>> doPersist, IObservable<TDontCare> manualSaveSignal, TimeSpan? interval = null)
             where T : IReactiveObject
@@ -150,10 +170,15 @@ public static IDisposable AutoPersistCollection<T, TDontCare>(this IReactiveColl
         /// removed from a collection. This class correctly handles both when
         /// a collection is initialized, as well as when the collection is Reset.
         /// </summary>
-        /// <param name="onAdd">A method to be called when an object is added
-        /// to the collection.</param>
-        /// <param name="onRemove">A method to be called when an object is removed
-        /// from the collection.</param>
+        /// <param name="This">
+        /// The reactive collection to watch for changes
+        /// </param>
+        /// <param name="onAdd">
+        /// A method to be called when an object is added to the collection.
+        /// </param>
+        /// <param name="onRemove">
+        /// A method to be called when an object is removed from the collection.
+        /// </param>
         /// <returns>A Disposable that deactivates this behavior.</returns>
         public static IDisposable ActOnEveryObject<T>(this IReactiveCollection<T> This, Action<T> onAdd, Action<T> onRemove)
             where T : IReactiveObject

src/ReactiveUI/AutoPersistHelper.cs

@@ -1,29 +1,22 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reactive.Subjects;
 
 namespace ReactiveUI
 {
-    public static class CompatMixins
+    internal static class CompatMixins
     {
         internal static void ForEach<T>(this IEnumerable<T> This, Action<T> block)
         {
             foreach (var v in This) {
-                block(v); 
+                block(v);
             }
         }
 
         internal static IEnumerable<T> SkipLast<T>(this IEnumerable<T> This, int count)
         {
             return This.Take(This.Count() - count);
         }
-
-        internal static IObservable<T> PermaRef<T>(this IConnectableObservable<T> This)
-        {
-            This.Connect();
-            return This;
-        }
     }
 
     // according to spouliot, this is just a string match, and will cause the

src/ReactiveUI/CompatMixins.cs

@@ -115,7 +115,7 @@ public TOutput GetOutput()
     /// <para>
     /// Note that handlers are not required to handle an interaction. They can choose to ignore it, leaving it
     /// for some other handler to handle. If no handler handles the interaction, the <see cref="Handle"/> method
-    /// will throw an <see cref="UnhandledInteractionException"/>.
+    /// will throw an <see cref="UnhandledInteractionException{TInput, TOutput}"/>.
     /// </para>
     /// </remarks>
     /// <typeparam name="TInput">
@@ -228,15 +228,15 @@ public IDisposable RegisterHandler<TDontCare>(Func<InteractionContext<TInput, TO
         /// <para>
         /// This method passes the interaction through to relevant handlers in reverse order of registration,
         /// ceasing once any handler handles the interaction. If the interaction remains unhandled after all
-        /// relevant handlers have executed, an <see cref="UnhandledInteractionException"/> is thrown.
+        /// relevant handlers have executed, an <see cref="UnhandledInteractionException{TInput, TOutput}"/> is thrown.
         /// </para>
         /// </remarks>
         /// <param name="input">
         /// The input for the interaction.
         /// </param>
         /// <returns>
         /// An observable that ticks when the interaction completes, or throws an
-        /// <see cref="UnhandledInteractionException"/> if no handler handles the interaction.
+        /// <see cref="UnhandledInteractionException{TInput, TOutput}"/> if no handler handles the interaction.
         /// </returns>
         public virtual IObservable<TOutput> Handle(TInput input)
         {