class Rugged::Blob

Public Class Methods

Source

static VALUE rb_git_blob_from_buffer(VALUE self, VALUE rb_repo, VALUE rb_buffer)
{
        int error;
        git_oid oid;
        git_repository *repo;

        Check_Type(rb_buffer, T_STRING);
        rugged_check_repo(rb_repo);

        Data_Get_Struct(rb_repo, git_repository, repo);

        error = git_blob_create_frombuffer(&oid, repo, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}

Write a blob to repository with the contents specified in buffer, where buffer is a String. The encoding of buffer is ignored and bytes are copied as-is.

from_disk(repository, file_path) → oid

Source

static VALUE rb_git_blob_from_disk(VALUE self, VALUE rb_repo, VALUE rb_path)
{
        int error;
        git_oid oid;
        git_repository *repo;

        FilePathValue(rb_path);
        rugged_check_repo(rb_repo);

        Data_Get_Struct(rb_repo, git_repository, repo);

        error = git_blob_create_fromdisk(&oid, repo, StringValueCStr(rb_path));
        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}

Write the file specified in file_path to a blob in repository. The repository can be bare or not.

Example:

Blob.from_disk(repo, '/var/repos/blob.h') #=> '5b5b025afb0b4c913b4c338a42934a3863bf3643'

from_io(repository, io [, hint_path]) → oid

Source

static VALUE rb_git_blob_from_io(int argc, VALUE *argv, VALUE klass)
{
        VALUE rb_repo, rb_io, rb_hint_path, rb_buffer, rb_read_args[2];
        const char * hint_path = NULL;
        git_writestream *stream;
        int error = 0, exception = 0, max_length = 4096;
        git_oid oid;
        git_repository *repo;

        rb_scan_args(argc, argv, "21", &rb_repo, &rb_io, &rb_hint_path);

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        if (!NIL_P(rb_hint_path)) {
                FilePathValue(rb_hint_path);
                hint_path = StringValueCStr(rb_hint_path);
        }

        error = git_blob_create_fromstream(&stream, repo, hint_path);
        if (error)
                goto cleanup;

        rb_read_args[0] = rb_io;
        rb_read_args[1] = INT2FIX(max_length);

        do {
                rb_buffer = rb_protect(rb_read_check, (VALUE)rb_read_args, &exception);

                if (exception)
                        goto cleanup;

                if (NIL_P(rb_buffer))
                        break;

                error = stream->write(stream, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
                if (error)
                        goto cleanup;
        } while (RSTRING_LEN(rb_buffer) == max_length);

        error = git_blob_create_fromstream_commit(&oid, stream);

cleanup:

        if (exception)
                rb_jump_tag(exception);

        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}

Write a loose blob to the repository from an IO provider of data.

The repository can be bare or not.

The data provider io should respond to a read(size) method. Generally any instance of a class based on Ruby’s IO class should work(ex. File). On each read call it should return a String with maximum size of size.

NOTE: If an exception is raised in the io object’s read method, no blob will be created.

Provided the hint_path parameter is given, its value will help to determine what git filters should be applied to the object before it can be placed to the object database.

File.open('/path/to/file') do |file|
  Blob.from_io(repo, file, 'hint/blob.h') #=> '42cab3c0cde61e2b5a2392e1eadbeffa20ffa171'
end

from_workdir(repository, file_path) → oid

Source

static VALUE rb_git_blob_from_workdir(VALUE self, VALUE rb_repo, VALUE rb_path)
{
        int error;
        git_oid oid;
        git_repository *repo;

        FilePathValue(rb_path);
        rugged_check_repo(rb_repo);

        Data_Get_Struct(rb_repo, git_repository, repo);

        error = git_blob_create_fromworkdir(&oid, repo, StringValueCStr(rb_path));
        rugged_exception_check(error);

        return rugged_create_oid(&oid);
}

Write the file specified in file_path to a blob in repository. file_path must be relative to the repository’s working folder. The repository cannot be bare.

Blob.from_workdir(repo, 'src/blob.h') #=> '9d09060c850defbc7711d08b57def0d14e742f4e'

merge_files (p1, p2, p3, p4, p5 = v5)

Source

static VALUE rb_git_blob_merge_files(int argc, VALUE *argv, VALUE klass)
{
        VALUE rb_repo, rb_ancestor, rb_ours, rb_theirs, rb_options, rb_result = Qnil;

        git_repository *repo = NULL;
        rugged_merge_file_input ancestor = RUGGED_MERGE_FILE_INPUT_INIT,
                ours = RUGGED_MERGE_FILE_INPUT_INIT,
                theirs = RUGGED_MERGE_FILE_INPUT_INIT;
        git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
        git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
        git_merge_file_result result = {0};
        int error;

        rb_scan_args(argc, argv, "41", &rb_repo, &rb_ancestor, &rb_ours, &rb_theirs, &rb_options);

        if (!NIL_P(rb_repo)) {
                rugged_check_repo(rb_repo);
                Data_Get_Struct(rb_repo, git_repository, repo);
        }

        if (!NIL_P(rb_options))
                rugged_parse_merge_file_options(&opts, rb_options);

        if (!NIL_P(rb_ancestor))
                rugged_parse_merge_file_input(&ancestor, repo, rb_ancestor);
        if (!NIL_P(rb_ours))
                rugged_parse_merge_file_input(&ours, repo, rb_ours);
        if (!NIL_P(rb_theirs))
                rugged_parse_merge_file_input(&theirs, repo, rb_theirs);

        if ((error = rugged_load_merge_file_input(&ancestor_blob, repo, &ancestor)) < 0 ||
                (error = rugged_load_merge_file_input(&our_blob, repo, &ours)) < 0 ||
                (error = rugged_load_merge_file_input(&their_blob, repo, &theirs)) < 0 ||
                (error = git_merge_file(&result, &ancestor.parent, &ours.parent, &theirs.parent, &opts)) < 0)
                goto done;

        rb_result = rb_merge_file_result_fromC(&result);

done:
        git_blob_free(ancestor_blob);
        git_blob_free(our_blob);
        git_blob_free(their_blob);
        git_merge_file_result_free(&result);

        rugged_exception_check(error);
        return rb_result;
}

to_buffer (p1, p2, p3 = v3)

Source

static VALUE rb_git_blob_to_buffer(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_repo, rb_sha1, rb_max_bytes;
        VALUE rb_ret;

        git_repository *repo = NULL;
        git_blob *blob = NULL;

        size_t size;
        const char *content;

        rb_scan_args(argc, argv, "21", &rb_repo, &rb_sha1, &rb_max_bytes);

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        blob = (git_blob *)rugged_object_get(repo, rb_sha1, GIT_OBJ_BLOB);

        content = git_blob_rawcontent(blob);
        size = git_blob_rawsize(blob);

        if (!NIL_P(rb_max_bytes)) {
                int maxbytes;

                Check_Type(rb_max_bytes, T_FIXNUM);
                maxbytes = FIX2INT(rb_max_bytes);

                if (maxbytes >= 0 && (size_t)maxbytes < size)
                        size = (size_t)maxbytes;
        }

        rb_ret = rb_ary_new();

        rb_ary_push(rb_ret, rb_str_new(content, size));
        rb_ary_push(rb_ret, INT2FIX(git_blob_rawsize(blob)));

        git_object_free((git_object*)blob);

        /* TODO: LOC */

        return rb_ret;
}

Public Instance Methods

binary? → true or false

Source

static VALUE rb_git_blob_is_binary(VALUE self)
{
        git_blob *blob;
        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);
        return git_blob_is_binary(blob) ? Qtrue : Qfalse;
}

Determine if the blob content is most certainly binary or not.

The heuristic used to guess if a file is binary is taken from core git: Searching for NUL bytes and looking for a reasonable ratio of printable to non-printable characters among the first 4000 bytes.

content(max_bytes=-1) → string

Source

static VALUE rb_git_blob_content_GET(int argc, VALUE *argv, VALUE self)
{
        git_blob *blob;
        size_t size;
        const char *content;
        VALUE rb_max_bytes;

        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);
        rb_scan_args(argc, argv, "01", &rb_max_bytes);

        content = git_blob_rawcontent(blob);
        size = git_blob_rawsize(blob);

        if (!NIL_P(rb_max_bytes)) {
                int maxbytes;

                Check_Type(rb_max_bytes, T_FIXNUM);
                maxbytes = FIX2INT(rb_max_bytes);

                if (maxbytes >= 0 && (size_t)maxbytes < size)
                        size = (size_t)maxbytes;
        }

        /*
         * since we don't really ever know the encoding of a blob
         * lets default to the binary encoding (ascii-8bit)
         */
        return rb_str_new(content, size);
}

