DOCS.txt

PHP libgit2 bindings API documentation
--------------------------------------------------------------------------------
The API is divided (roughly) by the kind of libgit2 object on which the API
function operates (e.g. git_repository, git_reference, ETC.). In most cases the
PHP API uses resource values for the major libgit2 opaque data types.

Since PHP has native exception handling, most API calls are reworked to return
the main result value and throw an exception on error. For example,
git_repository_new() returns a resource to the repository (originally assigned
to the first by-reference parameter). We also rework the structure of some
library calls due to inherent difficulties porting the C interface to PHP
(e.g. when pointers are used). Sometimes this requires adding API routines not
originally in the libgit2 specification.

Please consult the official libgit2 documentation for descriptions of the
behavior of the functions and their arguments. This section only details the PHP
interface.

--------------------------------------------------------------------------------
API Structure Reference

The following structures are represented as resources in the PHP API. They
generally represent opaque structures from the C API (but not necessarily).

Note that the PHP resource type names (which are really just diagnostic in
purpose) are determined by the C++ compiler via 'typeid'.

    git2 type
    ---------

    git_annotated_commit
    git_blame
    git_blob
    git_branch_iterator
    git_commit
    git_config
    git_config_iterator
    git_credential
    git_describe_result
    git_diff
    git_diff_stats
    git_index
    git_index_conflict_iterator
    git_indexer
    git_note
    git_note_iterator
    git_object
    git_odb
    git_odb_object
    git_packbuilder
    git_patch
    git_rebase
    git_refdb
    git_reference
    git_reference_iterator
    git_reflog
    git_refspec
    git_remote
    git_repository
    git_revwalk
    git_signature
    git_status_list
    git_submodule
    git_tag
    git_tree
    git_tree_entry
    git_treebuilder

The following structures are not represented as resources in the PHP
API. Instead a scalar, array or object type is used:

   git2 type                                      PHP type
   ---------                                      --------

    git_blame_hunk                                 array
    git_buf                                        string
    git_cherrypick_options                         array
    git_config_backend                             \GitConfigBackend
    git_config_entry                               array
    git_describe_format_options                    array
    git_describe_options                           array
    git_diff_binary                                array
    git_diff_binary_file                           array
    git_diff_delta                                 array
    git_diff_file                                  array
    git_diff_format_email_options                  array
    git_diff_hunk                                  array
    git_diff_line                                  array
    git_diff_options                               array
    git_index_entry                                array
    git_merge_file_input                           array
    git_merge_file_options                         array
    git_merge_file_result                          array
    git_merge_options                              array
    git_odb_backend                                \GitODBBackend
    git_odb_stream                                 \GitODBStream
    git_odb_writepack                              \GitODBWritepack
    git_oid                                        string
    git_refdb_backend                              \GitRefDBBackend
    git_reflog_entry                               array
    git_revspec                                    array
    git_status_entry                               array
    git_status_options                             array
    git_writestream                                \GitWritestream

For objects, see the later section regarding Classes.

Enumeration types are treated as integers in PHP userspace. A global constant is
generally defined for enumerator. If an enumerator is missing, then it is
acceptable to define it yourself using "define(...)" or by just using the
correct constant value from the git2 headers.

--------------------------------------------------------------------------------
Error Handling

When an underlying libgit2 function fails with an error code, the extension will
throw an exception of type Git2Exception (see declaration below). The error code
returned is accessible via the $code property on the thrown exception.

Example:

  function render_reference($repo,string $refName) {
    try {
      $oid = git_reference_name_to_id($repo,$refName);
      echo "<p>The OID for <code>$refName</code> is <code>$oid</code></p>";
    } catch (\Git2Exception $ex) {
      if ($ex->getCode() == GIT_ENOTFOUND) {
        echo '<p>Not Found</p>';
      }
      else {
        throw $ex;
      }
    }
  }

Declaration of exception class Git2Exception:
  class Git2Exception extends RuntimeException

--------------------------------------------------------------------------------
Function API Reference

Core API routines operate on opaque, resource values. They try to conform to the
original, C library calls they wrap. Most if not all of these functions have the
prefix "git_".

Functions provided by the extension that are not git2 wrappers have the prefix
'git2_*'. These are provided as supplements or additions where appropriate.

----------------------------------------
[general]
----------------------------------------

int git_libgit2_features()

?string git_libgit2_prerelease()

void git_libgit2_version(int &$major,int &$minor,int &$rev)

string git2_version()

    Gets a string representing both the php-git2 and libgit2 versions.

----------------------------------------
[git_annotated_commit]
----------------------------------------

resource git_annotated_commit_from_fetchhead(resource $repo,string $branch_name,string $remote_url,string $oid)

    Returns git_annotated_commit resource

resource git_annotated_commit_from_ref(resource,resource)

    Returns git_annotated_commit resource

resource git_annotated_commit_from_revspec(resource,string)

    Returns git_annotated_commit resource

resource git_annotated_commit_lookup(resource,string)

    Returns git_annotated_commit resource

string git_annotated_commit_id(resource)

void git_annotated_commit_free(resource)

----------------------------------------
[git_attr]
----------------------------------------

void git_attr_add_macro(resource $repo,string $name,string $values)

void git_attr_cache_flush(resource $repo)

void git_attr_foreach(resource $repo,int $flags,string $path,callable $callback,mixed $payload)

    Callback signature:
        void callback(string $name,?string $value,mixed $payload)

        The function should throw on error.

string git_attr_get(resource $repo,int $flags,string $path,string $name)

int git_attr_value(string $attr)

----------------------------------------
[git_blame]
----------------------------------------

resource git_blame_buffer(resource $reference,string $buffer)

    Parameter $reference is a resource of type git_blame.

    Returns git_blame resource

resource git_blame_file(resource $repo,string $path,?array $options)

    The final parameter $options is an array of options with keys corresponding
    to the git_blame_options struct. It may be null if you want to use the
    defaults.

    Returns git_blame resource

void git_blame_free(resource $blame)

array git_blame_get_hunk_byindex(resource $blame,int $index)

    Note: the return array contains a single dimensional representation of
    the hunk data. Example:

     array(15) {
       ["lines_in_hunk"]
       ["final_commit_id"]
       ["final_start_line_number"]
       ["final_signature.name"]
       ["final_signature.email"]
       ["final_signature.when.time"]
       ["final_signature.when.offset"]
       ["orig_commit_id"]
       ["orig_path"]
       ["orig_start_line_number"]
       ["orig_signature.name"]
       ["orig_signature.email"]
       ["orig_signature.when.time"]
       ["orig_signature.when.offset"]
       ["boundary"]
     }

array git_blame_get_hunk_byline(resource $blame,int $lineno)

    See git_blame_get_hunk_by_index() for an example of what the return
    result looks like.

int git_blame_get_hunk_count(resource $blame)

----------------------------------------
[git_blob]
----------------------------------------

string git_blob_create_frombuffer(resource $repo,string $buffer)

string git_blob_create_fromdisk(resource $repo,string $path)

\GitWritestream git_blob_create_fromstream(resource $repo,?string $hintpath)

string git_blob_create_fromstream_commit(GitWritestream $stream)

string git_blob_create_fromworkdir(resource $repo,string $relative_path)

resource git_blob_dup(resource $blob)

    Returns git_blob resource

string git_blob_filtered_content(resource $blob,string $as_path,bool $check_for_binary_data)

void git_blob_free(resource $blob)

string git_blob_id(resource $blob)

bool git_blob_is_binary(resource $blob)

    Returns bool

resource git_blob_lookup(resource $repo,string $id)

    Returns git_blob resource

resource git_blob_lookup_prefix(resource $repo,string $id)

    Returns resource

resource git_blob_owner(resource $blob)

    Returns git_repository resource

string git_blob_rawcontent(resource $blob)

int git_blob_rawsize(resource $blob)

----------------------------------------
[git_branch]
----------------------------------------

resource git_branch_create(resource $repo,string $branch_name,resource $target,bool $force)

    Returns git_reference resource

resource git_branch_create_from_annotated(resource $repo,string $branch_name,resource $commit,bool $force)

    Parameter $commit is a resource of type git_annotated_commit.

    Returns git_reference resource

void git_branch_delete(resource $branch)

bool git_branch_is_head(resource $branch)

void git_branch_iterator_free(resource $iter)

    Parameter $iter is a resource of type git_branch_iterator.

resource git_branch_iterator_new(resource $repo,int $flags)

    Returns git_branch_iterator resource

resource git_branch_lookup(resource $repo,string $branch_name,int $branch_type)

    Returns git_reference resource

resource git_branch_move(resource $branch,string $new_branch_name,bool $force)

    Returns git_reference resource

string git_branch_name(resource $branch)

resource|bool git_branch_next(&int $type,resource $iter)

    Parameter $iter is a resource of type git_branch_iterator.

    Returns git_reference resource or false at iter over

void git_branch_set_upstream(resource $branch,?string $branch_name)

resource|bool git_branch_upstream(resource $branch)

    Returns git_reference resource if found, false otherwise

string|bool git_branch_upstream_name(resource $repo,string $refname)

    Returns string if found, false otherwise

string git_branch_upstream_remote(resource $repo,string $refname)

