GitInfo.php

Go to the documentation of this file.

<?php
class GitInfo {

    protected static $repo = null;

    protected $basedir;

    private static $viewers = false;

    public function __construct( $dir ) {
        $this->basedir = $dir . DIRECTORY_SEPARATOR . '.git';
        if ( is_readable( $this->basedir ) && !is_dir( $this->basedir ) ) {
            $GITfile = file_get_contents( $this->basedir );
            if ( strlen( $GITfile ) > 8 && substr( $GITfile, 0, 8 ) === 'gitdir: ' ) {
                $path = rtrim( substr( $GITfile, 8 ), "\r\n" );
                $isAbsolute = $path[0] === '/' || substr( $path, 1, 1 ) === ':';
                $this->basedir = $isAbsolute ? $path : $dir . DIRECTORY_SEPARATOR . $path;
            }
        }
    }

    public static function repo() {
        global $IP;
        if ( is_null( self::$repo ) ) {
            self::$repo = new self( $IP );
        }
        return self::$repo;
    }

    public static function isSHA1( $str ) {
        return !!preg_match( '/^[0-9A-F]{40}$/i', $str );
    }

    public function getHead() {
        $headFile = "{$this->basedir}/HEAD";

        if ( !is_readable( $headFile ) ) {
            return false;
        }

        $head = file_get_contents( $headFile );

        if ( preg_match( "/ref: (.*)/", $head, $m ) ) {
            return rtrim( $m[1] );
        } else {
            return rtrim( $head );
        }
    }

    public function getHeadSHA1() {
        $head = $this->getHead();

        // If detached HEAD may be a SHA1
        if ( self::isSHA1( $head ) ) {
            return $head;
        }

        // If not a SHA1 it may be a ref:
        $refFile = "{$this->basedir}/{$head}";
        if ( !is_readable( $refFile ) ) {
            return false;
        }

        $sha1 = rtrim( file_get_contents( $refFile ) );

        return $sha1;
    }

    public function getHeadCommitDate() {
        global $wgGitBin;

        if ( !is_file( $wgGitBin ) || !is_executable( $wgGitBin ) ) {
            return false;
        }

        $environment = array( "GIT_DIR" => $this->basedir );
        $cmd = wfEscapeShellArg( $wgGitBin ) . " show -s --format=format:%ct HEAD";
        $retc = false;
        $commitDate = wfShellExec( $cmd, $retc, $environment );

        if ( $retc !== 0 ) {
            return false;
        } else {
            return (int)$commitDate;
        }
    }

    public function getCurrentBranch() {
        $head = $this->getHead();
        if ( $head && preg_match( "#^refs/heads/(.*)$#", $head, $m ) ) {
            return $m[1];
        } else {
            return $head;
        }
    }

    public function getHeadViewUrl() {
        $config = "{$this->basedir}/config";
        if ( !is_readable( $config ) ) {
            return false;
        }

        wfSuppressWarnings();
        $configArray = parse_ini_file( $config, true );
        wfRestoreWarnings();
        $remote = false;

        // Use the "origin" remote repo if available or any other repo if not.
        if ( isset( $configArray['remote origin'] ) ) {
            $remote = $configArray['remote origin'];
        } elseif ( is_array( $configArray ) ) {
            foreach ( $configArray as $sectionName => $sectionConf ) {
                if ( substr( $sectionName, 0, 6 ) == 'remote' ) {
                    $remote = $sectionConf;
                }
            }
        }

        if ( $remote === false || !isset( $remote['url'] ) ) {
            return false;
        }

        $url = $remote['url'];
        if ( substr( $url, -4 ) !== '.git' ) {
            $url .= '.git';
        }
        foreach ( self::getViewers() as $repo => $viewer ) {
            $pattern = '#^' . $repo . '$#';
            if ( preg_match( $pattern, $url, $matches ) ) {
                $viewerUrl = preg_replace( $pattern, $viewer, $url );
                $headSHA1 = $this->getHeadSHA1();
                $replacements = array(
                    '%h' => substr( $headSHA1, 0, 7 ),
                    '%H' => $headSHA1,
                    '%r' => urlencode( $matches[1] ),
                );
                return strtr( $viewerUrl, $replacements );
            }
        }
        return false;
    }

    public static function headSHA1() {
        return self::repo()->getHeadSHA1();
    }

    public static function currentBranch() {
        return self::repo()->getCurrentBranch();
    }

    public static function headViewUrl() {
        return self::repo()->getHeadViewUrl();
    }

    protected static function getViewers() {
        global $wgGitRepositoryViewers;

        if ( self::$viewers === false ) {
            self::$viewers = $wgGitRepositoryViewers;
            wfRunHooks( 'GitViewers', array( &self::$viewers ) );
        }

        return self::$viewers;
    }
}