perl/Git.pm

   1 =head1 NAME
   2
   3 Git - Perl interface to the Git version control system
   4
   5 =cut
   6
   7
   8 package Git;
   9
  10 use strict;
  11
  12
  13 BEGIN {
  14
  15 our ($VERSION, @ISA, @EXPORT, @EXPORT_OK);
  16
  17 # Totally unstable API.
  18 $VERSION = '0.01';
  19
  20
  21 =head1 SYNOPSIS
  22
  23   use Git;
  24
  25   my $version = Git::command_oneline('version');
  26
  27   git_cmd_try { Git::command_noisy('update-server-info') }
  28               '%s failed w/ code %d';
  29
  30   my $repo = Git->repository (Directory => '/srv/git/cogito.git');
  31
  32
  33   my @revs = $repo->command('rev-list', '--since=last monday', '--all');
  34
  35   my ($fh, $c) = $repo->command_output_pipe('rev-list', '--since=last monday', '--all');
  36   my $lastrev = <$fh>; chomp $lastrev;
  37   $repo->command_close_pipe($fh, $c);
  38
  39   my $lastrev = $repo->command_oneline( [ 'rev-list', '--all' ],
  40                                         STDERR => 0 );
  41
  42 =cut
  43
  44
  45 require Exporter;
  46
  47 @ISA = qw(Exporter);
  48
  49 @EXPORT = qw(git_cmd_try);
  50
  51 # Methods which can be called as standalone functions as well:
  52 @EXPORT_OK = qw(command command_oneline command_noisy
  53                 command_output_pipe command_input_pipe command_close_pipe
  54                 version exec_path hash_object git_cmd_try);
  55
  56
  57 =head1 DESCRIPTION
  58
  59 This module provides Perl scripts easy way to interface the Git version control
  60 system. The modules have an easy and well-tested way to call arbitrary Git
  61 commands; in the future, the interface will also provide specialized methods
  62 for doing easily operations which are not totally trivial to do over
  63 the generic command interface.
  64
  65 While some commands can be executed outside of any context (e.g. 'version'
  66 or 'init-db'), most operations require a repository context, which in practice
  67 means getting an instance of the Git object using the repository() constructor.
  68 (In the future, we will also get a new_repository() constructor.) All commands
  69 called as methods of the object are then executed in the context of the
  70 repository.
  71
  72 Part of the "repository state" is also information about path to the attached
  73 working copy (unless you work with a bare repository). You can also navigate
  74 inside of the working copy using the C<wc_chdir()> method. (Note that
  75 the repository object is self-contained and will not change working directory
  76 of your process.)
  77
  78 TODO: In the future, we might also do
  79
  80         my $remoterepo = $repo->remote_repository (Name => 'cogito', Branch => 'master');
  81         $remoterepo ||= Git->remote_repository ('http://git.or.cz/cogito.git/');
  82         my @refs = $remoterepo->refs();
  83
  84 Currently, the module merely wraps calls to external Git tools. In the future,
  85 it will provide a much faster way to interact with Git by linking directly
  86 to libgit. This should be completely opaque to the user, though (performance
  87 increate nonwithstanding).
  88
  89 =cut
  90
  91
  92 use Carp qw(carp croak); # but croak is bad - throw instead
  93 use Error qw(:try);
  94 use Cwd qw(abs_path);
  95
  96 require XSLoader;
  97 XSLoader::load('Git', $VERSION);
  98
  99 }
 100
 101 my $instance_id = 0;
 102
 103
 104 =head1 CONSTRUCTORS
 105
 106 =over 4
 107
 108 =item repository ( OPTIONS )
 109
 110 =item repository ( DIRECTORY )
 111
 112 =item repository ()
 113
 114 Construct a new repository object.
 115 C<OPTIONS> are passed in a hash like fashion, using key and value pairs.
 116 Possible options are:
 117
 118 B<Repository> - Path to the Git repository.
 119
 120 B<WorkingCopy> - Path to the associated working copy; not strictly required
 121 as many commands will happily crunch on a bare repository.
 122
 123 B<WorkingSubdir> - Subdirectory in the working copy to work inside.
 124 Just left undefined if you do not want to limit the scope of operations.
 125
 126 B<Directory> - Path to the Git working directory in its usual setup.
 127 The C<.git> directory is searched in the directory and all the parent
 128 directories; if found, C<WorkingCopy> is set to the directory containing
 129 it and C<Repository> to the C<.git> directory itself. If no C<.git>
 130 directory was found, the C<Directory> is assumed to be a bare repository,
 131 C<Repository> is set to point at it and C<WorkingCopy> is left undefined.
 132 If the C<$GIT_DIR> environment variable is set, things behave as expected
 133 as well.
 134
 135 You should not use both C<Directory> and either of C<Repository> and
 136 C<WorkingCopy> - the results of that are undefined.
 137
 138 Alternatively, a directory path may be passed as a single scalar argument
 139 to the constructor; it is equivalent to setting only the C<Directory> option
 140 field.
 141
 142 Calling the constructor with no options whatsoever is equivalent to
 143 calling it with C<< Directory => '.' >>. In general, if you are building
 144 a standard porcelain command, simply doing C<< Git->repository() >> should
 145 do the right thing and setup the object to reflect exactly where the user
 146 is right now.
 147
 148 =cut
 149
 150 sub repository {
 151         my $class = shift;
 152         my @args = @_;
 153         my %opts = ();
 154         my $self;
 155
 156         if (defined $args[0]) {
 157                 if ($#args % 2 != 1) {
 158                         # Not a hash.
 159                         $#args == 0 or throw Error::Simple("bad usage");
 160                         %opts = ( Directory => $args[0] );
 161                 } else {
 162                         %opts = @args;
 163                 }
 164         }
 165
 166         if (not defined $opts{Repository} and not defined $opts{WorkingCopy}) {
 167                 $opts{Directory} ||= '.';
 168         }
 169
 170         if ($opts{Directory}) {
 171                 -d $opts{Directory} or throw Error::Simple("Directory not found: $!");
 172
 173                 my $search = Git->repository(WorkingCopy => $opts{Directory});
 174                 my $dir;
 175                 try {
 176                         $dir = $search->command_oneline(['rev-parse', '--git-dir'],
 177                                                         STDERR => 0);
 178                 } catch Git::Error::Command with {
 179                         $dir = undef;
 180                 };
 181
 182                 if ($dir) {
 183                         $dir =~ m#^/# or $dir = $opts{Directory} . '/' . $dir;
 184                         $opts{Repository} = $dir;
 185
 186                         # If --git-dir went ok, this shouldn't die either.
 187                         my $prefix = $search->command_oneline('rev-parse', '--show-prefix');
 188                         $dir = abs_path($opts{Directory}) . '/';
 189                         if ($prefix) {
 190                                 if (substr($dir, -length($prefix)) ne $prefix) {
 191                                         throw Error::Simple("rev-parse confused me - $dir does not have trailing $prefix");
 192                                 }
 193                                 substr($dir, -length($prefix)) = '';
 194                         }
 195                         $opts{WorkingCopy} = $dir;
 196                         $opts{WorkingSubdir} = $prefix;
 197
 198                 } else {
 199                         # A bare repository? Let's see...
 200                         $dir = $opts{Directory};
 201
 202                         unless (-d "$dir/refs" and -d "$dir/objects" and -e "$dir/HEAD") {
 203                                 # Mimick git-rev-parse --git-dir error message:
 204                                 throw Error::Simple('fatal: Not a git repository');
 205                         }
 206                         my $search = Git->repository(Repository => $dir);
 207                         try {
 208                                 $search->command('symbolic-ref', 'HEAD');
 209                         } catch Git::Error::Command with {
 210                                 # Mimick git-rev-parse --git-dir error message:
 211                                 throw Error::Simple('fatal: Not a git repository');
 212                         }
 213
 214                         $opts{Repository} = abs_path($dir);
 215                 }
 216
 217                 delete $opts{Directory};
 218         }
 219
 220         $self = { opts => \%opts, id => $instance_id++ };
 221         bless $self, $class;
 222 }
 223
 224
 225 =back
 226
 227 =head1 METHODS
 228
 229 =over 4
 230
 231 =item command ( COMMAND [, ARGUMENTS... ] )
 232
 233 =item command ( [ COMMAND, ARGUMENTS... ], { Opt => Val ... } )
 234
 235 Execute the given Git C<COMMAND> (specify it without the 'git-'
 236 prefix), optionally with the specified extra C<ARGUMENTS>.
 237
 238 The second more elaborate form can be used if you want to further adjust
 239 the command execution. Currently, only one option is supported:
 240
 241 B<STDERR> - How to deal with the command's error output. By default (C<undef>)
 242 it is delivered to the caller's C<STDERR>. A false value (0 or '') will cause
 243 it to be thrown away. If you want to process it, you can get it in a filehandle
 244 you specify, but you must be extremely careful; if the error output is not
 245 very short and you want to read it in the same process as where you called
 246 C<command()>, you are set up for a nice deadlock!
 247
 248 The method can be called without any instance or on a specified Git repository
 249 (in that case the command will be run in the repository context).
 250
 251 In scalar context, it returns all the command output in a single string
 252 (verbatim).
 253
 254 In array context, it returns an array containing lines printed to the
 255 command's stdout (without trailing newlines).
 256
 257 In both cases, the command's stdin and stderr are the same as the caller's.
 258
 259 =cut
 260
 261 sub command {
 262         my ($fh, $ctx) = command_output_pipe(@_);
 263
 264         if (not defined wantarray) {
 265                 # Nothing to pepper the possible exception with.
 266                 _cmd_close($fh, $ctx);
 267
 268         } elsif (not wantarray) {
 269                 local $/;
 270                 my $text = <$fh>;
 271                 try {
 272                         _cmd_close($fh, $ctx);
 273                 } catch Git::Error::Command with {
 274                         # Pepper with the output:
 275                         my $E = shift;
 276                         $E->{'-outputref'} = \$text;
 277                         throw $E;
 278                 };
 279                 return $text;
 280
 281         } else {
 282                 my @lines = <$fh>;
 283                 chomp @lines;
 284                 try {
 285                         _cmd_close($fh, $ctx);
 286                 } catch Git::Error::Command with {
 287                         my $E = shift;
 288                         $E->{'-outputref'} = \@lines;
 289                         throw $E;
 290                 };
 291                 return @lines;
 292         }
 293 }
 294
 295
 296 =item command_oneline ( COMMAND [, ARGUMENTS... ] )
 297
 298 =item command_oneline ( [ COMMAND, ARGUMENTS... ], { Opt => Val ... } )
 299
 300 Execute the given C<COMMAND> in the same way as command()
 301 does but always return a scalar string containing the first line
 302 of the command's standard output.
 303
 304 =cut
 305
 306 sub command_oneline {
 307         my ($fh, $ctx) = command_output_pipe(@_);
 308
 309         my $line = <$fh>;
 310         defined $line and chomp $line;
 311         try {
 312                 _cmd_close($fh, $ctx);
 313         } catch Git::Error::Command with {
 314                 # Pepper with the output:
 315                 my $E = shift;
 316                 $E->{'-outputref'} = \$line;
 317                 throw $E;
 318         };
 319         return $line;
 320 }
 321
 322
 323 =item command_output_pipe ( COMMAND [, ARGUMENTS... ] )
 324
 325 =item command_output_pipe ( [ COMMAND, ARGUMENTS... ], { Opt => Val ... } )
 326
 327 Execute the given C<COMMAND> in the same way as command()
 328 does but return a pipe filehandle from which the command output can be
 329 read.
 330
 331 The function can return C<($pipe, $ctx)> in array context.
 332 See C<command_close_pipe()> for details.
 333
 334 =cut
 335
 336 sub command_output_pipe {
 337         _command_common_pipe('-|', @_);
 338 }
 339
 340
 341 =item command_input_pipe ( COMMAND [, ARGUMENTS... ] )
 342
 343 =item command_input_pipe ( [ COMMAND, ARGUMENTS... ], { Opt => Val ... } )
 344
 345 Execute the given C<COMMAND> in the same way as command_output_pipe()
 346 does but return an input pipe filehandle instead; the command output
 347 is not captured.
 348
 349 The function can return C<($pipe, $ctx)> in array context.
 350 See C<command_close_pipe()> for details.
 351
 352 =cut
 353
 354 sub command_input_pipe {
 355         _command_common_pipe('|-', @_);
 356 }
 357
 358
 359 =item command_close_pipe ( PIPE [, CTX ] )
 360
 361 Close the C<PIPE> as returned from C<command_*_pipe()>, checking
 362 whether the command finished successfuly. The optional C<CTX> argument
 363 is required if you want to see the command name in the error message,
 364 and it is the second value returned by C<command_*_pipe()> when
 365 called in array context. The call idiom is:
 366
 367         my ($fh, $ctx) = $r->command_output_pipe('status');
 368         while (<$fh>) { ... }
 369         $r->command_close_pipe($fh, $ctx);
 370
 371 Note that you should not rely on whatever actually is in C<CTX>;
 372 currently it is simply the command name but in future the context might
 373 have more complicated structure.
 374
 375 =cut
 376
 377 sub command_close_pipe {
 378         my ($self, $fh, $ctx) = _maybe_self(@_);
 379         $ctx ||= '<unknown>';
 380         _cmd_close($fh, $ctx);
 381 }
 382
 383
 384 =item command_noisy ( COMMAND [, ARGUMENTS... ] )
 385
 386 Execute the given C<COMMAND> in the same way as command() does but do not
 387 capture the command output - the standard output is not redirected and goes
 388 to the standard output of the caller application.
 389
 390 While the method is called command_noisy(), you might want to as well use
 391 it for the most silent Git commands which you know will never pollute your
 392 stdout but you want to avoid the overhead of the pipe setup when calling them.
 393
 394 The function returns only after the command has finished running.
 395
 396 =cut
 397
 398 sub command_noisy {
 399         my ($self, $cmd, @args) = _maybe_self(@_);
 400         _check_valid_cmd($cmd);
 401
 402         my $pid = fork;
 403         if (not defined $pid) {
 404                 throw Error::Simple("fork failed: $!");
 405         } elsif ($pid == 0) {
 406                 _cmd_exec($self, $cmd, @args);
 407         }
 408         if (waitpid($pid, 0) > 0 and $?>>8 != 0) {
 409                 throw Git::Error::Command(join(' ', $cmd, @args), $? >> 8);
 410         }
 411 }
 412
 413
 414 =item version ()
 415
 416 Return the Git version in use.
 417
 418 Implementation of this function is very fast; no external command calls
 419 are involved.
 420
 421 =cut
 422
 423 # Implemented in Git.xs.
 424
 425
 426 =item exec_path ()
 427
 428 Return path to the Git sub-command executables (the same as
 429 C<git --exec-path>). Useful mostly only internally.
 430
 431 Implementation of this function is very fast; no external command calls
 432 are involved.
 433
 434 =cut
 435
 436 # Implemented in Git.xs.
 437
 438
 439 =item repo_path ()
 440
 441 Return path to the git repository. Must be called on a repository instance.
 442
 443 =cut
 444
 445 sub repo_path { $_[0]->{opts}->{Repository} }
 446
 447
 448 =item wc_path ()
 449
 450 Return path to the working copy. Must be called on a repository instance.
 451
 452 =cut
 453
 454 sub wc_path { $_[0]->{opts}->{WorkingCopy} }
 455
 456
 457 =item wc_subdir ()
 458
 459 Return path to the subdirectory inside of a working copy. Must be called
 460 on a repository instance.
 461
 462 =cut
 463
 464 sub wc_subdir { $_[0]->{opts}->{WorkingSubdir} ||= '' }
 465
 466
 467 =item wc_chdir ( SUBDIR )
 468
 469 Change the working copy subdirectory to work within. The C<SUBDIR> is
 470 relative to the working copy root directory (not the current subdirectory).
 471 Must be called on a repository instance attached to a working copy
 472 and the directory must exist.
 473
 474 =cut
 475
 476 sub wc_chdir {
 477         my ($self, $subdir) = @_;
 478         $self->wc_path()
 479                 or throw Error::Simple("bare repository");
 480
 481         -d $self->wc_path().'/'.$subdir
 482                 or throw Error::Simple("subdir not found: $!");
 483         # Of course we will not "hold" the subdirectory so anyone
 484         # can delete it now and we will never know. But at least we tried.
 485
 486         $self->{opts}->{WorkingSubdir} = $subdir;
 487 }
 488
 489
 490 =item config ( VARIABLE )
 491
 492 Retrieve the configuration C<VARIABLE> in the same manner as C<repo-config>
 493 does. In scalar context requires the variable to be set only one time
 494 (exception is thrown otherwise), in array context returns allows the
 495 variable to be set multiple times and returns all the values.
 496
 497 Must be called on a repository instance.
 498
 499 This currently wraps command('repo-config') so it is not so fast.
 500
 501 =cut
 502
 503 sub config {
 504         my ($self, $var) = @_;
 505         $self->repo_path()
 506                 or throw Error::Simple("not a repository");
 507
 508         try {
 509                 if (wantarray) {
 510                         return $self->command('repo-config', '--get-all', $var);
 511                 } else {
 512                         return $self->command_oneline('repo-config', '--get', $var);
 513                 }
 514         } catch Git::Error::Command with {
 515                 my $E = shift;
 516                 if ($E->value() == 1) {
 517                         # Key not found.
 518                         return undef;
 519                 } else {
 520                         throw $E;
 521                 }
 522         };
 523 }
 524
 525
 526 =item ident ( TYPE | IDENTSTR )
 527
 528 =item ident_person ( TYPE | IDENTSTR | IDENTARRAY )
 529
 530 This suite of functions retrieves and parses ident information, as stored
 531 in the commit and tag objects or produced by C<var GIT_type_IDENT> (thus
 532 C<TYPE> can be either I<author> or I<committer>; case is insignificant).
 533
 534 The C<ident> method retrieves the ident information from C<git-var>
 535 and either returns it as a scalar string or as an array with the fields parsed.
 536 Alternatively, it can take a prepared ident string (e.g. from the commit
 537 object) and just parse it.
 538
 539 C<ident_person> returns the person part of the ident - name and email;
 540 it can take the same arguments as C<ident> or the array returned by C<ident>.
 541
 542 The synopsis is like:
 543
 544         my ($name, $email, $time_tz) = ident('author');
 545         "$name <$email>" eq ident_person('author');
 546         "$name <$email>" eq ident_person($name);
 547         $time_tz =~ /^\d+ [+-]\d{4}$/;
 548
 549 Both methods must be called on a repository instance.
 550
 551 =cut
 552
 553 sub ident {
 554         my ($self, $type) = @_;
 555         my $identstr;
 556         if (lc $type eq lc 'committer' or lc $type eq lc 'author') {
 557                 $identstr = $self->command_oneline('var', 'GIT_'.uc($type).'_IDENT');
 558         } else {
 559                 $identstr = $type;
 560         }
 561         if (wantarray) {
 562                 return $identstr =~ /^(.*) <(.*)> (\d+ [+-]\d{4})$/;
 563         } else {
 564                 return $identstr;
 565         }
 566 }
 567
 568 sub ident_person {
 569         my ($self, @ident) = @_;
 570         $#ident == 0 and @ident = $self->ident($ident[0]);
 571         return "$ident[0] <$ident[1]>";
 572 }
 573
 574
 575 =item get_object ( TYPE, SHA1 )
 576
 577 Return contents of the given object in a scalar string. If the object has
 578 not been found, undef is returned; however, do not rely on this! Currently,
 579 if you use multiple repositories at once, get_object() on one repository
 580 _might_ return the object even though it exists only in another repository.
 581 (But do not rely on this behaviour either.)
 582
 583 The method must be called on a repository instance.
 584
 585 Implementation of this method is very fast; no external command calls
 586 are involved. That's why it is broken, too. ;-)
 587
 588 =cut
 589
 590 # Implemented in Git.xs.
 591
 592
 593 =item hash_object ( TYPE, FILENAME )
 594
 595 =item hash_object ( TYPE, FILEHANDLE )
 596
 597 Compute the SHA1 object id of the given C<FILENAME> (or data waiting in
 598 C<FILEHANDLE>) considering it is of the C<TYPE> object type (C<blob>,
 599 C<commit>, C<tree>).
 600
 601 In case of C<FILEHANDLE> passed instead of file name, all the data
 602 available are read and hashed, and the filehandle is automatically
 603 closed. The file handle should be freshly opened - if you have already
 604 read anything from the file handle, the results are undefined (since
 605 this function works directly with the file descriptor and internal
 606 PerlIO buffering might have messed things up).
 607
 608 The method can be called without any instance or on a specified Git repository,
 609 it makes zero difference.
 610
 611 The function returns the SHA1 hash.
 612
 613 Implementation of this function is very fast; no external command calls
 614 are involved.
 615
 616 =cut
 617
 618 sub hash_object {
 619         my ($self, $type, $file) = _maybe_self(@_);
 620
 621         # hash_object_* implemented in Git.xs.
 622
 623         if (ref($file) eq 'GLOB') {
 624                 my $hash = hash_object_pipe($type, fileno($file));
 625                 close $file;
 626                 return $hash;
 627         } else {
 628                 hash_object_file($type, $file);
 629         }
 630 }
 631
 632
 633
 634 =back
 635
 636 =head1 ERROR HANDLING
 637
 638 All functions are supposed to throw Perl exceptions in case of errors.
 639 See the L<Error> module on how to catch those. Most exceptions are mere
 640 L<Error::Simple> instances.
 641
 642 However, the C<command()>, C<command_oneline()> and C<command_noisy()>
 643 functions suite can throw C<Git::Error::Command> exceptions as well: those are
 644 thrown when the external command returns an error code and contain the error
 645 code as well as access to the captured command's output. The exception class
 646 provides the usual C<stringify> and C<value> (command's exit code) methods and
 647 in addition also a C<cmd_output> method that returns either an array or a
 648 string with the captured command output (depending on the original function
 649 call context; C<command_noisy()> returns C<undef>) and $<cmdline> which
 650 returns the command and its arguments (but without proper quoting).
 651
 652 Note that the C<command_*_pipe()> functions cannot throw this exception since
 653 it has no idea whether the command failed or not. You will only find out
 654 at the time you C<close> the pipe; if you want to have that automated,
 655 use C<command_close_pipe()>, which can throw the exception.
 656
 657 =cut
 658
 659 {
 660         package Git::Error::Command;
 661
 662         @Git::Error::Command::ISA = qw(Error);
 663
 664         sub new {
 665                 my $self = shift;
 666                 my $cmdline = '' . shift;
 667                 my $value = 0 + shift;
 668                 my $outputref = shift;
 669                 my(@args) = ();
 670
 671                 local $Error::Depth = $Error::Depth + 1;
 672
 673                 push(@args, '-cmdline', $cmdline);
 674                 push(@args, '-value', $value);
 675                 push(@args, '-outputref', $outputref);
 676
 677                 $self->SUPER::new(-text => 'command returned error', @args);
 678         }
 679
 680         sub stringify {
 681                 my $self = shift;
 682                 my $text = $self->SUPER::stringify;
 683                 $self->cmdline() . ': ' . $text . ': ' . $self->value() . "\n";
 684         }
 685
 686         sub cmdline {
 687                 my $self = shift;
 688                 $self->{'-cmdline'};
 689         }
 690
 691         sub cmd_output {
 692                 my $self = shift;
 693                 my $ref = $self->{'-outputref'};
 694                 defined $ref or undef;
 695                 if (ref $ref eq 'ARRAY') {
 696                         return @$ref;
 697                 } else { # SCALAR
 698                         return $$ref;
 699                 }
 700         }
 701 }
 702
 703 =over 4
 704
 705 =item git_cmd_try { CODE } ERRMSG
 706
 707 This magical statement will automatically catch any C<Git::Error::Command>
 708 exceptions thrown by C<CODE> and make your program die with C<ERRMSG>
 709 on its lips; the message will have %s substituted for the command line
 710 and %d for the exit status. This statement is useful mostly for producing
 711 more user-friendly error messages.
 712
 713 In case of no exception caught the statement returns C<CODE>'s return value.
 714
 715 Note that this is the only auto-exported function.
 716
 717 =cut
 718
 719 sub git_cmd_try(&$) {
 720         my ($code, $errmsg) = @_;
 721         my @result;
 722         my $err;
 723         my $array = wantarray;
 724         try {
 725                 if ($array) {
 726                         @result = &$code;
 727                 } else {
 728                         $result[0] = &$code;
 729                 }
 730         } catch Git::Error::Command with {
 731                 my $E = shift;
 732                 $err = $errmsg;
 733                 $err =~ s/\%s/$E->cmdline()/ge;
 734                 $err =~ s/\%d/$E->value()/ge;
 735                 # We can't croak here since Error.pm would mangle
 736                 # that to Error::Simple.
 737         };
 738         $err and croak $err;
 739         return $array ? @result : $result[0];
 740 }
 741
 742
 743 =back
 744
 745 =head1 COPYRIGHT
 746
 747 Copyright 2006 by Petr Baudis E<lt>pasky@suse.czE<gt>.
 748
 749 This module is free software; it may be used, copied, modified
 750 and distributed under the terms of the GNU General Public Licence,
 751 either version 2, or (at your option) any later version.
 752
 753 =cut
 754
 755
 756 # Take raw method argument list and return ($obj, @args) in case
 757 # the method was called upon an instance and (undef, @args) if
 758 # it was called directly.
 759 sub _maybe_self {
 760         # This breaks inheritance. Oh well.
 761         ref $_[0] eq 'Git' ? @_ : (undef, @_);
 762 }
 763
 764 # Check if the command id is something reasonable.
 765 sub _check_valid_cmd {
 766         my ($cmd) = @_;
 767         $cmd =~ /^[a-z0-9A-Z_-]+$/ or throw Error::Simple("bad command: $cmd");
 768 }
 769
 770 # Common backend for the pipe creators.
 771 sub _command_common_pipe {
 772         my $direction = shift;
 773         my ($self, @p) = _maybe_self(@_);
 774         my (%opts, $cmd, @args);
 775         if (ref $p[0]) {
 776                 ($cmd, @args) = @{shift @p};
 777                 %opts = ref $p[0] ? %{$p[0]} : @p;
 778         } else {
 779                 ($cmd, @args) = @p;
 780         }
 781         _check_valid_cmd($cmd);
 782
 783         my $fh;
 784         if ($^O eq '##INSERT_ACTIVESTATE_STRING_HERE##') {
 785                 # ActiveState Perl
 786                 #defined $opts{STDERR} and
 787                 #       warn 'ignoring STDERR option - running w/ ActiveState';
 788                 $direction eq '-|' or
 789                         die 'input pipe for ActiveState not implemented';
 790                 tie ($fh, 'Git::activestate_pipe', $cmd, @args);
 791
 792         } else {
 793                 my $pid = open($fh, $direction);
 794                 if (not defined $pid) {
 795                         throw Error::Simple("open failed: $!");
 796                 } elsif ($pid == 0) {
 797                         if (defined $opts{STDERR}) {
 798                                 close STDERR;
 799                         }
 800                         if ($opts{STDERR}) {
 801                                 open (STDERR, '>&', $opts{STDERR})
 802                                         or die "dup failed: $!";
 803                         }
 804                         _cmd_exec($self, $cmd, @args);
 805                 }
 806         }
 807         return wantarray ? ($fh, join(' ', $cmd, @args)) : $fh;
 808 }
 809
 810 # When already in the subprocess, set up the appropriate state
 811 # for the given repository and execute the git command.
 812 sub _cmd_exec {
 813         my ($self, @args) = @_;
 814         if ($self) {
 815                 $self->repo_path() and $ENV{'GIT_DIR'} = $self->repo_path();
 816                 $self->wc_path() and chdir($self->wc_path());
 817                 $self->wc_subdir() and chdir($self->wc_subdir());
 818         }
 819         _execv_git_cmd(@args);
 820         die "exec failed: $!";
 821 }
 822
 823 # Execute the given Git command ($_[0]) with arguments ($_[1..])
 824 # by searching for it at proper places.
 825 # _execv_git_cmd(), implemented in Git.xs.
 826
 827 # Close pipe to a subprocess.
 828 sub _cmd_close {
 829         my ($fh, $ctx) = @_;
 830         if (not close $fh) {
 831                 if ($!) {
 832                         # It's just close, no point in fatalities
 833                         carp "error closing pipe: $!";
 834                 } elsif ($? >> 8) {
 835                         # The caller should pepper this.
 836                         throw Git::Error::Command($ctx, $? >> 8);
 837                 }
 838                 # else we might e.g. closed a live stream; the command
 839                 # dying of SIGPIPE would drive us here.
 840         }
 841 }
 842
 843
 844 # Trickery for .xs routines: In order to avoid having some horrid
 845 # C code trying to do stuff with undefs and hashes, we gate all
 846 # xs calls through the following and in case we are being ran upon
 847 # an instance call a C part of the gate which will set up the
 848 # environment properly.
 849 sub _call_gate {
 850         my $xsfunc = shift;
 851         my ($self, @args) = _maybe_self(@_);
 852
 853         if (defined $self) {
 854                 # XXX: We ignore the WorkingCopy! To properly support
 855                 # that will require heavy changes in libgit.
 856                 # For now, when we will need to do it we could temporarily
 857                 # chdir() there and then chdir() back after the call is done.
 858
 859                 xs__call_gate($self->{id}, $self->repo_path());
 860         }
 861
 862         # Having to call throw from the C code is a sure path to insanity.
 863         local $SIG{__DIE__} = sub { throw Error::Simple("@_"); };
 864         &$xsfunc(@args);
 865 }
 866
 867 sub AUTOLOAD {
 868         my $xsname;
 869         our $AUTOLOAD;
 870         ($xsname = $AUTOLOAD) =~ s/.*:://;
 871         throw Error::Simple("&Git::$xsname not defined") if $xsname =~ /^xs_/;
 872         $xsname = 'xs_'.$xsname;
 873         _call_gate(\&$xsname, @_);
 874 }
 875
 876 sub DESTROY { }
 877
 878
 879 # Pipe implementation for ActiveState Perl.
 880
 881 package Git::activestate_pipe;
 882 use strict;
 883
 884 sub TIEHANDLE {
 885         my ($class, @params) = @_;
 886         # FIXME: This is probably horrible idea and the thing will explode
 887         # at the moment you give it arguments that require some quoting,
 888         # but I have no ActiveState clue... --pasky
 889         my $cmdline = join " ", @params;
 890         my @data = qx{$cmdline};
 891         bless { i => 0, data => \@data }, $class;
 892 }
 893
 894 sub READLINE {
 895         my $self = shift;
 896         if ($self->{i} >= scalar @{$self->{data}}) {
 897                 return undef;
 898         }
 899         return $self->{'data'}->[ $self->{i}++ ];
 900 }
 901
 902 sub CLOSE {
 903         my $self = shift;
 904         delete $self->{data};
 905         delete $self->{i};
 906 }
 907
 908 sub EOF {
 909         my $self = shift;
 910         return ($self->{i} >= scalar @{$self->{data}});
 911 }
 912
 913
 914 1; # Famous last words