class Rugged::Tree

Tree

Attributes

owner[R]
repo[R]

Public Class Methods

diff(repo, tree, diffable[, options]) → diff click to toggle source

Returns a diff between the ‘tree` and the diffable object that was given. diffable can either be a Rugged::Commit, a Rugged::Tree, a Rugged::Index, or nil.

The tree object will be used as the “old file” side of the diff, while the parent tree or the diffable object will be used for the “new file” side.

If tree or diffable are nil, they will be treated as an empty tree. Passing both as ‘nil` will raise an exception.

The following options can be passed in the options Hash:

:paths

An array of paths / fnmatch patterns to constrain the diff to a specific set of files. Also see :disable_pathspec_match.

:max_size

An integer specifying the maximum byte size of a file before a it will be treated as binary. The default value is 512MB.

:context_lines

The number of unchanged lines that define the boundary of a hunk (and to display before and after the actual changes). The default is 3.

:interhunk_lines

The maximum number of unchanged lines between hunk boundaries before the hunks will be merged into a one. The default is 0.

:old_prefix

The virtual “directory” to prefix to old filenames in hunk headers. The default is “a”.

:new_prefix

The virtual “directory” to prefix to new filenames in hunk headers. The default is “b”.

:reverse

If true, the sides of the diff will be reversed.

:force_text

If true, all files will be treated as text, disabling binary attributes & detection.

:ignore_whitespace

If true, all whitespace will be ignored.

:ignore_whitespace_change

If true, changes in amount of whitespace will be ignored.

:ignore_whitespace_eol

If true, whitespace at end of line will be ignored.

:ignore_submodules

if true, submodules will be excluded from the diff completely.

:patience

If true, the “patience diff” algorithm will be used (currenlty unimplemented).

:include_ignored

If true, ignored files will be included in the diff.

:include_untracked

If true, untracked files will be included in the diff.

:include_unmodified

If true, unmodified files will be included in the diff.

:recurse_untracked_dirs

Even if :include_untracked is true, untracked directories will only be marked with a single entry in the diff. If this flag is set to true, all files under ignored directories will be included in the diff, too.

:disable_pathspec_match

If true, the given :paths will be applied as exact matches, instead of as fnmatch patterns.

:deltas_are_icase

If true, filename comparisons will be made with case-insensitivity.

:show_untracked_content

if true, untracked content will be contained in the the diff patch text.

:skip_binary_check

If true, diff deltas will be generated without spending time on binary detection. This is useful to improve performance in cases where the actual file content difference is not needed.

:include_typechange

If true, type changes for files will not be interpreted as deletion of the “old file” and addition of the “new file”, but will generate typechange records.

:include_typechange_trees

Even if :include_typechange is true, blob -> tree changes will still usually be handled as a deletion of the blob. If this flag is set to true, blob -> tree changes will be marked as typechanges.

:ignore_filemode

If true, file mode changes will be ignored.

:recurse_ignored_dirs

Even if :include_ignored is true, ignored directories will only be marked with a single entry in the diff. If this flag is set to true, all files under ignored directories will be included in the diff, too.

Examples:

# Emulating `git diff <treeish>`
tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
diff = tree.diff(repo.index)
diff.merge!(tree.diff)

# Tree-to-Tree Diff
tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
other_tree = Rugged::Tree.lookup(repo, "7a9e0b02e63179929fed24f0a3e0f19168114d10")
diff = tree.diff(other_tree)
# File lib/rugged/tree.rb, line 129
def self.diff(repo, tree, other_tree = nil, options = {})
  if tree && !tree.is_a?(Rugged::Tree)
    raise TypeError, "At least a Rugged::Tree object is required for diffing"
  end

  if other_tree.nil?
    if tree.nil?
      raise TypeError, "Need 'old' or 'new' for diffing"
    else
      diff_tree_to_tree repo, tree, nil, options
    end
  else
    if other_tree.is_a?(::String)
      other_tree = Rugged::Object.rev_parse repo, other_tree
    end

    case other_tree
    when Rugged::Commit
      diff_tree_to_tree repo, tree, other_tree.tree, options
    when Rugged::Tree
      diff_tree_to_tree repo, tree, other_tree, options
    when Rugged::Index
      diff_tree_to_index repo, tree, other_tree, options
    else
      raise TypeError, "A Rugged::Commit, Rugged::Tree or Rugged::Index instance is required"
    end
  end
