public Repository(string path) { Contract.Requires<ArgumentNullException>(path != null, "path"); RepositoryOptions repositoryOptions = new RepositoryOptions(); this._git = new LibGit2Sharp.Repository(path, repositoryOptions); var navigator = new RepositoryNavigator(this._git); this.Root = new Container(navigator); }
/// <summary> /// Initializes a new instance of the <see cref = "Repository" /> class, providing ooptional behavioral overrides through <paramref name="options"/> parameter. /// <para>For a standard repository, <paramref name = "path" /> should either point to the ".git" folder or to the working directory. For a bare repository, <paramref name = "path" /> should directly point to the repository folder.</para> /// </summary> /// <param name = "path"> /// The path to the git repository to open, can be either the path to the git directory (for non-bare repositories this /// would be the ".git" folder inside the working directory) or the path to the working directory. /// </param> /// <param name="options"> /// Overrides to the way a repository is opened. /// </param> public Repository(string path, RepositoryOptions options = null) { Ensure.ArgumentNotNullOrEmptyString(path, "path"); Ensure.Success(NativeMethods.git_repository_open(out handle, path)); RegisterForCleanup(handle); bool isBare = NativeMethods.RepositoryStateChecker(handle, NativeMethods.git_repository_is_bare); Func<Index> indexBuilder = () => new Index(this); if (options != null) { bool isWorkDirNull = string.IsNullOrEmpty(options.WorkingDirectoryPath); bool isIndexNull = string.IsNullOrEmpty(options.IndexPath); if (isWorkDirNull && isIndexNull) { throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "At least one member of the {0} instance has to be provided.", typeof(RepositoryOptions).Name)); } if (isBare && (isWorkDirNull ^ isIndexNull)) { throw new ArgumentException("When overriding the opening of a bare repository, both RepositoryOptions.WorkingDirectoryPath an RepositoryOptions.IndexPath have to be provided."); } isBare = false; if (!isIndexNull) { indexBuilder = () => new Index(this, options.IndexPath); } if (!isWorkDirNull) { Ensure.Success(NativeMethods.git_repository_set_workdir(handle, options.WorkingDirectoryPath)); } } if (!isBare) { index = indexBuilder(); } commits = new CommitCollection(this); refs = new ReferenceCollection(this); branches = new BranchCollection(this); tags = new TagCollection(this); info = new Lazy<RepositoryInformation>(() => new RepositoryInformation(this, isBare)); config = new Lazy<Configuration>(() => new Configuration(this)); remotes = new Lazy<RemoteCollection>(() => new RemoteCollection(this)); odb = new Lazy<ObjectDatabase>(() => new ObjectDatabase(this)); diff = new Diff(this); }
public void InitNewRepo() { string repoPath = InitNewRepository(); string configPath = CreateConfigurationWithDummyUser(Constants.Identity); var options = new RepositoryOptions {GlobalConfigurationLocation = configPath}; using (var repo = new Repository(repoPath, options)) { string dir = repo.Info.Path; Assert.IsTrue(Path.IsPathRooted(dir)); Assert.IsTrue(Directory.Exists(dir)); } }
private void EagerlyLoadTheConfigIfAnyPathHaveBeenPassed(RepositoryOptions options) { if (options == null) { return; } if (options.GlobalConfigurationLocation == null && options.XdgConfigurationLocation == null && options.SystemConfigurationLocation == null) { return; } // Dirty hack to force the eager load of the configuration // without Resharper pestering about useless code if (!Config.HasConfig(ConfigurationLevel.Local)) { throw new InvalidOperationException("Unexpected state."); } }
/// <summary> /// Clone with specified options. /// </summary> /// <param name="sourceUrl">URI for the remote repository</param> /// <param name="workdirPath">Local path to clone into</param> /// <param name="bare">True will result in a bare clone, false a full clone.</param> /// <param name="checkout">If true, the origin's HEAD will be checked out. This only applies /// to non-bare repositories.</param> /// <param name="onTransferProgress">Handler for network transfer and indexing progress information</param> /// <param name="onCheckoutProgress">Handler for checkout progress information</param> /// <param name="options">Overrides to the way a repository is opened.</param> /// <param name="credentials">Credentials to use for user/pass authentication</param> /// <returns></returns> public static Repository Clone(string sourceUrl, string workdirPath, bool bare = false, bool checkout = true, TransferProgressHandler onTransferProgress = null, CheckoutProgressHandler onCheckoutProgress = null, RepositoryOptions options = null, Credentials credentials = null) { var cloneOpts = new GitCloneOptions { Bare = bare ? 1 : 0, TransferProgressCallback = TransferCallbacks.GenerateCallback(onTransferProgress), CheckoutOpts = { version = 1, progress_cb = CheckoutCallbacks.GenerateCheckoutCallbacks(onCheckoutProgress), checkout_strategy = checkout ? CheckoutStrategy.GIT_CHECKOUT_SAFE_CREATE : CheckoutStrategy.GIT_CHECKOUT_NONE }, }; if (credentials != null) { cloneOpts.CredAcquireCallback = (out IntPtr cred, IntPtr url, IntPtr username_from_url, uint types, IntPtr payload) => NativeMethods.git_cred_userpass_plaintext_new(out cred, credentials.Username, credentials.Password); } using (Proxy.git_clone(sourceUrl, workdirPath, cloneOpts)) {} // To be safe, make sure the credential callback is kept until // alive until at least this point. GC.KeepAlive(cloneOpts.CredAcquireCallback); return(new Repository(workdirPath, options)); }
/// <summary> /// Initializes a new instance of the <see cref="Repository"/> class, providing ooptional behavioral overrides through <paramref name="options"/> parameter. /// <para>For a standard repository, <paramref name="path"/> should either point to the ".git" folder or to the working directory. For a bare repository, <paramref name="path"/> should directly point to the repository folder.</para> /// </summary> /// <param name="path"> /// The path to the git repository to open, can be either the path to the git directory (for non-bare repositories this /// would be the ".git" folder inside the working directory) or the path to the working directory. /// </param> /// <param name="options"> /// Overrides to the way a repository is opened. /// </param> public Repository(string path, RepositoryOptions options = null) { Ensure.ArgumentNotNullOrEmptyString(path, "path"); try { handle = Proxy.git_repository_open(path); RegisterForCleanup(handle); isBare = Proxy.git_repository_is_bare(handle); Func <Index> indexBuilder = () => new Index(this); string configurationGlobalFilePath = null; string configurationXDGFilePath = null; string configurationSystemFilePath = null; if (options != null) { bool isWorkDirNull = string.IsNullOrEmpty(options.WorkingDirectoryPath); bool isIndexNull = string.IsNullOrEmpty(options.IndexPath); if (isBare && (isWorkDirNull ^ isIndexNull)) { throw new ArgumentException( "When overriding the opening of a bare repository, both RepositoryOptions.WorkingDirectoryPath an RepositoryOptions.IndexPath have to be provided."); } isBare = false; if (!isIndexNull) { indexBuilder = () => new Index(this, options.IndexPath); } if (!isWorkDirNull) { Proxy.git_repository_set_workdir(handle, options.WorkingDirectoryPath); } configurationGlobalFilePath = options.GlobalConfigurationLocation; configurationXDGFilePath = options.XdgConfigurationLocation; configurationSystemFilePath = options.SystemConfigurationLocation; } if (!isBare) { index = indexBuilder(); } commits = new CommitLog(this); refs = new ReferenceCollection(this); branches = new BranchCollection(this); tags = new TagCollection(this); stashes = new StashCollection(this); info = new Lazy <RepositoryInformation>(() => new RepositoryInformation(this, isBare)); config = new Lazy <Configuration>( () => RegisterForCleanup(new Configuration(this, configurationGlobalFilePath, configurationXDGFilePath, configurationSystemFilePath))); odb = new Lazy <ObjectDatabase>(() => new ObjectDatabase(this)); diff = new Diff(this); notes = new NoteCollection(this); ignore = new Ignore(this); network = new Lazy <Network>(() => new Network(this)); pathCase = new Lazy <PathCase>(() => new PathCase(this)); submodules = new SubmoduleCollection(this); EagerlyLoadTheConfigIfAnyPathHaveBeenPassed(options); } catch { CleanupDisposableDependencies(); throw; } }
public static Repository Init(string path, bool isBare, RepositoryOptions options) { string gitDirPath = Init(path, isBare); return(new Repository(gitDirPath, options)); }