Module: Rugged

Defined in:
lib/rugged/tag.rb,
lib/rugged/diff.rb,
lib/rugged/tree.rb,
lib/rugged/index.rb,
lib/rugged/branch.rb,
lib/rugged/commit.rb,
lib/rugged/object.rb,
lib/rugged/remote.rb,
lib/rugged/walker.rb,
lib/rugged/version.rb,
lib/rugged/diff/hunk.rb,
lib/rugged/diff/line.rb,
lib/rugged/reference.rb,
lib/rugged/diff/delta.rb,
lib/rugged/diff/patch.rb,
lib/rugged/repository.rb,
ext/rugged/rugged.c

Defined Under Namespace

Classes: Blob, Branch, Commit, Config, Diff, Error, Index, Object, OdbObject, Reference, Remote, Repository, Settings, Tag, Tree, Walker

Constant Summary collapse

Version = 
VERSION = '0.19.0'
SORT_NONE =

Constants

INT2FIX(0)
SORT_TOPO = 
INT2FIX(1)
SORT_DATE = 
INT2FIX(2)
SORT_REVERSE = 
INT2FIX(4)

Class Method Summary collapse

Class Method Details

.__cache_usage__ ⇒ Array

Returns an array representing the current bytes in the internal libgit2 cache and the maximum size of the cache.

Returns:

  • (Array) 


310
311
312
313
314
315
 
# File 'ext/rugged/rugged.c', line 310

static VALUE rb_git_cache_usage(VALUE self)
{
	int64_t used, max;
	git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, &used, &max);
	return rb_ary_new3(2, LL2NUM(used), LL2NUM(max));
}

.capabilities ⇒ Object

Returns an array representing the ‘capabilities’ that libgit2 was compiled with — this includes GIT_CAP_THREADS (thread support) and GIT_CAP_HTTPS (https). This is implemented in libgit2 with simple bitwise ops; we offer Rubyland an array of symbols representing the capabilities.

The possible capabilities are “threads” and “https”.

Rugged.capabilities #=> [:threads, :https]



95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'ext/rugged/rugged.c', line 95

static VALUE rb_git_capabilities(VALUE self)
{
	VALUE ret_arr = rb_ary_new();

	int caps = git_libgit2_capabilities();

	if (caps & GIT_CAP_THREADS)
		rb_ary_push(ret_arr, CSTR2SYM("threads"));

	if (caps & GIT_CAP_HTTPS)
		rb_ary_push(ret_arr, CSTR2SYM("https"));

	return ret_arr;
}

.hex_to_raw(oid) ⇒ Object

Turn a string of 40 hexadecimal characters into the buffer of 20 bytes it represents.

Rugged.hex_to_raw('d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f')
#=> "\330xk\374\227H^\215{\031\262\037\270\214\216\361\361\231\374?"



120
121
122
123
124
125
126
127
128
 
# File 'ext/rugged/rugged.c', line 120

static VALUE rb_git_hex_to_raw(VALUE self, VALUE hex)
{
	git_oid oid;

	Check_Type(hex, T_STRING);
	rugged_exception_check(git_oid_fromstr(&oid, StringValueCStr(hex)));

	return rb_str_new((const char *)oid.id, 20);
}

.libgit2_version ⇒ Object

Returns an array representing the current libgit2 version in use. Using the array makes it easier for the end-user to take conditional actions based on each respective version attribute: major, minor, rev.

Rugged.libgit2_version #=> [0, 17, 0]



70
71
72
73
74
75
76
77
78
79
80
 
# File 'ext/rugged/rugged.c', line 70

static VALUE rb_git_libgit2_version(VALUE self)
{
	int major;
	int minor;
	int rev;

	git_libgit2_version(&major, &minor, &rev);

	// We return an array of three elements to represent the version components
	return rb_ary_new3(3, INT2NUM(major), INT2NUM(minor), INT2NUM(rev));
}

.minimize_oid(oid_iterator, min_length = 7) {|short_oid| ... } ⇒ Object .minimize_oid(oid_iterator, min_length = 7) ⇒ Object