----------------------------------------
[git_checkout]
----------------------------------------

void git_checkout_head(resource $repo,?array $options = null)

    Note: the last parameter ($options) is passed as an array with the keys
    matching the properties of the git_checkout_options struct. Any properties
    that are not specified inherit the defaults provided via calling
    git_checkout_init_options(). You may specify null to use only the defaults.

void git_checkout_index(resource $repo,resource $index,?array $options = null)

    See notes for git_checkout_head().

void git_checkout_tree(resource $repo,resource $treeish,?array $options = null)

    Parameter $treeish is a resource of type git_object.

    See notes for git_checkout_head().

----------------------------------------
[git_cherrypick]
----------------------------------------

void git_cherrypick(resource $repo,resource $commit,?array $options = null)

    Parameter $options is an array having the keys of the git_cherrypick_options
    struct. Any properties that are not specified inherit the defaults provided
    via calling git_cherrypick_options_init(). You may specify null to use only
    the defaults.

resource git_cherrypick_commit(resource $repo,resource $cherrypick_commit,resource $our_commit,int $mainline,?array $options = null)

    Parameter $options is an array having the keys of the git_merge_options
    struct. Any properties that are not specified inherit the defaults provided
    via calling git_merge_options_init(). You may specify null to use only the
    defaults.

    Returns git_index resource

----------------------------------------
[git_clone]
----------------------------------------

resource git_clone(string $url,string $local_path,?array $options = null)

    Parameter $options is passed as an array with the keys representing the
    properties of the git_clone_options struct. The checkout_opts and fetch_opts
    properties may be arrays to their respective structures. Any properties that
    are not specified inherit the defaults provided via calling
    git_clone_init_options(). You may specify null to use only the defaults.

    Callback $options['repository_cb'] signature:
        resource callback(string $path,bool $bare,mixed $payload)

        The callback should return git_repository resource.

        The callback should throw on error.

    Returns git_repository resource

----------------------------------------
[git_commit]
----------------------------------------

string git_commit_amend(resource $commit_to_amend,?string $update_ref,?resource $author,?resource $committer,?string $message_encoding,?string $message,?resource $tree)

    The arguments behave like the C function in that NULL's are disregarded when
    amending the commit.

resource git_commit_author(resource $commit)

    Returns git_signature resource

string git_commit_body(resource $commit)

resource git_commit_committer(resource $commit)

    Returns git_signature resource

string git_commit_create(resource $repo,?string $update_ref,resource $author,resource $committer,?string $message_encoding,string $message,resource $tree,array $parents)

    Parameter $parents be an array of git_commit resource values.

string git_commit_create_buffer(resource $repo,resource $author,resource $committer,?string $message_encoding,string $message,resource $tree,array $parents)

    Parameter $parents should be an array of git_commit resource values.

string git_commit_create_from_callback(resource $repo,?string $update_ref,resource $author,resource $committer,?string $message_encoding,string $message,string $tree_id,callable $callback,mixed $payload)

    Callback signature:
        string callback(int $idx,mixed $payload)

        This callback is not designed to report errors. If an error occures,
        then the calling function will finish and the error will be logged as a
        warning.

string git_commit_create_from_ids(resource $repo,?string $update_ref,resource $author,resource $committer,?string $message_encoding,string $message,string $tree_id,array $parents)

    Parameter $parents should be a list of strings representing the parent
    commit OIDs.

string git_commit_create_with_signature(resource $repo,string $commit_content,string $signature,?string $signature_field = null)

resource git_commit_dup(resource $source)

    Parameter $source is a resource of type git_commit.

    Returns git_commit resource

string git_commit_extract_signature(string &$signed_data_out,resource $repo,string $commit_id,string $field = null)

    Returns the signature block

void git_commit_free(resource $commit)

string git_commit_header_field(resource $commit,string $field)

string git_commit_id(resource $commit)

resource git_commit_lookup(resource $repo,string $id)

    Returns git_commit resource

resource git_commit_lookup_prefix(resource $repo,string $id)

    Returns git_commit resource

string git_commit_message(resource $commit)

?string git_commit_message_encoding(resource $commit)

string git_commit_message_raw(resource $commit)

resource git_commit_nth_gen_ancestor(resource $commit,int $n)

    Returns git_commit resource

resource git_commit_owner(resource $commit)

    Returns git_repository resource

resource git_commit_parent(resource $commit,int $n)

    Returns git_commit resource

string git_commit_parent_id(resource $commit,int $n)

int git_commit_parentcount(resource $commit)

string git_commit_raw_header(resource $commit)

string git_commit_summary(resource $commit)

int git_commit_time(resource $commit)

int git_commit_time_offset(resource $commit)

resource git_commit_tree(resource $commit)

    Returns git_tree resource

string git_commit_tree_id(resource $commit)

----------------------------------------
[git_config]
----------------------------------------

void git_config_add_backend(resource $cfg,\GitConfigBackend $backend,int $level,?resource $repo,bool $force)

void git_config_add_file_ondisk(resource $cfg,string $path,int $level,?resource $repo,bool $force)

void git_config_backend_foreach_match(\GitConfigBackend $backend,?string $regexp,callable $callback,mixed $payload)

    See notes for git_config_foreach.

void git_config_delete_entry(resource $cfg,string $name)

void git_config_delete_multivar(resource $cfg,string $name,string $regexp)

string git_config_find_global()

string git_config_find_programdata()

string git_config_find_system()

string git_config_find_xdg()

void git_config_foreach(resource $cfg,callable $callback,mixed $payload)

    Callback signature:
        bool callback(array $entry,mixed $payload)

        Note: if an iteration of the callback returns TRUE, the operation is
        considered over and iterator stops.

        The callback should throw on error.

void git_config_foreach_match(resource $cfg,string $regexp,callable $callback,mixed $payload)

    See notes for git_config_foreach.

void git_config_free(resource $cfg)

bool git_config_get_bool(resource $cfg,string $name)

array git_config_get_entry(resource $cfg,string $name)

    Returns an array with the following structure:

      array(3) {
        ["name"]
        ["value"]
        ["level"]
      }

int git_config_get_int32(resource $cfg,string $name)

int git_config_get_int64(resource $cfg,string $name)

int git_config_get_mapped(resource $cfg,string $name,array $maps)

    Parameter $maps must be an indexed array of 3-tuple array elements, with
    each inner 3-tuple array containing the git_configmap fields in the order
    [type,str_match,map_value]. The map_value entry is forced to be an integer.

void git_config_get_multivar_foreach(resource $cfg,string $name,?string $regexp,callable $callback,mixed $payload)

    Callback signature:
        bool callback(array $entry,mixed $payload)

string git_config_get_path(resource $cfg,string $name)

string git_config_get_string(resource $cfg,string $name)

string git_config_get_string_buf(resource $cfg,string $name)

    Note: this function is functionally equivalent to git_config_get_string() in
    PHP, except that it can encode binary strings. However binary strings are
    typically not stored in git config files...

void git_config_iterator_free(resource $iter)

    Parameter $iter is a resource of type git_config_iterator.

resource git_config_iterator_glob_new(resource $cfg,string $regexp)

    Returns git_config_iterator resource

resource git_config_iterator_new(resource $cfg)

    Returns git_config_iterator resource

int git_config_lookup_map_value(array $maps,string $value)

    Parameter $maps must be an indexed array of 3-tuple array elements, with
    each inner 3-tuple array containing the git_configmap fields in the order
    [type,str_match,map_value]. The map_value entry is forced to be an integer.

resource git_config_multivar_iterator_new(resource $cfg,string $name,?string $regexp)

    Returns git_config_iterator resource

resource git_config_new()

    Returns git_config resource

array|bool git_config_next(resource $iter)

    Parameter $iter is a resource of type git_config_iterator.

    See git_config_get_entry() for details on returned value. Returns FALSE when
    iteration is over.

resource git_config_open_default()

    Returns git_config resource

resource git_config_open_global(resource $cfg)

    Returns git_config resource

resource git_config_open_level(resource $parent,int $level)

    Parameter $parent is a resource of type git_config.

    Returns git_config resource

resource git_config_open_ondisk(string $path)

    Returns git_config resource

bool git_config_parse_bool(string $value)

int git_config_parse_int32(string $value)

int git_config_parse_int64(string $value)

string git_config_parse_path(string $value)

void git_config_set_bool(resource $cfg,string $name,bool $value)

void git_config_set_int32(resource $cfg,string $name,int $value)

void git_config_set_int64(resource $cfg,string $name,int $value)

void git_config_set_multivar(resource $cfg,string $name,string $regexp,string $value)

void git_config_set_string(resource $cfg,string $name,string $value)

resource git_config_snapshot(resource $cfg)

    Returns git_config resource

----------------------------------------
[git_credential]
----------------------------------------

Note: all git_credential_* functions are aliased as git_cred_* for backwards
compatibility. The git_cred_* API is deprecated in libgit2 version 1 and will be
removed in later versions.

resource git_credential_default_new()

    Returns git_credential resource

void git_credential_free(resource $cred)

bool git_credential_has_username(resource $cred)

resource git_credential_ssh_key_from_agent(string $username)

    Returns git_credential resource

resource git_credential_ssh_key_memory_new(string $username,string $publickey,string $privatekey,string $passphrase)

    Returns git_credential resource