end
empty(repo) → tree click to toggle source

Look up the empty tree in the given repository repo. The empty tree’s id is hard-coded to exist in a repository.

Returns a new instance of the empty tree.

static VALUE rb_git_tree_empty(VALUE self, VALUE rb_repo)
{
        git_repository *repo;
        git_tree *tree;

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        rugged_exception_check(git_tree_lookup(&tree, repo, &empty_tree));

        return rugged_object_new(rb_repo, (git_object *) tree);
}

Public Instance Methods

[]
Alias for: get_entry
count → count click to toggle source

Return the number of entries contained in the tree.

Note that this only applies to entries in the root of the tree, not any other entries contained in sub-folders.

static VALUE rb_git_tree_entrycount(VALUE self)
{
        git_tree *tree;
        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);

        return INT2FIX(git_tree_entrycount(tree));
}
Also aliased as: length
count_recursive(limit=nil) → count click to toggle source

‘limit` - The maximum number of blobs to the count in the repository. Rugged will stop walking the tree after `limit` items to avoid long execution times.

Return the number of blobs (up to the limit) contained in the tree and all subtrees.

static VALUE rb_git_tree_entrycount_recursive(int argc, VALUE* argv, VALUE self)
{
        git_tree *tree;
        int error;
        struct rugged_treecount_cb_payload payload;
        VALUE rb_limit;

        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);

        rb_scan_args(argc, argv, "01", &rb_limit);

        payload.limit = -1;
        payload.count = 0;

        if (!NIL_P(rb_limit)) {
                Check_Type(rb_limit, T_FIXNUM);
                payload.limit = FIX2INT(rb_limit);
        }


        error = git_tree_walk(tree, GIT_TREEWALK_PRE, &rugged__treecount_cb, (void *)&payload);

        if (error && giterr_last()->klass == GITERR_CALLBACK) {
                giterr_clear();
                error = 0;
        }

        rugged_exception_check(error);

        return INT2FIX(payload.count);
}
diff(other = nil, options = nil) click to toggle source
# File lib/rugged/tree.rb, line 163
def diff(other = nil, options = nil)
  Tree.diff(repo, self, other, options)
end
diff_workdir([options]) → diff click to toggle source

Returns a diff between a tree and the current workdir.

The tree object will be used as the “old file” side of the diff, while the content of the current workdir will be used for the “new file” side.

See Rugged::Tree#diff for a list of options that can be passed.

static VALUE rb_git_tree_diff_workdir(int argc, VALUE *argv, VALUE self)
{
        git_tree *tree;
        git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
        git_repository *repo;
        git_diff *diff;
        VALUE owner, rb_options;
        int error;

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

        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);
        owner = rugged_owner(self);
        Data_Get_Struct(owner, git_repository, repo);

        error = git_diff_tree_to_workdir(&diff, repo, tree, &opts);

        xfree(opts.pathspec.strings);
        rugged_exception_check(error);

        return rugged_diff_new(rb_cRuggedDiff, owner, diff);
}
each { |entry| block } click to toggle source
each → enumerator

Call block with each of the entries of the subtree as a Hash. If no block is given, an enumerator is returned instead.

Note that only the entries in the root of the tree are yielded; if you need to list also entries in subfolders, use tree.walk instead.

tree.each { |entry| puts entry.inspect }

generates:

{:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
{:name => "bar.txt", :type => :blob, :oid => "de5ba987198bcf2518885f0fc1350e5172cded78", :filemode => 0}
...
static VALUE rb_git_tree_each(VALUE self)
{
        git_tree *tree;
        size_t i, count;

        RETURN_ENUMERATOR(self, 0, 0);
        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);

        count = git_tree_entrycount(tree);

        for (i = 0; i < count; ++i) {
                const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
                rb_yield(rb_git_treeentry_fromC(entry));
        }

        return Qnil;
}
each_blob() { |e| ... } click to toggle source

Iterate over the blobs in this tree

# File lib/rugged/tree.rb, line 186
def each_blob
  return to_enum(__method__) unless block_given?
  self.each { |e| yield e if e[:type] == :blob }
end
each_tree() { |e| ... } click to toggle source

Iterate over the subtrees in this tree

# File lib/rugged/tree.rb, line 192
def each_tree
  return to_enum(__method__) unless block_given?
  self.each { |e| yield e if e[:type] == :tree }
end
get_entry(e) → entry click to toggle source

Return one of the entries from a tree as a Hash. If e is a number, the +e+nth entry from the tree will be returned. If e is a string, the entry with that name will be returned.

If the entry doesn’t exist, nil will be returned.

tree[3] #=> {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
tree['bar.txt'] #=> {:name => "bar.txt", :type => :blob, :oid => "de5ba987198bcf2518885f0fc1350e5172cded78", :filemode => 0}
tree['baz.txt'] #=> nil
static VALUE rb_git_tree_get_entry(VALUE self, VALUE entry_id)
{
        git_tree *tree;
        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);

        if (TYPE(entry_id) == T_FIXNUM)
                return rb_git_treeentry_fromC(git_tree_entry_byindex(tree, FIX2INT(entry_id)));

        else if (TYPE(entry_id) == T_STRING)
                return rb_git_treeentry_fromC(git_tree_entry_byname(tree, StringValueCStr(entry_id)));

        else
                rb_raise(rb_eTypeError, "entry_id must be either an index or a filename");
}
Also aliased as: []
get_entry_by_oid(rb_oid) → entry click to toggle source

Return one of the entries from a tree as a Hash, based off the oid SHA.

If the entry doesn’t exist, nil will be returned.

This does a full traversal of the every element in the tree, so this method is not especially fast.

tree.get_entry_by_oid("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f")
#=> {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
static VALUE rb_git_tree_get_entry_by_oid(VALUE self, VALUE rb_oid)
{
        git_tree *tree;
        git_oid oid;
        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);

        Check_Type(rb_oid, T_STRING);
        rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(rb_oid)));

        return rb_git_treeentry_fromC(git_tree_entry_byid(tree, &oid));
}
inspect() click to toggle source
# File lib/rugged/tree.rb, line 167
def inspect
  data = "#<Rugged::Tree:#{object_id} {oid: #{oid}}>\n"
  self.each { |e| data << "  <\"#{e[:name]}\" #{e[:oid]}>\n" }
  data
end
length → count

Return the number of entries contained in the tree.

Note that this only applies to entries in the root of the tree, not any other entries contained in sub-folders.

Alias for: count
merge(p1, p2 = v2, p3 = v3) click to toggle source

tree.merge(other_tree[, ancestor_tree[, options]]) -> Rugged::Index tree.merge(other_tree[, options]) -> Rugged::Index

Merges two trees and returns the a Rugged::Index object that reflects the result of the merge.

The following options can be passed in the options Hash:

:renames

If true, looking for renames will be enabled (‘–find-renames`), set to false to disable (default true).

