mirror of
https://code.mensbeam.com/MensBeam/Arsse.git
synced 2024-12-22 13:12:41 +00:00
262 lines
11 KiB
PHP
262 lines
11 KiB
PHP
<?php
|
|
|
|
use Robo\Result;
|
|
|
|
class RoboFile extends \Robo\Tasks {
|
|
const BASE = __DIR__.\DIRECTORY_SEPARATOR;
|
|
const BASE_TEST = self::BASE."tests".\DIRECTORY_SEPARATOR;
|
|
|
|
/** Runs the typical test suite
|
|
*
|
|
* Arguments passed to the task are passed on to PHPUnit. Thus one may, for
|
|
* example, run the following command and get the expected results:
|
|
*
|
|
* ./robo test --testsuite TTRSS --exclude-group slow --testdox
|
|
*
|
|
* Please see the PHPUnit documentation for available options.
|
|
*/
|
|
public function test(array $args): Result {
|
|
return $this->runTests(escapeshellarg(\PHP_BINARY), "typical", $args);
|
|
}
|
|
|
|
/** Runs the full test suite
|
|
*
|
|
* This includes pedantic tests which may help to identify problems.
|
|
* See help for the "test" task for more details.
|
|
*/
|
|
public function testFull(array $args): Result {
|
|
return $this->runTests(escapeshellarg(\PHP_BINARY), "full", $args);
|
|
}
|
|
|
|
/**
|
|
* Runs a quick subset of the test suite
|
|
*
|
|
* See help for the "test" task for more details.
|
|
*/
|
|
public function testQuick(array $args): Result {
|
|
return $this->runTests(escapeshellarg(\PHP_BINARY), "quick", $args);
|
|
}
|
|
|
|
/** Produces a code coverage report
|
|
*
|
|
* By default this task produces an HTML-format coverage report in
|
|
* tests/coverage/. Additional reports may be produced by passing
|
|
* arguments to this task as one would to PHPUnit.
|
|
*
|
|
* Robo first tries to use phpdbg and will fall back to Xdebug if available.
|
|
* Because Xdebug slows down non-coverage tasks, however, phpdbg is highly
|
|
* recommended if debugging facilities are not otherwise needed.
|
|
*/
|
|
public function coverage(array $args): Result {
|
|
// run tests with code coverage reporting enabled
|
|
$exec = $this->findCoverageEngine();
|
|
return $this->runTests($exec, "coverage", array_merge(["--coverage-html", self::BASE_TEST."coverage"], $args));
|
|
}
|
|
|
|
/** Produces a code coverage report, with redundant tests
|
|
*
|
|
* Depending on the environment, some tests that normally provide
|
|
* coverage may be skipped, while working alternatives are normally
|
|
* suppressed for reasons of time. This coverage report will try to
|
|
* run all tests which may cover code.
|
|
*
|
|
* See also help for the "coverage" task for more details.
|
|
*/
|
|
public function coverageFull(array $args): Result {
|
|
// run tests with code coverage reporting enabled
|
|
$exec = $this->findCoverageEngine();
|
|
return $this->runTests($exec, "typical", array_merge(["--coverage-html", self::BASE_TEST."coverage"], $args));
|
|
}
|
|
|
|
/** Runs the coding standards fixer */
|
|
public function clean($opts = ['demo|d' => false]): Result {
|
|
$t = $this->taskExec(realpath(self::BASE."vendor/bin/php-cs-fixer"));
|
|
$t->arg("fix");
|
|
if ($opts['demo']) {
|
|
$t->args("--dry-run", "--diff")->option("--diff-format", "udiff");
|
|
}
|
|
return $t->run();
|
|
}
|
|
|
|
protected function findCoverageEngine(): string {
|
|
if ($this->isWindows()) {
|
|
$dbg = dirname(\PHP_BINARY)."\\phpdbg.exe";
|
|
$dbg = file_exists($dbg) ? $dbg : "";
|
|
} else {
|
|
$dbg = trim(`which phpdbg`);
|
|
}
|
|
if ($dbg) {
|
|
return escapeshellarg($dbg)." -qrr";
|
|
} else {
|
|
return escapeshellarg(\PHP_BINARY);
|
|
}
|
|
}
|
|
|
|
protected function isWindows(): bool {
|
|
return defined("PHP_WINDOWS_VERSION_MAJOR");
|
|
}
|
|
|
|
protected function blackhole(bool $all = false): string {
|
|
$hole = $this->isWindows() ? "nul" : "/dev/null";
|
|
return $all ? ">$hole 2>&1" : "2>$hole";
|
|
}
|
|
|
|
protected function runTests(string $executor, string $set, array $args) : Result {
|
|
switch ($set) {
|
|
case "typical":
|
|
$set = ["--exclude-group", "optional"];
|
|
break;
|
|
case "quick":
|
|
$set = ["--exclude-group", "optional,slow"];
|
|
break;
|
|
case "coverage":
|
|
$set = ["--exclude-group", "optional,coverageOptional"];
|
|
break;
|
|
case "full":
|
|
$set = [];
|
|
break;
|
|
default:
|
|
throw new \Exception;
|
|
}
|
|
$execpath = realpath(self::BASE."vendor-bin/phpunit/vendor/phpunit/phpunit/phpunit");
|
|
$confpath = realpath(self::BASE_TEST."phpunit.xml");
|
|
$this->taskServer(8000)->host("localhost")->dir(self::BASE_TEST."docroot")->rawArg("-n")->arg(self::BASE_TEST."server.php")->rawArg($this->blackhole())->background()->run();
|
|
return $this->taskExec($executor)->arg($execpath)->option("-c", $confpath)->args(array_merge($set, $args))->run();
|
|
}
|
|
|
|
/** Packages a given commit of the software into a release tarball
|
|
*
|
|
* The version to package may be any Git tree-ish identifier: a tag, a branch,
|
|
* or any commit hash. If none is provided on the command line, Robo will prompt
|
|
* for a commit to package; the default is "head".
|
|
*
|
|
* Note that while it is possible to re-package old versions, the resultant tarball
|
|
* may not be equivalent due to subsequent changes in the exclude list, or because
|
|
* of new tooling.
|
|
*/
|
|
public function package(string $version = null): Result {
|
|
// establish which commit to package
|
|
$version = $version ?? $this->askDefault("Commit to package:", "head");
|
|
$archive = self::BASE."arsse-$version.tar.gz";
|
|
// start a collection
|
|
$t = $this->collectionBuilder();
|
|
// create a temporary directory
|
|
$dir = $t->tmpDir().\DIRECTORY_SEPARATOR;
|
|
// create a Git worktree for the selected commit in the temp location
|
|
$t->taskExec("git worktree add ".escapeshellarg($dir)." ".escapeshellarg($version));
|
|
// perform Composer installation in the temp location
|
|
$t->taskComposerInstall()->dir($dir)->noDev()->optimizeAutoloader()->arg("--no-scripts");
|
|
// delete unwanted files
|
|
$t->taskFilesystemStack()->remove([
|
|
$dir.".git",
|
|
$dir.".gitignore",
|
|
$dir.".gitattributes",
|
|
$dir."composer.json",
|
|
$dir."composer.lock",
|
|
$dir.".php_cs.dist",
|
|
$dir."phpdoc.dist.xml",
|
|
$dir."build.xml",
|
|
$dir."RoboFile.php",
|
|
$dir."CONTRIBUTING.md",
|
|
$dir."tests",
|
|
$dir."vendor-bin",
|
|
$dir."robo",
|
|
$dir."robo.bat",
|
|
]);
|
|
// generate a sample configuration file
|
|
$t->taskExec(escapeshellarg(\PHP_BINARY)." arsse.php conf save-defaults config.defaults.php")->dir($dir);
|
|
// package it all up
|
|
$t->taskPack($archive)->addDir("arsse", $dir);
|
|
// execute the collection
|
|
$out = $t->run();
|
|
// clean the Git worktree list
|
|
$this->_exec("git worktree prune");
|
|
return $out;
|
|
}
|
|
|
|
/** Generates static manual pages in the "manual" directory
|
|
*
|
|
* The resultant files are suitable for offline viewing and inclusion into release builds
|
|
*/
|
|
public function manual(array $args): Result {
|
|
$execpath = escapeshellarg(realpath(self::BASE."vendor/bin/daux"));
|
|
return $this->taskExec($execpath)->arg("generate")->option("-d", self::BASE."manual")->args($args)->run();
|
|
}
|
|
|
|
/** Serves a live view of the manual using PHP's built-in Web server */
|
|
public function manualLive(array $args): Result {
|
|
$execpath = escapeshellarg(realpath(self::BASE."vendor/bin/daux"));
|
|
return $this->taskExec($execpath)->arg("serve")->args($args)->run();
|
|
}
|
|
|
|
/** Rebuilds the manual theme
|
|
*
|
|
* This requires Node and Yarn to be installed, and only needs to be done when
|
|
* Daux's theme changes
|
|
*/
|
|
public function manualTheme(array $args): Result {
|
|
$postcss = escapeshellarg(realpath(self::BASE."node_modules/.bin/postcss"));
|
|
$languages = ["php", "bash", "shell", "xml", "nginx", "apache"];
|
|
$themesrc = realpath(self::BASE."docs/theme/src/").\DIRECTORY_SEPARATOR;
|
|
$themeout = realpath(self::BASE."docs/theme/arsse/").\DIRECTORY_SEPARATOR;
|
|
$dauxjs = realpath(self::BASE."vendor-bin/daux/vendor/daux/daux.io/themes/daux/js/").\DIRECTORY_SEPARATOR;
|
|
$dauxout = realpath(self::BASE."docs/theme/daux/js/").\DIRECTORY_SEPARATOR;
|
|
// start a collection; this stops after the first failure
|
|
$t = $this->collectionBuilder();
|
|
$tmp = $t->tmpDir().\DIRECTORY_SEPARATOR;
|
|
// install dependencies via Yarn
|
|
$t->taskExec("yarn install");
|
|
// compile the stylesheet
|
|
$t->taskExec($postcss)->arg($themesrc."arsse.scss")->option("-o", $themeout."arsse.css");
|
|
// copy JavaScript files from the Daux theme
|
|
foreach(glob($dauxjs."daux*") as $file) {
|
|
$t->taskFilesystemStack()->copy($file, $themeout.basename($file), true);
|
|
}
|
|
foreach(glob($dauxjs."jquery*") as $file) {
|
|
$t->taskFilesystemStack()->copy($file, $themeout.basename("jquery.min.js"), true);
|
|
}
|
|
foreach(glob($dauxjs."html5shiv*") as $file) {
|
|
$t->taskFilesystemStack()->copy($file, $dauxout.basename($file), true);
|
|
}
|
|
// download highlight.js
|
|
$t->addCode(function() use ($languages, $tmp, $themeout) {
|
|
$post = http_build_query((function($langs) {
|
|
$out = [];
|
|
foreach($langs as $l) {
|
|
$out[$l.".js"] = "on";
|
|
}
|
|
return $out;
|
|
})($languages));
|
|
$conn = @fopen("https://highlightjs.org/download/", "r");
|
|
if ($conn === false) {
|
|
throw new Exception("Unable to download Highlight.js");
|
|
}
|
|
foreach (stream_get_meta_data($conn)['wrapper_data'] as $field) {
|
|
if (preg_match("/^Set-Cookie: csrftoken=([^;]+)/i", $field, $cookie)) {
|
|
break;
|
|
}
|
|
}
|
|
$token = stream_get_contents($conn);
|
|
preg_match("/<input type='hidden' name='csrfmiddlewaretoken' value='([^']*)'/", $token, $token);
|
|
$post = "csrfmiddlewaretoken={$token[1]}&$post";
|
|
$hljs = @file_get_contents("https://highlightjs.org/download/", false, stream_context_create(['http' => [
|
|
'method' => "POST",
|
|
'content' => $post,
|
|
'header' => [
|
|
"Referer: https://highlightjs.org/download/",
|
|
"Cookie: csrftoken={$cookie[1]}",
|
|
"Content-Type: application/x-www-form-urlencoded",
|
|
],
|
|
]]));
|
|
if ($hljs === false) {
|
|
throw new Exception("Unable to download Highlight.js");
|
|
} else {
|
|
file_put_contents($tmp."highlightjs.zip", $hljs);
|
|
}
|
|
$this->taskExtract($tmp."highlightjs.zip")->to($tmp."hljs")->run();
|
|
$this->taskFilesystemStack()->copy($tmp."hljs".\DIRECTORY_SEPARATOR."highlight.pack.js", $themeout."highlight.pack.js")->run();
|
|
}, "downloadHighlightjs");
|
|
// execute the collection
|
|
return $t->run();
|
|
}
|
|
}
|