resource git_credential_ssh_key_new(string $username,string $publickey,string $privatekey,string $passphrase)

    Returns git_credential resource

resource git_credential_username_new(string $username)

    Returns git_credential resource

resource git_credential_userpass_plaintext_new(string $username,string $password)

    Returns git_credential resource

----------------------------------------
[git_describe]
----------------------------------------

resource git_describe_commit(resource $committish,?array $options = null)

    Parameter $committish is a resource of type git_object.

    Parameter $options is an array corresponding to the git_describe_options
    struct. Options omitted from the array will default to values provided via
    git_describe_init_options(). If $options is omitted then default options are
    passed via git_describe_init_options().

    Returns git_describe_result resource

string git_describe_format(resource $result,?array $options = null)

    Parameter $result is a resource of type git_describe_result.

    Parameter $options is an array corresponding to the
    git_describe_format_options struct. Options omitted from the array will
    default to values provided via git_describe_format_options_init(). If
    $options is omitted then default options are passed via
    git_describe_format_options_init().

void git_describe_result_free(resource $result)

    Parameter $result is a resource of type git_describe_result.

resource git_describe_workdir(resource $repo,?array $options = null)

    Parameter $options is an array corresponding to the git_describe_options
    struct. Options omitted from the array will default to values provided via
    git_describe_init_options(). If $options is omitted then default options are
    passed via git_describe_init_options().

    Returns git_describe_result resource

----------------------------------------
[git_diff]
----------------------------------------

Callback signatures for git_diff functions:

    notify_callback:
        int callback(resource $diff,array $delta,string $matchedPathspec,mixed $payload)

        NOTE: Errors generated by this callback cannot be handled and will be
        logged as warnings.

    progress_callback:
        bool callback(resource $diff,string $oldPath,string $newPath,mixed $payload)

        NOTE: Errors generated by this callback cannot be handled and will be
        logged as warnings.

        A return value of FALSE aborts the diff

    file_callback:
        void callback(array $delta,float $progress,mixed $payload)

        The callback should throw on error.

    binary_callback:
        void callback(array $delta,array $binary,mixed $payload)

        The callback should throw on error.

    hunk_callback:
        void callback(array $delta,array $hunk,mixed $payload)

        The callback should throw on error.

    line_callback:
        void callback(array $delta,array $hunk,array $line,mixed $payload)

        The callback should throw on error.

void git_diff_blob_to_buffer(?resource $old_blob,?string $old_as_path,?string $buffer,?string $buffer_as_path,?array $options,?callable $file_callback,?callable $binary_callback,?callable $hunk_callback,?callable $line_callback,mixed $payload)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

void git_diff_blobs(?resource $old_blob,?string $old_as_path,?resource $new_blob,?string $new_as_path,?array $options,?callable $file_callback,?callable $binary_callback,?callable $hunk_callback,?callable $line_callback,mixed $payload)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

void git_diff_buffers(?string $old_buffer,?string $old_as_path,?string $new_buffer,?string $new_as_path,?array $options,?callable $file_callback,?callable $binary_callback,?callable $hunk_callback,?callable $line_callback,mixed $payload)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

string git_diff_commit_as_email(resource $repo,resource $commit,int $patch_no,int $total_patches,int $flags,?array $options)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

void git_diff_find_similar(resource $diff,?array $options)

    Parameter $options is an array corresponding to
    git_diff_find_options. Options are defaulted using
    git_diff_find_options_init().

void git_diff_foreach(resource $diff,?callable $file_callback,?callable $binary_callback,?callable $hunk_callback,?callable $line_callback,mixed $payload)

string git_diff_format_email(resource $diff,?array $options)

    Parameter $options is an array corresponding to
    git_diff_format_email_options. Options are defaulted using
    git_diff_format_email_options_init().

    The $options['author'] option can be either an array like those returned
    from git2_signature_convert() OR a git_signature resource.

void git_diff_free(resource $diff)

resource git_diff_from_buffer(string $buffer)

    Returns git_diff resource

array git_diff_get_delta(resource $diff,int $idx)

array git_diff_get_perfdata(resource $diff)

resource git_diff_get_stats(resource $diff)

    Returns git_diff_stats resource

resource git_diff_index_to_index(resource $repo,?resource $old_index,?resource $new_index,?array $options)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

    Returns git_diff resource

resource git_diff_index_to_workdir(resource $repo,?resource $index,?array $options)

    Returns git_diff resource

bool git_diff_is_sorted_icase(resource $diff)

void git_diff_merge(resource $diff_onto,resource $diff_from)

int git_diff_num_deltas(resource $diff)

int git_diff_num_deltas_of_type(resource $diff,int $type)

void git_diff_print(resource $diff,int $format,callable $callback,mixed $payload)

int git_diff_stats_deletions(resource $stats)

int git_diff_stats_files_changed(resource $stats)

void git_diff_stats_free(resource $stats)

int git_diff_stats_insertions(resource $stats)

string git_diff_stats_to_buf(resource $stats,int $format,int $width)

string git_diff_status_char(int $status)

string git_diff_to_buf(resource $diff,int $format)

resource git_diff_tree_to_index(resource $repo,?resource $old_tree,?resource $index,?array $options)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

    Returns git_diff resource

resource git_diff_tree_to_tree(resource $repo,?resource $old_tree,?resource $new_tree,?array $options)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

    Returns git_diff resource

resource git_diff_tree_to_workdir(resource $repo,?resource $old_tree,?array $options)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

    Returns git_diff resource

resource git_diff_tree_to_workdir_with_index(resource $repo,?resource $old_tree,?array $options)

    Parameter $options is an array corresponding to git_diff_options. Options
    are defaulted using git_diff_options_init().

    Returns git_diff resource

----------------------------------------
[git_ignore]
----------------------------------------

void git_ignore_add_rule(resource $repo,string $rules)

void git_ignore_clear_internal_rules(resource $repo)

bool git_ignore_path_is_ignored(resource $repo,string $path)

----------------------------------------
[git_index]
----------------------------------------

void git_index_add(resource $index,array $source_entry)

bool git_index_add_all(resource $index,array $pathspec,int $flags,callable $callback,mixed $paylaod)

    Callback signature: void callback(string $path,string $matched_pathspec,mixed $payload)

        The callback should throw on error and return less than zero to stop
        iteration early.

    This function returns FALSE if the scan was aborted (i.e. iteration
    stopped).

void git_index_add_bypath(resource $index,string $path)

void git_index_add_from_buffer(resource $index,array $entry,string $buffer)

int git_index_caps(resource $index)

string git_index_checksum(resource $index)

void git_index_clear(resource $index)

void git_index_conflict_add(resource $index,array $ancestor_entry,array $our_entry,array $their_entry)

void git_index_conflict_cleanup(resource $index)

void git_index_conflict_get(array &$ancestor,array &$ours,array &$theirs,resource $index,string $path)

void git_index_conflict_iterator_free(resource $iter)

resource git_index_conflict_iterator_new(resource $index)

    Returns git_index_conflict_iterator resource

bool git_index_conflict_next(array &$ancestor,array &$ours,array &$theirs,resource $iterator)

    Returns false when iteration is over.

void git_index_conflict_remove(resource $index,string $path)

int git_index_entrycount(resource $index)

bool git_index_entry_is_conflict(array $entry)

int git_index_stage(array $entry)

int git_index_find(resource $index,string $path)

int git_index_find_prefix(resource $index,string $prefix)

void git_index_free(resource $index)

array|bool git_index_get_byindex(resource $index,int $n)

    Returns git_index_entry array, or false if out of bounds

array|bool git_index_get_bypath(resource $index,string $path,int $stage)

    Returns git_index_entry array, or false if does not exist

bool git_index_has_conflicts(resource $index)

resource git_index_new()

    Returns git_index resource

resource git_index_open(string $index_path)

    Returns git_index resource

resource git_index_owner(resource $index)

    Returns git_repository resource

?string git_index_path(resource $index)

void git_index_read(resource $index,bool $force)

void git_index_read_tree(resource $index,resource $tree)

void git_index_remove(resource $index,string $path,int $stage)

bool git_index_remove_all(resource $index,array $pathspec,callable $callback,mixed $payload)

    See git_index_add_all() for callback description.

void git_index_remove_bypath(resource $index,string $path)

void git_index_remove_directory(resource $index,string $dir,int $stage)

void git_index_set_caps(resource $index,int $caps)

void git_index_set_version(resource $index,int $version)

bool git_index_update_all(resource $index,array $pathspec,callable $callback,mixed $payload)

    See git_index_add_all() for callback description.

int git_index_version(resource $index)

void git_index_write(resource $index)

string git_index_write_tree(resource $index)

string git_index_write_tree_to(resource $index,resource $repo)

----------------------------------------
[git_indexer]
----------------------------------------

void git_indexer_append(resource $indexer,string $data)

    Transfer progress is stored in the resource. As such it is not passed to
    this function. To obtain transfer progress stats, call git2_indexer_stats().

void git_indexer_commit(resource $indexer)

    Transfer progress is stored in the resource. As such it is not passed to
    this function. To obain transfer progress stats, call git2_indexer_stats().

void git_indexer_free(resource $indexer)

