326 lines
8.8 KiB
PHP
Executable File
326 lines
8.8 KiB
PHP
Executable File
<?php
|
|
|
|
namespace Github;
|
|
|
|
use Github\Api\ApiInterface;
|
|
use Github\Exception\InvalidArgumentException;
|
|
use Github\Exception\BadMethodCallException;
|
|
use Github\HttpClient\HttpClient;
|
|
use Github\HttpClient\HttpClientInterface;
|
|
|
|
/**
|
|
* Simple yet very cool PHP GitHub client
|
|
*
|
|
* @method Api\CurrentUser currentUser()
|
|
* @method Api\CurrentUser me()
|
|
* @method Api\Enterprise ent()
|
|
* @method Api\Enterprise enterprise()
|
|
* @method Api\GitData git()
|
|
* @method Api\GitData gitData()
|
|
* @method Api\Gists gist()
|
|
* @method Api\Gists gists()
|
|
* @method Api\Issue issue()
|
|
* @method Api\Issue issues()
|
|
* @method Api\Markdown markdown()
|
|
* @method Api\Organization organization()
|
|
* @method Api\Organization organizations()
|
|
* @method Api\PullRequest pr()
|
|
* @method Api\PullRequest pullRequest()
|
|
* @method Api\PullRequest pullRequests()
|
|
* @method Api\Repo repo()
|
|
* @method Api\Repo repos()
|
|
* @method Api\Repo repository()
|
|
* @method Api\Repo repositories()
|
|
* @method Api\Organization team()
|
|
* @method Api\Organization teams()
|
|
* @method Api\User user()
|
|
* @method Api\User users()
|
|
* @method Api\Authorizations authorization()
|
|
* @method Api\Authorizations authorizations()
|
|
* @method Api\Meta meta()
|
|
*
|
|
* @author Joseph Bielawski <stloyd@gmail.com>
|
|
*
|
|
* Website: http://github.com/KnpLabs/php-github-api
|
|
*/
|
|
class Client
|
|
{
|
|
/**
|
|
* Constant for authentication method. Indicates the default, but deprecated
|
|
* login with username and token in URL.
|
|
*/
|
|
const AUTH_URL_TOKEN = 'url_token';
|
|
|
|
/**
|
|
* Constant for authentication method. Not indicates the new login, but allows
|
|
* usage of unauthenticated rate limited requests for given client_id + client_secret
|
|
*/
|
|
const AUTH_URL_CLIENT_ID = 'url_client_id';
|
|
|
|
/**
|
|
* Constant for authentication method. Indicates the new favored login method
|
|
* with username and password via HTTP Authentication.
|
|
*/
|
|
const AUTH_HTTP_PASSWORD = 'http_password';
|
|
|
|
/**
|
|
* Constant for authentication method. Indicates the new login method with
|
|
* with username and token via HTTP Authentication.
|
|
*/
|
|
const AUTH_HTTP_TOKEN = 'http_token';
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
private $options = array(
|
|
'base_url' => 'https://api.github.com/',
|
|
|
|
'user_agent' => 'php-github-api (http://github.com/KnpLabs/php-github-api)',
|
|
'timeout' => 10,
|
|
|
|
'api_limit' => 5000,
|
|
'api_version' => 'beta',
|
|
|
|
'cache_dir' => null
|
|
);
|
|
|
|
/**
|
|
* The Buzz instance used to communicate with GitHub
|
|
*
|
|
* @var HttpClient
|
|
*/
|
|
private $httpClient;
|
|
|
|
/**
|
|
* Instantiate a new GitHub client
|
|
*
|
|
* @param null|HttpClientInterface $httpClient Github http client
|
|
*/
|
|
public function __construct(HttpClientInterface $httpClient = null)
|
|
{
|
|
$this->httpClient = $httpClient;
|
|
}
|
|
|
|
/**
|
|
* @param string $name
|
|
*
|
|
* @return ApiInterface
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public function api($name)
|
|
{
|
|
switch ($name) {
|
|
case 'me':
|
|
case 'current_user':
|
|
case 'currentUser':
|
|
$api = new Api\CurrentUser($this);
|
|
break;
|
|
|
|
case 'ent':
|
|
case 'enterprise':
|
|
$api = new Api\Enterprise($this);
|
|
break;
|
|
|
|
case 'git':
|
|
case 'git_data':
|
|
case 'gitData':
|
|
$api = new Api\GitData($this);
|
|
break;
|
|
|
|
case 'gist':
|
|
case 'gists':
|
|
$api = new Api\Gists($this);
|
|
break;
|
|
|
|
case 'issue':
|
|
case 'issues':
|
|
$api = new Api\Issue($this);
|
|
break;
|
|
|
|
case 'markdown':
|
|
$api = new Api\Markdown($this);
|
|
break;
|
|
|
|
case 'organization':
|
|
case 'organizations':
|
|
$api = new Api\Organization($this);
|
|
break;
|
|
|
|
case 'pr':
|
|
case 'pullRequest':
|
|
case 'pull_request':
|
|
case 'pullRequests':
|
|
case 'pull_requests':
|
|
$api = new Api\PullRequest($this);
|
|
break;
|
|
|
|
case 'repo':
|
|
case 'repos':
|
|
case 'repository':
|
|
case 'repositories':
|
|
$api = new Api\Repo($this);
|
|
break;
|
|
|
|
case 'team':
|
|
case 'teams':
|
|
$api = new Api\Organization\Teams($this);
|
|
break;
|
|
|
|
case 'user':
|
|
case 'users':
|
|
$api = new Api\User($this);
|
|
break;
|
|
|
|
case 'authorization':
|
|
case 'authorizations':
|
|
$api = new Api\Authorizations($this);
|
|
break;
|
|
|
|
case 'meta':
|
|
$api = new Api\Meta($this);
|
|
break;
|
|
|
|
default:
|
|
throw new InvalidArgumentException(sprintf('Undefined api instance called: "%s"', $name));
|
|
}
|
|
|
|
return $api;
|
|
}
|
|
|
|
/**
|
|
* Authenticate a user for all next requests
|
|
*
|
|
* @param string $tokenOrLogin GitHub private token/username/client ID
|
|
* @param null|string $password GitHub password/secret (optionally can contain $authMethod)
|
|
* @param null|string $authMethod One of the AUTH_* class constants
|
|
*
|
|
* @throws InvalidArgumentException If no authentication method was given
|
|
*/
|
|
public function authenticate($tokenOrLogin, $password = null, $authMethod = null)
|
|
{
|
|
if (null === $password && null === $authMethod) {
|
|
throw new InvalidArgumentException('You need to specify authentication method!');
|
|
}
|
|
|
|
if (null === $authMethod && in_array($password, array(self::AUTH_URL_TOKEN, self::AUTH_URL_CLIENT_ID, self::AUTH_HTTP_PASSWORD, self::AUTH_HTTP_TOKEN))) {
|
|
$authMethod = $password;
|
|
$password = null;
|
|
}
|
|
|
|
if (null === $authMethod) {
|
|
$authMethod = self::AUTH_HTTP_PASSWORD;
|
|
}
|
|
|
|
$this->getHttpClient()->authenticate($tokenOrLogin, $password, $authMethod);
|
|
}
|
|
|
|
/**
|
|
* Sets the URL of your GitHub Enterprise instance.
|
|
*
|
|
* @param string $enterpriseUrl URL of the API in the form of http(s)://hostname
|
|
*/
|
|
public function setEnterpriseUrl($enterpriseUrl)
|
|
{
|
|
$baseUrl = (substr($enterpriseUrl, -1) == '/') ? substr($enterpriseUrl, 0, -1) : $enterpriseUrl;
|
|
$this->getHttpClient()->client->setBaseUrl($baseUrl . '/api/v3');
|
|
}
|
|
|
|
/**
|
|
* @return HttpClient
|
|
*/
|
|
public function getHttpClient()
|
|
{
|
|
if (null === $this->httpClient) {
|
|
$this->httpClient = new HttpClient($this->options);
|
|
}
|
|
|
|
return $this->httpClient;
|
|
}
|
|
|
|
/**
|
|
* @param HttpClientInterface $httpClient
|
|
*/
|
|
public function setHttpClient(HttpClientInterface $httpClient)
|
|
{
|
|
$this->httpClient = $httpClient;
|
|
}
|
|
|
|
/**
|
|
* Clears used headers
|
|
*/
|
|
public function clearHeaders()
|
|
{
|
|
$this->getHttpClient()->clearHeaders();
|
|
}
|
|
|
|
/**
|
|
* @param array $headers
|
|
*/
|
|
public function setHeaders(array $headers)
|
|
{
|
|
$this->getHttpClient()->setHeaders($headers);
|
|
}
|
|
|
|
/**
|
|
* @param string $name
|
|
*
|
|
* @return mixed
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public function getOption($name)
|
|
{
|
|
if (!array_key_exists($name, $this->options)) {
|
|
throw new InvalidArgumentException(sprintf('Undefined option called: "%s"', $name));
|
|
}
|
|
|
|
return $this->options[$name];
|
|
}
|
|
|
|
/**
|
|
* @param string $name
|
|
* @param mixed $value
|
|
*
|
|
* @throws InvalidArgumentException
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public function setOption($name, $value)
|
|
{
|
|
if (!array_key_exists($name, $this->options)) {
|
|
throw new InvalidArgumentException(sprintf('Undefined option called: "%s"', $name));
|
|
}
|
|
$supportedApiVersions = $this->getSupportedApiVersions();
|
|
if ('api_version' == $name && !in_array($value, $supportedApiVersions)) {
|
|
throw new InvalidArgumentException(sprintf('Invalid API version ("%s"), valid are: %s', $name, implode(', ', $supportedApiVersions)));
|
|
}
|
|
|
|
$this->options[$name] = $value;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of valid API versions supported by this client.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getSupportedApiVersions()
|
|
{
|
|
return array('v3', 'beta');
|
|
}
|
|
|
|
/**
|
|
* @param string $name
|
|
*
|
|
* @return ApiInterface
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public function __call($name, $args) {
|
|
try {
|
|
return $this->api($name);
|
|
} catch (InvalidArgumentException $e) {
|
|
throw new BadMethodCallException(sprintf('Undefined method called: "%s"', $name));
|
|
}
|
|
}
|
|
}
|