class Rugged::Patch

Attributes

diff[RW]

owner[RW]

Public Class Methods

from_strings(old_content = nil, new_content = nil, options = {}) → patch click to toggle source

Directly generate a Rugged::Patch from the difference between the content of the two strings `old_content` and `new_content`.

The following options can be passed in the options Hash:

:old_path: An optional string to treat blob as if it had this filename.
:new_path: An optional string to treat other as if it had this filename.

Additionally, `options` can also contain all other valid diff options (see Rugged::Tree#diff for a complete list).

VALUE rb_git_patch_from_strings(int argc, VALUE *argv, VALUE self)
{
        git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
        git_patch *patch;
        char * old_path = NULL, * new_path = NULL;
        VALUE rb_old_buffer, rb_new_buffer, rb_options;

        rb_scan_args(argc, argv, "02:", &rb_old_buffer, &rb_new_buffer, &rb_options);

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

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("old_path"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_STRING);
                        old_path = StringValueCStr(rb_value);
                }

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("new_path"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_STRING);
                        new_path = StringValueCStr(rb_value);
                }

                rugged_parse_diff_options(&opts, rb_options);
        }

        rugged_exception_check(git_patch_from_buffers(&patch,
                NIL_P(rb_old_buffer) ? NULL : StringValuePtr(rb_old_buffer),
                NIL_P(rb_old_buffer) ? 0 : RSTRING_LEN(rb_old_buffer),
                old_path,
                NIL_P(rb_new_buffer) ? NULL : StringValuePtr(rb_new_buffer),
                NIL_P(rb_new_buffer) ? 0 : RSTRING_LEN(rb_new_buffer),
                new_path,
                &opts
        ));

        return rugged_patch_new(self, patch);
}

Public Instance Methods

changes() click to toggle source

Returns the number of changes in the patch.

# File lib/rugged/patch.rb, line 17
def changes
  stat.reduce { |t,v| t + v }
end

count()

Alias for: hunk_count

delta → delta click to toggle source

Returns the delta object associated with the patch.

static VALUE rb_git_diff_patch_delta(VALUE self)
{
        git_patch *patch;
        Data_Get_Struct(self, git_patch, patch);

        return rugged_diff_delta_new(rugged_owner(self), git_patch_get_delta(patch));
}

each()

Alias for: each_hunk

each_hunk { |hunk| } → self click to toggle source

each_hunk → enumerator

If given a block, yields each hunk that is part of the patch.

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

static VALUE rb_git_diff_patch_each_hunk(VALUE self)
{
        git_patch *patch;
        const git_diff_hunk *hunk;
        size_t lines_in_hunk;
        int error = 0;
        size_t hunks_count, h;

        if (!rb_block_given_p()) {
                return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each_hunk"), self);
        }

        Data_Get_Struct(self, git_patch, patch);

        hunks_count = git_patch_num_hunks(patch);
        for (h = 0; h < hunks_count; ++h) {
                error = git_patch_get_hunk(&hunk, &lines_in_hunk, patch, h);
                if (error) break;

                rb_yield(rugged_diff_hunk_new(self, h, hunk, lines_in_hunk));
        }
        rugged_exception_check(error);

        return self;
}

Also aliased as: each

hunk_count → int click to toggle source

Returns the number of hunks in the patch.

static VALUE rb_git_diff_patch_hunk_count(VALUE self)
{
        git_patch *patch;
        Data_Get_Struct(self, git_patch, patch);

        return INT2FIX(git_patch_num_hunks(patch));
}

Also aliased as: size, count

hunks() click to toggle source

Returns an Array containing all hunks of the patch.

# File lib/rugged/patch.rb, line 22
def hunks
  each_hunk.to_a
end

inspect() click to toggle source

# File lib/rugged/patch.rb, line 12
def inspect
  "#<#{self.class.name}:#{object_id}>"
end

lines → int click to toggle source

Returns the total number of lines in the patch.

static VALUE rb_git_diff_patch_lines(VALUE self)
{
        git_patch *patch;
        size_t context, adds, dels;
        Data_Get_Struct(self, git_patch, patch);

        git_patch_line_stats(&context, &adds, &dels, patch);

        return INT2FIX(context + adds + dels);
}

size()

Alias for: hunk_count

stat → int, int click to toggle source

Returns the number of additions and deletions in the patch.

static VALUE rb_git_diff_patch_stat(VALUE self)
{
        git_patch *patch;
        size_t additions, deletions;
        Data_Get_Struct(self, git_patch, patch);

        git_patch_line_stats(NULL, &additions, &deletions, patch);

        return rb_ary_new3(2, INT2FIX(additions), INT2FIX(deletions));
}

to_s → str click to toggle source

Returns the contents of the patch as a single diff string.

static VALUE rb_git_diff_patch_to_s(VALUE self)
{
        git_patch *patch;
        VALUE rb_str = rb_str_new(NULL, 0);
        Data_Get_Struct(self, git_patch, patch);

        rugged_exception_check(git_patch_print(patch, patch_print_cb, (void*)rb_str));

        return rb_str;
}