string git_indexer_hash(resource $indexer)

resource git_indexer_new(string $path,int $mode,?resource $odb,?array $options)

    Parameter $options is an associative array matching struct
    git_indexer_options.

    Return git_indexer resource

array git2_indexer_stats(resource $indexer)

    To avoid the expense of translating a stats object every time an indexer
    operation is performed, the library allocates an internal
    git_indexer_progress structure on the resource object; this structure is
    automatically passed to underlying calls.

    The user may call this function to get the indexer transfer progress stats
    at any time.

    The return value is an associative array with git_transfer_progress fields.

----------------------------------------
[git_merge]
----------------------------------------

void git_merge(resource $repo,array $their_heads,?array $merge_options,?array $checkout_options)

    Parameter $their_heads is an array of git_annotated_commit resources.

    Parameter $merge_options is an associative array corresponding to
    git_merge_options. Options are defaulted using git_merge_options_init().

    Parameter $checkout_options in an associative array corresponding to
    git_checkout_options. Options are defaulted using
    git_checkout_init_options().

int git_merge_analysis(int &$preference,resource $repo,array $their_heads)

    Parameter $their_heads is an array of git_annotated_commit resources.

    Returns the analysis enumeration result

string git_merge_base(resource $repo,string $one,string $two)

string git_merge_base_many(resource $repo,array $input_array)

    Parameter $input_array is an array of strings.

string git_merge_base_octopus(resource $repo,array $input_array)

    Parameter $input_array is an array of strings.

array git_merge_bases(resource $repo,string $one,string $two)

    Returns an array of string

array git_merge_bases_many(resource $repo,array $input_array)

    Parameter $input_array is an array of strings.

    Returns an array of string

resource git_merge_commits(resource $repo,resource $our_commit,resource $their_commit,?array $merge_options)

    Parameter $merge_options is an associative array corresponding to
    git_merge_options. Options are defaulted using git_merge_options_init().    

    Returns git_index resource

array git_merge_file(array $ancestor,array $ours,array $theirs,?array $merge_file_options)

    Parameters $ancestor, $ours and $theirs are associative arrays matching the
    git_merge_file_input struct. The git_merge_file_input array contains a
    property "ptr" that encapsulates both the "ptr" and "size" fields from the C
    structure.

    Parameter $merge_file_options is an associative array corresponding to
    git_merge_file_options. Options are defaulted using
    git_merge_file_init_options().

    Returns array (git_merge_file_result)

array git_merge_file_from_index(resource $repo,?array $ancestor,array $ours,array $theirs,?array $merge_file_options)

    Parameters $ancestor, $ours and $theirs are associative arrays matching the
    git_index_entry struct.

    Parameter $merge_file_options is an associative array corresponding to
    git_merge_file_options. Options are defaulted using
    git_merge_file_init_options().

    Returns array (git_merge_file_result)

resource git_merge_trees(resource $repo,?resource $ancestor_tree,resource $our_tree,resource $their_tree,?array $merge_options)

    Returns git_index resource

----------------------------------------
[git_note]
----------------------------------------

resource git_note_author(resource $note)

    Returns git_signature resource

resource git_note_committer(resource $note)

    Returns git_signature resource

string git_note_create(resource $repo,?string $notes_ref,resource $author,resource $committer,string $oid,string $note,bool $force)

void git_note_foreach(resource $repo,?string $notes_ref,callable $callback,mixed $payload)

    Callback signature: void callback(string $blob_id,string $annotated_object_id,mixed $payload)

void git_note_free(resource $note)

string git_note_id(resource $note)

void git_note_iterator_free(resource $note_iterator)

resource git_note_iterator_new(resource $repo,?string $notes_ref)

    Returns git_note_iterator resource

string git_note_message(resource $note)

    Returns string

string git_note_next(string &$annotated_id,resource $note_iterator)

    Returns the note ID string

resource git_note_read(resource $repo,?string $notes_ref,string $oid)

    Returns git_note resource

void git_note_remove(resource $repo,?string $notes_ref,resource $author,resource $committer,string $oid)

----------------------------------------
[git_object]
----------------------------------------
resource git_object_dup(resource $object)

    Returns git_object resource

void git_object_free(resource $object)

string git_object_id(resource $object)

resource git_object_lookup(resource $repo,string $id,int $type)

    Returns git_object resource

resource git_object_lookup_bypath(resource $repo,string $path,int $type)

    Returns git_object resource

resource git_object_lookup_prefix(resource $repo,string $id,int $type)

    Returns git_object resource

resource git_object_owner(resource $object)

    Returns git_repository resource

resource git_object_peel(resource $object,int $target_type)

    Returns git_object resource

string git_object_short_id(resource $object)

int git_object_string2type(string $str)

int git_object_type(resource $object)

string git_object_type2string(int $type)

bool git_object_typeisloose(int $type)

----------------------------------------
[git_odb]
    [git_odb_object]
----------------------------------------

void git_odb_add_alternate(resource $odb,GitODBBackend $backend,int $priority)

void git_odb_add_backend(resource $odb,GitODBBackend $backend,int $priority)

void git_odb_add_disk_alternate(resource $odb,string $path)

GitODBBackend git_odb_backend_loose(string $objects_dir,int $compression_level,bool $do_fsync,int $dir_mode,int $file_mode)

GitODBBackend git_odb_backend_one_pack(string $index_file)

GitODBBackend git_odb_backend_pack(string $objects_dir)

bool git_odb_exists(resource $odb,string $id)

string git_odb_exists_prefix(resource $odb,string $prefix)

    This function throws when not found or ambiguous. It returns a string when
    the object is found.

    Returns string

void git_odb_expand_ids(resource $odb,array &$ids)

    This function will return results in the $ids parameter. While this
    parameter employs reference semantics, it is not technically passed by
    reference in the implementation.

void git_odb_foreach(resource $odb,callable $callback,mixed $payload)

    Callback signature: bool callback(string $oid,mixed $payload)

        To stop iteration, the callback should return false.

        The callback should throw on error.

void git_odb_free(resource $odb)

GitODBBackend git_odb_get_backend(resource $odb,int $pos)

string git_odb_hash(string $data,int $type)

string git_odb_hashfile(string $path,int $type)

resource git_odb_new()

    Return git_odb resource

int git_odb_num_backends(resource $odb)

string git_odb_object_data(resource $odb_object)

resource git_odb_object_dup(resource $odb_object)

    Returns git_odb_object resource

void git_odb_object_free(resource $odb_object)

string git_odb_object_id(resource $odb_object)

int git_odb_object_size(resource $odb_object)

int git_odb_object_type(resource $odb_object)

resource git_odb_open(string $objects_dir)

    Returns git_odb resource

GitODBStream git_odb_open_rstream(int &$length,int &$type,resource $odb,string $oid)

GitODBStream git_odb_open_wstream(resource $odb,int $size,int $type)

resource git_odb_read(resource $odb,string $id)

    Returns git_odb_object resource

int git_odb_read_header(int &$type,resource $odb,string $id)

    Returns the length of the header

resource git_odb_read_prefix(resource $odb,string $prefix)

    Returns git_odb_object resource

void git_odb_refresh(resource $odb)

string git_odb_stream_finalize_write(GitODBStream $stream)

string git_odb_stream_read(GitODBStream $stream,int $buffer_length)

    Parameter $buffer_length is the length of the buffer to read.

    Returns the read buffer

void git_odb_stream_write(GitODBStream $stream,string $buffer)

string git_odb_write(resource $odb,string $data,int $type)

    Returns the OID result of the write

GitODBWritepack_Internal git_odb_write_pack(resource $odb,callable $progress_callback,mixed $payload)

----------------------------------------
[git_packbuilder]
----------------------------------------

void git_packbuilder_foreach(resource $packbuilder,callable $callback,mixed $payload_or_stream)

    If $payload_or_stream is a PHP stream resource and $callback is null, then
    the extension will internally write callback data to the stream. (This is a
    non-standard extension to libgit2 behavior provided by php-git2.)

    Callback signature: bool callback(string $data,int $length,mixed $payload)

        The callback should return false to cancel the transaction.

        The callback should throw on error.

void git_packbuilder_free(resource $packbuilder)

string git_packbuilder_hash(resource $packbuilder)

void git_packbuilder_insert(resource $packbuilder,string $id,?string $name)

void git_packbuilder_insert_commit(resource $packbuilder,string $id)

void git_packbuilder_insert_recur(resource $packbuilder,string $id,?string $name)

void git_packbuilder_insert_tree(resource $packbuilder,string $id)

void git_packbuilder_insert_walk(resource $packbuilder,resource $revwalk)

resource git_packbuilder_new(resource $repo)

    Returns git_packbuilder resource

int git_packbuilder_object_count(resource $packbuilder)

void git_packbuilder_set_callbacks(resource $packbuilder,callable $progress_callback,mixed $payload)

    Callback signature: void callback(int $stage,int $current,int $total,mixed $payload)

        The callback should throw on error.

void git_packbuilder_set_threads(resource $packbuilder,int $n_threads)

void git_packbuilder_write(resource $packbuilder,string $path,int $mode,callable $progress_callback,mixed $payload)

    Callback signature: void callback(array $stats)

        The $stats array has properties of the libgit2 git_transfer_progress
        struct.