Return up to max_bytes from the contents of a blob as bytes String. If max_bytes is less than 0, the full string is returned.

This string is tagged with the ASCII-8BIT encoding: the bytes are returned as-is, since Git is encoding agnostic.

diff(other, options = {}) → patch

Source

static VALUE rb_git_blob_diff(int argc, VALUE *argv, VALUE self)
{
        git_blob *blob;
        git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
        git_patch *patch;
        const char *old_path = NULL, *new_path = NULL;
        VALUE rb_other, rb_options;
        int error;

        rb_scan_args(argc, argv, "10:", &rb_other, &rb_options);
        if (!NIL_P(rb_options)) {
                VALUE rb_value;

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("old_path"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_STRING);
                        old_path = StringValueCStr(rb_value);
                }

                rb_value = rb_hash_aref(rb_options, CSTR2SYM("new_path"));
                if (!NIL_P(rb_value)) {
                        Check_Type(rb_value, T_STRING);
                        new_path = StringValueCStr(rb_value);
                }

                rugged_parse_diff_options(&opts, rb_options);
        }

        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);

        if (NIL_P(rb_other)) {
                error = git_patch_from_blobs(&patch, blob, old_path, NULL, new_path, &opts);
        } else if (rb_obj_is_kind_of(rb_other, rb_cRuggedBlob)) {
                git_blob *other_blob;

                TypedData_Get_Struct(rb_other, git_blob, &rugged_object_type, other_blob);

                error = git_patch_from_blobs(&patch, blob, old_path, other_blob, new_path, &opts);
        } else if (TYPE(rb_other) == T_STRING) {
                const char * buffer = StringValueCStr(rb_other);

                error = git_patch_from_blob_and_buffer(&patch, blob, old_path, buffer, RSTRING_LEN(rb_other), new_path, &opts);
        } else {
                rb_raise(rb_eTypeError, "wrong argument type %s (expected Rugged::Blob, String, or nil)",
                        rb_obj_classname(rb_other));
        }

        rugged_exception_check(error);

        return rugged_patch_new(self, patch);
}

