Phile\Plugin\Phile\ParserMeta\Parser\Meta

Complexity

Total Complexity

15

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

97.67%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	parsePhileFormat()	0	17	4
B	parse()	0	28	6
A	convertKeys()	0	13	3

<?php
/**
 * The Meta Parser Interface
 */
namespace Phile\Plugin\Phile\ParserMeta\Parser;

use Phile\ServiceLocator\MetaInterface;
use Symfony\Component\Yaml\Yaml;

/**
 * Class Meta
 *
 * @author  PhileCMS
 * @link    https://philecms.com
 * @license http://opensource.org/licenses/MIT
 * @package Phile\Plugin\Phile\ParserMeta\Parser
 */
class Meta implements MetaInterface
{
    /**
 * @var array $config the configuration for this parser
*/
    private $config;

    /**
     * the constructor
     *
     * @param array $config
     */
    public function __construct(array $config = null)
    {
        if (!is_null($config)) {
            $this->config = $config;
        }
    }

    /**
     * parse the content and extract meta information
     *
     * @param  string $rawData raw page data
     * @return array with key/value store
     */
    public function parse($rawData)
    {
        $rawData = trim($rawData);
        $fences = $this->config['fences'];

        $start = $stop = null;
        foreach ($fences as $fence) {
            $start = $fence['open'];
            $length = strlen($start);
            if (substr($rawData, 0, $length) === $start) {
                $stop = $fence['close'];
                break;
            }
        }

        if ($stop === null) {
            return [];
        }

        $meta = trim(substr($rawData, strlen($start), strpos($rawData, $stop, strlen($start)) - (strlen($stop) + 1)));
        if (strtolower($this->config['format']) === 'yaml') {
            $meta = Yaml::parse($meta);
        } else {
            $meta = $this->parsePhileFormat($meta);

The method Phile\Plugin\Phile\ParserMeta\Parser\Meta::parsePhileFormat() has been deprecated with message: since 1.6.0 Phile is going to switch to YAML

        }
        $meta = ($meta === null) ? [] : $this->convertKeys($meta);
        return $meta;
    }

    /**
     * convert meta data keys
     *
     * Creates "compatible" keys allowing easy access e.g. as template var.
     *
     * Conversions applied:
     *
     * - lowercase all chars
     * - replace special chars and whitespace with underscore
     *
     * @param  array $meta meta-data
     * @return array
     */
    protected function convertKeys(array $meta)
    {
        $return = [];
        foreach ($meta as $key => $value) {
            if (is_array($value)) {
                $value = $this->convertKeys($value);
            }
            $newKey = strtolower($key);
            $newKey = preg_replace('/[^\w+]/', '_', $newKey);
            $return[$newKey] = $value;
        }
        return $return;
    }

    /**
     * Phile meta format parser.
     *
     * @param  string $string unparsed meta-data
     * @return array|null array with meta-tags; null: on meta-data found
     *
     * @deprecated since 1.6.0 Phile is going to switch to YAML
     */
    protected function parsePhileFormat($string)
    {
        if (empty($string)) {
            return null;
        }
        $meta = [];
        $lines = explode("\n", $string);
        foreach ($lines as $line) {
            $parts = explode(':', $line, 2);
            if (count($parts) !== 2) {
                continue;
            }
            $parts = array_map('trim', $parts);
            $meta[$parts[0]] = $parts[1];
        }
        return $meta;
    }
}