class Rugged::Diff

Attributes

owner[R]

Public Instance Methods

deltas() click to toggle source
# File lib/rugged/diff.rb, line 21
def deltas
  each_delta.to_a
end
Alias for: each_patch
each_delta { |delta| } → self click to toggle source
each_delta → enumerator

If given a block, yields each delta that is part of the diff. If no block is given, an enumerator will be returned.

This method should be preferred over each_patch if you're not interested in the actual line-by-line changes of the diff.

static VALUE rb_git_diff_each_delta(VALUE self)
{
        git_diff *diff;
        const git_diff_delta *delta;
        size_t d, delta_count;

        RETURN_ENUMERATOR(self, 0, 0);
        Data_Get_Struct(self, git_diff, diff);

        delta_count = git_diff_num_deltas(diff);
        for (d = 0; d < delta_count; ++d) {
                delta = git_diff_get_delta(diff, d);
                rb_yield(rugged_diff_delta_new(self, delta));
        }

        return self;
}
each_line([format = :patch]) { |line| } → self click to toggle source
each_line([format = :patch]) → enumerator
static VALUE rb_git_diff_each_line(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_format;
        git_diff *diff;
        git_diff_format_t format;
        int exception = 0, error;

        RETURN_ENUMERATOR(self, argc, argv);
        Data_Get_Struct(self, git_diff, diff);

        if (rb_scan_args(argc, argv, "01", &rb_format) == 1) {
                Check_Type(rb_format, T_SYMBOL);
        } else {
                rb_format = CSTR2SYM("patch");
        }

        if (SYM2ID(rb_format) == rb_intern("patch")) {
                format = GIT_DIFF_FORMAT_PATCH;
        } else if (SYM2ID(rb_format) == rb_intern("patch_header")) {
                format = GIT_DIFF_FORMAT_PATCH_HEADER;
        } else if (SYM2ID(rb_format) == rb_intern("raw")) {
                format = GIT_DIFF_FORMAT_RAW;
        } else if (SYM2ID(rb_format) == rb_intern("name_only")) {
                format = GIT_DIFF_FORMAT_NAME_ONLY;
        } else if (SYM2ID(rb_format) == rb_intern("name_status")) {
                format = GIT_DIFF_FORMAT_NAME_STATUS;
        } else {
                rb_raise(rb_eArgError, "unknown :format");
        }

        error = git_diff_print(diff, format, each_line_cb, &exception);

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

        return self;
}

If given a block, yields each patch that is part of the diff. If no block is given, an enumerator will be returned.

static VALUE rb_git_diff_each_patch(VALUE self)
{
        git_diff *diff;
        git_patch *patch;
        int error = 0;
        size_t d, delta_count;

        RETURN_ENUMERATOR(self, 0, 0);
        Data_Get_Struct(self, git_diff, diff);

        delta_count = git_diff_num_deltas(diff);
        for (d = 0; d < delta_count; ++d) {
                error = git_patch_from_diff(&patch, diff, d);
                if (error) break;

                rb_yield(rugged_patch_new(self, patch));
        }

        rugged_exception_check(error);

        return self;
}
Also aliased as: each
find_similar!([options]) → self click to toggle source

Detects entries in the diff that look like renames or copies (based on the given options) and replaces them with actual rename or copy entries.

Additionally, modified files can be broken into add/delete pairs if the amount of changes are above a specific threshold (see :break_rewrite_threshold).

By default, similarity will be measured without leading whitespace. You you can use the :dont_ignore_whitespace to disable this.

The following options can be passed in the options Hash:

:rename_threshold

An integer specifying the similarity to consider a file renamed (default 50).

:rename_from_rewrite_threshold

An integer specifying the similarity of modified to be eligible rename source (default 50).

:copy_threshold

An integer specifying the similarity to consider a file a copy (default 50).

:break_rewrite_threshold

An integer specifying the similarity to split modify into delete/add pair (default 60).

:rename_limit