int git_packbuilder_written(resource $packbuilder)

----------------------------------------
[git_patch]
----------------------------------------

void git_patch_free(resource $patch)

resource git_patch_from_blob_and_buffer(?resource $old_blob,?string $old_as_path,?string $buffer,?string $buffer_as_path,?array $options)

    Returns git_patch resource

resource git_patch_from_blobs(?resource $old_blob,?string $old_as_path,?resource $new_blob,?string $new_as_path,?array $options)

    Returns git_patch resource

resource git_patch_from_buffers(?string $old_buffer,?string $old_as_path,?string $new_buffer,?string $new_as_path,?array $options)

    Returns git_patch resource

resource git_patch_from_diff(resource $diff,int $idx)

    Returns git_patch_resource

array git_patch_get_delta(resource $patch)

    Returns an associative array corresponding to the git_diff_delta struct.

array git_patch_get_hunk(int &$lines_in_hunk,resource $patch,int $hunk_idx)

    Returns a git_diff_hunk array

array git_patch_get_line_in_hunk(resource $patch,int $hunk_idx,int $line_of_hunk)

    Returns a git_diff_line array

int git_patch_line_stats(int &$total_additions,int &$total_deletions,resource $patch)

    Returns the total_context value

int git_patch_num_hunks(resource $patch)

int|bool git_patch_num_lines_in_hunk(resource $patch,int $hunk_idx)

    Returns int or false if invalid hunk index

void git_patch_print(resource $patch,callable $callback,mixed $payload)

    Callback signature: void callback(array $delta,array $hunk,array $line,mixed $payload)

        The callback should throw on error.

int git_patch_size(resource $patch,bool $include_context,bool $include_hunk_headers,bool $include_file_headers)

string git_patch_to_buf(resource $patch)

----------------------------------------
[git_rebase]
----------------------------------------

bool git_rebase_abort(resource $rebase)

    Returns true if successful, false if a rebase is not in progress

int git_rebase_commit(string &$id,resource $rebase,?resource $author,resource $committer,string $message_encoding = null,string $message = null)

    Returns the underlying function result

void git_rebase_finish(resource $rebase,?resource $signature)

void git_rebase_free(resource $rebase)

resource git_rebase_init(resource $repo,?resource $branch,?resource $upstream,?resource $onto,?array $options)

    Parameters $branch, $upstream and $onto can either be null or a resource of
    type git_annotated_commit.

    Parameter $options is an associative array corresponding to the
    git_rebase_options structure. Options are defaulted using
    git_rebase_options_init().

    Returns git_rebase resource

resource git_rebase_inmemory_index(resource $rebase)

    Returns git_index resource

array git_rebase_next(resource $rebase)

    Returns a git_rebase_operation array

resource git_rebase_open(resource $repo,?array $options)

    Parameter $options is an associative array corresponding to the
    git_rebase_options structure. Options are defaulted using
    git_rebase_options_init().

    Returns git_rebase resource

array git_rebase_operation_byindex(resource $rebase,int $idx)

    Returns a git_rebase_operation array

int git_rebase_operation_current(resource $rebase)

int git_rebase_operation_entrycount(resource $rebase)

----------------------------------------
[git_refdb]
----------------------------------------

GitRefDBBackend_Internal git_refdb_backend_fs(resource $refdb)

    Returns GitRefDBBackend_Internal object

void git_refdb_compress(resource $refdb)

void git_refdb_free(resource $refdb)

resource git_refdb_new(resource $repo)

    Returns git_refdb resource

resource git_refdb_open(resource $repo)

    Returns git_refdb resource

void git_refdb_set_backend(resource $refdb,GitRefDBBackend $backend)

----------------------------------------
[git_reference]
----------------------------------------

int git_reference_cmp(resource $ref1,resource $ref2)

    Returns the same return value as underlying library call.

resource git_reference_create(resource $repo,string $name,string $id,bool $force,string $log_message)

    Returns git_reference resource

resource git_reference_create_matching(resource $repo,string $name,string $id,bool $force,string $current_id,string $log_message)

    Returns git_reference resource

void git_reference_delete(resource $ref)

resource git_reference_dup(resource $ref)

    Returns git_reference resource

resource git_reference_dwim(resource $repo,string $shorthand)

    Returns git_reference resource

void git_reference_ensure_log(resource $repo,string $refname)

void git_reference_foreach(resource $repo,callable $callback,mixed $payload)

    Callback signature:
        void callback(resource $ref,mixed $payload)

        The callback should throw on error.

void git_reference_foreach_glob(resource $repo,string $glob,callable $callback,mixed $payload)

void git_reference_foreach_name(resource $repo,callable $callback,mixed $payload)

    Callback signature:
        void callback(string $name,mixed $payload)

        The callback should throw on error.

void git_reference_free(resource $ref)

bool git_reference_has_log(resource $repo,string $refname)

bool git_reference_is_branch(resource $ref)

bool git_reference_is_note(resource $ref)

bool git_reference_is_remote(resource $ref)

bool git_reference_is_tag(resource $ref)

bool git_reference_is_valid_name(string $refname)

bool git_reference_iterator_free(resource $iterator)

resource git_reference_iterator_glob_new(resource $repo,string $glob)

    Returns git_reference_iterator resource

resource git_reference_iterator_new(resource $repo)

    Returns git_reference_iterator resource

array git_reference_list(resource $repo)

    Returns array of string

resource git_reference_lookup(resource $repo,string $name)

    Returns git_reference resource

string git_reference_name(resource $ref)

string git_reference_name_to_id(resource $repo,string $name)

resource|bool git_reference_next(resource $iter)

    Returns git_reference resource or false if iteration is over

string|bool git_reference_next_name(resource $iter)

    Returns string or false if iteration is over

string git_reference_normalize_name(string $name,int $flags)

resource git_reference_owner(resource $ref)

    Returns git_repository resource

resource git_reference_peel(resource $ref,int $type)

    Returns git_object resource

void git_reference_remove(resource $repo,string $name)

resource git_reference_rename(resource $ref,string $new_name,bool $force,string $log_message)

    Returns git_reference resource

resource git_reference_resolve(resource $ref)

    Returns git_reference resource

resource git_reference_set_target(resource $ref,string $id,string $log_message)

    Returns git_reference resource

string git_reference_shorthand(resource $ref)

resource git_reference_symbolic_create(resource $repo,string $name,string $target,bool $force,string $log_message)

    Returns git_reference resource

resource git_reference_symbolic_create_matching(resource $repo,string $name,string $target,bool $force,string $current_value,string $log_message)

    Returns git_reference resource

resource git_reference_symbolic_set_target(resource $ref,string $target,string $log_message)

    Returns git_reference resource

?string git_reference_symbolic_target(resource $ref)

?string git_reference_target(resource $ref)

?string git_reference_target_peel(resource $ref)

int git_reference_type(resource $ref)

----------------------------------------
[git_reflog]
----------------------------------------

void git_reflog_append(resource $reflog,string $id,resource $committer,?string $msg)

void git_reflog_delete(resource $repo,string $name)

bool git_reflog_drop(resource $reflog,int $idx,bool $rewrite_previous_entry)

array git_reflog_entry_byindex(resource $reflog,int $idx)

    Returns a git_reflog_entry array

int git_reflog_entrycount(resource $reflog)

void git_reflog_free(resource $reflog)

resource git_reflog_read(resource $repo,string $name)

    Returns git_reflog resource

void git_reflog_rename(resource $repo,string $old_name,string $name)

void git_reflog_write(resource $reflog)

----------------------------------------
[git_refspec]
----------------------------------------

int git_refspec_direction(resource $refspec)

string git_refspec_dst(resource $refspec)

bool git_refspec_dst_matches(resource $refspec,string $refname)

bool git_refspec_force(resource $refspec)

string git_refspec_rtransform(resource $refspec,string $name)

string git_refspec_src(resource $refspec)

bool git_refspec_src_matches(resource $refspec,string $refname)

string git_refspec_string(resource $refspec)

string git_refspec_transform(resource $refspec,string $name)

----------------------------------------
[git_remote]
----------------------------------------

Callback signatures:

    Transport message callback:

        bool callback(string $str,mixed $payload)

            If the function returns non-null and false, then the operation is
            aborted.

    Completion callback:

        void callback(int $type,mixed $payload)

    Credential acquire callback:

        ?resource callback(
            string $url,
            string $username_from_url,
            int $allowed_types,
            mixed $payload
        )

            Returns git_credential resource or NULL to passthrough

    Transport certificate check callback:

        bool callback(array $cert,bool $valid,string $host,mixed $payload)

    Transfer progress callback:

        void callback(array $stats,mixed $payload)

        Same as for git_indexer_new

    Update tips callback:

        void callback(string $refname,string $a,string $b,mixed $payload)

    Packbuilder progress callback:

        See git_packbuilder notes

        void callback(int $stage,int $current,int $total,mixed $payload)

    Push transfer progress callback:

        void callback(int $current,int $total,int $bytes,mixed $payload)

    Push update reference callback:

        void callback(string $refname,string $status,mixed $payload)

    Push negotiation callback:

        void callback(array $updates,mixed $payload)

    The transport callback is not implemented at this time since we do not yet
    implement custom transports.