:rename_threshold

An integer specifying the minimum similarity of a file to be seen as an eligible rename source (default 50).

:target_limit

An integer specifying the maximum byte size of a file before a it will be treated as binary. The default value is 512MB.

:favor

Specifies how and if conflicts are auto-resolved by favoring a specific file output. Can be one of ‘:normal`, `:ours`, `:theirs` or `:union`.

static VALUE rb_git_tree_merge(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_other_tree, rb_ancestor_tree, rb_options;
        VALUE rb_repo = rugged_owner(self);

        git_tree *tree, *other_tree, *ancestor_tree;
        git_repository *repo;
        git_index *index;
        git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
        int error;

        if (rb_scan_args(argc, argv, "12", &rb_other_tree, &rb_ancestor_tree, &rb_options) == 2) {
                if (TYPE(rb_ancestor_tree) == T_HASH) {
                        rb_options = rb_ancestor_tree;
                        rb_ancestor_tree = Qnil;
                }
        }

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

        if (!rb_obj_is_kind_of(rb_other_tree, rb_cRuggedTree))
                rb_raise(rb_eTypeError, "Expecting a Rugged::Tree instance");
        else if (!NIL_P(rb_ancestor_tree) && !rb_obj_is_kind_of(rb_ancestor_tree, rb_cRuggedTree))
                rb_raise(rb_eTypeError, "Expecting a Rugged::Tree instance");

        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);
        Data_Get_Struct(rb_repo, git_repository, repo);
        TypedData_Get_Struct(rb_other_tree, git_tree, &rugged_object_type, other_tree);

        if (!NIL_P(rb_ancestor_tree))
                TypedData_Get_Struct(rb_ancestor_tree, git_tree, &rugged_object_type, ancestor_tree);
        else
                ancestor_tree = NULL;

        error = git_merge_trees(&index, repo, ancestor_tree, tree, other_tree, &opts);
        if (error == GIT_EMERGECONFLICT)
                return Qnil;

        rugged_exception_check(error);

        return rugged_index_new(rb_cRuggedIndex, rb_repo, index);
}
path(path) → entry click to toggle source

Retrieve and return a tree entry by its relative path.

static VALUE rb_git_tree_path(VALUE self, VALUE rb_path)
{
        int error;
        git_tree *tree;
        git_tree_entry *entry;
        VALUE rb_entry;
        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);
        Check_Type(rb_path, T_STRING);

        error = git_tree_entry_bypath(&entry, tree, StringValueCStr(rb_path));
        rugged_exception_check(error);

        rb_entry = rb_git_treeentry_fromC(entry);
        git_tree_entry_free(entry);

        return rb_entry;
}
update(updates) click to toggle source

Create a new Rugged::Tree based on the curent one by applying the changes described in updates.

The updates are given as a list of Hash containing:

:action

:upsert or :remove to add/insert an entry, or to remove it resp.

:oid

The oid of the entry. This is ignored for removals.

:filemode

The octal filemode for the entry. This is ignored for remvals.

:path

The path of the entry. This may contain slashes and the intermediate trees will be created.

static VALUE rb_git_tree_update(VALUE self, VALUE rb_updates)
{
        git_repository *repo;
        git_tree *tree = NULL;
        git_tree_update *updates;
        int nupdates, error;
        git_oid id;

        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);
        repo = git_tree_owner(tree);

        parse_tree_updates(&updates, &nupdates, rb_updates);

        error = git_tree_create_updated(&id, repo, tree, nupdates, updates);
        xfree(updates);

        rugged_exception_check(error);

        return rugged_create_oid(&id);
}
walk(mode) { |root, entry| block } click to toggle source
walk(mode) → Enumerator

Walk tree with the given mode (either :preorder or :postorder) and yield to block every entry in tree and all its subtrees, as a Hash. The block also takes a root, the relative path in the traversal, starting from the root of the original tree.

If the block returns a falsy value, that entry and its sub-entries (in the case of a folder) will be skipped for the iteration.

If no block is given, an Enumerator is returned instead.

tree.walk(:postorder) { |root, entry| puts "#{root}#{entry[:name]} [#{entry[:oid]}]" }

generates:

USAGE.rb [02bae86c91f96b5fdb6b1cf06f5aa3612139e318]
ext [23f135b3c576b6ac4785821888991d7089f35db1]
ext/rugged [25c88faa9302e34e16664eb9c990deb2bcf77849]
ext/rugged/extconf.rb [40c1aa8a8cec8ca444ed5758e3f00ecff093070a]
...
static VALUE rb_git_tree_walk(VALUE self, VALUE rb_mode)
{
        git_tree *tree;
        int error, mode = 0, exception = 0;
        ID id_mode;

        TypedData_Get_Struct(self, git_tree, &rugged_object_type, tree);

        if (!rb_block_given_p())
                return rb_funcall(self, rb_intern("to_enum"), 2, CSTR2SYM("walk"), rb_mode);

        Check_Type(rb_mode, T_SYMBOL);
        id_mode = SYM2ID(rb_mode);

        if (id_mode == rb_intern("preorder"))
                mode = GIT_TREEWALK_PRE;
        else if (id_mode == rb_intern("postorder"))
                mode = GIT_TREEWALK_POST;
        else
                rb_raise(rb_eTypeError,
                                "Invalid iteration mode. Expected `:preorder` or `:postorder`");

        error = git_tree_walk(tree, mode, &rugged__treewalk_cb, (void *)&exception);

        if (exception)
                rb_jump_tag(exception);

        rugged_exception_check(error);

        return Qnil;
}
walk_blobs(mode=:postorder) { |root, e| ... } click to toggle source

Walks the tree but only yields blobs

# File lib/rugged/tree.rb, line 174
def walk_blobs(mode=:postorder)
  return to_enum(__method__) unless block_given?
  self.walk(mode) { |root, e| yield root, e if e[:type] == :blob }
end
walk_trees(mode=:postorder) { |root, e| ... } click to toggle source

Walks the tree but only yields subtrees

# File lib/rugged/tree.rb, line 180
def walk_trees(mode=:postorder)
  return to_enum(__method__) unless block_given?
  self.walk(mode) { |root, e| yield root, e if e[:type] == :tree }
end