Iterate through oid_iterator, which should yield any number of SHA1 OIDs (represented as 40-character hexadecimal strings), and tries to minify them.

Minifying a set of a SHA1 strings means finding the shortest root substring for each string that uniquely identifies it.

If no block is given, the function will return the minimal length as an integer value:

oids = [
  'd8786bfc974aaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
  'd8786bfc974bbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
  'd8786bfc974ccccccccccccccccccccccccccccc',
  '68d041ee999cb07c6496fbdd4f384095de6ca9e1',
]

Rugged.minimize_oids(oids) #=> 12

If a block is given, it will be called with each OID from iterator in its minified form:

Rugged.minimize_oid(oids) { |oid| puts oid }

produces:

d8786bfc974a
d8786bfc974b
d8786bfc974c
68d041ee999c

The optional min_length argument allows you to specify a lower bound for the minified strings; returned strings won’t be shorter than the given value, even if they would still be uniquely represented.

Rugged.minimize_oid(oids, 18) #=> 18

Overloads:

  • .minimize_oid(oid_iterator, min_length = 7) {|short_oid| ... } ⇒ Object

    Yields:

    • (short_oid) 


239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
 
# File 'ext/rugged/rugged.c', line 239

static VALUE rb_git_minimize_oid(int argc, VALUE *argv, VALUE self)
{
	git_oid_shorten *shrt;
	int length, minlen = 7;
	VALUE rb_enum, rb_minlen, rb_block;

	rb_scan_args(argc, argv, "11&", &rb_enum, &rb_minlen, &rb_block);

	if (!NIL_P(rb_minlen)) {
		Check_Type(rb_minlen, T_FIXNUM);
		minlen = FIX2INT(rb_minlen);
	}

	if (!rb_respond_to(rb_enum, rb_intern("each")))
		rb_raise(rb_eTypeError, "Expecting an Enumerable instance");

	shrt = git_oid_shorten_new(minlen);

	rb_iterate(rb_each, rb_enum, &minimize_cb, (VALUE)shrt);
	length = git_oid_shorten_add(shrt, NULL);

	git_oid_shorten_free(shrt);
	rugged_exception_check(length);

	if (!NIL_P(rb_block)) {
		VALUE yield_data[2];

		yield_data[0] = rb_block;
		yield_data[1] = INT2FIX(length);

		rb_iterate(rb_each, rb_enum, &minimize_yield, (VALUE)yield_data);
		return Qnil;
	}

	return INT2FIX(length);
}

.prettify_message(message, strip_comments) ⇒ Object

Process a commit or tag message into standard form, by stripping trailing spaces and comments, and making sure that the message has a proper header line.



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'ext/rugged/rugged.c', line 163

static VALUE rb_git_prettify_message(VALUE self, VALUE rb_message, VALUE rb_strip_comments)
{
	char *message;
	int strip_comments, message_len;
	VALUE result;

	Check_Type(rb_message, T_STRING);
	strip_comments = rugged_parse_bool(rb_strip_comments);

	message_len = (int)RSTRING_LEN(rb_message) + 2;
	message = xmalloc(message_len);

	message_len = git_message_prettify(message, message_len, StringValueCStr(rb_message), strip_comments);
	rugged_exception_check(message_len);

	result = rb_enc_str_new(message, message_len - 1, rb_utf8_encoding());
	xfree(message);

	return result;
}

.raw_to_hex(buffer) ⇒ Object

Turn a buffer of 20 bytes (representing a SHA1 OID) into its readable hexadecimal representation.

Rugged.raw_to_hex("\330xk\374\227H^\215{\031\262\037\270\214\216\361\361\231\374?")
#=> "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f"



140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'ext/rugged/rugged.c', line 140

static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
{
	git_oid oid;
	char out[40];

	Check_Type(raw, T_STRING);

	if (RSTRING_LEN(raw) != GIT_OID_RAWSZ)
		rb_raise(rb_eTypeError, "Invalid buffer size for an OID");

	git_oid_fromraw(&oid, (const unsigned char *)RSTRING_PTR(raw));
	git_oid_fmt(out, &oid);

	return rb_str_new(out, 40);
}