class Rugged::Repository

Repository is an interface into a Git repository on-disk. It's the primary interface between your app and the main Git objects Rugged makes available to you.

Public Class Methods

bare(path[, alternates]) → repository OR click to toggle source
bare(path[, options]) → repository

Open a bare Git repository at path and return a Repository object representing it.

This is faster than Rugged::Repository.new, as it won't attempt to perform any .git directory discovery, won't try to load the config options to determine whether the repository is bare and won't try to load the workdir.

Optionally, you can pass a list of alternate object folders or an options Hash.

Rugged::Repository.bare(path, ['./other/repo/.git/objects'])
Rugged::Repository.bare(path, opts)

The following options can be passed in the options Hash:

:backend

A Rugged::Backend instance

:alternates

A list of alternate object folders. Rugged::Repository.bare(path, :alternates => ['./other/repo/.git/objects'])

static VALUE rb_git_repo_open_bare(int argc, VALUE *argv, VALUE klass)
{
        git_repository *repo = NULL;
        int error = 0;
        VALUE rb_path, rb_options, rb_alternates = 0;

        rb_scan_args(argc, argv, "11", &rb_path, &rb_options);

        if (!NIL_P(rb_options) && TYPE(rb_options) == T_ARRAY)
                rb_alternates = rb_options;

        if (!NIL_P(rb_options) && TYPE(rb_options) == T_HASH) {
                /* Check for `:backend` */
                VALUE rb_backend = rb_hash_aref(rb_options, CSTR2SYM("backend"));

                if (!NIL_P(rb_backend)) {
                        rugged_repo_new_with_backend(&repo, rb_path, rb_backend);
                }

                /* Check for `:alternates` */
                rb_alternates = rb_hash_aref(rb_options, CSTR2SYM("alternates"));
        }

        if (!repo) {
                FilePathValue(rb_path);

                error = git_repository_open_bare(&repo, StringValueCStr(rb_path));
                rugged_exception_check(error);
        }

        if (rb_alternates) {
                load_alternates(repo, rb_alternates);
        }

        return rugged_repo_new(klass, repo);
}
clone_at(url, local_path[, options]) → repository click to toggle source

Clone a repository from url to local_path.

The following options can be passed in the options Hash:

:bare

If true, the clone will be created as a bare repository. Defaults to false.

:checkout_branch

The name of a branch to checkout. Defaults to the remote's HEAD.

:remote

The name to give to the “origin” remote. Defaults to "origin".

:ignore_cert_errors

If set to true, errors while validating the remote's host certificate will be ignored.

:proxy_url

The url of an http proxy to use to access the remote repository.

:credentials

The credentials to use for the clone operation. Can be either an instance of one of the Rugged::Credentials types, or a proc returning one of the former. The proc will be called with the url, the username from the url (if applicable) and a list of applicable credential types.

:progress

A callback that will be executed with the textual progress received from the remote. This is the text send over the progress side-band (ie. the “counting objects” output).

:transfer_progress

A callback that will be executed to report clone progress information. It will be passed the amount of total_objects, indexed_objects, received_objects, local_objects, total_deltas, indexed_deltas, and received_bytes.

:update_tips

A callback that will be executed each time a reference was updated locally. It will be passed the refname, old_oid and new_oid.

Example:

Repository.clone_at("https://github.com/libgit2/rugged.git", "./some/dir", {
  transfer_progress: lambda { |total_objects, indexed_objects, received_objects, local_objects, total_deltas, indexed_deltas, received_bytes|
    # ...
  }
})
static VALUE rb_git_repo_clone_at(int argc, VALUE *argv, VALUE klass)
{
        VALUE url, local_path, rb_options_hash;
        git_clone_options options = GIT_CLONE_OPTIONS_INIT;
        struct rugged_remote_cb_payload remote_payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
        git_repository *repo;
        int error;

        rb_scan_args(argc, argv, "21", &url, &local_path, &rb_options_hash);
        Check_Type(url, T_STRING);
        FilePathValue(local_path);

        parse_clone_options(&options, rb_options_hash, &remote_payload);

        error = git_clone(&repo, StringValueCStr(url), StringValueCStr(local_path), &options);

        if (RTEST(remote_payload.exception))
                rb_jump_tag(remote_payload.exception);
        rugged_exception_check(error);

        return rugged_repo_new(klass, repo);
}
discover(path = nil, across_fs = true) → repository click to toggle source

Traverse path upwards until a Git working directory with a .git folder has been found, open it and return it as a Repository object.

If path is nil, the current working directory will be used as a starting point.

If across_fs is true, the traversal won't stop when reaching a different device than the one that contained path (only applies to UNIX-based OSses).

static VALUE rb_git_repo_discover(int argc, VALUE *argv, VALUE klass)
{
        git_repository *repo;
        VALUE rb_path, rb_across_fs;
        git_buf repository_path = { NULL };
        int error, across_fs = 0;

        rb_scan_args(argc, argv, "02", &rb_path, &rb_across_fs);

        if (NIL_P(rb_path)) {
                VALUE rb_dir = rb_const_get(rb_cObject, rb_intern("Dir"));
                rb_path = rb_funcall(rb_dir, rb_intern("pwd"), 0);
        }

        if (!NIL_P(rb_across_fs)) {
                across_fs = rugged_parse_bool(rb_across_fs);
        }

        FilePathValue(rb_path);

        error = git_repository_discover(
                &repository_path,
                StringValueCStr(rb_path),
                across_fs,
                NULL
        );

        rugged_exception_check(error);

        error = git_repository_open(&repo, repository_path.ptr);
        git_buf_dispose(&repository_path);

        rugged_exception_check(error);

        return rugged_repo_new(klass, repo);
}
hash_data(str, type) → oid click to toggle source

Hash the contents of str as raw bytes (ignoring any encoding information) and adding the relevant header corresponding to type, and return a hex string representing the result from the hash.

Repository.hash_data('hello world', :commit) #=> "de5ba987198bcf2518885f0fc1350e5172cded78"

Repository.hash_data('hello_world', :tag) #=> "9d09060c850defbc7711d08b57def0d14e742f4e"
static VALUE rb_git_repo_hash(VALUE self, VALUE rb_buffer, VALUE rb_type)
{
        int error;
        git_oid oid;

        Check_Type(rb_buffer, T_STRING);

        error = git_odb_hash(&oid,
                RSTRING_PTR(rb_buffer),
                RSTRING_LEN(rb_buffer),
                rugged_otype_get(rb_type)
        );
        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}
hash_file(path, type) → oid click to toggle source

Hash the contents of the file pointed at by path, assuming that it'd be stored in the ODB with the given type, and return a hex string representing the SHA1 OID resulting from the hash.

Repository.hash_file('foo.txt', :commit) #=> "de5ba987198bcf2518885f0fc1350e5172cded78"

Repository.hash_file('foo.txt', :tag) #=> "9d09060c850defbc7711d08b57def0d14e742f4e"
static VALUE rb_git_repo_hashfile(VALUE self, VALUE rb_path, VALUE rb_type)
{
        int error;
        git_oid oid;

        FilePathValue(rb_path);

        error = git_odb_hashfile(&oid,
                StringValueCStr(rb_path),
                rugged_otype_get(rb_type)
        );
        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}
init_at(path, is_bare = false, opts = {}) → repository click to toggle source

Initialize a Git repository in path. This implies creating all the necessary files on the FS, or re-initializing an already existing repository if the files have already been created.

The is_bare (optional, defaults to false) attribute specifies whether the Repository should be created on disk as bare or not. Bare repositories have no working directory and are created in the root of path. Non-bare repositories are created in a .git folder and use path as working directory.

The following options can be passed in the options Hash:

:backend

A Rugged::Backend instance

Rugged::Repository.init_at('repository', :bare) #=> #<Rugged::Repository:0x108849488>

