Lechimp\Dicto\App\Config

Complexity

Total Complexity

20

Size/Duplication

Total Lines	281
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	path()	0	3	1
A	project_rules()	0	3	1
A	project_root()	0	3	1
A	project_storage()	0	3	1
A	analysis_ignore()	0	3	1
A	analysis_store_index()	0	3	1
A	analysis_report_stdout()	0	3	1
A	analysis_report_database()	0	3	1
A	__construct()	0	10	2
B	getConfigTreeBuilder()	0	90	1
A	maybe_prepend_path()	0	7	2
A	rules_schemas()	0	3	1
A	rules_properties()	0	3	1
A	rules_variables()	0	3	1
A	runtime_check_assertions()	0	3	1
A	reports()	0	17	3

<?php
/******************************************************************************
 * An implementation of dicto (scg.unibe.ch/dicto) in and for PHP.
 * 
 * Copyright (c) 2016 Richard Klees <richard.klees@rwth-aachen.de>
 *
 * This software is licensed under The MIT License. You should have received 
 * a copy of the license along with the code.
 */

namespace Lechimp\Dicto\App;

use Lechimp\Dicto\Report;

use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\Config\Definition\ConfigurationInterface;
use Symfony\Component\Config\Definition\Builder\TreeBuilder;

/**
 * Configuration for the app and engine.
 */
class Config implements ConfigurationInterface {
    /**
     * @var string
     */
    protected $path;

    /**
     * @var array
     */
    protected $values;

    /**
     * @var Report\Config[]|null
     */
    protected $reports = null;

    /**
     * @var array
     */
    protected $defaults =
        [ "analysis" =>
            [ "ignore"  => []
            , "store_index" => false
            , "report_stdout" => true 
            , "report_database" => true
            ]
        , "rules" =>
            [ "schemas" =>
                [ \Lechimp\Dicto\Rules\DependOn::class
                , \Lechimp\Dicto\Rules\Invoke::class
                , \Lechimp\Dicto\Rules\ContainText::class
                ]
            , "properties" =>
                [ \Lechimp\Dicto\Variables\Name::class
                , \Lechimp\Dicto\Variables\In::class
                ]
            , "variables" =>
                [ \Lechimp\Dicto\Variables\Namespaces::class
                , \Lechimp\Dicto\Variables\Classes::class
                , \Lechimp\Dicto\Variables\Interfaces::class
                , \Lechimp\Dicto\Variables\Traits::class
                , \Lechimp\Dicto\Variables\Functions::class
                , \Lechimp\Dicto\Variables\Globals::class
                , \Lechimp\Dicto\Variables\Files::class
                , \Lechimp\Dicto\Variables\Methods::class
                , \Lechimp\Dicto\Variables\ErrorSuppressor::class
                , \Lechimp\Dicto\Variables\Exit_::class
                , \Lechimp\Dicto\Variables\Die_::class
                , \Lechimp\Dicto\Variables\Eval_::class
                ]
            ]
        , "runtime" =>
            [ "check_assertions" => false
            ]
        ];

    /**
     * Build the configuration from nested arrays using a processor.
     *
     * @param   string  $path
     */
    public function __construct($path, array $values) {
        assert('is_string($path)');
        if (substr($path, strlen($path) - 1, 1) == "/") {
            $path = substr($path, 0, strlen($path) - 1);
        }
        $this->path = $path;
        $processor = new \Symfony\Component\Config\Definition\Processor();
        $values = array_merge([$this->defaults], $values);
        $this->values = $processor->processConfiguration($this, $values);
    }

