class Rugged::Diff
Attributes
Public Instance Methods
# File lib/rugged/diff.rb, line 21 def deltas each_delta.to_a end
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; }
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; }
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.
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; }
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; }
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; }
# File lib/rugged/diff.rb, line 17 def patches each_patch.to_a end
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)); }
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; }
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 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; }