static VALUE rb_git_repo_init_at(int argc, VALUE *argv, VALUE klass)
{
        git_repository *repo = NULL;
        VALUE rb_path, rb_is_bare, rb_options;
        int error;

        rb_scan_args(argc, argv, "11:", &rb_path, &rb_is_bare, &rb_options);
        FilePathValue(rb_path);

        if (!NIL_P(rb_options)) {
                /* Check for `:backend` */
                VALUE rb_backend = rb_hash_aref(rb_options, CSTR2SYM("backend"));

                if (rb_backend && !NIL_P(rb_backend)) {
                        rugged_repo_new_with_backend(&repo, rb_path, rb_backend);
                }
        }

        if(!repo) {
                error =       git_repository_init(&repo, StringValueCStr(rb_path), RTEST(rb_is_bare));
                rugged_exception_check(error);
        }

        return rugged_repo_new(klass, repo);
}
new(path, options = {}) → repository click to toggle source

Open a Git repository in the given path and return a Repository object representing it. An exception will be thrown if path doesn't point to a valid repository. If you need to create a repository from scratch, use Rugged::Repository.init_at instead.

The path must point to either the actual folder (.git) of a Git repository, or to the directorly that contains the .git folder.

See also Rugged::Repository.discover and Rugged::Repository.bare.

The following options can be passed in the options Hash:

:alternates

A list of alternate object folders.

Examples:

Rugged::Repository.new('test/.git') #=> #<Rugged::Repository:0x108849488>
Rugged::Repository.new(path, :alternates => ['./other/repo/.git/objects'])
static VALUE rb_git_repo_new(int argc, VALUE *argv, VALUE klass)
{
        git_repository *repo;
        int error = 0;
        VALUE rb_path, rb_options;

        rb_scan_args(argc, argv, "10:", &rb_path, &rb_options);
        FilePathValue(rb_path);

        error = git_repository_open(&repo, StringValueCStr(rb_path));
        rugged_exception_check(error);

        if (!NIL_P(rb_options)) {
                /* Check for `:alternates` */
                load_alternates(repo, rb_hash_aref(rb_options, CSTR2SYM("alternates")));
        }

        return rugged_repo_new(klass, repo);
}

Public Instance Methods

ahead_behind(local, upstream) → Array click to toggle source

Returns a 2 element Array containing the number of commits that the upstream object is ahead and behind the local object.

local and upstream can either be strings containing SHA1 OIDs or Rugged::Object instances.

static VALUE rb_git_repo_ahead_behind(VALUE self, VALUE rb_local, VALUE rb_upstream) {
        git_repository *repo;
        int error;
        git_oid local, upstream;
        size_t ahead, behind;
        VALUE rb_result;

        Data_Get_Struct(self, git_repository, repo);

        error = rugged_oid_get(&local, repo, rb_local);
        rugged_exception_check(error);

        error = rugged_oid_get(&upstream, repo, rb_upstream);
        rugged_exception_check(error);

        error = git_graph_ahead_behind(&ahead, &behind, repo, &local, &upstream);
        rugged_exception_check(error);

        rb_result = rb_ary_new2(2);
        rb_ary_push(rb_result, INT2FIX((int) ahead));
        rb_ary_push(rb_result, INT2FIX((int) behind));
        return rb_result;
}
apply(diff, options = {}) → true or false click to toggle source
Applies the given diff to the repository.

The following options can be passed in the options Hash:

:location

Whether to apply the changes to the workdir (default for non-bare), the index (default for bare) or both. Valid values: :index, :workdir, :both.

:delta_callback

While applying the patch, this callback will be executed per delta (file). The current delta will be passed to the block. The block's return value determines further behavior. When the block evaluates to:

- +true+: the hunk will be applied and the apply process will continue.
- +false+: the hunk will be skipped, but the apply process continues.
- +nil+: the hunk is not applied, and the apply process is aborted.
:hunk_callback

While applying the patch, this callback will be executed per hunk. The current hunk will be passed to the block. The block's return value determines further behavior, as per :delta_callback.

static VALUE rb_git_repo_apply(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_diff, rb_options;
        git_diff *diff;
        git_repository *repo;
        git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
        git_apply_location_t location;
        struct rugged_apply_cb_payload payload = { Qnil, Qnil, 0 };
        int error;

        Data_Get_Struct(self, git_repository, repo);
        if (git_repository_is_bare(repo)) {
                location = GIT_APPLY_LOCATION_INDEX;
        } else {
                location = GIT_APPLY_LOCATION_WORKDIR;
        }

        rb_scan_args(argc, argv, "11", &rb_diff, &rb_options);

        if (!rb_obj_is_kind_of(rb_diff, rb_cRuggedDiff)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Diff.");
        }

        if (!NIL_P(rb_options)) {
                Check_Type(rb_options, T_HASH);
                rugged_parse_apply_options(&opts, &location, rb_options, &payload);
        }

        Data_Get_Struct(rb_diff, git_diff, diff);

        error = git_apply(repo, diff, location, &opts);

        rugged_exception_check(error);

        return Qtrue;
}
attributes(path, options = {}) click to toggle source
# File lib/rugged/attributes.rb, line 8
def attributes(path, options = {})
  Attributes.new(self, path, options)
end
bare? → true or false click to toggle source

Return whether a repository is bare or not. A bare repository has no working directory.

static VALUE rb_git_repo_is_bare(VALUE self)
{
        RB_GIT_REPO_GETTER(is_bare);
}
blob_at(revision, path) click to toggle source

Get the blob at a path for a specific revision.

revision - The String SHA1. path - The String file path.

Returns a Rugged::Blob object

# File lib/rugged/repository.rb, line 242
def blob_at(revision, path)
  tree = Rugged::Commit.lookup(self, revision).tree
  begin
    blob_data = tree.path(path)
  rescue Rugged::TreeError
    return nil
  end
  blob = Rugged::Blob.lookup(self, blob_data[:oid])
  (blob.type == :blob) ? blob : nil
end
branches() click to toggle source

All the branches in the repository

Returns a BranchCollection containing Rugged::Branch objects

# File lib/rugged/repository.rb, line 207
def branches
  @branches ||= BranchCollection.new(self)
end
checkout(target, options = {}) click to toggle source

Checkout the specified branch, reference or commit.

target - A revparse spec for the branch, reference or commit to check out. options - Options passed to checkout_tree.

# File lib/rugged/repository.rb, line 29
def checkout(target, options = {})
  options[:strategy] ||= :safe
  options.delete(:paths)

  return checkout_head(**options) if target == "HEAD"

  if target.kind_of?(Rugged::Branch)
    branch = target
  else
    branch = branches[target]
  end

  if branch
    self.checkout_tree(branch.target, **options)

    if branch.remote?
      references.create("HEAD", branch.target_id, force: true)
    else
      references.create("HEAD", branch.canonical_name, force: true)
    end
  else
    commit = Commit.lookup(self, self.rev_parse_oid(target))
    references.create("HEAD", commit.oid, force: true)
    self.checkout_tree(commit, **options)
  end
end
checkout_head([options]) → nil click to toggle source

Updates files in the index and the working tree to match the content of the commit pointed at by HEAD.

See Repository#checkout_tree for a list of supported options.

static VALUE rb_git_checkout_head(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_options;
        git_repository *repo;
        git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
        struct rugged_cb_payload *payload;
        int error, exception = 0;

        rb_scan_args(argc, argv, "00:", &rb_options);

        Data_Get_Struct(self, git_repository, repo);

        rugged_parse_checkout_options(&opts, rb_options);

        error = git_checkout_head(repo, &opts);
        xfree(opts.paths.strings);

        if ((payload = opts.notify_payload) != NULL) {
                exception = payload->exception;
                xfree(opts.notify_payload);
        }

        if ((payload = opts.progress_payload) != NULL) {
                exception = payload->exception;
                xfree(opts.progress_payload);
        }

        if (exception)
                rb_jump_tag(exception);

        rugged_exception_check(error);

        return Qnil;
}
checkout_index(index[,options]) → nil click to toggle source

Updates files in the index and the working tree to match the content of the commit pointed at by index.

See Repository#checkout_tree for a list of supported options.