    /**
     * Definition of configuration for symfony.
     *
     * @inheritdocs
     */
    public function getConfigTreeBuilder() {
        // TODO: maybe change definition in a way that does not append
        //       to rules.*-arrays
        $tree_builder = new TreeBuilder();
        $root = $tree_builder->root("dicto");
        $root
            ->children()
                ->arrayNode("project")
                    ->children()
                        ->scalarNode("root")
                            ->isRequired()
                        ->end()
                        ->scalarNode("storage")
                            ->isRequired()
                        ->end()
                        ->scalarNode("rules")
                            ->isRequired()
                        ->end()
                    ->end()
                ->end()
                ->arrayNode("analysis")
                    ->children()
                        ->arrayNode("ignore")
                            ->prototype("scalar")
                            ->end()
                            ->isRequired()
                        ->end()
                        ->booleanNode("store_index")
                            ->isRequired()
                        ->end()
                        ->booleanNode("report_stdout")
                            ->isRequired()
                        ->end()
                        ->booleanNode("report_database")
                            ->isRequired()
                        ->end()
                    ->end()
                ->end()
                ->arrayNode("rules")
                    ->children()
                        ->arrayNode("schemas")
                            ->prototype("scalar")
                            ->end()
                            ->isRequired()
                        ->end()
                        ->arrayNode("properties")
                            ->prototype("scalar")
                            ->end()
                            ->isRequired()
                        ->end()
                        ->arrayNode("variables")
                            ->prototype("scalar")
                            ->end()
                            ->isRequired()
                        ->end()
                    ->end()
                ->end()
                ->arrayNode("runtime")
                    ->children()
                        ->booleanNode("check_assertions")
                            ->isRequired()
                        ->end()
                    ->end()
                ->end()
                ->arrayNode("reports")
                    ->prototype("array")
                        ->children()
                            ->scalarNode("name")
                                ->defaultValue(null)
                            ->end()
                            ->scalarNode("class")
                                ->isRequired()
                            ->end()
                            ->scalarNode("target")
                                ->isRequired()
                            ->end()
                            ->scalarNode("source")
                                ->defaultValue(null)
                            ->end()
                            ->variableNode("config")
                                ->defaultValue([])
                            ->end()
                        ->end()
                    ->end()
                ->end()
            ->end()
        ->end();

        return $tree_builder;
    }

    /**
     * @return  string
     */
    public function path() {
        return $this->path;
    }

    protected function maybe_prepend_path($path) {
        assert('is_string($path)');
        if (substr($path, 0, 2) === "./") {
            return $this->path()."/".substr($path, 2);
        }
        return $path;
    }

    /**
     * @return  string
     */
    public function project_rules() {
        return $this->maybe_prepend_path($this->values["project"]["rules"]);
    }

    /**
     * @return  string
     */
    public function project_root() {
        return $this->maybe_prepend_path($this->values["project"]["root"]);
    }

    /**
     * @return  string
     */
    public function project_storage() {
        return $this->maybe_prepend_path($this->values["project"]["storage"]);
    }

    /**
     * @return  string[]
     */
    public function analysis_ignore() {
        return $this->values["analysis"]["ignore"];
    }

    /**
     * @return  bool
     */
    public function analysis_store_index() {
        return $this->values["analysis"]["store_index"];
    }

    /**
     * @return  bool
     */
    public function analysis_report_stdout() {
        return $this->values["analysis"]["report_stdout"];
    }

    /**
     * @return  bool
     */
    public function analysis_report_database() {
        return $this->values["analysis"]["report_database"];
    }

    /**
     * @return  string[]
     */
    public function rules_schemas() {
        return $this->values["rules"]["schemas"];
    }

    /**
     * @return  string[]
     */
    public function rules_properties() {
        return $this->values["rules"]["properties"];
    }

    /**
     * @return  string[]
     */
    public function rules_variables() {
        return $this->values["rules"]["variables"];
    }

    /**
     * @return  bool
     */
    public function runtime_check_assertions() {
        return $this->values["runtime"]["check_assertions"];
    }

    /**
     * @return Report\Config[]
     */
    public function reports() {
        if ($this->reports !== null) {
            return $this->reports;
        }
        $this->reports = [];
        foreach ($this->values["reports"] as $rep) {
            $this->reports[] = new Report\Config
                ( $this->path()
                , $rep["class"]
                , $rep["target"]
                , $rep["config"]
                , $rep["name"]
                , $rep["source"]
                );
        }
        return $this->reports;
    }
}