class Rugged::Tree::Builder

Public Class Methods

Source

static VALUE rb_git_treebuilder_new(int argc, VALUE *argv, VALUE klass)
{
        git_treebuilder *builder;
        git_repository *repo;
        git_tree *tree = NULL;
        VALUE rb_object, rb_builder, rb_repo;
        int error;

        if (rb_scan_args(argc, argv, "11", &rb_repo, &rb_object) == 2) {
                if (!rb_obj_is_kind_of(rb_object, rb_cRuggedTree))
                        rb_raise(rb_eTypeError, "A Rugged::Tree instance is required");

                TypedData_Get_Struct(rb_object, git_tree, &rugged_object_type, tree);
        }

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

        error = git_treebuilder_new(&builder, repo, tree);
        rugged_exception_check(error);

        rb_builder = Data_Wrap_Struct(klass, NULL, &rb_git_treebuilder_free, builder);
        rugged_set_owner(rb_builder, rb_repo);

        return rb_builder;
}

Create a new Rugged::Tree::Builder instance to write a tree to the given repository.

If an optional tree is given, the returned Tree::Builder will be initialized with the entry of tree. Otherwise, the Tree::Builder will be empty and has to be filled manually.

Public Instance Methods

builder << entry → nil

Inser a new entry into builder.

Alias for: insert

builder[path] → entry

Source

static VALUE rb_git_treebuilder_get(VALUE self, VALUE path)
{
        git_treebuilder *builder;
        Data_Get_Struct(self, git_treebuilder, builder);

        Check_Type(path, T_STRING);

        return rb_git_treeentry_fromC(git_treebuilder_get(builder, StringValueCStr(path)));
}

Return an entry from builder based on its relative path.

clear → nil

Source

static VALUE rb_git_treebuilder_clear(VALUE self)
{
        git_treebuilder *builder;
        Data_Get_Struct(self, git_treebuilder, builder);
        git_treebuilder_clear(builder);
        return Qnil;
}

Clear all entries in builder.

insert(entry) → nil

Source

static VALUE rb_git_treebuilder_insert(VALUE self, VALUE rb_entry)
{
        git_treebuilder *builder;
        VALUE rb_path, rb_oid, rb_attr;
        git_oid oid;
        int error;

        Data_Get_Struct(self, git_treebuilder, builder);
        Check_Type(rb_entry, T_HASH);

        rb_path = rb_hash_aref(rb_entry, CSTR2SYM("name"));
        Check_Type(rb_path, T_STRING);

        rb_oid = rb_hash_aref(rb_entry, CSTR2SYM("oid"));
        Check_Type(rb_oid, T_STRING);
        rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(rb_oid)));

        rb_attr = rb_hash_aref(rb_entry, CSTR2SYM("filemode"));
        Check_Type(rb_attr, T_FIXNUM);

        error = git_treebuilder_insert(NULL,
                builder,
                StringValueCStr(rb_path),
                &oid,
                FIX2INT(rb_attr));

        rugged_exception_check(error);
        return Qnil;
}

Inser a new entry into builder.

Also aliased as: <<

reject! { |entry| block } → nil

Source

static VALUE rb_git_treebuilder_filter(VALUE self)
{
        git_treebuilder *builder;

        rb_need_block();
        Data_Get_Struct(self, git_treebuilder, builder);

        git_treebuilder_filter(builder, &treebuilder_cb, (void *)rb_block_proc());
        return Qnil;
}

Deletes every tree entry from builder for which the given block evaluates to true.

remove(path) → true or false

Source

static VALUE rb_git_treebuilder_remove(VALUE self, VALUE path)
{
        git_treebuilder *builder;
        int error;

        Data_Get_Struct(self, git_treebuilder, builder);
        Check_Type(path, T_STRING);

        error = git_treebuilder_remove(builder, StringValueCStr(path));
        if (error == GIT_ENOTFOUND) {
                return Qfalse;
        } else if (error == GIT_ERROR && giterr_last()->klass == GITERR_TREE) {
                return Qfalse;
        }

        rugged_exception_check(error);
        return Qtrue;
}

Remove an entry from builder by its relative path.

Returns true if the entry was successfully removed, or false if the entry was not found.

write → oid

Source

static VALUE rb_git_treebuilder_write(VALUE self)
{
        git_treebuilder *builder;
        git_oid written_id;
        int error;

        Data_Get_Struct(self, git_treebuilder, builder);

        error = git_treebuilder_write(&written_id, builder);
        rugged_exception_check(error);

        return rugged_create_oid(&written_id);
}

Write builder‘s content as a tree to the repository that owns the builder and return the oid for the newly created tree.