layout: guides

- [Basics](install/)

- [Opening](repositories/)

- [HTTP/HTTPS](cloning/)

title: HTTP/HTTPS Guide

description: How to clone with HTTP/HTTPS

**In order to run examples, you will need to [Install NodeGit](../../install/basics)

first.**

[Return to cloning guides](../)

HTTP/HTTPS

This guide explains how to clone a repository, and in the case of failure,

attempt to open the existing path.

[View example source](index.js)

In the guides directory, we like to keep our NodeGit relative to the project

root.

``` javascript

var Git = require("../../../");

However, in your project you will most likely be using the following command:

``` javascript

var Git = require("nodegit");

The first argument to the `clone` method is a URL.

In this example we're going to clone one of our test repositories from GitHub.

You could easily substitute this with any valid http or https Git repository

URL.

``` javascript

var cloneURL = "https://github.com/nodegit/test";

The second argument to the `clone` method is a path.

Ideally your application will clone a repository into the same folder path

regardless of how or where you execute it from. Paths are relative to the

current working directory in NodeGit, so you will need to normalize it first.

This is very simple in Node:

``` javascript

var localPath = require("path").join(__dirname, "tmp");

Now this `tmp` directory will be created along side your script, no matter how

or where you execute it from.

The third argument to the `clone` method is an optional simple object.

``` javascript

var cloneOptions = {};

**If you are using HTTP the OS X issue below does not affect you.**

Unfortunately in OS X there is a problem where libgit2 is unable to look up

GitHub certificates correctly. In order to bypass this problem, we're going

to passthrough the certificate check.

*Note: this is not a problem with Windows or Linux*

``` javascript

cloneOptions.remoteCallbacks = {

certificateCheck: function() { return 1; }

};

You can easily invoke our top-level Clone as a function passing along the three

aforementioned arguments.

``` javascript

var cloneRepository = Git.Clone(cloneURL, localPath, cloneOptions);

Notice how we store the return value from `Git.Clone`. This is a

[Promise](https://www.promisejs.org/) to represent the asynchronous operation.

It offers finer control flow by allowing us to capture errors and fallback if

there is a clone failure.

A naive way to handle a clone failure is to try opening the same path. Clones

will most commonly fail when the directory already exists. We can define

a function to attempt opening in this case.

``` javascript

var errorAndAttemptOpen = function() {

return Git.Repository.open(local);

};

This will be called as part of the Promise resolution in the final step.

Lastly in our clone operation, we'll assemble a Promise chain to handle errors

and work with the `Git.Repository` instance result.

``` javascript

cloneRepository.catch(errorAndAttemptOpen)

.then(function(repository) {

// Access any repository methods here.

console.log("Is the repository bare? %s", Boolean(repository.isBare()));

});

title: Install Basics

[Return to install guides](../)

<a name="with-npm"></a>From NPM

``` bash

npm install nodegit

<a name="from-github"></a>From GitHub

Start by cloning the repository, chances are you will only need the latest

commit, so you can pass the `--depth` flag to make a shallow clone:

``` bash

git clone --depth=1 https://github.com/nodegit/nodegit

Change your directory into the newly created nodegit folder.

``` bash

cd nodegit

Now you can issue the local installation command:

``` bash

npm install