Directly generate a Rugged::Patch from the difference between blob and other.

other can either be another Rugged::Blob instance, a string, or nil (treated as an empty blob).

The following options can be passed in the options Hash:

:max_size: An integer specifying the maximum byte size of a blob before a it will be treated as binary. The default value is 512MB.
:context_lines: The number of unchanged lines that define the boundary of a hunk (and to display before and after the actual changes). The default is 3.
:interhunk_lines: The maximum number of unchanged lines between hunk boundaries before the hunks will be merged into a one. The default is 0.
:reverse: If true, the sides of the diff will be reversed.
:force_text: If true, all files will be treated as text, disabling binary attributes & detection.
:ignore_whitespace: If true, all whitespace will be ignored.
:ignore_whitespace_change: If true, changes in amount of whitespace will be ignored.
:ignore_whitespace_eol: If true, whitespace at end of line will be ignored.
:patience: If true, the “patience diff” algorithm will be used (currently unimplemented).
:skip_binary_check: If true, diff deltas will be generated without spending time on binary detection. This is useful to improve performance in cases where the actual file content difference is not needed.
:old_path: An optional string to treat blob as if it had this filename.
:new_path: An optional string to treat other as if it had this filename.

hashsig (options = 0)

Source

# File lib/rugged/blob.rb, line 14
def hashsig(options = 0)
  @hashsig ||= HashSignature.new(self, options)