void git_remote_add_fetch(resource $repo,string $remote,string $refspec)

void git_remote_add_push(resource $repo,string $remote,string $refspec)

int git_remote_autotag(resource $remote)

void git_remote_connect(resource $remote,int $direction,?array $callbacks,?array $proxy_options,?array $custom_headers)

    Parameter $callbacks is an associative array corresponding to
    git_remote_callbacks.

    Parameter $proxy_options is an associative array corresponding to
    git_proxy_options. Options are defaulted using git_proxy_init_options().

    Parameter $custom_headers is an array of strings.

bool git_remote_connected(resource $remote)

resource git_remote_create(resource $repo,string $name,string $url)

    Returns git_remote resource

resource git_remote_create_anonymous(resource $repo,string $url)

    Returns git_remote resource

resource git_remote_create_with_fetchspec(resource $repo,string $name,string $url,string $fetchspec)

    Returns git_remote resource

string git_remote_default_branch(resource $remote)

void git_remote_delete(resource $repo,string $name)

void git_remote_disconnect(resource $remote)

void git_remote_download(resource $remote,?array $refspecs,?array $fetch_options)

    Parameter $fetch_options is an associative array corresponding to
    git_fetch_options. Options are defaulted using git_fetch_init_options().

resource git_remote_dup(resource $remote)

    Returns git_remote resource

void git_remote_fetch(resource $remote,?array $refspecs,?array $fetch_options,?string $reflog_message)

    Parameter $refspecs is an array of strings.

    Parameter $fetch_options is an associative array corresponding to
    git_fetch_options. Options are defaulted using git_fetch_init_options().

void git_remote_free(resource $remote)

array git_remote_get_fetch_refspecs(resource $remote)

array git_remote_get_push_refspecs(resource $remote)

resource git_remote_get_refspec(resource $remote,int $n)

    Returns git_refspec resource

bool git_remote_is_valid_name(string $remote_name)

array git_remote_list(resource $repo)

resource git_remote_lookup(resource $repo,string $name)

    Returns git_remote resource

array git_remote_ls(resource $remote)

    Returns an indexed array of git_remote_head arrays

string git_remote_name(resource $remote)

resource git_remote_owner(resource $remote)

    Returns git_repository resource

void git_remote_prune(resource $remote,?array $callbacks)

    Parameter $callbacks is an associative array corresponding to
    git_remote_callbacks.

void git_remote_prune_refs(resource $remote)

void git_remote_push(resource $remote,?array $refspecs,?array $push_options)

    Parameter $refspecs is an array of string.

    Parameter $push_options is an associative array corresponding to
    git_push_options. Options are defaulted using git_push_init_options().

string git_remote_pushurl(resource $remote)

int git_remote_refspec_count(resource $remote)

array git_remote_rename(resource $repo,string $name,string $new_name)

void git_remote_set_autotag(resource $repo,string $remote,int $value)

void git_remote_set_pushurl(resource $repo,string $remote,string $url)

void git_remote_set_url(resource $repo,string $remote,string $url)

array git_remote_stats(resource $remote)

void git_remote_stop(resource $remote)

void git_remote_update_tips(resource $remote,?array $callbacks,bool $update_fetchhead,int $download_tags,?string $reflog_message)

    Parameter $callbacks is an associative array corresponding to
    git_remote_callbacks.

void git_remote_upload(resource $remote,?array $refspecs,?array $push_options)

    Parameter $refspecs is an array of string.

    Parameter $push_options is an associative array corresponding to
    git_push_options. Options are defaulted using git_push_init_options().

string git_remote_url(resource $remote)

----------------------------------------
[git_repository]
----------------------------------------

resource git_repository_config(resource $repo)

    Returns git_config resource

resource git_repository_config_snapshot(resource $repo)

    Returns git_config resource

int git_repository_detach_head(resource $repo)

string git_repository_discover(string $start_path,bool $across_fs,string $ceiling_dirs = null)

    Returns string

void git_repository_fetchhead_foreach(resource $repo,callable $callback,mixed $payload)

  Callback signature:
      void callback(string $ref_name,string $remote_url,string $oid,bool $is_merge,mixed $payload)

void git_repository_free(resource $repo)

string git_repository_get_namespace(resource $repo)

string git_repository_hashfile(resource $repo,string $path,int $type,string $as_path = null)

resource git_repository_head(resource $repo)

    Returns git_reference resource

bool git_repository_head_detached(resource $repo)

bool git_repository_head_unborn(resource $repo)

string git_repository_ident(string &$email,resource $repo)

    Returns the name

resource git_repository_index(resource $repo)

    Returns git_index resource

resource git_repository_init(string $path,bool $is_bare = false)

    Returns git_repository resource

resource git_repository_init_ext(string $path,array $options = null)

    The final parameter is an array of options with keys corresponding to the
    git_repository_init_options struct. If you do not specify an option key, it
    will be filled in with the default value supplied via
    git_repository_init_init_options. It may be null if you want to purely use
    the defaults.

    NOTE: the git2 extension does not implement
    git_repository_init_init_options(). Just use an array to pass in init
    options and it will be initialized for you behind-the-scenes.

    Returns git_repository resource

bool git_repository_is_bare(resource $repo)

bool git_repository_is_empty(resource $repo)

bool git_repository_is_shallow(resource $repo)

void git_repository_mergehead_foreach(resource $repo,callable $callback,mixed $payload)

    Callback signature:
        void callback(string $oid,mixed $payload)

string|bool git_repository_message(resource $repo)

    Returns false if no message exists

void git_repository_message_remove(resource $repo)

resource git_repository_new()

    Returns git_repository resource

resource git_repository_odb(resource $repo)

    Returns git_odb resource

resource git_repository_open(string $path)

    Returns git_repository resource

resource git_repository_open_bare(string $bare_path)

    Returns git_repository resource

resource git_repository_open_ext(?string $path,int $flags,string $ceiling_dirs)

    Returns git_repository resource

string git_repository_path(resource $repo)

resource git_repository_refdb(resource $repo)

    Returns git_refdb resource

void git_repository_reinit_filesystem(resource $repo,bool $recurse_submodules = true)

void git_repository_set_bare(resource $repo)

void git_repository_set_config(resource $repo,resource $config)

void git_repository_set_head(resource $repo,string $refname)

bool git_repository_set_head_detached(resource $repo,string $committish)

    Returns bool

bool git_repository_set_head_detached_from_annotated(resource $repo,resource $committish)

    $committish must be a resource of type git_annotated_commit

void git_repository_set_ident(resource $repo,string $name,string $email)

void git_repository_set_index(resource $repo,resource $index)

void git_repository_set_namespace(resource $repo,string $namespace)

void git_repository_set_odb(resource $repo,resource $odb)

void git_repository_set_refdb(resource $repo,resource $refdb)

void git_repository_set_workdir(resource $repo,string $workdir,bool $update_gitlink)

int git_repository_state(resource $repo)

void git_repository_state_cleanup(resource $repo)

?string git_repository_workdir(resource $repo)

    Returns NULL if the repository has no workdir (i.e. for a bare repository)

resource git_repository_wrap_odb(resource $odb)

    Returns git_repository resource

----------------------------------------
[git_reset]
----------------------------------------

void git_reset(resource $repo,resource $target_object,int $reset_type,?array $checkout_options)

    Parameter $checkout_options is an associative array corresponding to
    git_checkout_options. Options are defaulted using
    git_checkout_options_init().

void git_reset_default(resource $repo,?resource $target_object,array $pathspecs)

void git_reset_from_annotated(resource $repo,resource $annotated_commit,int $reset_type,?array $checkout_options)

----------------------------------------
[git_revert]
----------------------------------------

void git_revert(resource $repo,resource $commit,?array $revert_options)

    Parameter $revert_options is an associative array corresponding to
    git_revert_options. Options are defaulted using git_revert_options_init().

resource git_revert_commit(resource $repo,resource $revert_commit,resource $our_commit,int $mainline,?array $merge_options)

    Parameter $merge_options is an array having the keys of the
    git_merge_options struct. Any properties that are not specified inherit the
    defaults provided via calling git_merge_options_init(). You may specify null
    to use only the defaults.

    Returns git_index resource

----------------------------------------
[git_revparse]
----------------------------------------

array git_revparse(resource $repo,string $spec)

    The return array contains the fields of the revspec structure. Example:

        array(3) {
          ["from"]  resource of type git_object (may be null)
          ["to"]    resource of type git_object (may be null)
          ["flags"] int
        }

resource git_revparse_ext(?resource &$reference,resource $repo,string $spec)

    Returns a git_object resource

resource git_revparse_single(resource $repo,string $spec)

    Returns git_object resource

----------------------------------------
[git_revwalk]
----------------------------------------
void git_revwalk_add_hide_cb(resource $revwalk,callable $callback,mixed $payload)

    Callback signature: void callback(string $commit_id,mixed $payload)

        The function should throw on error.

void git_revwalk_free(resource $revwalk)

void git_revwalk_hide(resource $revwalk,string $commit_id)

void git_revwalk_hide_glob(resource $revwalk,string $glob)

void git_revwalk_hide_head(resource $revwalk)

void git_revwalk_hide_ref(resource $revwalk,string $refname)

