new¶

    Git::Repository->new( %args, $options );

Create a new Git::Repository object, based on an existing Git repository.

Parameters are:

git_dir => $gitdir

The location of the git repository (.git directory or equivalent).

For backward compatibility with versions 1.06 and before, "repository" is accepted in place of "git_dir" (but the newer name takes precedence).

work_tree => $dir

The location of the git working copy (for a non-bare repository).

If "work_tree" actually points to a subdirectory of the work tree, Git::Repository will automatically recompute the proper value.

For backward compatibility with versions 1.06 and before, "working_copy" is accepted in place of "work_tree" (but the newer name takes precedence).

If none of the parameter is given, Git::Repository will find the appropriate repository just like Git itself does. Otherwise, one of the parameters is usually enough, as Git::Repository can work out where the other directory (if any) is.

new() also accepts a reference to an option hash which will be used as the default by Git::Repository::Command when working with the corresponding Git::Repository instance.

So this:

    my $r = Git::Repository->new(
        # parameters
        work_tree => $dir,
        # options
        {   git => '/path/to/some/other/git',
            env => {
                GIT_COMMITTER_EMAIL => 'book@cpan.org',
                GIT_COMMITTER_NAME  => 'Philippe Bruhat (BooK)',
            },
        }
    );

is equivalent to explicitly passing the option hash to each run() or command() call. The documentation for Git::Repository::Command lists all available options.

Note that Git::Repository and Git::Repository::Command take great care in finding the option hash wherever it may be in @_, and to merge multiple option hashes if more than one is provided.

It probably makes no sense to set the "input" option in new(), but Git::Repository won't stop you. Note that on some systems, some git commands may close standard input on startup, which will cause a "SIGPIPE". Git::Repository::Command will raise an exception.

To create a Git repository and obtain a Git::Repository object pointing to it, simply do it in two steps:

    # run a clone or init command without an instance,
    # using options like cwd
    Git::Repository->run( ... );
    # obtain a Git::Repository instance
    # on the resulting repository
    $r = Git::Repository->new( ... );

command¶

    Git::Repository->command( @cmd );
    $r->command( @cmd );

Runs the git sub-command and options, and returns a Git::Repository::Command object pointing to the sub-process running the command.

As described in the Git::Repository::Command documentation, @cmd may also contain a hashref containing options for the command.

run¶

    Git::Repository->run( @cmd );
    $r->run( @cmd );

Runs the command and returns the output as a string in scalar context, or as a list of lines in list context. Also accepts a hashref of options.

Lines are automatically "chomp"ed.

In addition to the options hashref supported by Git::Repository::Command, the parameter list can also contain code references, that will be applied successively to each line of output. The line being processed is in $_, but the coderef must still return the result string (like "map").

If the git command printed anything on stderr, it will be printed as warnings. For convenience, if the git sub-process exited with status 128 (fatal error), or 129 (usage message), run() will die(). The exit status values for which run() dies can be modified using the "fatal" option (see Git::Repository::Command for details).

The exit status of the command that was just run is accessible as usual using "$? >> 8". See perlvar for details about $?.

git_dir¶

Returns the repository path.

work_tree¶

Returns the working copy path. Used as current working directory by Git::Repository::Command.

options¶

Return the option hash that was passed to "Git::Repository->new()".

version¶

Return the version of git, as given by "git --version".

Version-comparison "operators"¶

Git evolves very fast, and new features are constantly added. To facilitate the creation of programs that can properly handle the wide variety of Git versions seen in the wild, a number of version comparison "operators" are available.

They are named "version_op" where op is the equivalent of the Perl operators "lt", "gt", "le", "ge", "eq", "ne". They return a boolean value, obtained by comparing the version of the git binary and the version string passed as parameter.

The methods are:

version_lt( $version )

version_gt( $version )

version_le( $version )

version_ge( $version )

version_eq( $version )

version_ne( $version )

All those methods also accept an option hash, just like the others.

The actual version-comparison logic is managed by Git::Version::Compare. Check its documentation for details.

Git.pm¶

Git.pm was not on CPAN in 2010. It is packaged with Git, and installed with the system Perl libraries. Not being on CPAN made it harder to install in any Perl. It made it harder for a CPAN library to depend on it.

It doesn't allow calling "git init" or "git clone".

The "command_bidi_pipe" function especially has problems: <http://kerneltrap.org/mailarchive/git/2008/10/24/3789584>

The Git module from git.git was packaged as a CPAN distribution by MSOUTH in June 2013.

Git::Class¶

Git::Class depends on Moose, which seems an unnecessary dependency for a simple wrapper around Git. The startup penalty could become significant for command-line tools.

Although it supports "git init" and "git clone" (and has methods to call any Git command), it is mostly aimed at porcelain commands, and provides no way to control bidirectional commands (such as "git commit-tree").

Git::Wrapper¶

Git::Wrapper doesn't support streams or bidirectional commands.

Git::Sub¶

(This description was added for completeness in May 2013.)

Git::Sub appeared in 2013, as a set of Git-specific System::Sub functions. It provide a nice set of "git::" functions, and has some limitations (due to the way System::Sub itself works) which don't impact most Git commands.

Git::Sub doesn't support working with streams.

Git::Raw¶

(This description was added for completeness in September 2014, upon request of the author of Git::Raw.)

Git::Raw provides bindings to libgit2 <https://libgit2.github.io/>, a pure C implementation of the Git core methods. Most of the functions provided by libgit2 are available. If you have complex workflows, or even if speed is of the essence, this may be a more attractive solution than shelling out to git.