end

loc → int

Source

static VALUE rb_git_blob_loc(VALUE self)
{
        git_blob *blob;
        const char *data, *data_end;
        size_t loc = 0;

        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);

        data = git_blob_rawcontent(blob);
        data_end = data + git_blob_rawsize(blob);

        if (data == data_end)
                return INT2FIX(0);

        for (; data < data_end; ++data) {
                if (data[0] == '\n') {
                        loc++;
                }
                else if (data[0] == '\r') {
                        if (data + 1 < data_end && data[1] == '\n')
                                data++;
                        loc++;
                }
        }

        if (data[-1] != '\n' && data[-1] != '\r')
                loc++;

        return INT2FIX(loc);
}

Return the number of lines for this blob, assuming the blob is plaintext (i.e. not binary)

similarity (other)

Source

# File lib/rugged/blob.rb, line 18
def similarity(other)
  other_sig = case other
  when HashSignature
    other
  when String
    HashSignature.new(other)
  when Blob
    other.hashsig
  else
    raise TypeError, "Expected a Rugged::Blob, String or Rugged::Blob::HashSignature"
  end

  HashSignature.compare(self.hashsig, other_sig)
end

rawsize → int

Source

static VALUE rb_git_blob_rawsize(VALUE self)
{
        git_blob *blob;
        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);

        return INT2FIX(git_blob_rawsize(blob));
}

Return the size in bytes of the blob. This is the real, uncompressed size and the length of blob.content, not the compressed size.

sloc → int

Source

static VALUE rb_git_blob_sloc(VALUE self)
{
        git_blob *blob;
        const char *data, *data_end;
        size_t sloc = 0;

        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);

        data = git_blob_rawcontent(blob);
        data_end = data + git_blob_rawsize(blob);

        if (data == data_end)
                return INT2FIX(0);

        /* go through the whole blob, counting lines
         * that are not empty */
        while (data < data_end) {
                if (*data++ == '\n') {
                        while (data < data_end && isspace(*data))
                                data++;

                        sloc++;
                }
        }

        /* last line without trailing '\n'? */
        if (data[-1] != '\n')
                sloc++;

        return INT2FIX(sloc);
}

Return the number of non-empty code lines for the blob, assuming the blob is plaintext (i.e. not binary)

text(max_lines = -1, encoding = Encoding.default_external) → string

Source

static VALUE rb_git_blob_text_GET(int argc, VALUE *argv, VALUE self)
{
        git_blob *blob;
        size_t size;
        const char *content;
        VALUE rb_max_lines, rb_encoding;

        TypedData_Get_Struct(self, git_blob, &rugged_object_type, blob);
        rb_scan_args(argc, argv, "02", &rb_max_lines, &rb_encoding);

        content = git_blob_rawcontent(blob);
        size = git_blob_rawsize(blob);

        if (!NIL_P(rb_max_lines)) {
                size_t i = 0;
                int lines = 0, maxlines;

                Check_Type(rb_max_lines, T_FIXNUM);
                maxlines = FIX2INT(rb_max_lines);

                if (maxlines >= 0) {
                        while (i < size && lines < maxlines) {
                                if (content[i++] == '\n')
                                        lines++;
                        }
                        size = (size_t)i;
                }

        }

        if (!NIL_P(rb_encoding)) {
                return rb_enc_str_new(content, size, rb_to_encoding(rb_encoding));
        }

        return rb_external_str_new(content, size);
}

Return up to max_lines of text from a blob as a String. If max_lines is less than 0, the full string is returned.

The string is created with the given encoding, defaulting to Encoding.default_external.

When limiting the size of the text with max_lines, the string is expected to have an ASCII-compatible encoding, and is checked for the newline \n character.