Module: Rugged

Defined in:
lib/rugged/tag.rb,
lib/rugged/diff.rb,
lib/rugged/tree.rb,
lib/rugged/index.rb,
lib/rugged/patch.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/repository.rb,
lib/rugged/credentials.rb,
ext/rugged/rugged.c

Defined Under Namespace

Modules: Credentials Classes: Blame, Blob, Branch, BranchCollection, Commit, Config, Diff, Error, Index, Object, OdbObject, Patch, Reference, ReferenceCollection, Remote, RemoteCollection, Repository, Settings, Tag, TagCollection, Tree, Walker

Constant Summary collapse

Version =
VERSION = '0.21.4'
SORT_NONE =

Sort the repository contents in no particular ordering; this sorting is arbitrary, implementation-specific and subject to change at any time. This is the default sorting for new walkers.

INT2FIX(GIT_SORT_NONE)
SORT_TOPO =

Sort the repository contents in topological order (parents before children); this sorting mode can be combined with time sorting.

INT2FIX(GIT_SORT_TOPOLOGICAL)
SORT_DATE =

Sort the repository contents by commit time; this sorting mode can be combined with topological sorting.

INT2FIX(GIT_SORT_TIME)
SORT_REVERSE =

Iterate through the repository contents in reverse order; this sorting mode can be combined with any of the above.

INT2FIX(GIT_SORT_REVERSE)

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.


352
353
354
355
356
357
# File 'ext/rugged/rugged.c', line 352

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));
}

.featuresArray

Returns an array representing the features that libgit2 was compiled with — this includes `:threads` (thread support), `:https` and `:ssh`.

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

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

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

  int caps = git_libgit2_features();

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

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

  if (caps & GIT_FEATURE_SSH)
    rb_ary_push(ret_arr, CSTR2SYM("ssh"));

  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?"

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

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_versionObject

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]

73
74
75
76
77
78
79
80
81
82
83
# File 'ext/rugged/rugged.c', line 73

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)

262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
# File 'ext/rugged/rugged.c', line 262

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.


165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
# File 'ext/rugged/rugged.c', line 165

static VALUE rb_git_prettify_message(int argc, VALUE *argv, VALUE self)
{
  char comment_char = '#';
  int strip_comments = 1;

  git_buf message = { NULL };
  VALUE rb_message, rb_strip;
  int error;
  VALUE result = Qnil;

  rb_scan_args(argc, argv, "11", &rb_message, &rb_strip);

  Check_Type(rb_message, T_STRING);
  
  switch (TYPE(rb_strip)) {
  case T_FALSE:
    strip_comments = 0;
    break;

  case T_STRING:
    if (RSTRING_LEN(rb_strip) > 0)
      comment_char = RSTRING_PTR(rb_strip)[0];
    break;

  case T_TRUE:
  case T_NIL:
  default:
    break;
  }

  error = git_message_prettify(&message,
        StringValueCStr(rb_message), strip_comments, comment_char);

  if (!error)
    result = rb_enc_str_new(message.ptr, message.size, rb_utf8_encoding());

  git_buf_free(&message);
  rugged_exception_check(error);

  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"

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

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);
}