public RepoClonesValidStateVm( IDriverRepositoryPreparationFollower driverRepositoryPreparation, IRunnerRepositoryPreparation runnerRepositoryPreparation) { _Valid = Observable.CombineLatest( driverRepositoryPreparation.DriverInfo, runnerRepositoryPreparation.State, (driver, runner) => driver.RunnableState.Succeeded && runner.RunnableState.Succeeded) .ToGuiProperty(this, nameof(Valid), deferSubscription: true); }
public AvailableProjects( IDriverRepositoryPreparationFollower driverRepositoryPreparation) { Projects = driverRepositoryPreparation.DriverInfo .Select(x => x.Item?.AvailableProjects ?? Enumerable.Empty <string>()) .Select(x => x.AsObservableChangeSet <string>()) .Switch() .ObserveOn(RxApp.MainThreadScheduler) .ToObservableCollection(this); }
public AvailableTags( ISelectedProjectInputVm selectedProjectInput, IDriverRepositoryPreparationFollower driverRepositoryPreparation, IAvailableProjects availableProjects) { var tagInput = Observable.CombineLatest( selectedProjectInput.Picker.WhenAnyValue(x => x.TargetPath), availableProjects.Projects.WhenAnyValue(x => x.Count), (targetPath, count) => (targetPath, count)); Tags = driverRepositoryPreparation.DriverInfo .Select(x => x.Item?.Tags ?? Enumerable.Empty <DriverTag>()) .Select(x => x.AsObservableChangeSet()) .Switch() .Filter( tagInput.Select(x => { if (x.count == 0) { return(new Func <DriverTag, bool>(_ => false)); } if (x.count == 1) { return(new Func <DriverTag, bool>(_ => true)); } if (!x.targetPath.EndsWith(".csproj")) { return(new Func <DriverTag, bool>(_ => false)); } var projName = Path.GetFileName(x.targetPath); return(new Func <DriverTag, bool>(i => i.Name.StartsWith(projName, StringComparison.OrdinalIgnoreCase))); })) .Sort(SortExpressionComparer <DriverTag> .Descending(x => x.Index)) .Transform(x => x.Name) .ObserveOn(RxApp.MainThreadScheduler) .ToObservableCollection(this); }
public GitPatcherState( IDriverRepositoryPreparationFollower driverRepositoryPreparation, IRunnerRepositoryPreparation runnerRepositoryState, IRunnableStateProvider runnableStateProvider, IPatcherRunnabilityCliState runnabilityCliState, IInstalledSdkFollower dotNetInstalled, IEnvironmentErrorsVm envErrors, IMissingMods missingMods, ILogger logger) { State = Observable.CombineLatest( driverRepositoryPreparation.DriverInfo .Select(x => x.ToUnit()), runnerRepositoryState.State, runnableStateProvider.WhenAnyValue(x => x.State) .Select(x => x.ToUnit()), runnabilityCliState.Runnable, dotNetInstalled.DotNetSdkInstalled .Select(x => (x, true)) .StartWith((new DotNetVersion(string.Empty, false), false)), envErrors.WhenAnyFallback(x => x.ActiveError !.ErrorString), missingMods.Missing .QueryWhenChanged() .Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler) .StartWith(ListExt.Empty <ModKey>()), (driver, runner, checkout, runnability, dotnet, envError, reqModsMissing) => { if (driver.IsHaltingError) { return(driver); } if (runner.IsHaltingError) { return(runner); } if (!dotnet.Item2) { return(new ConfigurationState(ErrorResponse.Fail("Determining DotNet SDK installed")) { IsHaltingError = false }); } if (!dotnet.Item1.Acceptable) { return(new ConfigurationState(ErrorResponse.Fail("No DotNet SDK installed"))); } if (envError != null) { return(new ConfigurationState(ErrorResponse.Fail(envError))); } if (reqModsMissing.Count > 0) { return(new ConfigurationState(ErrorResponse.Fail( $"Required mods missing from load order:{Environment.NewLine}{string.Join(Environment.NewLine, reqModsMissing)}"))); } if (runnability.RunnableState.Failed) { return(runnability.BubbleError()); } if (checkout.RunnableState.Failed) { return(checkout.BubbleError()); } logger.Information("State returned success!"); return(ConfigurationState.Success); }) .Replay(1) .RefCount(); }
public GitStatusDisplay( IRunnableStateProvider runnableStateProvider, ICompilationProvider compilationProvider, IPatcherRunnabilityCliState runnabilityCliState, IDriverRepositoryPreparationFollower driverRepositoryPreparation) { StatusDisplay = Observable.CombineLatest( driverRepositoryPreparation.DriverInfo, runnableStateProvider.WhenAnyValue(x => x.State), compilationProvider.State, runnabilityCliState.Runnable, (driver, runnable, comp, runnability) => { if (driver.RunnableState.Failed) { if (driver.IsHaltingError) { return(new StatusRecord( Text: "Blocking Error", Processing: false, Blocking: true, Command: null)); } return(new StatusRecord( Text: "Analyzing repository", Processing: true, Blocking: false, Command: null)); } if (runnable.RunnableState.Failed) { if (runnable.IsHaltingError) { return(new StatusRecord( Text: "Blocking Error", Processing: false, Blocking: true, Command: null)); } return(new StatusRecord( Text: "Checking out desired state", Processing: true, Blocking: false, Command: null)); } if (comp.RunnableState.Failed) { if (comp.IsHaltingError) { return(new StatusRecord( Text: "Blocking Error", Processing: false, Blocking: true, Command: null)); } return(new StatusRecord( Text: "Compiling", Processing: true, Blocking: false, Command: null)); } if (runnability.RunnableState.Failed) { if (runnability.IsHaltingError) { return(new StatusRecord( Text: "Blocking Error", Processing: false, Blocking: true, Command: null)); } return(new StatusRecord( Text: "Checking runnability", Processing: true, Blocking: false, Command: null)); } return(new StatusRecord( Text: "Ready", Processing: false, Blocking: false, Command: null)); }) .Replay(1) .RefCount(); }
public GitPatcherTargetingVm( ILockToCurrentVersioning lockToCurrentVersioning, IDriverRepositoryPreparationFollower driverRepositoryPreparation) { var targetOriginBranchName = this.WhenAnyValue(x => x.TargetBranchName) .Select(x => $"origin/{x}") .Replay(1).RefCount(); // Set latest checkboxes to drive user input driverRepositoryPreparation.DriverInfo .FlowSwitch(this.WhenAnyValue(x => x.BranchFollowMain)) .Throttle(TimeSpan.FromMilliseconds(150), RxApp.MainThreadScheduler) .Subscribe(state => { if (state.RunnableState.Succeeded) { this.TargetBranchName = state.Item.MasterBranchName; } }) .DisposeWith(this); Observable.CombineLatest( driverRepositoryPreparation.DriverInfo, targetOriginBranchName, (Driver, TargetBranch) => (Driver, TargetBranch)) .FlowSwitch( Observable.CombineLatest( this.WhenAnyValue(x => x.BranchAutoUpdate), this.WhenAnyValue(x => x.PatcherVersioning), (autoBranch, versioning) => autoBranch && versioning == PatcherVersioningEnum.Branch)) .Throttle(TimeSpan.FromMilliseconds(150), RxApp.MainThreadScheduler) .Subscribe(x => { if (x.Driver.RunnableState.Succeeded && x.Driver.Item.BranchShas.TryGetValue(x.TargetBranch, out var sha)) { this.TargetCommit = sha; } }) .DisposeWith(this); driverRepositoryPreparation.DriverInfo .Select(x => x.RunnableState.Failed ? default : x.Item.Tags.OrderByDescending(x => x.Index).FirstOrDefault()) .FlowSwitch( Observable.CombineLatest( this.WhenAnyValue(x => x.TagAutoUpdate), lockToCurrentVersioning.WhenAnyValue(x => x.Lock), this.WhenAnyValue(x => x.PatcherVersioning), (autoTag, locked, versioning) => !locked && autoTag && versioning == PatcherVersioningEnum.Tag)) .Throttle(TimeSpan.FromMilliseconds(150), RxApp.MainThreadScheduler) .Subscribe(x => { this.TargetTag = x?.Name ?? string.Empty; this.TargetCommit = x?.Sha ?? string.Empty; }) .DisposeWith(this); var targetBranchSha = Observable.CombineLatest( driverRepositoryPreparation.DriverInfo .Select(x => x.RunnableState.Failed ? default : x.Item.BranchShas), targetOriginBranchName, (dict, branch) => dict?.GetOrDefault(branch)) .Replay(1) .RefCount(); var targetTag = Observable.CombineLatest( driverRepositoryPreparation.DriverInfo .Select(x => x.RunnableState.Failed ? default : x.Item.Tags), this.WhenAnyValue(x => x.TargetTag), (tags, tag) => tags? .Where(tagItem => tagItem.Name == tag) .FirstOrDefault()) .Replay(1) .RefCount(); // Set up empty target autofill // Usually for initial bootstrapping Observable.CombineLatest( targetBranchSha, this.WhenAnyValue(x => x.TargetCommit), (targetBranchSha, targetCommit) => (targetBranchSha, targetCommit)) .Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler) .Where(x => x.targetBranchSha != null && TargetCommit.IsNullOrWhitespace()) .Subscribe(x => { this.TargetCommit = x.targetBranchSha ?? string.Empty; }) .DisposeWith(this); Observable.CombineLatest( targetTag, this.WhenAnyValue(x => x.TargetCommit), (targetTagSha, targetCommit) => (targetTagSha, targetCommit)) .Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler) .Where(x => x.targetTagSha != null && TargetCommit.IsNullOrWhitespace()) .Subscribe(x => { this.TargetCommit = x.targetTagSha?.Sha ?? string.Empty; }) .DisposeWith(this); // Set up update available systems UpdateToBranchCommand = NoggogCommand.CreateFromObject( objectSource: Observable.CombineLatest( targetBranchSha, this.WhenAnyValue(x => x.TargetCommit), (branch, target) => (BranchSha: branch, Current: target)), canExecute: o => o.BranchSha != null && o.BranchSha != o.Current, extraCanExecute: this.WhenAnyValue(x => x.PatcherVersioning) .Select(vers => vers == PatcherVersioningEnum.Branch), execute: o => { this.TargetCommit = o.BranchSha !; }, this); UpdateToTagCommand = NoggogCommand.CreateFromObject( objectSource: Observable.CombineLatest( targetTag, Observable.CombineLatest( this.WhenAnyValue(x => x.TargetCommit), this.WhenAnyValue(x => x.TargetTag), (TargetSha, TargetTag) => (TargetSha, TargetTag)), (tag, target) => (TagSha: tag?.Sha, Tag: tag?.Name, Current: target)), canExecute: o => (o.TagSha != null && o.Tag != null) && (o.TagSha != o.Current.TargetSha || o.Tag != o.Current.TargetTag), extraCanExecute: this.WhenAnyValue(x => x.PatcherVersioning) .Select(vers => vers == PatcherVersioningEnum.Tag), execute: o => { this.TargetTag = o.Tag !; this.TargetCommit = o.TagSha !; }, this); ActivePatcherVersion = Observable.CombineLatest( this.WhenAnyValue(x => x.PatcherVersioning), this.WhenAnyValue(x => x.TargetTag), this.WhenAnyValue(x => x.TargetCommit), targetOriginBranchName, Observable.CombineLatest( this.WhenAnyValue(x => x.TagAutoUpdate), lockToCurrentVersioning.WhenAnyValue(x => x.Lock), (auto, locked) => !locked && auto), Observable.CombineLatest( this.WhenAnyValue(x => x.BranchAutoUpdate), lockToCurrentVersioning.WhenAnyValue(x => x.Lock), (auto, locked) => !locked && auto), (versioning, tag, commit, branch, tagAuto, branchAuto) => { return(GitPatcherVersioning.Factory( versioning: versioning, tag: tag, commit: commit, branch: branch, autoTag: tagAuto, autoBranch: branchAuto)); }) .DistinctUntilChanged() .Replay(1) .RefCount(); }