class Rugged::Diff
Attributes
Public Instance Methods
Source
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; }
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.
Source
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; }
Source
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; }
If given a block, yields each patch that is part of the diff. If no block is given, an enumerator will be returned.
Source
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; }
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 thediff.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.
Source
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; }
Merges all diff information from other_diff
.
Source
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; }
Return a string containing the diff in patch form.
Source
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)); }
Returns the number of deltas/patches in this diff.
Source
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; }
Returns true when deltas are sorted case insensitively.
Source
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)); }
Returns the number of files/additions/deletions in this diff.
Source
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; }
Write a patch directly to an object which responds to “write”.