static VALUE rb_git_checkout_index(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_index, rb_options;
        git_repository *repo;
        git_index *index;
        git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
        struct rugged_cb_payload *payload;
        int error, exception = 0;

        rb_scan_args(argc, argv, "10:", &rb_index, &rb_options);

        if (!rb_obj_is_kind_of(rb_index, rb_cRuggedIndex))
                rb_raise(rb_eTypeError, "Expected Rugged::Index");

        Data_Get_Struct(self, git_repository, repo);
        Data_Get_Struct(rb_index, git_index, index);

        rugged_parse_checkout_options(&opts, rb_options);

        error = git_checkout_index(repo, index, &opts);
        xfree(opts.paths.strings);

        if ((payload = opts.notify_payload) != NULL) {
                exception = payload->exception;
                xfree(opts.notify_payload);
        }

        if ((payload = opts.progress_payload) != NULL) {
                exception = payload->exception;
                xfree(opts.progress_payload);
        }

        if (exception)
                rb_jump_tag(exception);

        rugged_exception_check(error);

        return Qnil;
}
checkout_tree(treeish[, options]) click to toggle source

Updates files in the index and working tree to match the content of the tree pointed at by the treeish.

The following options can be passed in the options Hash:

:progress

A callback that will be executed for checkout progress notifications. Up to 3 parameters are passed on each execution:

  • The path to the last updated file (or nil on the very first invocation).

  • The number of completed checkout steps.

  • The number of total checkout steps to be performed.

:notify

A callback that will be executed for each checkout notification types specified with :notify_flags. Up to 5 parameters are passed on each execution:

  • An array containing the :notify_flags that caused the callback execution.

  • The path of the current file.

  • A hash describing the baseline blob (or nil if it does not exist).

  • A hash describing the target blob (or nil if it does not exist).

  • A hash describing the workdir blob (or nil if it does not exist).

:strategy

A single symbol or an array of symbols representing the strategies to use when performing the checkout. Possible values are:

:none

Perform a dry run (default).

:safe

Allow safe updates that cannot overwrite uncommitted data.

:recreate_missing

Allow checkout to recreate missing files.

:force

Allow all updates to force working directory to look like index.

:allow_conflicts

Allow checkout to make safe updates even if conflicts are found.

:remove_untracked

Remove untracked files not in index (that are not ignored).

:remove_ignored

Remove ignored files not in index.

:update_only

Only update existing files, don't create new ones.

:dont_update_index

Normally checkout updates index entries as it goes; this stops that.

:no_refresh

Don't refresh index/config/etc before doing checkout.

:disable_pathspec_match

Treat pathspec as simple list of exact match file paths.

:skip_locked_directories

Ignore directories in use, they will be left empty.

:skip_unmerged

Allow checkout to skip unmerged files (NOT IMPLEMENTED).

:use_ours

For unmerged files, checkout stage 2 from index (NOT IMPLEMENTED).

:use_theirs

For unmerged files, checkout stage 3 from index (NOT IMPLEMENTED).

:update_submodules

Recursively checkout submodules with same options (NOT IMPLEMENTED).

:update_submodules_if_changed

Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED).

:disable_filters

If true, filters like CRLF line conversion will be disabled.

:dir_mode

Mode for newly created directories. Default: 0755.

:file_mode

Mode for newly created files. Default: 0755 or 0644.

:file_open_flags

Mode for opening files. Default: IO::CREAT | IO::TRUNC | IO::WRONLY.

:notify_flags

A single symbol or an array of symbols representing the cases in which the :notify callback should be invoked. Possible values are:

:none

Do not invoke the :notify callback (default).

:conflict

Invoke the callback for conflicting paths.

:dirty

Invoke the callback for “dirty” files, i.e. those that do not need an update but no longer match the baseline.

:updated

Invoke the callback for any file that was changed.

:untracked

Invoke the callback for untracked files.

:ignored

Invoke the callback for ignored files.

:all

Invoke the callback for all these cases.

:paths

A glob string or an array of glob strings specifying which paths should be taken into account for the checkout operation. nil will match all files. Default: nil.

:baseline

A Rugged::Tree that represents the current, expected contents of the workdir. Default: HEAD.

:target_directory

A path to an alternative workdir directory in which the checkout should be performed.

static VALUE rb_git_checkout_tree(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_treeish, rb_options;
        git_repository *repo;
        git_object *treeish;
        git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
        struct rugged_cb_payload *payload;
        int error, exception = 0;

        rb_scan_args(argc, argv, "10:", &rb_treeish, &rb_options);

        if (TYPE(rb_treeish) == T_STRING) {
                rb_treeish = rugged_object_rev_parse(self, rb_treeish, 1);
        }

        if (!rb_obj_is_kind_of(rb_treeish, rb_cRuggedCommit) &&
                        !rb_obj_is_kind_of(rb_treeish, rb_cRuggedTag) &&
                        !rb_obj_is_kind_of(rb_treeish, rb_cRuggedTree)) {
                rb_raise(rb_eTypeError, "Expected Rugged::Commit, Rugged::Tag or Rugged::Tree");
        }

        Data_Get_Struct(self, git_repository, repo);
        TypedData_Get_Struct(rb_treeish, git_object, &rugged_object_type, treeish);

        rugged_parse_checkout_options(&opts, rb_options);

        error = git_checkout_tree(repo, treeish, &opts);
        xfree(opts.paths.strings);

        if ((payload = opts.notify_payload) != NULL) {
                exception = payload->exception;
                xfree(opts.notify_payload);
        }

        if ((payload = opts.progress_payload) != NULL) {
                exception = payload->exception;
                xfree(opts.progress_payload);
        }

        if (exception)
                rb_jump_tag(exception);

        rugged_exception_check(error);

        return Qnil;
}
cherrypick(commit[, options]) → nil click to toggle source

Cherry-pick the given commit and update the index and working directory accordingly.

`commit` can be either a string containing a commit id or a `Rugged::Commit` object.

The following options can be passed in the options Hash:

:mainline

When cherry-picking a merge, you need to specify the parent number (starting from 1) which should be considered the mainline.

