public LoggingConfiguration(IProgram program, IOperatingSystem os, IVSServices vsservice)
{
NLog.Config.LoggingConfiguration conf;
string assemblyFolder = program.ExecutingAssemblyDirectory;
try
{
conf = new XmlLoggingConfiguration(Path.Combine(assemblyFolder, "NLog.config"), true);
}
catch (Exception ex)
{
vsservice.ActivityLogError(string.Format(CultureInfo.InvariantCulture, "Error loading nlog.config. {0}", ex));
conf = new NLog.Config.LoggingConfiguration();
}
var fileTarget = conf.FindTargetByName("file") as FileTarget;
if (fileTarget == null)
{
fileTarget = new FileTarget();
conf.AddTarget(Path.GetRandomFileName(), fileTarget);
conf.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, fileTarget));
}
fileTarget.FileName = Path.Combine(os.Environment.GetLocalGitHubApplicationDataPath(), "extension.log");
fileTarget.Layout = layout;
try
{
LogManager.Configuration = conf;
}
catch (Exception ex)
{
vsservice.ActivityLogError(string.Format(CultureInfo.InvariantCulture, "Error configuring the log. {0}", ex));
}
}
/// <summary>
/// This is main method.
/// </summary>
/// <param name="args">String args.</param>
public static void Main(string[] args)
{
OsFactory factory = new OsFactory();
IOperatingSystem os = factory.GetOs("android");
os.Spec();
}
static PullRequestService CreateTarget(
IGitClient gitClient = null,
IGitService gitService = null,
IVSGitExt gitExt = null,
IApiClientFactory apiClientFactory = null,
IGraphQLClientFactory graphqlFactory = null,
IOperatingSystem os = null,
IUsageTracker usageTracker = null)
{
gitClient = gitClient ?? Substitute.For <IGitClient>();
gitService = gitService ?? Substitute.For <IGitService>();
gitExt = gitExt ?? Substitute.For <IVSGitExt>();
apiClientFactory = apiClientFactory ?? Substitute.For <IApiClientFactory>();
graphqlFactory = graphqlFactory ?? Substitute.For <IGraphQLClientFactory>();
os = os ?? Substitute.For <IOperatingSystem>();
usageTracker = usageTracker ?? Substitute.For <IUsageTracker>();
return(new PullRequestService(
gitClient,
gitService,
gitExt,
apiClientFactory,
graphqlFactory,
os,
usageTracker));
}
public PullRequestService(IGitClient gitClient, IGitService gitService, IOperatingSystem os, IUsageTracker usageTracker)
{
this.gitClient = gitClient;
this.gitService = gitService;
this.os = os;
this.usageTracker = usageTracker;
}
public InspectionResultsViewModel(RubberduckParserState state, IInspector inspector, VBE vbe, INavigateCommand navigateCommand, IClipboardWriter clipboard,
IGeneralConfigService configService, IOperatingSystem operatingSystem)
{
_state = state;
_inspector = inspector;
_vbe = vbe;
_navigateCommand = navigateCommand;
_clipboard = clipboard;
_configService = configService;
_operatingSystem = operatingSystem;
_refreshCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), async param => await Task.Run(() => ExecuteRefreshCommandAsync()), CanExecuteRefreshCommand);
_disableInspectionCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteDisableInspectionCommand);
_quickFixCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixCommand, CanExecuteQuickFixCommand);
_quickFixInModuleCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInModuleCommand, _ => _state.Status == ParserState.Ready);
_quickFixInProjectCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteQuickFixInProjectCommand, _ => _state.Status == ParserState.Ready);
_copyResultsCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), ExecuteCopyResultsCommand, CanExecuteCopyResultsCommand);
_openSettingsCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), OpenSettings);
_configService.SettingsChanged += _configService_SettingsChanged;
_setInspectionTypeGroupingCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), param =>
{
GroupByInspectionType = (bool)param;
GroupByLocation = !(bool)param;
});
_setLocationGroupingCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), param =>
{
GroupByLocation = (bool)param;
GroupByInspectionType = !(bool)param;
});
_state.StateChanged += _state_StateChanged;
}
public SettingsForm(IGeneralConfigService configService, IOperatingSystem operatingSystem, SettingsViews activeView = SettingsViews.GeneralSettings) : this()
{
var config = configService.LoadConfiguration();
ViewModel = new SettingsControlViewModel(configService,
config,
new SettingsView
{
Control = new GeneralSettings(new GeneralSettingsViewModel(config, operatingSystem)),
View = SettingsViews.GeneralSettings
},
new SettingsView
{
Control = new TodoSettings(new TodoSettingsViewModel(config)),
View = SettingsViews.TodoSettings
},
new SettingsView
{
Control = new InspectionSettings(new InspectionSettingsViewModel(config)),
View = SettingsViews.InspectionSettings
},
new SettingsView
{
Control = new UnitTestSettings(new UnitTestSettingsViewModel(config)),
View = SettingsViews.UnitTestSettings
},
new SettingsView
{
Control = new IndenterSettings(new IndenterSettingsViewModel(config)),
View = SettingsViews.IndenterSettings
},
activeView);
ViewModel.OnWindowClosed += ViewModel_OnWindowClosed;
}
public PullRequestService(IGitClient gitClient, IGitService gitService, IOperatingSystem os, IUsageTracker usageTracker)
{
this.gitClient = gitClient;
this.gitService = gitService;
this.os = os;
this.usageTracker = usageTracker;
}
public RepositoryRecloneViewModel(
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
{
Guard.ArgumentNotNull(cloneService, nameof(cloneService));
Guard.ArgumentNotNull(operatingSystem, nameof(operatingSystem));
this.operatingSystem = operatingSystem;
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.Create(() => { }, canCloneObservable);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public LoggingConfiguration(IProgram program, IOperatingSystem os, IVSServices vsservice)
{
NLog.Config.LoggingConfiguration conf;
string assemblyFolder = program.ExecutingAssemblyDirectory;
try
{
conf = new XmlLoggingConfiguration(Path.Combine(assemblyFolder, "NLog.config"), true);
}
catch (Exception ex)
{
vsservice.ActivityLogError(string.Format(CultureInfo.InvariantCulture, "Error loading nlog.config. {0}", ex));
conf = new NLog.Config.LoggingConfiguration();
}
var fileTarget = conf.FindTargetByName("file") as FileTarget;
if (fileTarget == null)
{
fileTarget = new FileTarget();
conf.AddTarget(Path.GetRandomFileName(), fileTarget);
conf.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, fileTarget));
}
fileTarget.FileName = Path.Combine(os.Environment.GetLocalGitHubApplicationDataPath(), "extension.log");
fileTarget.Layout = layout;
try
{
LogManager.Configuration = conf;
}
catch (Exception ex)
{
vsservice.ActivityLogError(string.Format(CultureInfo.InvariantCulture, "Error configuring the log. {0}", ex));
}
}
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, notificationService)
{ }
public GeneralSettingsViewModel(
Configuration config,
IOperatingSystem operatingSystem,
IMessageBox messageBox,
IVbeSettings vbeSettings,
IExperimentalTypesProvider experimentalTypesProvider,
IFilePersistanceService <Rubberduck.Settings.GeneralSettings> service,
IFilePersistanceService <HotkeySettings> hotkeyService)
: base(service)
{
_operatingSystem = operatingSystem;
_messageBox = messageBox;
_vbeSettings = vbeSettings;
_experimentalFeatureTypes = experimentalTypesProvider.ExperimentalTypes;
Languages = new ObservableCollection <DisplayLanguageSetting>(Locales.AvailableCultures
.OrderBy(locale => locale.NativeName)
.Select(locale => new DisplayLanguageSetting(locale.Name)));
LogLevels = new ObservableCollection <MinimumLogLevel>(
LogLevelHelper.LogLevels.Select(l => new MinimumLogLevel(l.Ordinal, l.Name)));
TransferSettingsToView(config.UserSettings.GeneralSettings, config.UserSettings.HotkeySettings);
ShowLogFolderCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), _ => ShowLogFolder());
ExportButtonCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), _ => ExportSettings(GetCurrentGeneralSettings()));
ImportButtonCommand = new DelegateCommand(LogManager.GetCurrentClassLogger(), _ => ImportSettings());
_hotkeyService = hotkeyService;
}
static RepositoryCloneViewModel CreateTarget(
IOperatingSystem os = null,
IConnectionManager connectionManager = null,
IRepositoryCloneService service = null,
IUsageService usageService = null,
IUsageTracker usageTracker = null,
IRepositorySelectViewModel gitHubTab = null,
IRepositorySelectViewModel enterpriseTab = null,
IGitService gitService = null,
IRepositoryUrlViewModel urlTab = null,
string defaultClonePath = defaultPath)
{
os = os ?? Substitute.For <IOperatingSystem>();
connectionManager = connectionManager ?? CreateConnectionManager("https://github.com");
service = service ?? CreateRepositoryCloneService(defaultClonePath);
usageService = usageService ?? CreateUsageService();
usageTracker = usageTracker ?? Substitute.For <IUsageTracker>();
gitHubTab = gitHubTab ?? CreateSelectViewModel();
enterpriseTab = enterpriseTab ?? CreateSelectViewModel();
gitService = gitService ?? CreateGitService(true, "https://github.com/owner/repo");
urlTab = urlTab ?? CreateRepositoryUrlViewModel();
return(new RepositoryCloneViewModel(
os,
connectionManager,
service,
gitService,
usageService,
usageTracker,
gitHubTab,
enterpriseTab,
urlTab));
}
public RepositoryCloneService(IOperatingSystem operatingSystem, IVSGitServices vsGitServices)
{
this.operatingSystem = operatingSystem;
this.vsGitServices = vsGitServices;
defaultClonePath = GetLocalClonePathFromGitProvider(operatingSystem.Environment.GetUserRepositoriesPath());
}
public RepositoryCloneService(IOperatingSystem operatingSystem, IVSServices vsservices)
{
this.operatingSystem = operatingSystem;
this.vsservices = vsservices;
defaultClonePath = GetLocalClonePathFromGitProvider(operatingSystem.Environment.GetUserRepositoriesPath());
}
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
IVSServices vsServices)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, vsServices)
{ }
public RepositoryCloneService(IOperatingSystem operatingSystem, IVSServices vsservices)
{
this.operatingSystem = operatingSystem;
this.vsservices = vsservices;
defaultClonePath = GetLocalClonePathFromGitProvider(operatingSystem.Environment.GetUserDocumentsPathForApplication());
}
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem)
{
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TestBaseLoggable{T}"/> class.
/// </summary>
/// <param name="operatingSystem">The operating system.</param>
/// <param name="testOutputHelper">The test output helper.</param>
/// <param name="initialMinimumLevel">The initial minimum level.</param>
/// <param name="xUnitSerilogFormatter">The x unit serilog formatter.</param>
/// <autogeneratedoc />
protected TestBaseLoggable(IOperatingSystem operatingSystem, ITestOutputHelper testOutputHelper,
LogLevel initialMinimumLevel = LogLevel.Debug,
XUnitSerilogFormatter xUnitSerilogFormatter = XUnitSerilogFormatter.RenderedCompactJsonFormatter)
: this(new FileSystem(typeof(T), operatingSystem), testOutputHelper, initialMinimumLevel,
xUnitSerilogFormatter)
{
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService, avatarProvider)
{}
public StartPageCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
{
this.operatingSystem = operatingSystem;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.Create(canCloneObservable);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public StartPageCloneViewModel(
IGlobalConnection connection,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
: this(connection.Get(), cloneService, operatingSystem)
{
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService, usageTracker)
{}
public RepositoryCreationViewModel(
IModelServiceFactory modelServiceFactory,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
{
Guard.ArgumentNotNull(modelServiceFactory, nameof(modelServiceFactory));
Guard.ArgumentNotNull(operatingSystem, nameof(operatingSystem));
Guard.ArgumentNotNull(repositoryCreationService, nameof(repositoryCreationService));
Guard.ArgumentNotNull(usageTracker, nameof(usageTracker));
this.modelServiceFactory = modelServiceFactory;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
this.usageTracker = usageTracker;
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(this.WhenAny(x => x.BaseRepositoryPath, x => x.Value))
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid);
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty(Resources.RepositoryNameValidatorEmpty)
.IfTrue(x => x.Length > 100, Resources.RepositoryNameValidatorTooLong)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return(parsedReference != repoName ? String.Format(CultureInfo.CurrentCulture, Resources.SafeRepositoryNameWarning, parsedReference) : null);
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
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 TrackingCollection<IRemoteRepositoryModel>();
repositories.ProcessingDelay = TimeSpan.Zero;
repositories.Comparer = OrderedComparer<IRemoteRepositoryModel>.OrderBy(x => x.Owner).ThenBy(x => x.Name).Compare;
repositories.Filter = FilterRepository;
repositories.NewerComparer = OrderedComparer<IRemoteRepositoryModel>.OrderByDescending(x => x.UpdatedAt).Compare;
filterTextIsEnabled = this.WhenAny(x => x.IsLoading,
loading => loading.Value || repositories.UnfilteredCount > 0 && !LoadingFailed)
.ToProperty(this, x => x.FilterTextIsEnabled);
this.WhenAny(x => x.IsLoading, x => x.LoadingFailed,
(loading, failed) => !loading.Value && !failed.Value && repositories.UnfilteredCount == 0)
.Subscribe(x => NoRepositoriesFound = x);
this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler)
.Subscribe(_ => repositories.Filter = FilterRepository);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
NoRepositoriesFound = true;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
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);
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)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler);
FilteredRepositories = Repositories.CreateDerivedCollection(
x => x,
filter: FilterRepository,
signalReset: filterResetSignal
);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty("Please enter a repository path")
.IfTrue(x => x.Length > 200, "Path too long")
.IfContainsInvalidPathChars("Path contains invalid characters")
.IfPathNotRooted("Please enter a valid path")
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public JsonConnectionCache(IProgram program, IOperatingSystem os, string cacheFile)
{
this.os = os;
cachePath = Path.Combine(
os.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData),
program.ApplicationName,
cacheFile);
}
StartPageCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, notificationService, usageTracker)
{ }
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService, avatarProvider)
{
}
public RepositoryCloneViewModel(
IGlobalConnection connection,
IModelServiceFactory modelServiceFactory,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
: this(connection.Get(), modelServiceFactory, cloneService, operatingSystem)
{
}
private Collector(IOperatingSystem os, ICollectorLog collectorLog)
{
_os = os;
_collectorLog = collectorLog;
_currentProcess = os.GetCurrentProcessName();
_currentProcessStartTime = DateTime.UtcNow;
_lastSave = DateTime.UtcNow;
_millisecondsIdle = 0;
}
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, notificationService, usageTracker)
{
}
internal LTAFRunner(IFileSystem fileSystem, IOperatingSystem operatingSystem, IWebServer webServer)
{
this.WebServer = webServer;
this.OperatingSystem = operatingSystem;
this.FileSystem = fileSystem;
this.WaitForStartup = true;
this.WaitForLog = true;
this.StartupTimeoutInMilliseconds = 60000; // 1 mins
}
public RepositoryCreationViewModel(
IGlobalConnection connection,
IModelServiceFactory modelServiceFactory,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
: this(connection.Get(), modelServiceFactory, operatingSystem, repositoryCreationService, usageTracker)
{
}
private Collector(IOperatingSystem os, ICollectorLog collectorLog)
{
_os = os;
_collectorLog = collectorLog;
_currentProcess = os.GetCurrentProcessName();
_currentProcessStartTime = DateTime.UtcNow;
_lastSave = DateTime.UtcNow;
_millisecondsIdle = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="FileSystem"/> class.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="operatingSystem">The operating system.</param>
/// <exception cref="ArgumentNullException">
/// type
/// or
/// operatingSystem
/// </exception>
/// <autogeneratedoc />
public FileSystem(Type type, IOperatingSystem operatingSystem)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
AppFolderName = TypeNameHelper.GetTypeDisplayName(type).Replace(".", "/");
OperatingSystem = operatingSystem ?? throw new ArgumentNullException(nameof(operatingSystem));
}
/// <summary>
/// Initializes a new instance of the <see cref="CommonServices"/> class.
/// </summary>
/// <param name="processRunner">The process runner.</param>
/// <param name="fileSystem">The file system.</param>
/// <param name="networkingSystem">The networking system.</param>
/// <param name="operatingSystem">The operating system.</param>
/// <param name="operationRunner">The operation runner.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <exception cref="ArgumentNullException">
/// processRunner
/// or
/// fileSystem
/// or
/// operatingSystem
/// or
/// operationRunner
/// </exception>
/// <autogeneratedoc />
public CommonServices(IProcessRunner processRunner, IFileSystem fileSystem, INetworkingSystem networkingSystem,
IOperatingSystem operatingSystem, IOperationRunner operationRunner, IPureLoggerFactory loggerFactory) :
base(loggerFactory)
{
NetworkingSystem = networkingSystem ?? throw new ArgumentNullException(nameof(networkingSystem));
ProcessRunner = processRunner ?? throw new ArgumentNullException(nameof(processRunner));
FileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
OperatingSystem = operatingSystem ?? throw new ArgumentNullException(nameof(operatingSystem));
OperationRunner = operationRunner ?? throw new ArgumentNullException(nameof(operationRunner));
}
/// <summary>
/// Initializes a new instance of the <see cref="FtpServer" /> class.
/// </summary>
/// <param name="configuration">The <see cref="FtpConfiguration" /> to configure the server with.</param>
/// <param name="fileSystem">The <see cref="IFileSystem" /> to use for file operations.</param>
/// <param name="operatingSystem">The <see cref="IOperatingSystem" /> to use for OS level operations.</param>
public FtpServer(FtpConfiguration configuration, IFileSystem fileSystem, IOperatingSystem operatingSystem)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
Configuration = configuration;
this.fileSystem = fileSystem;
this.operatingSystem = operatingSystem;
}
static RepositoryCloneViewModel GetVM(IRepositoryHost repositoryHost, IRepositoryCloneService cloneService,
IOperatingSystem os, INotificationService notificationService, IUsageTracker usageTracker)
{
var vm = new RepositoryCloneViewModel(
repositoryHost,
cloneService,
os);
vm.Initialize(null);
return(vm);
}
public SettingsForm(IGeneralConfigService configService, IOperatingSystem operatingSystem, IMessageBox messageBox, IVbeSettings vbeSettings, SettingsViews activeView = SettingsViews.GeneralSettings) : this()
{
var config = configService.LoadConfiguration();
ViewModel = new SettingsControlViewModel(messageBox, configService,
config,
new SettingsView
{
// FIXME inject types marked as ExperimentalFeatures
/*
* These ExperimentalFeatureTypes were originally obtained by directly calling into the IoC container
* (since only it knows, which Assemblies have been loaded as Plugins). The code is preserved here for easy access.
* RubberduckIoCInstaller.AssembliesToRegister()
* .SelectMany(s => s.DefinedTypes)
* .Where(w => Attribute.IsDefined(w, typeof(ExperimentalAttribute)))
*/
Control = new GeneralSettings(new GeneralSettingsViewModel(config, operatingSystem, messageBox, vbeSettings, new List <Type>())),
View = SettingsViews.GeneralSettings
},
new SettingsView
{
Control = new TodoSettings(new TodoSettingsViewModel(config)),
View = SettingsViews.TodoSettings
},
new SettingsView
{
Control = new InspectionSettings(new InspectionSettingsViewModel(config)),
View = SettingsViews.InspectionSettings
},
new SettingsView
{
Control = new UnitTestSettings(new UnitTestSettingsViewModel(config)),
View = SettingsViews.UnitTestSettings
},
new SettingsView
{
Control = new IndenterSettings(new IndenterSettingsViewModel(config)),
View = SettingsViews.IndenterSettings
},
new SettingsView
{
Control = new AutoCompleteSettings(new AutoCompleteSettingsViewModel(config)),
View = SettingsViews.AutoCompleteSettings
},
new SettingsView
{
Control = new WindowSettings(new WindowSettingsViewModel(config)),
View = SettingsViews.WindowSettings
},
activeView);
ViewModel.OnWindowClosed += ViewModel_OnWindowClosed;
}
static RepositoryCloneViewModel GetVM(IRepositoryHost repositoryHost, IRepositoryCloneService cloneService,
IOperatingSystem os, INotificationService notificationService, IUsageTracker usageTracker)
{
var vm = new RepositoryCloneViewModel(
repositoryHost,
cloneService,
os,
notificationService,
usageTracker);
vm.Initialize(null);
return vm;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
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);
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)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler);
FilteredRepositories = Repositories.CreateDerivedCollection(
x => x,
filter: FilterRepository,
signalReset: filterResetSignal
);
BaseRepositoryPathValidator = this.CreateBaseRepositoryPathValidator();
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public void RunOnce(IOperatingSystem os, ICollectorLog collectorLog)
{
DateTime now = DateTime.UtcNow;
ulong milliseconds = os.GetMillisecondsSinceLastInput();
if (milliseconds > 15000)
{
_millisecondsIdle = milliseconds;
}
else
{
if (_millisecondsIdle != 0)
{
collectorLog.Log("Idle", GetTimeInSeconds(now));
_currentProcessStartTime = now;
_millisecondsIdle = 0;
return;
}
}
string processName = os.GetCurrentProcessName();
if (processName != _currentProcess)
{
collectorLog.Log(_currentProcess, GetTimeInSeconds(now));
_currentProcess = processName;
_currentProcessStartTime = now;
}
// Every 10 minutes save
if (now.Subtract(_lastSave).TotalSeconds > _timeBetweenSending)
{
string log = _millisecondsIdle > 15000 ? "Idle" : _currentProcess;
collectorLog.Log(log, GetTimeInSeconds(now));
_currentProcessStartTime = now;
_lastSave = now;
collectorLog.Send(now);
}
}
public StartPageCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
{
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public RepositoryCreationViewModel(
IRepositoryHost repositoryHost,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
{
this.repositoryHost = repositoryHost;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CreateTitle, repositoryHost.Title);
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
accounts = repositoryHost.ModelService.GetAccounts()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, vm => vm.Accounts, initialValue: new ReadOnlyCollection<IAccount>(new IAccount[] {}));
this.WhenAny(x => x.Accounts, x => x.Value)
.Select(accts => accts?.FirstOrDefault())
.WhereNotNull()
.Subscribe(a => SelectedAccount = a);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(this.WhenAny(x => x.BaseRepositoryPath, x => x.Value))
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid);
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty(Resources.RepositoryNameValidatorEmpty)
.IfTrue(x => x.Length > 100, Resources.RepositoryNameValidatorTooLong)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return parsedReference != repoName ? String.Format(CultureInfo.CurrentCulture, Resources.SafeRepositoryNameWarning, parsedReference) : null;
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
GitIgnoreTemplates = TrackingCollection.CreateListenerCollectionAndRun(
repositoryHost.ModelService.GetGitIgnoreTemplates(),
new[] { GitIgnoreItem.None },
OrderedComparer<GitIgnoreItem>.OrderByDescending(item => GitIgnoreItem.IsRecommended(item.Name)).Compare,
x =>
{
if (x.Name.Equals("VisualStudio", StringComparison.OrdinalIgnoreCase))
SelectedGitIgnoreTemplate = x;
});
Licenses = TrackingCollection.CreateListenerCollectionAndRun(
repositoryHost.ModelService.GetLicenses(),
new[] { LicenseItem.None },
OrderedComparer<LicenseItem>.OrderByDescending(item => LicenseItem.IsRecommended(item.Name)).Compare);
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
public RepositoryCreationViewModel(
IRepositoryHost repositoryHost,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
{
this.repositoryHost = repositoryHost;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
Title = string.Format(CultureInfo.CurrentCulture, "Create a {0} Repository", repositoryHost.Title);
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
accounts = repositoryHost.ModelService.GetAccounts()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, vm => vm.Accounts, initialValue: new ReadOnlyCollection<IAccount>(new IAccount[] {}));
this.WhenAny(x => x.Accounts, x => x.Value)
.WhereNotNull()
.Where(accts => accts.Any())
.Subscribe(accts => {
var selectedAccount = accts.FirstOrDefault();
if (selectedAccount != null)
{
SelectedAccount = accts.FirstOrDefault();
}
});
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = this.CreateBaseRepositoryPathValidator();
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty("Please enter a repository name")
.IfTrue(x => x.Length > 100, "Repository name must be fewer than 100 characters")
.IfTrue(IsAlreadyRepoAtPath, "Repository with same name already exists at this location");
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return parsedReference != repoName ? "Will be created as " + parsedReference : null;
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
gitIgnoreTemplates = repositoryHost.ModelService.GetGitIgnoreTemplates()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.GitIgnoreTemplates, initialValue: new GitIgnoreItem[] { });
this.WhenAny(x => x.GitIgnoreTemplates, x => x.Value)
.WhereNotNull()
.Where(ignores => ignores.Any())
.Subscribe(ignores =>
{
SelectedGitIgnoreTemplate = ignores.FirstOrDefault(
template => template.Name.Equals("VisualStudio", StringComparison.OrdinalIgnoreCase));
});
licenses = repositoryHost.ModelService.GetLicenses()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.Licenses, initialValue: new LicenseItem[] { });
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