An integer specifying the maximum amount of similarity sources to examine (a la diff's -l option or the diff.renameLimit config) (default 200).

:renames

If true, looking for renames will be enabled (--find-renames).

:renames_from_rewrites

If true, the “old side” of modified files will be considered for renames (+–break-rewrites=N+).

:copies

If true, looking for copies will be enabled (--find-copies).

:copies_from_unmodified

If true, unmodified files will be considered as copy sources (--find-copies-harder).

:break_rewrites

If true, larger rewrites will be split into delete/add pairs (+–break-rewrites=/M+).

:all

If true, enables all finding features.

:ignore_whitespace

If true, similarity will be measured with all whitespace ignored.

:dont_ignore_whitespace

If true, similarity will be measured without ignoring any whitespace.

static VALUE rb_git_diff_find_similar(int argc, VALUE *argv, VALUE self)
{
        git_diff *diff;
        git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
        VALUE rb_options;
        int error;

        Data_Get_Struct(self, git_diff, diff);

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

        if (!NIL_P(rb_options)) {
                VALUE rb_value = rb_hash_aref(rb_options, CSTR2SYM("rename_threshold"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_FIXNUM);
                        opts.rename_threshold = FIX2INT(rb_value);
                }

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("rename_from_rewrite_threshold"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_FIXNUM);
                        opts.rename_from_rewrite_threshold = FIX2INT(rb_value);
                }

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("copy_threshold"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_FIXNUM);
                        opts.copy_threshold = FIX2INT(rb_value);
                }

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("break_rewrite_threshold"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_FIXNUM);
                        opts.break_rewrite_threshold = FIX2INT(rb_value);
                }

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("rename_limit"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_FIXNUM);
                        opts.rename_limit = FIX2INT(rb_value);
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("renames")))) {
                        opts.flags |= GIT_DIFF_FIND_RENAMES;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("renames_from_rewrites")))) {
                        opts.flags |= GIT_DIFF_FIND_RENAMES_FROM_REWRITES;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("copies")))) {
                        opts.flags |= GIT_DIFF_FIND_COPIES;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("copies_from_unmodified")))) {
                        opts.flags |= GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("break_rewrites")))) {
                        opts.flags |= GIT_DIFF_FIND_AND_BREAK_REWRITES;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("all")))) {
                        opts.flags |= GIT_DIFF_FIND_ALL;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("ignore_whitespace")))) {
                        opts.flags |= GIT_DIFF_FIND_IGNORE_WHITESPACE;
                }

                if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("dont_ignore_whitespace")))) {
                        opts.flags |= GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE;
                }
        }

        error = git_diff_find_similar(diff, &opts);
        rugged_exception_check(error);

        return self;
}
merge!(other_diff) → self click to toggle source

Merges all diff information from other_diff.

static VALUE rb_git_diff_merge(VALUE self, VALUE rb_other)
{
        git_diff *diff;
        git_diff *other;
        int error;

        if (!rb_obj_is_kind_of(rb_other, rb_cRuggedDiff))
                rb_raise(rb_eTypeError, "A Rugged::Diff instance is required");

        Data_Get_Struct(self, git_diff, diff);
        Data_Get_Struct(rb_other, git_diff, other);

        error = git_diff_merge(diff, other);
        rugged_exception_check(error);

        return self;
}
patch → patch click to toggle source
patch(:compact => true) → compact_patch

Return a string containing the diff in patch form.

static VALUE rb_git_diff_patch(int argc, VALUE *argv, VALUE self)
{
        git_diff *diff;
        VALUE rb_str = rb_str_new(NULL, 0);
        VALUE rb_opts;

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

        Data_Get_Struct(self, git_diff, diff);

        if (!NIL_P(rb_opts)) {
                if (rb_hash_aref(rb_opts, CSTR2SYM("compact")) == Qtrue)
                        git_diff_print(diff, GIT_DIFF_FORMAT_NAME_STATUS, diff_print_cb, (void*)rb_str);
                else
                        git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, diff_print_cb, (void*)rb_str);
        } else {
                git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, diff_print_cb, (void*)rb_str);
        }

        return rb_str;
}
patches() click to toggle source
# File lib/rugged/diff.rb, line 17
def patches
  each_patch.to_a
end
size → int click to toggle source

Returns the number of deltas/patches in this diff.

static VALUE rb_git_diff_size(VALUE self)
{
        git_diff *diff;

        Data_Get_Struct(self, git_diff, diff);

        return INT2FIX(git_diff_num_deltas(diff));
}
sorted_icase? click to toggle source

Returns true when deltas are sorted case insensitively.

static VALUE rb_git_diff_sorted_icase_p(VALUE self)
{
        git_diff *diff;
        Data_Get_Struct(self, git_diff, diff);
        return git_diff_is_sorted_icase(diff) ? Qtrue : Qfalse;
}
stat → int, int, int click to toggle source

Returns the number of files/additions/deletions in this diff.

static VALUE rb_git_diff_stat(VALUE self)
{
        git_diff *diff;
        struct diff_stats stats = { 0, 0, 0 };

        Data_Get_Struct(self, git_diff, diff);

        git_diff_foreach(
                diff, diff_file_stats_cb, NULL, NULL, diff_line_stats_cb, &stats);

        return rb_ary_new3(
                3, INT2FIX(stats.files), INT2FIX(stats.adds), INT2FIX(stats.dels));
}
write_patch(io) → nil click to toggle source
write_patch(io, :compact => true) → nil

Write a patch directly to an object which responds to “write”.

static VALUE rb_git_diff_write_patch(int argc, VALUE *argv, VALUE self)
{
        git_diff *diff;
        VALUE rb_io, rb_opts;

        rb_scan_args(argc, argv, "10:", &rb_io, &rb_opts);

        if (!rb_respond_to(rb_io, rb_intern("write")))
                rb_raise(rb_eArgError, "Expected io to respond to \"write\"");

        Data_Get_Struct(self, git_diff, diff);

        if (!NIL_P(rb_opts)) {
                if (rb_hash_aref(rb_opts, CSTR2SYM("compact")) == Qtrue)
                        git_diff_print(diff, GIT_DIFF_FORMAT_NAME_STATUS, diff_write_cb, (void*)rb_io);
                else
                        git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, diff_write_cb, (void*)rb_io);
        } else {
                git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, diff_write_cb, (void*)rb_io);
        }

        return Qnil;
}