static VALUE rb_git_repo_cherrypick(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_options, rb_commit;

        git_repository *repo;
        git_commit *commit;
        git_cherrypick_options opts = GIT_CHERRYPICK_OPTIONS_INIT;

        int error;

        rb_scan_args(argc, argv, "10:", &rb_commit, &rb_options);

        if (TYPE(rb_commit) == T_STRING) {
                rb_commit = rugged_object_rev_parse(self, rb_commit, 1);
        }

        if (!rb_obj_is_kind_of(rb_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }

        Data_Get_Struct(self, git_repository, repo);
        TypedData_Get_Struct(rb_commit, git_commit, &rugged_object_type, commit);

        rugged_parse_cherrypick_options(&opts, rb_options);

        error = git_cherrypick(repo, commit, &opts);
        rugged_exception_check(error);

        return Qnil;
}
cherrypick_commit(commit, our_commit, [mainline, options]) → nil click to toggle source

Cherry-pick the given commit on the given base in-memory and return an index with the result.

`commit` can be either a string containing a commit id or a `Rugged::Commit` object.

`our_commit` is the base commit, can be either a string containing a commit id or a `Rugged::Commit` object.

`mainline` when cherry-picking a merge, this is the parent number

(starting from 1) which should be considered the mainline.
static VALUE rb_git_repo_cherrypick_commit(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_options, rb_commit, rb_our_commit, rb_mainline;

        git_repository *repo;
        git_commit *commit, *our_commit;
        git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
        git_index *index;
        int error, mainline;

        rb_scan_args(argc, argv, "21:", &rb_commit, &rb_our_commit, &rb_mainline, &rb_options);

        if (TYPE(rb_commit) == T_STRING) {
                rb_commit = rugged_object_rev_parse(self, rb_commit, 1);
        }
        if (TYPE(rb_our_commit) == T_STRING) {
                rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);
        }

        if (!rb_obj_is_kind_of(rb_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }
        if (!rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }

        Data_Get_Struct(self, git_repository, repo);
        TypedData_Get_Struct(rb_commit, git_commit, &rugged_object_type, commit);
        TypedData_Get_Struct(rb_our_commit, git_commit, &rugged_object_type, our_commit);

        rugged_parse_merge_options(&opts, rb_options);

        mainline = NIL_P(rb_mainline) ? 0 : FIX2UINT(rb_mainline);
        error = git_cherrypick_commit(&index, repo, commit, our_commit, mainline, &opts);
        rugged_exception_check(error);

        return rugged_index_new(rb_cRuggedIndex, self, index);
}
close → nil click to toggle source

Frees all the resources used by this repository immediately. The repository can still be used after this call. Resources will be opened as necessary.

It is not required to call this method explicitly. Repositories are closed automatically before garbage collection

static VALUE rb_git_repo_close(VALUE self)
{
        git_repository *repo;
        Data_Get_Struct(self, git_repository, repo);

        git_repository__cleanup(repo);

        return Qnil;
}
config → cfg click to toggle source

Return a Rugged::Config object representing this repository's config.

static VALUE rb_git_repo_get_config(VALUE self)
{
        RB_GIT_REPO_OWNED_GET(rb_cRuggedConfig, config);
}
config = cfg click to toggle source

Set the configuration file for this Repository. cfg must be a instance of Rugged::Config. This config file will be used internally by all operations that need to lookup configuration settings on repo.

Note that it's not necessary to set the config for any repository; by default repositories are loaded with their relevant config files on the filesystem, and the corresponding global and system files if they can be found.

static VALUE rb_git_repo_set_config(VALUE self, VALUE rb_data)
{
        RB_GIT_REPO_OWNED_SET(rb_cRuggedConfig, config);
}
create_branch(name, sha_or_ref = "HEAD") click to toggle source

Create a new branch in the repository

name - The name of the branch (without a full reference path) sha_or_ref - The target of the branch; either a String representing an OID or a reference name, or a Rugged::Object instance.

Returns a Rugged::Branch object

# File lib/rugged/repository.rb, line 225
def create_branch(name, sha_or_ref = "HEAD")
  case sha_or_ref
  when Rugged::Object
    target = sha_or_ref.oid
  else
    target = rev_parse_oid(sha_or_ref)
  end

  branches.create(name, target)
end
default_signature → signature or nil click to toggle source

Returns a Hash with the default user signature or nil.

Looks up the user.name and user.email from the configuration and uses the current time as the timestamp, and creates a new signature based on that information. It will return nil if either the user.name or user.email are not set.

Returns a Hash:

  • :name: the user.name config value

  • :email: the user.email config value

  • :time: the current time as a Time instance

static VALUE rb_git_repo_default_signature(VALUE self) {
        int error;
        git_repository *repo;
        git_signature *signature;
        VALUE rb_signature;

        Data_Get_Struct(self, git_repository, repo);

        error = git_signature_default(&signature, repo);

        if (error == GIT_ENOTFOUND)
                return Qnil;

        rugged_exception_check(error);

        rb_signature = rugged_signature_new(signature, NULL);
        git_signature_free(signature);
        return rb_signature;
}
descendant_of?(commit, ancestor) → true or false click to toggle source

commit and ancestor must be String commit OIDs or instances of Rugged::Commit.

Returns true if commit is a descendant of ancestor, or false if not.

static VALUE rb_git_repo_descendant_of(VALUE self, VALUE rb_commit, VALUE rb_ancestor)
{
        int result;
        int error;
        git_repository *repo;
        git_oid commit, ancestor;

        Data_Get_Struct(self, git_repository, repo);

        error = rugged_oid_get(&commit, repo, rb_commit);
        rugged_exception_check(error);

        error = rugged_oid_get(&ancestor, repo, rb_ancestor);
        rugged_exception_check(error);

        result = git_graph_descendant_of(repo, &commit, &ancestor);
        rugged_exception_check(result);

        return result ? Qtrue : Qfalse;
}
diff(left, right, opts = {}) click to toggle source
# File lib/rugged/repository.rb, line 99
def diff(left, right, opts = {})
  left = rev_parse(left) if left.kind_of?(String)
  right = rev_parse(right) if right.kind_of?(String)

  if !left.is_a?(Rugged::Tree) && !left.is_a?(Rugged::Commit) && !left.nil?
    raise TypeError, "Expected a Rugged::Tree or Rugged::Commit instance"
  end

  if !right.is_a?(Rugged::Tree) && !right.is_a?(Rugged::Commit) && !right.nil?
    raise TypeError, "Expected a Rugged::Tree or Rugged::Commit instance"
  end

  if left
    left.diff(right, opts)
  elsif right
    right.diff(left, opts.merge(:reverse => !opts[:reverse]))
  end
end
diff_from_buffer(buffer) → Rugged::Diff object click to toggle source

Where buffer is a String. Returns A Rugged::Diff object

static VALUE rb_git_diff_from_buffer(VALUE self, VALUE rb_buffer)
{
        git_diff *diff = NULL;
        const char *buffer;
        size_t len;
        int error;

        Check_Type(rb_buffer, T_STRING);
        buffer = RSTRING_PTR(rb_buffer);
        len = RSTRING_LEN(rb_buffer);

        error = git_diff_from_buffer(&diff, buffer, len);
        rugged_exception_check(error);

        return rugged_diff_new(rb_cRuggedDiff, self, diff);
}
diff_workdir(left, opts = {}) click to toggle source
# File lib/rugged/repository.rb, line 118
def diff_workdir(left, opts = {})
  left = rev_parse(left) if left.kind_of?(String)

  if !left.is_a?(Rugged::Tree) && !left.is_a?(Rugged::Commit)
    raise TypeError, "Expected a Rugged::Tree or Rugged::Commit instance"
  end

  left.diff_workdir(opts)
end
each_id { |id| block } click to toggle source
each_id → Enumerator

Call the given block once with every object ID found in repo and all its alternates. Object IDs are passed as 40-character strings.

static VALUE rb_git_repo_each_id(VALUE self)
{
        git_repository *repo;
        git_odb *odb;
        int error, exception = 0;

        RETURN_ENUMERATOR(self, 0, 0);

        Data_Get_Struct(self, git_repository, repo);

        error = git_repository_odb(&odb, repo);
        rugged_exception_check(error);

        error = git_odb_foreach(odb, &rugged__each_id_cb, &exception);
        git_odb_free(odb);

        if (exception)
                rb_jump_tag(exception);
        rugged_exception_check(error);

        return Qnil;
}
empty? → true or false click to toggle source

Return whether a repository is empty or not. An empty repository has HEAD pointing to the default value and there are no other references.

static VALUE rb_git_repo_is_empty(VALUE self)
{
        RB_GIT_REPO_GETTER(is_empty);
}
exists?(oid) → true or false click to toggle source

Return whether an object with the given SHA1 OID (represented as a hex string of at least 7 characters) exists in the repository.

repo.include?("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f") #=> true
repo.include?("d8786bfc") #=> true
static VALUE rb_git_repo_exists(VALUE self, VALUE hex)
{
        git_repository *repo;
        git_odb *odb;
        git_oid oid;
        int error;

        Data_Get_Struct(self, git_repository, repo);
        Check_Type(hex, T_STRING);

        error = git_oid_fromstrn(&oid, RSTRING_PTR(hex), RSTRING_LEN(hex));
        rugged_exception_check(error);

        error = git_repository_odb(&odb, repo);
        rugged_exception_check(error);

        error = git_odb_exists_prefix(NULL, odb, &oid, RSTRING_LEN(hex));
        git_odb_free(odb);

        if (error == 0 || error == GIT_EAMBIGUOUS)
                return Qtrue;

        return Qfalse;
}
Also aliased as: include?
expand_oids([oid..], object_type = :any) → hash click to toggle source
expand_oids([oid..], object_type = [type..]) → hash

Expand a list of short oids to their full value, assuming they exist in the repository. If `object_type` is passed and is an array, it must be the same length as the OIDs array. If it's a single type name, all OIDs will be expected to resolve to that object type. OIDs that don't match the expected object types will not be expanded.

Returns a hash of `{ short_oid => full_oid }` for the short OIDs which exist in the repository and match the expected object type. Missing OIDs will not appear in the resulting hash.

static VALUE rb_git_repo_expand_oids(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_result, rb_oids, rb_expected_type;

        git_repository *repo;
        git_odb *odb;
        git_odb_expand_id *expand;
        long i, expand_count;
        int error;

        Data_Get_Struct(self, git_repository, repo);
        rb_scan_args(argc, argv, "11", &rb_oids, &rb_expected_type);

        Check_Type(rb_oids, T_ARRAY);
        expand_count = RARRAY_LEN(rb_oids);
        expand = alloca(expand_count * sizeof(git_odb_expand_id));

        for (i = 0; i < expand_count; ++i) {
                VALUE rb_hex = rb_ary_entry(rb_oids, i);
                Check_Type(rb_hex, T_STRING);

                rugged_exception_check(
                        git_oid_fromstrn(&expand[i].id, RSTRING_PTR(rb_hex), RSTRING_LEN(rb_hex))
                );
                expand[i].length = RSTRING_LEN(rb_hex);
        }

        if (TYPE(rb_expected_type) == T_ARRAY) {
                if (RARRAY_LEN(rb_expected_type) != expand_count)
                        rb_raise(rb_eRuntimeError,
                                "the `object_type` array must be the same length as the `oids` array");

                for (i = 0; i < expand_count; ++i) {
                        VALUE rb_type = rb_ary_entry(rb_expected_type, i);
                        expand[i].type = rugged_otype_get(rb_type);
                }
        } else {
                git_otype expected_type = GIT_OBJ_ANY;

                if (!NIL_P(rb_expected_type))
                        expected_type = rugged_otype_get(rb_expected_type);

                for (i = 0; i < expand_count; ++i)
                        expand[i].type = expected_type;
        }

        error = git_repository_odb(&odb, repo);
        rugged_exception_check(error);

        error = git_odb_expand_ids(odb, expand, (size_t)expand_count);
        git_odb_free(odb);
        rugged_exception_check(error);

        rb_result = rb_hash_new();

        for (i = 0; i < expand_count; ++i) {
                if (expand[i].length) {
                        rb_hash_aset(rb_result,
                                rb_ary_entry(rb_oids, i), rugged_create_oid(&expand[i].id));
                }
        }

        return rb_result;
}
fetch(remote_or_url, *args, **kwargs) click to toggle source
# File lib/rugged/repository.rb, line 253
def fetch(remote_or_url, *args, **kwargs)
  unless remote_or_url.kind_of? Remote
    remote_or_url = remotes[remote_or_url] || remotes.create_anonymous(remote_or_url)
  end
  remote_or_url.fetch(*args, **kwargs)
end
fetch_attributes(p1, p2 = v2, p3 = v3) click to toggle source
static VALUE rb_git_repo_attributes(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_path, rb_names, rb_options;

        git_repository *repo;
        int error, options = 0;

        rb_scan_args(argc, argv, "12", &rb_path, &rb_names, &rb_options);

        Data_Get_Struct(self, git_repository, repo);
        FilePathValue(rb_path);

        if (!NIL_P(rb_options)) {
                Check_Type(rb_options, T_FIXNUM);
                options = FIX2INT(rb_options);
        }

        switch (TYPE(rb_names)) {
        case T_ARRAY:
        {
                VALUE rb_result;
                const char **values;
                const char **names;
                long i, num_attr = RARRAY_LEN(rb_names);

                if (num_attr > 32)
                        rb_raise(rb_eRuntimeError, "Too many attributes requested");

                values = alloca(num_attr * sizeof(const char *));
                names = alloca(num_attr * sizeof(const char *));

                for (i = 0; i < num_attr; ++i) {
                        VALUE attr = rb_ary_entry(rb_names, i);
                        Check_Type(attr, T_STRING);
                        names[i] = StringValueCStr(attr);
                }

                error = git_attr_get_many(
                        values, repo, options,
                        StringValueCStr(rb_path),
                        (size_t)num_attr, names);

                rugged_exception_check(error);

                rb_result = rb_hash_new();
                for (i = 0; i < num_attr; ++i) {
                        VALUE attr = rb_ary_entry(rb_names, i);
                        rb_hash_aset(rb_result, attr, rugged_create_attr(values[i]));
                }
                return rb_result;
        }

        case T_STRING:
        {
                const char *value;

                error = git_attr_get(
                        &value, repo, options,
                        StringValueCStr(rb_path),
                        StringValueCStr(rb_names));

                rugged_exception_check(error);

                return rugged_create_attr(value);
        }

        case T_NIL:
        {
                VALUE rb_result = rb_hash_new();

                error = git_attr_foreach(
                        repo, options,
                        StringValueCStr(rb_path),
                        &foreach_attr_hash,
                        (void *)rb_result);

                rugged_exception_check(error);
                return rb_result;
        }

        default:
                rb_raise(rb_eTypeError,
                        "Invalid attribute name (expected String or Array)");
        }
}
head → ref click to toggle source

Retrieve and resolve the reference pointed at by the repository's HEAD.

Returns nil if HEAD is missing.

static VALUE rb_git_repo_get_head(VALUE self)
{
        git_repository *repo;
        git_reference *head;
        int error;

        Data_Get_Struct(self, git_repository, repo);

        error = git_repository_head(&head, repo);
        if (error == GIT_ENOTFOUND)
                return Qnil;
        else
                rugged_exception_check(error);

        return rugged_ref_new(rb_cRuggedReference, self, head);
}
head = str click to toggle source

Make the repository's HEAD point to the specified reference.

static VALUE rb_git_repo_set_head(VALUE self, VALUE rb_head)
{
        git_repository *repo;
        int error;

        Data_Get_Struct(self, git_repository, repo);

        Check_Type(rb_head, T_STRING);
        error = git_repository_set_head(repo, StringValueCStr(rb_head));
        rugged_exception_check(error);

        return Qnil;
}
head_detached? → true or false click to toggle source

Return whether the HEAD of a repository is detached or not.

static VALUE rb_git_repo_head_detached(VALUE self)
{
        RB_GIT_REPO_GETTER(head_detached);
}
head_unborn? → true or false click to toggle source

Return whether the current branch is unborn (HEAD points to a non-existent branch).

static VALUE rb_git_repo_head_unborn(VALUE self)
{
        RB_GIT_REPO_GETTER(head_unborn);
}
ident → ident click to toggle source

Return a Hash containing the identity that is used to write reflogs.

ident is a Hash containing name and/or email entries, or `nil`.

static VALUE rb_git_repo_get_ident(VALUE self)
{
        VALUE rb_ident = rb_hash_new();

        git_repository *repo;
        const char *name = NULL, *email = NULL;

        Data_Get_Struct(self, git_repository, repo);

        rugged_exception_check(
                git_repository_ident(&name, &email, repo)
        );

        if (name) {
                rb_hash_aset(rb_ident, CSTR2SYM("name"), rb_str_new_utf8(name));
        }

        if (email) {
                rb_hash_aset(rb_ident, CSTR2SYM("email"), rb_str_new_utf8(email));
        }

        return rb_ident;
}
ident = ident click to toggle source

Set the identity to be used for writing reflogs.

ident can be either nil or a Hash containing name and/or email entries.

static VALUE rb_git_repo_set_ident(VALUE self, VALUE rb_ident) {
        VALUE rb_val;

        git_repository *repo;
        const char *name = NULL, *email = NULL;

        Data_Get_Struct(self, git_repository, repo);

        if (!NIL_P(rb_ident)) {
                Check_Type(rb_ident, T_HASH);

                if (!NIL_P(rb_val = rb_hash_aref(rb_ident, CSTR2SYM("name")))) {
                        Check_Type(rb_val, T_STRING);
                        name = StringValueCStr(rb_val);
                }

                if (!NIL_P(rb_val = rb_hash_aref(rb_ident, CSTR2SYM("email")))) {
                        Check_Type(rb_val, T_STRING);
                        email = StringValueCStr(rb_val);
                }
        }

        rugged_exception_check(
                git_repository_set_ident(repo, name, email)
        );

        return Qnil;
}
include?(oid) → true or false

Return whether an object with the given SHA1 OID (represented as a hex string of at least 7 characters) exists in the repository.

repo.include?("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f") #=> true
repo.include?("d8786bfc") #=> true
Alias for: exists?
index → idx click to toggle source

Return the default index for this repository.

static VALUE rb_git_repo_get_index(VALUE self)
{
        RB_GIT_REPO_OWNED_GET(rb_cRuggedIndex, index);
}
index = idx click to toggle source

Set the index for this Repository. idx must be a instance of Rugged::Index. This index will be used internally by all operations that use the Git index on repo.

Note that it's not necessary to set the index for any repository; by default repositories are loaded with the index file that can be located on the .git folder in the filesystem.

static VALUE rb_git_repo_set_index(VALUE self, VALUE rb_data)
{
        RB_GIT_REPO_OWNED_SET(rb_cRuggedIndex, index);
}
inspect() click to toggle source

Pretty formatting of a Repository.

Returns a very pretty String.

# File lib/rugged/repository.rb, line 14
def inspect
  "#<Rugged::Repository:#{object_id} {path: #{path.inspect}}>"
end
last_commit() click to toggle source

Get the most recent commit from this repo.

Returns a Rugged::Commit object.

# File lib/rugged/repository.rb, line 21
def last_commit
  self.head.target
end
lookup(oid) click to toggle source

Look up a SHA1.

Returns one of the four classes that inherit from Rugged::Object.

# File lib/rugged/repository.rb, line 146
def lookup(oid)
  Rugged::Object.lookup(self, oid)
end
merge_analysis(their_commit) → Array click to toggle source

Analyzes the given commit and determines the opportunities for merging it into the repository's HEAD. Returns an Array containing a combination of the following symbols:

:normal

A “normal” merge is possible, both HEAD and the given commit have diverged from their common ancestor. The divergent commits must be merged.

:up_to_date

The given commit is reachable from HEAD, meaning HEAD is up-to-date and no merge needs to be performed.

:fastforward

The given commit is a fast-forward from HEAD and no merge needs to be performed. HEAD can simply be set to the given commit.

:unborn

The HEAD of the current repository is “unborn” and does not point to a valid commit. No merge can be performed, but the caller may wish to simply set HEAD to the given commit.

static VALUE rb_git_repo_merge_analysis(int argc, VALUE *argv, VALUE self)
{
        int error;
        git_repository *repo;
        git_commit *their_commit;
        git_annotated_commit *annotated_commit;
        git_merge_analysis_t analysis;
        git_merge_preference_t preference;
        VALUE rb_their_commit, result;

        rb_scan_args(argc, argv, "10", &rb_their_commit);

        Data_Get_Struct(self, git_repository, repo);

        if (TYPE(rb_their_commit) == T_STRING) {
                rb_their_commit = rugged_object_rev_parse(self, rb_their_commit, 1);
        }

        if (!rb_obj_is_kind_of(rb_their_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }

        TypedData_Get_Struct(rb_their_commit, git_commit, &rugged_object_type, their_commit);

        error = git_annotated_commit_lookup(&annotated_commit, repo, git_commit_id(their_commit));
        rugged_exception_check(error);

        error = git_merge_analysis(&analysis, &preference, repo,
                                   /* hack as we currently only do one commit */
                                   (const git_annotated_commit **) &annotated_commit, 1);
        git_annotated_commit_free(annotated_commit);
        rugged_exception_check(error);

        result = rb_ary_new();
        if (analysis & GIT_MERGE_ANALYSIS_NORMAL)
                rb_ary_push(result, CSTR2SYM("normal"));
        if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE)
                rb_ary_push(result, CSTR2SYM("up_to_date"));
        if (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD)
                rb_ary_push(result, CSTR2SYM("fastforward"));
        if (analysis & GIT_MERGE_ANALYSIS_UNBORN)
                rb_ary_push(result, CSTR2SYM("unborn"));

        return result;
}
merge_base(oid1, oid2, ...) click to toggle source
merge_base(ref1, ref2, ...)
merge_base(commit1, commit2, ...)

Find a merge base, given two or more commits or oids. Returns nil if a merge base is not found.

static VALUE rb_git_repo_merge_base(VALUE self, VALUE rb_args)
{
        int error = GIT_OK, i;
        git_repository *repo;
        git_oid base, *input_array = xmalloc(sizeof(git_oid) * RARRAY_LEN(rb_args));
        int len = (int)RARRAY_LEN(rb_args);

        if (len < 2)
                rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", len);

        Data_Get_Struct(self, git_repository, repo);

        for (i = 0; !error && i < len; ++i) {
                error = rugged_oid_get(&input_array[i], repo, rb_ary_entry(rb_args, i));
        }

        if (error) {
                xfree(input_array);
                rugged_exception_check(error);
        }

        error = git_merge_base_many(&base, repo, len, input_array);
        xfree(input_array);

        if (error == GIT_ENOTFOUND)
                return Qnil;

        rugged_exception_check(error);

        return rugged_create_oid(&base);
}
merge_bases(oid1, oid2, ...) → Array click to toggle source
merge_bases(ref1, ref2, ...) → Array
merge_bases(commit1, commit2, ...) → Array

Find all merge bases, given two or more commits or oids. Returns an empty array if no merge bases are found.

static VALUE rb_git_repo_merge_bases(VALUE self, VALUE rb_args)
{
        int error = GIT_OK;
        size_t i, len = (size_t)RARRAY_LEN(rb_args);
        git_repository *repo;
        git_oidarray bases = {NULL, 0};
        git_oid *input_array;

        VALUE rb_bases;

        if (len < 2)
                rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2+)", RARRAY_LEN(rb_args));

        Data_Get_Struct(self, git_repository, repo);

        input_array = xmalloc(sizeof(git_oid) * len);

        for (i = 0; !error && i < len; ++i) {
                error = rugged_oid_get(&input_array[i], repo, rb_ary_entry(rb_args, i));
        }

        if (error) {
                xfree(input_array);
                rugged_exception_check(error);
        }

        error = git_merge_bases_many(&bases, repo, len, input_array);
        xfree(input_array);

        if (error != GIT_ENOTFOUND)
                rugged_exception_check(error);

        rb_bases = rb_ary_new2(bases.count);

        for (i = 0; i < bases.count; ++i) {
                rb_ary_push(rb_bases, rugged_create_oid(&bases.ids[i]));
        }

        git_oidarray_free(&bases);

        return rb_bases;
}
merge_commits(our_commit, their_commit, options = {}) → index click to toggle source