resource git_revwalk_new(resource $repo)

    Returns git_revwalk resource

string|bool git_revwalk_next(resource $revwalk)

    Returns string or false when on iterover

void git_revwalk_push(resource $revwalk,string $id)

void git_revwalk_push_glob(resource $revwalk,string $glob)

void git_revwalk_push_head(resource $revwalk)

void git_revwalk_push_range(resource $revwalk,string $range)

void git_revwalk_push_ref(resource $revwalk,string $refname)

resource git_revwalk_repository(resource $revwalk)

    Returns git_repository resource

void git_revwalk_reset(resource $revwalk)

void git_revwalk_simplify_first_parent(resource $revwalk)

void git_revwalk_sorting(resource $revwalk,int $sort_mode)

----------------------------------------
[git_signature]
----------------------------------------

resource git_signature_default(resource $repo)

    Returns git_signature resource

resource git_signature_dup(resource $signature)

    Returns git_signature resource

void git_signature_free(resource $signature)

resource git_signature_from_buffer(string $buffer)

    Returns git_signature resource

resource git_signature_new(string $name,string $email,int $time,int $offset)

    Returns git_signature resource

resource git_signature_now(string $name,string $email)

    Returns git_signature resource

array git2_signature_convert(resource $signature)

    Returns an associative array corresponding to the git_signature
    structure. The associative array has the following keys:

        - name
        - email
        - when.time
        - when.offset

----------------------------------------
[git_stash]
----------------------------------------

Stash apply options callback signature:

    void callback(int $progress,mixed $payload)

        The callback should return false to abort the stash.

        The callback should throw on error.

void git_stash_apply(resource $repo,int $index,?array $stash_apply_options)

    Parameter $stash_apply_options is an associative array corresponding to
    git_stash_apply_options. Options are defaulted using
    git_stash_apply_options_init().

void git_stash_drop(resource $repo,int $index)

void git_stash_foreach(resource $repo,callable $callback,mixed $payload)

    Callback signature:

        void callback(int $index,string $message,string $stash_id,mixed $payload)

            The callback should return false to stop iteration.

            The callback should throw on error.

void git_stash_pop(resource $repo,int $index,?array $stash_apply_options)

    Parameter $stash_apply_options is an associative array corresponding to
    git_stash_apply_options. Options are defaulted using
    git_stash_apply_options_init().

string git_stash_save(resource $repo,resource $signature,string $message,int $flags)

----------------------------------------
[git_status]
----------------------------------------

array git_status_byindex(resource $statuslist,int $idx)

    ** The return array has the following structure: **

        array(3) {
          ["status"]
          ["head_to_index"]
            // git_diff_delta array
          ["index_to_workdir"]
            // git_diff_delta array
        }

    Returns a git_status_entry array

?int|bool git_status_file(resource $repo,string $path)

    The function returns:

        - int: if the path was successfully found, the return value is an
               integer bitmask containing the status flags
        - null: the path was ambiguous
        - false: the path was not found

void git_status_foreach(resource $repo,callable $callback,mixed $payload)

    Callback signature: void callback(string $path,int $status_flag,mixed $payload)

        The function should throw on error.

void git_status_foreach_ext(resource $repo,?array $status_options,callable $callback,mixed $payload)

    See notes on git_status_foreach() for callback signature.

int git_status_list_entrycount(resource $statuslist)

void git_status_list_free(resource $statuslist)

array git_status_list_get_perfdata(resource $statuslist)

resource git_status_list_new(resource $repo,?array $status_options)

    Returns git_status_list resource

bool git_status_should_ignore(resource $repo,string $path)

----------------------------------------
[git_submodule]
----------------------------------------

void git_submodule_add_finalize(resource $submodule)

resource git_submodule_add_setup(resource $repo,string $url,string $path,bool $use_gitlink)

    Returns git_submodule resource

void git_submodule_add_to_index(resource $submodule,bool $write_index)

string git_submodule_branch(resource $submodule)

int git_submodule_fetch_recurse_submodules(resource $submodule)

void git_submodule_foreach(resource $repo,callable $callback,mixed $payload)

void git_submodule_free(resource $submodule)

?string git_submodule_head_id(resource $submodule)

int git_submodule_ignore(resource $submodule)

?string git_submodule_index_id(resource $submodule)

void git_submodule_init(resource $submodule,bool $overwrite)

int git_submodule_location(resource $submodule)

resource git_submodule_lookup(resource $repo,string $name)

    Returns git_submodule resource

string git_submodule_name(resource $submodule)

resource git_submodule_open(resource $submodule)

    Returns git_repository resource

resource git_submodule_owner(resource $submodule)

    Returns git_repository resource

string git_submodule_path(resource $submodule)

void git_submodule_reload(resource $submodule,bool $force)

resource git_submodule_repo_init(resource $submodule,bool $use_gitlink)

    Returns git_repository resource

string git_submodule_resolve_url(resource $repo,string $url)

void git_submodule_set_branch(resource $repo,string $name,string $branch)

void git_submodule_set_fetch_recurse_submodules(resource $repo,string $name,int $fetch_recurse_submodules)

void git_submodule_set_ignore(resource $repo,string $name,int $ignore)

void git_submodule_set_update(resource $repo,string $name,int $update)

void git_submodule_set_url(resource $repo,string $name,string $url)

int git_submodule_status(resource $repo,string $name,int $ignore)

void git_submodule_sync(resource $submodule)

void git_submodule_update(resource $submodule,bool $init,?array $submodule_update_options)

int git_submodule_update_strategy(resource $submodule)

string git_submodule_url(resource $submodule)

?string git_submodule_wd_id(resource $submodule)

----------------------------------------
[git_tag]
----------------------------------------

string git_tag_annotation_create(resource $repo,string $tag_name,resource $target,resource $tagger,string $message)

string git_tag_create(resource $repo,string $tag_name,resource $target,resource $tagger,string $message,bool $force)

string git_tag_create_frombuffer(resource $repo,string $buffer,bool $force)

string git_tag_create_lightweight(resource $repo,string $tag_name,resource $target,bool $buffer)

void git_tag_delete(resource $repo,string $tag_name)

resource git_tag_dup(resource $tag)

    Returns git_tag resource

void git_tag_foreach(resource $repo,callable $callback,mixed $payload)

    Callback signature: void callback(string $name,string $oid,mixed $payload)

        The callback should throw on error.

void git_tag_free(resource $tag)

string git_tag_id(resource $tag)

array git_tag_list(resource $repo)

array git_tag_list_match(string $pattern,resource $repo)

resource git_tag_lookup(resource $repo,string $id)

    Returns git_tag resource

resource git_tag_lookup_prefix(resource $repo,string $id_prefix)

    Returns git_tag resource

?string git_tag_message(resource $tag)

string git_tag_name(resource $tag)

resource git_tag_owner(resource $tag)

    Returns git_repository resource

resource git_tag_peel(resource $tag)

    Returns git_object resource

?resource git_tag_tagger(resource $tag)

resource git_tag_target(resource $tag)

    Returns git_object resource

string git_tag_target_id(resource $tag)

int git_tag_target_type(resource $tag)

----------------------------------------
[git_trace]
----------------------------------------

void git_trace_set(int $level)

    This function uses the standard PHP error log to write traces instead of a
    callback function.

    This function will only work if your libgit2 was built with tracing enabled.

----------------------------------------
[git_tree]
    [git_tree_entry]
----------------------------------------

resource git_tree_dup(resource $tree)

    Returns git_tree resource

?resource git_tree_entry_byid(resource $tree,string $id)

    Returns git_tree_entry resource or null

?resource git_tree_entry_byindex(resource $tree,int $idx)

    Returns git_tree_entry resource or null

?resource git_tree_entry_byname(resource $tree,string $filename)

    Returns git_tree_entry resource or null

resource git_tree_entry_bypath(resource $tree,string $path)

    Returns git_tree_entry resource

int git_tree_entry_cmp(resource $tree_entry_1,resource $tree_entry_2)

resource git_tree_entry_dup(resource $tree_entry)

    Returns git_tree_entry resource

int git_tree_entry_filemode(resource $tree_entry)

int git_tree_entry_filemode_raw(resource $tree_entry)

void git_tree_entry_free(resource $tree_entry)

string git_tree_entry_id(resource $tree_entry)

string git_tree_entry_name(resource $tree_entry)

resource git_tree_entry_to_object(resource $repo,resource $tree_entry)

    Returns git_object resource

int git_tree_entry_type(resource $tree_entry)

int git_tree_entrycount(resource $tree)

void git_tree_free(resource $tree)

string git_tree_id(resource $tree)

resource git_tree_lookup(resource $repo,string $id)

    Returns git_tree resource

resource git_tree_lookup_prefix(resource $repo,string $id_prefix)

    Returns git_tree resource

resource git_tree_owner(resource $tree)

    Returns git_repository resource

void git_tree_walk(resource $tree,int $mode,callable $callback,mixed $payload)

    Callback signature: void callback(string $root,resource $entry,mixed $payload)

        The callback should throw on error.

----------------------------------------
[git_treebuilder]
----------------------------------------

void git_treebuilder_clear(resource $treebuilder)

int git_treebuilder_entrycount(resource $treebuilder)

