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

additions() click to toggle source

Returns the number of additions in the patch.

# File lib/rugged/patch.rb, line 22
def additions
  stat[0]
end
bytesize(options = {}) → int click to toggle source

The following options can be passed in the options Hash:

:exclude_context

Boolean value specifying that context lines should be excluded when counting the number of bytes in the patch.

:exclude_hunk_headers

Boolean value specifying that hunk headers should be excluded when counting the number of bytes in the patch.

:exclude_file_headers

Boolean value specifying that file headers should be excluded when counting the number of bytes in the patch.

Returns the number of bytes in the patch, depending on which options are specified.

static VALUE rb_git_diff_patch_bytesize(int argc, VALUE *argv, VALUE self)
{
        git_patch *patch;
        size_t bytesize;
        VALUE rb_options;
        int include_context, include_hunk_headers, include_file_headers;
        Data_Get_Struct(self, git_patch, patch);

        include_context = include_hunk_headers = include_file_headers = 1;

        rb_scan_args(argc, argv, "0:", &rb_options);
        if (!NIL_P(rb_options)) {
                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_context")))) {
                        include_context = 0;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_hunk_headers")))) {
                        include_hunk_headers = 0;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_file_headers")))) {
                        include_file_headers = 0;
                }
        }

        bytesize = git_patch_size(patch, include_context, include_hunk_headers, include_file_headers);

        return INT2FIX(bytesize);
}
changes() click to toggle source

Returns the number of total changes in the patch.

# File lib/rugged/patch.rb, line 32
def changes
  additions + deletions
end
Alias for: hunk_count
deletions() click to toggle source

Returns the number of deletions in the patch.

# File lib/rugged/patch.rb, line 27
def deletions
  stat[1]
end
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));
}
Alias for: each_hunk

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;

        RETURN_ENUMERATOR(self, 0, 0);
        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
header → str click to toggle source

Returns only the header of the patch as a string.

static VALUE rb_git_diff_patch_header(VALUE self)
{
        git_patch *patch;
        int error = 0;
        VALUE rb_buffer = rb_ary_new();
        Data_Get_Struct(self, git_patch, patch);

        error = git_patch_print(patch, patch_print_header_cb, (void*)rb_buffer);
        if (error && error != GIT_ITEROVER)
                rugged_exception_check(error);

        return rb_ary_join(rb_buffer, Qnil);
}
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 37
def hunks
  each_hunk.to_a
end
inspect() click to toggle source
# File lib/rugged/patch.rb, line 17
def inspect
  "#<#{self.class.name}:#{object_id}>"
end
lines(options = {}) → int click to toggle source

The following options can be passed in the options Hash:

:exclude_context

Boolean value specifying that context line counts should be excluded from the returned total.

:exclude_additions

Boolean value specifying that addition line counts should be excluded from the returned total.

:exclude_deletions

Boolean value specifying that deletion line counts should be excluded from the returned total.

:exclude_eofnl

Boolean value specifying that end-of-file newline change lines should be excluded from the returned total.

Returns the total number of lines in the patch, depending on the options specified.

static VALUE rb_git_diff_patch_lines(int argc, VALUE *argv, VALUE self)
{
        git_patch *patch;
        size_t lines = 0;
        int options = 0;
        VALUE rb_options;
        Data_Get_Struct(self, git_patch, patch);

        rb_scan_args(argc, argv, "0:", &rb_options);
        if (!NIL_P(rb_options)) {
                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_context")))) {
                        options |= EXCLUDE_CONTEXT;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_additions")))) {
                        options |= EXCLUDE_ADDITIONS;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_deletions")))) {
                        options |= EXCLUDE_DELETIONS;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_eofnl")))) {
                        options |= EXCLUDE_EOFNL;
                }
        }

        if (options == 0) {
                size_t i = 0, hunks_count = git_patch_num_hunks(patch);
                for (i = 0; i < hunks_count; ++i) {
                        lines += git_patch_num_lines_in_hunk(patch, i);
                }
        } else {
                size_t i = 0, hunks_count = git_patch_num_hunks(patch);
                for (i = 0; i < hunks_count; ++i) {
                        size_t lines_in_hunk = git_patch_num_lines_in_hunk(patch, i), l = 0;

                        for (l = 0; l < lines_in_hunk; ++l) {
                                const git_diff_line *line;
                                rugged_exception_check(
                                        git_patch_get_line_in_hunk(&line, patch, i, l)
                                );

                                switch (line->origin) {
                                case GIT_DIFF_LINE_CONTEXT:
                                        if (options & EXCLUDE_CONTEXT) continue;
                                        break;

                                case GIT_DIFF_LINE_ADDITION:
                                        if (options & EXCLUDE_ADDITIONS) continue;
                                        break;

                                case GIT_DIFF_LINE_DELETION:
                                        if (options & EXCLUDE_DELETIONS) continue;
                                        break;

                                case GIT_DIFF_LINE_ADD_EOFNL:
                                case GIT_DIFF_LINE_DEL_EOFNL:
                                        if (options & EXCLUDE_EOFNL) continue;
                                        break;
                                }

                                lines += 1;
                        }
                }
        }

        return INT2FIX(lines);
}
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_buffer = rb_ary_new();
        Data_Get_Struct(self, git_patch, patch);

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

        return rb_ary_join(rb_buffer, Qnil);
}