Merges the two given commits, returning a Rugged::Index that reflects the result of the merge.

our_commit and their_commit can either be Rugged::Commit objects, or OIDs resolving to the former.

static VALUE rb_git_repo_merge_commits(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_our_commit, rb_their_commit, rb_options;
        git_commit *our_commit, *their_commit;
        git_index *index;
        git_repository *repo;
        git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
        int error;

        rb_scan_args(argc, argv, "20:", &rb_our_commit, &rb_their_commit, &rb_options);

        if (TYPE(rb_our_commit) == T_STRING) {
                rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);
        }

        if (!rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }

        if (TYPE(rb_their_commit) == T_STRING) {
                rb_their_commit = rugged_object_rev_parse(self, rb_their_commit, 1);
        }

        if (!rb_obj_is_kind_of(rb_their_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }

        if (!NIL_P(rb_options)) {
                Check_Type(rb_options, T_HASH);
                rugged_parse_merge_options(&opts, rb_options);
        }

        Data_Get_Struct(self, git_repository, repo);
        TypedData_Get_Struct(rb_our_commit, git_commit, &rugged_object_type, our_commit);
        TypedData_Get_Struct(rb_their_commit, git_commit, &rugged_object_type, their_commit);

        error = git_merge_commits(&index, repo, our_commit, their_commit, &opts);
        if (error == GIT_EMERGECONFLICT)
                return Qnil;

        rugged_exception_check(error);

        return rugged_index_new(rb_cRuggedIndex, self, index);
}
namespace → str click to toggle source

