8
0
daux.io/libs/Daux.php

414 Zeilen
12 KiB
PHP

<?php namespace Todaymade\Daux;
2015-07-17 18:34:00 +02:00
use Symfony\Component\Console\Output\NullOutput;
2018-06-05 20:31:51 +02:00
use Symfony\Component\Console\Output\OutputInterface;
2015-07-29 22:31:41 +02:00
use Todaymade\Daux\ContentTypes\ContentTypeHandler;
use Todaymade\Daux\Tree\Builder;
use Todaymade\Daux\Tree\Content;
use Todaymade\Daux\Tree\Directory;
use Todaymade\Daux\Tree\Root;
2015-04-22 12:23:57 +02:00
2015-04-23 00:32:30 +02:00
class Daux
{
const STATIC_MODE = 'DAUX_STATIC';
const LIVE_MODE = 'DAUX_LIVE';
2018-06-05 20:31:51 +02:00
public static $output;
2015-07-18 21:45:38 +02:00
/** @var string */
2015-04-23 00:32:30 +02:00
public $local_base;
2015-07-18 21:45:38 +02:00
/** @var \Todaymade\Daux\Format\Base\Generator */
protected $generator;
2015-07-29 22:31:41 +02:00
/** @var ContentTypeHandler */
protected $typeHandler;
/**
* @var string[]
*/
protected $validExtensions;
2015-07-18 21:45:38 +02:00
/** @var Processor */
2015-07-17 18:34:00 +02:00
protected $processor;
2015-07-18 21:45:38 +02:00
/** @var Tree\Root */
2015-04-23 00:32:30 +02:00
public $tree;
2015-07-17 23:38:06 +02:00
2015-07-18 21:45:38 +02:00
/** @var Config */
2015-04-23 00:32:30 +02:00
public $options;
2015-07-18 21:45:38 +02:00
/** @var string */
2015-04-23 00:32:30 +02:00
private $mode;
2015-07-19 14:05:12 +02:00
/** @var bool */
private $merged_tree = false;
2015-07-18 21:45:38 +02:00
/**
* @param string $mode
*/
2018-06-05 20:31:51 +02:00
public function __construct($mode, OutputInterface $output)
{
2018-06-05 20:31:51 +02:00
Daux::$output = $output;
2015-04-23 00:32:30 +02:00
$this->mode = $mode;
2017-11-07 22:44:27 +01:00
$this->local_base = dirname(__DIR__);
// global.json
$this->loadBaseConfiguration();
2015-04-23 00:32:30 +02:00
}
2015-07-18 21:45:38 +02:00
/**
* @param string $override_file
* @throws Exception
*/
public function initializeConfiguration($override_file = null)
2015-04-23 00:32:30 +02:00
{
$params = $this->getParams();
// Validate and set theme path
2016-09-21 23:10:10 +02:00
$params->setDocumentationDirectory(
$docs_path = $this->normalizeDocumentationPath($this->getParams()->getDocumentationDirectory())
);
// Read documentation overrides
$this->loadConfiguration($docs_path . DIRECTORY_SEPARATOR . 'config.json');
2015-07-20 15:59:52 +02:00
// Read command line overrides
$override_file = $this->getConfigurationOverride($override_file);
if ($override_file !== null) {
$params->setConfigurationOverrideFile($override_file);
$this->loadConfiguration($override_file);
2015-07-20 15:59:52 +02:00
}
// Validate and set theme path
$params->setThemesPath($this->normalizeThemePath($params->getThemesDirectory()));
2015-07-20 15:59:52 +02:00
// Set a valid default timezone
if ($params->hasTimezone()) {
date_default_timezone_set($params->getTimezone());
2015-07-20 15:59:52 +02:00
} elseif (!ini_get('date.timezone')) {
date_default_timezone_set('GMT');
}
2015-04-23 00:32:30 +02:00
}
2017-06-07 23:40:12 +02:00
/**
* Get the file requested for configuration overrides
*
2017-11-07 22:44:27 +01:00
* @param string|null $path
2017-06-07 23:40:12 +02:00
* @return string|null the path to a file to load for configuration overrides
* @throws Exception
*/
2017-11-07 22:44:27 +01:00
public function getConfigurationOverride($path)
{
2017-11-07 22:44:27 +01:00
$validPath = DauxHelper::findLocation($path, $this->local_base, 'DAUX_CONFIGURATION', 'file');
2017-11-07 22:44:27 +01:00
if ($validPath === null) {
return null;
}
2017-11-07 22:44:27 +01:00
if (!$validPath) {
throw new Exception('The configuration override file does not exist. Check the path again : ' . $path);
}
2017-11-07 22:44:27 +01:00
return $validPath;
}
2016-07-28 22:48:50 +02:00
public function normalizeThemePath($path)
{
2017-11-07 22:44:27 +01:00
$validPath = DauxHelper::findLocation($path, $this->local_base, 'DAUX_THEME', 'dir');
2016-09-21 23:10:10 +02:00
2017-11-07 22:44:27 +01:00
if (!$validPath) {
throw new Exception('The Themes directory does not exist. Check the path again : ' . $path);
}
2017-11-07 22:44:27 +01:00
return $validPath;
}
2016-09-21 23:10:10 +02:00
public function normalizeDocumentationPath($path)
{
2017-11-07 22:44:27 +01:00
$validPath = DauxHelper::findLocation($path, $this->local_base, 'DAUX_SOURCE', 'dir');
2017-11-07 22:44:27 +01:00
if (!$validPath) {
throw new Exception('The Docs directory does not exist. Check the path again : ' . $path);
}
2015-07-31 12:53:22 +02:00
2017-11-07 22:44:27 +01:00
return $validPath;
}
2015-07-18 21:45:38 +02:00
/**
* Load and validate the global configuration
*
* @throws Exception
*/
2015-07-20 15:59:52 +02:00
protected function loadBaseConfiguration()
2015-04-23 00:32:30 +02:00
{
2015-07-20 15:59:52 +02:00
$this->options = new Config();
// Set the default configuration
$this->options->merge([
'docs_directory' => 'docs',
2016-07-27 21:32:51 +02:00
'valid_content_extensions' => ['md', 'markdown'],
//Paths and tree
'mode' => $this->mode,
'local_base' => $this->local_base,
'templates' => 'templates',
'index_key' => 'index.html',
'base_page' => '',
'base_url' => '',
2015-07-20 15:59:52 +02:00
]);
2015-07-20 15:59:52 +02:00
// Load the global configuration
$this->loadConfiguration($this->local_base . DIRECTORY_SEPARATOR . 'global.json', false);
2015-04-23 00:32:30 +02:00
}
2015-07-20 15:59:52 +02:00
/**
* @param string $config_file
* @param bool $optional
* @throws Exception
*/
protected function loadConfiguration($config_file, $optional = true)
{
if (!file_exists($config_file)) {
if ($optional) {
return;
}
2015-07-20 15:59:52 +02:00
throw new Exception('The configuration file is missing. Check path : ' . $config_file);
2015-04-23 00:32:30 +02:00
}
2015-07-20 15:59:52 +02:00
$config = json_decode(file_get_contents($config_file), true);
if (!isset($config)) {
throw new Exception('The configuration file "' . $config_file . '" is corrupt. Is your JSON well-formed ?');
}
2015-07-20 15:59:52 +02:00
$this->options->merge($config);
2015-04-23 00:32:30 +02:00
}
2015-07-18 21:45:38 +02:00
/**
* Generate the tree that will be used
*/
2015-07-19 23:17:57 +02:00
public function generateTree()
2015-04-23 00:32:30 +02:00
{
$this->options['valid_content_extensions'] = $this->getContentExtensions();
$this->tree = new Root($this->getParams());
Builder::build($this->tree, $this->options['ignore']);
// Apply the language name as Section title
if ($this->options->isMultilanguage()) {
2015-04-23 00:32:30 +02:00
foreach ($this->options['languages'] as $key => $node) {
2015-07-18 21:45:38 +02:00
$this->tree->getEntries()[$key]->setTitle($node);
}
}
// Enhance the tree with processors
$this->getProcessor()->manipulateTree($this->tree);
// Sort the tree one last time before it is finalized
2017-11-07 22:44:27 +01:00
Builder::sortTree($this->tree);
2017-11-07 22:44:27 +01:00
Builder::finalizeTree($this->tree);
2015-04-23 00:32:30 +02:00
}
/**
2015-07-14 23:35:47 +02:00
* @return Config
*/
2015-04-23 00:32:30 +02:00
public function getParams()
{
2015-07-19 14:05:12 +02:00
if ($this->tree && !$this->merged_tree) {
$this->options['tree'] = $this->tree;
$this->options['index'] = $this->tree->getIndexPage() ?: $this->tree->getFirstPage();
if ($this->options->isMultilanguage()) {
2015-04-22 12:23:57 +02:00
foreach ($this->options['languages'] as $key => $name) {
$this->options['entry_page'][$key] = $this->tree->getEntries()[$key]->getFirstPage();
2015-04-22 12:23:57 +02:00
}
} else {
$this->options['entry_page'] = $this->tree->getFirstPage();
}
2015-07-19 14:05:12 +02:00
$this->merged_tree = true;
}
return $this->options;
2015-04-22 12:23:57 +02:00
}
2015-07-17 18:34:00 +02:00
/**
* @return Processor
*/
public function getProcessor()
{
if (!$this->processor) {
2018-06-05 20:31:51 +02:00
$this->processor = new Processor($this, Daux::getOutput(), 0);
2015-07-17 18:34:00 +02:00
}
return $this->processor;
}
/**
* @param Processor $processor
*/
public function setProcessor(Processor $processor)
{
$this->processor = $processor;
// This is not the cleanest but it's
// the best i've found to use the
// processor in very remote places
$this->options['processor_instance'] = $processor;
}
public function getGenerators()
{
$default = [
'confluence' => '\Todaymade\Daux\Format\Confluence\Generator',
'html-file' => '\Todaymade\Daux\Format\HTMLFile\Generator',
'html' => '\Todaymade\Daux\Format\HTML\Generator',
];
$extended = $this->getProcessor()->addGenerators();
return array_replace($default, $extended);
2015-07-17 18:34:00 +02:00
}
public function getProcessorClass()
{
$processor = $this->getParams()['processor'];
if (empty($processor)) {
return null;
}
2016-07-27 21:32:51 +02:00
$class = '\\Todaymade\\Daux\\Extension\\' . $processor;
if (!class_exists($class)) {
throw new \RuntimeException("Class '$class' not found. We cannot use it as a Processor");
}
2016-07-27 21:32:51 +02:00
if (!array_key_exists('Todaymade\\Daux\\Processor', class_parents($class))) {
2016-01-31 11:59:35 +01:00
throw new \RuntimeException("Class '$class' invalid, should extend '\\Todaymade\\Daux\\Processor'");
}
return $class;
}
protected function findAlternatives($input, $words) {
$alternatives = [];
foreach ($words as $word) {
$lev = levenshtein($input, $word);
if ($lev <= \strlen($word) / 3) {
$alternatives[] = $word;
}
}
return $alternatives;
}
/**
* @return \Todaymade\Daux\Format\Base\Generator
*/
public function getGenerator()
{
if ($this->generator) {
return $this->generator;
}
$generators = $this->getGenerators();
$format = $this->getParams()->getFormat();
if (!array_key_exists($format, $generators)) {
$message = "The format '$format' doesn't exist, did you forget to set your processor ?";
$alternatives = $this->findAlternatives($format, array_keys($generators));
if (0 == \count($alternatives)) {
$message .= "\n\nAvailable formats are \n " . implode("\n ", array_keys($generators));
} elseif (1 == \count($alternatives)) {
$message .= "\n\nDid you mean this?\n " . implode("\n ", $alternatives);
} else {
$message .= "\n\nDid you mean one of these?\n " . implode("\n ", $alternatives);
}
throw new \RuntimeException($message);
}
$class = $generators[$format];
if (!class_exists($class)) {
throw new \RuntimeException("Class '$class' not found. We cannot use it as a Generator");
}
$interface = 'Todaymade\Daux\Format\Base\Generator';
if (!in_array('Todaymade\Daux\Format\Base\Generator', class_implements($class))) {
throw new \RuntimeException("The class '$class' does not implement the '$interface' interface");
}
return $this->generator = new $class($this);
}
public function getContentTypeHandler()
{
if ($this->typeHandler) {
return $this->typeHandler;
}
$base_types = $this->getGenerator()->getContentTypes();
$extended = $this->getProcessor()->addContentType();
$types = array_merge($base_types, $extended);
return $this->typeHandler = new ContentTypeHandler($types);
}
/**
* Get all content file extensions
*
* @return string[]
*/
public function getContentExtensions()
{
2016-07-29 22:38:03 +02:00
if (!empty($this->validExtensions)) {
return $this->validExtensions;
}
return $this->validExtensions = $this->getContentTypeHandler()->getContentExtensions();
}
2018-06-05 20:31:51 +02:00
public static function getOutput() {
if (!Daux::$output) {
2018-06-07 20:40:38 +02:00
Daux::$output = new NullOutput();
2018-06-05 20:31:51 +02:00
}
return Daux::$output;
}
/**
* Writes a message to the output.
*
* @param string|array $messages The message as an array of lines or a single string
* @param bool $newline Whether to add a newline
* @param int $options A bitmask of options (one of the OUTPUT or VERBOSITY constants), 0 is considered the same as self::OUTPUT_NORMAL | self::VERBOSITY_NORMAL
*/
public static function write($messages, $newline = false, $options = 0) {
2018-06-07 20:40:38 +02:00
Daux::getOutput()->write($messages, $newline, $options);
2018-06-05 20:31:51 +02:00
}
/**
* Writes a message to the output and adds a newline at the end.
*
* @param string|array $messages The message as an array of lines of a single string
* @param int $options A bitmask of options (one of the OUTPUT or VERBOSITY constants), 0 is considered the same as self::OUTPUT_NORMAL | self::VERBOSITY_NORMAL
*/
public static function writeln($messages, $options = 0) {
2018-06-07 20:40:38 +02:00
Daux::getOutput()->write($messages, true, $options);
2018-06-05 20:31:51 +02:00
}
public static function getVerbosity() {
return Daux::getOutput()->getVerbosity();
}
2015-04-23 00:32:30 +02:00
}