void git_treebuilder_filter(resource $treebuilder,callable $callback,mixed $payload)

    Callback signature:
        bool callback(array $entry,mixed $payload)

        Returns false to filter (i.e. remove) the entry.

void git_treebuilder_free(resource $treebuilder)

resource git_treebuilder_get(resource $treebuilder,string $filename)

    Returns git_tree_entry resource

resource git_treebuilder_insert(resource $treebuilder,string $filename,string $id,int $filemode)

    This function always returns the tree entry.

    Returns git_tree_entry resource

resource git_treebuilder_new(resource $repo,?resource $tree)

    Returns git_treebuilder resource

void git_treebuilder_remove(resource $treebuilder,string $filename)

string git_treebuilder_write(resource $treebuilder)

----------------------------------------
[git_worktree]
----------------------------------------

resource git_worktree_add(resource $repo,string $name,string $path,?array $opts)

void git_worktree_free(resource $worktree)

bool git_worktree_is_locked(string &$reason,resource $worktree)

bool git_worktree_is_prunable(resource $worktree,?array $opts)

array git_worktree_list(resource $repo)

void git_worktree_lock(resource $worktree,string $reason)

resource git_worktree_lookup(resource $repo,string $name)

string git_worktree_name(resource $worktree)

resource git_worktree_open_from_repository(resource $repo)

string git_worktree_path(resource $worktree)

int git_worktree_prune(resource $worktree,?array $opts)

int git_worktree_unlock(resource $worktree)

void git_worktree_validate(resource $worktree)

  This function will throw an exception when the worktree fails to validate.

--------------------------------------------------------------------------------
Class API Reference

The php-git2 extension provides an abstraction as a PHP class only when it is
useful for subclassing the construct (e.g. in the case of a git_odb_backend) or
when the C API employs struct with pointer-to-function members.

The following classes are provided by the extension:

abstract class GitODBBackend:

    This class has properties/methods that align with the git_odb_backend
    structure. You use it to define your own custom backend.

    properties:

        int $version

        resource $odb

    methods:

        NOTE: All methods should throw on failure.

        NOTE: If a method is not to be implemented, either leave it alone
              (i.e. do not implement it) or have it call trigger_error() with
              E_USER_ERROR. These functions can be called from userspace if you
              know what is available; however they are designed to be defined in
              userspace and called by git2.

        string read(int &$type,string $oid)

            The method should write the object type to the $type out parameter.

        string read_prefix(string &$full_oid,int &$type,string $abbrev_oid)

            Will return oid and type as out parameters respectively.

        void read_header(int &$size,int &$type,string $oid)

            Will return size and type as out parameters respectively.

        void write(string $oid,string $data,int $type)

        GitODBStream writestream(int $offset,int $object_type)

        GitODBStream readstream(int &$length,int &$type,string $oid)

            Return false if object not found.

        bool exists(string $oid)

        bool exists_prefix(string &$full_oid,string $prefix)

        void refresh()

        void for_each(callable $callback,mixed $payload)

            Note: This function is not named canonically with git2 since
                  "foreach" is a reserved word in PHP.

            Callback signature: int callback(string $id,mixed $payload)

            Notes on overriding:

            Some important distinctions apply when overriding due to
            implementation constraints. When the git2 library internally is
            routed to this method by the extension, the payload will be null
            even if some underlying value is assigned. In this case the
            extension takes care of forwarding the payload "behind the scenes"
            since the payload value cannot be converted to a PHP value (plus,
            that operation would be wasteful anyway). The payload value only
            really matters in userspace if userspace initiated the method call
            itself.

            An implementation overriding this method should always pass in the
            payload as the second parameter to the callback so that a userspace
            payload is routed correctly.

            If the callback returns FALSE (exactly), then the implementation
            should stop the iteration.

        GitODBWritepack writepack(resource $odb,callable $callback,mixed $payload)

            Callback signature: int callback(array $stats,mixed $payload)

            If the callack returns less than zero, the transfer should be
            canceled.

            NOTE: If this is called from GitODBBackend_Internal, then the object
            will be of type GitODBWritepack_Internal.

final class GitODBBackend_Internal extends GitODBBackend

    This class is used to represent internal ODB backends. It cannot be
    instantiated directly.

abstract class GitODBWritepack:

    This class has properties/methods that align with the git_odb_writepack
    structure.

    properties:

        GitODBBackend $backend

    methods:

        void append(array &$stats,string $data)

        void commit(array &$stats)

final class GitODBWritepack_Internal extends GitODBWritepack

    This class is used to represent an internal ODB writepack. It cannot be
    instantiated directly.

    You can access the transfer progress stats at any time via the $progress
    property. This is the same value returned via calls to append() and
    commit().

    properties:

        GitODBBackend $backend
        array $progress

    methods:

        void append(array &$stats,string $data)

        void commit(array &$stats)

abstract class GitODBStream:

    This class has properties/methods that align with the git_odb_stream
    structure. You use this class to interface with ODB stream's returned by
    libgit2 and to create your own custom ODB streams.

    properties:

        int $mode
        int $declared_size
        int $received_bytes

    methods:

        NOTE: All methods should throw on failure.

        string read(int $bufsz)

            Creates a buffer of the specified size and calls the read() function
            for the stream.

        void write(string $buffer)

        void finalize_write(string $oid)

final class GitODBStream_Internal extends GitODBStream:

    This class is used to represent internal ODB stream objects. It cannot be
    instantiated directly.

final class GitWritestream:

    This class has properties/methods that align with the git_writestream
    structure.

    methods:

        void write(string $buffer)

        void close()

abstract class GitConfigBackend:

    This class has properties/methods that align with the git_config_backend
    structure.

    properties:

        bool $readonly

    methods:

        NOTE: All methods should throw on failure.

        NOTE: If a method is not to be implemented, either leave it alone
              (i.e. do not implement it) or have it call trigger_error() with
              E_USER_ERROR. These functions can be called from userspace if you
              know what is available; however they are designed to be defined in
              userspace and called by git2.

        void open(int $level,resource $repo)

        array|bool get(string $key)

            This method returns array with properties 'name', 'value' and
            'level' corresponding to git_config_entry. If the method fails
            lookup, it should return false.

            If 'level' is not specified in the return array, then level defaults
            to GIT_CONFIG_LEVEL_APP.

        void set(string $key,string $value)

        void set_multivar(string $name,string $regexp,string $value)

        void del(string $name)

        void del_multivar(string $name,string $regexp)

        mixed iterator_new()

            This method should initialize the object for a new
            iteration. Iteration will call the iterator_next() method. The
            return value is interpreted as a context value that is passed to
            iterator_next(). The context value may be null if context is not
            required. (This is largely not useful since git2 config iteration is
            currently only synchronous when used by the library.)

        array|bool iterator_next(mixed $context)

            This method should return the next config value. The return value is
            the same as for the get() method.

            The $context argument holds the value returned from a previous call
            to iterator_new().

            This method must return false when iteration is over.

        GitConfigBackend snapshot()

        void lock()

        void unlock(bool $success)

abstract class GitRefDBBackend:

    This class has methods and properties that align with the git_refdb_backend
    structure. You can use this class to define your own custom reference
    databases.

    methods:

        bool exists(string $ref_name)

        mixed lookup(string $ref_name)

            Returns either:
              a) string value that is interpreted as either a reference OID or
                 symbolic name
              b) resource value of type 'git_reference'

        void iterator_new(string $glob)

            Parameter $glob may be NULL

        mixed iterator_next(string &$name)

            Returns either:
              a) string value that is interpreted as either a reference OID or
                 symbolic name
              b) resource value of type 'git_reference'

            Method should assign the reference name to the $name parameter in
            the case where a string reference OID or symbolic name is
            returned. If a reference resource is returned, the $name parameter
            is ignored.

            Method should return false when iteration is over.

        void write(resource $ref,bool $force,array $who,string $message,string $old,string $old_target)

            NOTE: $message may be NULL.

        resource rename(string $old_name,string $new_name,bool $force,array $who,string $message)

            NOTE: $message may be NULL.

            Returns git_reference resource

        void del(string $ref_name,string $old_id,string $old_target);

        void compress()

        bool has_log(string $refname)

        void ensure_log(string $refname)

        array reflog_read(string $name)

            NOTE: This method is unimplementable by custom backends until
                  libgit2 exposes proper support for creating/manipulating
                  reflogs.

            Method returns indexed array of reflog entries.

        void reflog_write(resource $reflog)

            Method is passed a git_reflog resource.

        void reflog_rename(string $old_name,string $new_name)

        void reflog_delete(string $name)

        mixed lock(string $refname)

            NOTE: Whatever value is returned from this method is the value
                  subsequently passed as the first argument to the unlock()
                  method.

        void unlock(mixed $payload,bool $success,bool $update_reflog,resource $ref,array $sig,string $message)

final class GitRefDBBackend_Internal extends GitRefDBBackend:

    This class represents internal refdb backends. You use this class to
    interface with refdb backends returned by libgit2, such as from
    git_refdb_backend_fs().

    This class cannot be instantiated directly.

    This class does not provide access to the lock() and unlock() methods. They
    will generate a fatal error if called.

    The lookup() method will always return a resource value.