Returns the active namespace for the repository.

static VALUE rb_git_repo_get_namespace(VALUE self)
{
        git_repository *repo;
        const char *namespace;

        Data_Get_Struct(self, git_repository, repo);

        namespace = git_repository_get_namespace(repo);
        return namespace ? rb_str_new_utf8(namespace) : Qnil;
}
namespace = new_namespace click to toggle source

Sets the active namespace for the repository. If set to nil, no namespace will be active.

static VALUE rb_git_repo_set_namespace(VALUE self, VALUE rb_namespace)
{
        git_repository *repo;
        int error;

        Data_Get_Struct(self, git_repository, repo);

        if (!NIL_P(rb_namespace)) {
                Check_Type(rb_namespace, T_STRING);
                error = git_repository_set_namespace(repo, StringValueCStr(rb_namespace));
        } else {
                error = git_repository_set_namespace(repo, NULL);
        }
        rugged_exception_check(error);

        return Qnil;
}
path → path click to toggle source

Return the full, normalized path to this repository. For non-bare repositories, this is the path of the actual .git folder, not the working directory.

repo.path #=> "/home/foo/workthing/.git"
static VALUE rb_git_repo_path(VALUE self)
{
        git_repository *repo;
        const char *path;

        Data_Get_Struct(self, git_repository, repo);
        path = git_repository_path(repo);

        return path ? rb_str_new_utf8(path) : Qnil;
}
path_ignored?(path) → true or false click to toggle source

Return whether a path is ignored or not.

static VALUE rb_git_repo_is_path_ignored(VALUE self, VALUE rb_path) {
        git_repository *repo;
        const char *path;
        int error;
        int ignored;

        Data_Get_Struct(self, git_repository, repo);
        path = StringValueCStr(rb_path);
        error = git_ignore_path_is_ignored(&ignored, repo, path);
        rugged_exception_check(error);
        return ignored ? Qtrue : Qfalse;
}
push(remote_or_url, *args, **kwargs) click to toggle source

Push a list of refspecs to the given remote.

refspecs - A list of refspecs that should be pushed to the remote.

Returns a hash containing the pushed refspecs as keys and any error messages or nil as values.

# File lib/rugged/repository.rb, line 266
def push(remote_or_url, *args, **kwargs)
  unless remote_or_url.kind_of? Remote
    remote_or_url = remotes[remote_or_url] || remotes.create_anonymous(remote_or_url)
  end

  remote_or_url.push(*args, **kwargs)
end
read(oid) → str click to toggle source

Read and return the raw data of the object identified by the given oid.

static VALUE rb_git_repo_read(VALUE self, VALUE hex)
{
        git_repository *repo;
        git_oid oid;
        int error;

        Data_Get_Struct(self, git_repository, repo);
        Check_Type(hex, T_STRING);

        error = git_oid_fromstr(&oid, StringValueCStr(hex));
        rugged_exception_check(error);

        return rugged_raw_read(repo, &oid);
}
read_header(oid) → hash click to toggle source

Read and return the header information in repo's ODB for the object identified by the given oid.

Returns a Hash object with the following key/value pairs:

:type

A Symbol denoting the object's type. Possible values are: :tree, :blob, :commit or :tag.

:len

A Number representing the object's length, in bytes.

static VALUE rb_git_repo_read_header(VALUE self, VALUE hex)
{
        git_repository *repo;
        git_oid oid;
        git_odb *odb;
        git_otype type;
        size_t len;
        VALUE rb_hash;
        int error;

        Data_Get_Struct(self, git_repository, repo);
        Check_Type(hex, T_STRING);

        error = git_oid_fromstr(&oid, StringValueCStr(hex));
        rugged_exception_check(error);

        error = git_repository_odb(&odb, repo);
        rugged_exception_check(error);

        error = git_odb_read_header(&len, &type, odb, &oid);
        git_odb_free(odb);
        rugged_exception_check(error);

        rb_hash = rb_hash_new();
        rb_hash_aset(rb_hash, CSTR2SYM("type"), CSTR2SYM(git_object_type2string(type)));
        rb_hash_aset(rb_hash, CSTR2SYM("len"), INT2FIX(len));

        return rb_hash;
}
ref(ref_name) click to toggle source

Look up a single reference by name.

Example:

repo.ref 'refs/heads/master'
# => #<Rugged::Reference:2199125780 {name: "refs/heads/master",
       target: "25b5d3b40c4eadda8098172b26c68cf151109799"}>

Returns a Rugged::Reference.

# File lib/rugged/repository.rb, line 173
def ref(ref_name)
  references[ref_name]
end
ref_names(glob = nil) click to toggle source
# File lib/rugged/repository.rb, line 185
def ref_names(glob = nil)
  references.each_name(glob)
end
references() click to toggle source
# File lib/rugged/repository.rb, line 181
def references
  @references ||= ReferenceCollection.new(self)
end
refs(glob = nil) click to toggle source
# File lib/rugged/repository.rb, line 177
def refs(glob = nil)
  references.each(glob)
end
remotes() click to toggle source

All the remotes in the repository.

Returns a Rugged::RemoteCollection containing all the Rugged::Remote objects in the repository.

# File lib/rugged/repository.rb, line 200
def remotes
  @remotes ||= RemoteCollection.new(self)
end
reset(target, reset_type) → nil click to toggle source

Sets the current head to the specified commit oid and optionally resets the index and working tree to match.

:soft

the head will be moved to the commit.

:mixed

will trigger a :soft reset, plus the index will be replaced with the content of the commit tree.

:hard

will trigger a :mixed reset and the working directory will be replaced with the content of the index. (Untracked and ignored files will be left alone)

Examples:

repo.reset('origin/master', :hard) #=> nil
static VALUE rb_git_repo_reset(VALUE self, VALUE rb_target, VALUE rb_reset_type)
{
        git_repository *repo;
        int reset_type;
        git_object *target = NULL;
        int error;

        Data_Get_Struct(self, git_repository, repo);

        reset_type = parse_reset_type(rb_reset_type);
        target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);

        error = git_reset(repo, target, reset_type, NULL);

        git_object_free(target);

        rugged_exception_check(error);

        return Qnil;
}
reset_path(pathspecs, target=nil) → nil click to toggle source

Updates entries in the index from the target commit tree, matching the given pathspecs.

Passing a nil target will result in removing entries in the index matching the provided pathspecs.

  • pathspecs: list of pathspecs to operate on (String or Array of String objects)

  • target(optional): Rugged::Commit, Rugged::Tag or rev that resolves to a commit or tag object.

Examples:

reset_path(File.join('subdir','file.txt'), '441034f860c1d5d90e4188d11ae0d325176869a8') #=> nil
static VALUE rb_git_repo_reset_path(int argc, VALUE *argv, VALUE self)
{
        git_repository *repo;
        git_object *target = NULL;
        git_strarray pathspecs;
        VALUE rb_target, rb_paths;
        int error = 0;

        pathspecs.strings = NULL;
        pathspecs.count = 0;

        Data_Get_Struct(self, git_repository, repo);

        rb_scan_args(argc, argv, "11", &rb_paths, &rb_target);

        rugged_rb_ary_to_strarray(rb_paths, &pathspecs);

        if (!NIL_P(rb_target))
                target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);

        error = git_reset_default(repo, target, &pathspecs);

        xfree(pathspecs.strings);
        git_object_free(target);

        rugged_exception_check(error);

        return Qnil;
}
rev_parse(spec) click to toggle source

Look up an object by a revision string.

Returns one of the four classes that inherit from Rugged::Object.

# File lib/rugged/repository.rb, line 153
def rev_parse(spec)
  Rugged::Object.rev_parse(self, spec)
end
rev_parse_oid(spec) click to toggle source

Look up an object by a revision string.

Returns the oid of the matched object as a String

# File lib/rugged/repository.rb, line 160
def rev_parse_oid(spec)
  Rugged::Object.rev_parse_oid(self, spec)
end
revert_commit(revert_commit, our_commit, options = {}) → index click to toggle source

Reverts the given commit against the given “our” commit, producing an index that reflects the result of the revert.

static VALUE rb_git_repo_revert_commit(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_revert_commit, rb_our_commit, rb_options;
        git_commit *revert_commit, *our_commit;
        git_index *index;
        git_repository *repo;
        git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
        unsigned int mainline = 0;
        int error;

        rb_scan_args(argc, argv, "20:", &rb_revert_commit, &rb_our_commit, &rb_options);

        if (TYPE(rb_revert_commit) == T_STRING)
                rb_revert_commit = rugged_object_rev_parse(self, rb_revert_commit, 1);

        if (TYPE(rb_our_commit) == T_STRING)
                rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);

        if (!rb_obj_is_kind_of(rb_revert_commit, rb_cRuggedCommit) ||
                !rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
                rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
        }

        if (!NIL_P(rb_options)) {
                VALUE rb_mainline;

                Check_Type(rb_options, T_HASH);
                rugged_parse_merge_options(&opts, rb_options);

                rb_mainline = rb_hash_aref(rb_options, CSTR2SYM("mainline"));
                if (!NIL_P(rb_mainline)) {
                        Check_Type(rb_mainline, T_FIXNUM);
                        mainline = FIX2UINT(rb_mainline);
                }
        }

        Data_Get_Struct(self, git_repository, repo);
        TypedData_Get_Struct(rb_revert_commit, git_commit, &rugged_object_type, revert_commit);
        TypedData_Get_Struct(rb_our_commit, git_commit, &rugged_object_type, our_commit);

        error = git_revert_commit(&index, repo, revert_commit, our_commit, mainline, &opts);
        if (error == GIT_EMERGECONFLICT)
                return Qnil;

        rugged_exception_check(error);

        return rugged_index_new(rb_cRuggedIndex, self, index);
}
shallow? → true or false click to toggle source

Return whether a repository is a shallow clone or not. A shallow clone has a truncated history and can not be cloned or fetched from, nor can be pushed from nor into it.

static VALUE rb_git_repo_is_shallow(VALUE self)
{
        RB_GIT_REPO_GETTER(is_shallow);
}
status { |file, status_data| block } click to toggle source
status(path) → status_data

Returns the status for one or more files in the working directory of the repository. This is equivalent to the +git status+ command.

The returned status_data is always an array containing one or more status flags as Ruby symbols. Possible flags are:

  • :index_new: the file is new in the index

  • :index_modified: the file has been modified in the index

  • :index_deleted: the file has been deleted from the index

  • :worktree_new: the file is new in the working directory

  • :worktree_modified: the file has been modified in the working directory

  • :worktree_deleted: the file has been deleted from the working directory

If a block is given, status information will be gathered for every single file on the working dir. The block will be called with the status data for each file.

repo.status { |file, status_data| puts "#{file} has status: #{status_data.inspect}" }

results in, for example:

src/diff.c has status: [:index_new, :worktree_new]
README has status: [:worktree_modified]

If a path is given instead, the function will return the status_data for the file pointed to by path, or raise an exception if the path doesn't exist.

path must be relative to the repository's working directory.

repo.status('src/diff.c') #=> [:index_new, :worktree_new]
# File lib/rugged/repository.rb, line 91
def status(file = nil, &block)
  if file
    file_status file
  else
    each_status(&block)
  end
end
submodules() click to toggle source

All the submodules in the repository

Returns a SubmoduleCollection containing Rugged::Submodule objects

# File lib/rugged/repository.rb, line 214
def submodules
  @submodules ||= SubmoduleCollection.new(self)
end
tags() click to toggle source

All the tags in the repository.

Returns a TagCollection containing all the tags.

# File lib/rugged/repository.rb, line 192
def tags
  @tags ||= TagCollection.new(self)
end
walk(from, sorting=Rugged::SORT_DATE, &block) click to toggle source

Walks over a set of commits using Rugged::Walker.

from - The String SHA1 to push onto Walker to begin our walk. sorting - The sorting order of the commits, as defined in the README. block - A block that we pass into walker#each.

Returns nothing if called with a block, otherwise returns an instance of Enumerable::Enumerator containing Rugged::Commit objects.

# File lib/rugged/repository.rb, line 136
def walk(from, sorting=Rugged::SORT_DATE, &block)
  walker = Rugged::Walker.new(self)
  walker.sorting(sorting)
  walker.push(from)
  walker.each(&block)
end
workdir → path or nil click to toggle source

Return the working directory for this repository, or nil if the repository is bare.

repo1.bare? #=> false
repo1.workdir #=> "/home/foo/workthing/"

repo2.bare? #=> true
repo2.workdir #=> nil
static VALUE rb_git_repo_workdir(VALUE self)
{
        git_repository *repo;
        const char *workdir;

        Data_Get_Struct(self, git_repository, repo);
        workdir = git_repository_workdir(repo);

        return workdir ? rb_str_new_utf8(workdir) : Qnil;
}
workdir = path click to toggle source

Sets the working directory of repo to path. All internal operations on repo that affect the working directory will instead use path.

The workdir can be set on bare repositories to temporarily turn them into normal repositories.

repo.bare? #=> true
repo.workdir = "/tmp/workdir"
repo.bare? #=> false
repo.checkout
static VALUE rb_git_repo_set_workdir(VALUE self, VALUE rb_workdir)
{
        git_repository *repo;

        Data_Get_Struct(self, git_repository, repo);
        Check_Type(rb_workdir, T_STRING);

        rugged_exception_check(
                git_repository_set_workdir(repo, StringValueCStr(rb_workdir), 0)
        );

        return Qnil;
}
write(buffer, type) → oid click to toggle source

Write the data contained in the buffer string as a raw object of the given type into the repository's object database.

type can be either :tag, :commit, :tree or :blob.

Returns the newly created object's oid.

static VALUE rb_git_repo_write(VALUE self, VALUE rb_buffer, VALUE rub_type)
{
        git_repository *repo;
        git_odb_stream *stream;

        git_odb *odb;
        git_oid oid;
        int error;

        git_otype type;

        Data_Get_Struct(self, git_repository, repo);
        Check_Type(rb_buffer, T_STRING);

        error = git_repository_odb(&odb, repo);
        rugged_exception_check(error);

        type = rugged_otype_get(rub_type);

        error = git_odb_open_wstream(&stream, odb, RSTRING_LEN(rb_buffer), type);
        git_odb_free(odb);
        rugged_exception_check(error);

        error = git_odb_stream_write(stream, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
        if (!error)
                error = git_odb_stream_finalize_write(&oid, stream);

        git_odb_stream_free(stream);
        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}

Private Instance Methods

each_status() click to toggle source
static VALUE rb_git_repo_file_each_status(VALUE self)
{
        int error, exception = 0;
        size_t i, nentries;
        git_repository *repo;
        git_status_list *list;

        Data_Get_Struct(self, git_repository, repo);

        if (!rb_block_given_p())
                rb_raise(rb_eRuntimeError,
                        "A block was expected for iterating through "
                        "the repository contents.");

        error = git_status_list_new(&list, repo, NULL);
        rugged_exception_check(error);

        nentries = git_status_list_entrycount(list);
        for (i = 0; i < nentries; i++) {
                const git_status_entry *entry;
                const char *path;
                VALUE args;

                entry = git_status_byindex(list, i);

                path = entry->head_to_index ?
                       entry->head_to_index->old_file.path :
                       entry->index_to_workdir->old_file.path;
                args = rb_ary_new3(2, rb_str_new_utf8(path), flags_to_rb(entry->status));
                rb_protect(rb_yield, args, &exception);
                if (exception != 0)
                        break;
        }
        git_status_list_free(list);

        if (exception != 0)
                rb_jump_tag(exception);

        return Qnil;
}
file_status(p1) click to toggle source
static VALUE rb_git_repo_file_status(VALUE self, VALUE rb_path)
{
        unsigned int flags;
        int error;
        git_repository *repo;

        Data_Get_Struct(self, git_repository, repo);
        FilePathValue(rb_path);
        error = git_status_file(&flags, repo, StringValueCStr(rb_path));
        rugged_exception_check(error);

        return flags_to_rb(flags);
}