ConfigSchema::constraints() - Code Metrics - weew/config-schema - Measure and Improve Code Quality continuously with Scrutinizer

ConfigSchema::constraints() A
last analyzed 2016-08-28 20:30 UTC

↳ Parent: ConfigSchema

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	5
rs	9.4285
cc	1
eloc	3
nc	1
nop	2

<?php

namespace Weew\ConfigSchema;

use Weew\Config\IConfig;
use Weew\ConfigSchema\Exceptions\ConfigValidationException;
use Weew\ConfigSchema\Nodes\ArrayNode;
use Weew\ConfigSchema\Nodes\BooleanNode;
use Weew\ConfigSchema\Nodes\IArrayNode;
use Weew\ConfigSchema\Nodes\IBooleanNode;
use Weew\ConfigSchema\Nodes\INumericNode;
use Weew\ConfigSchema\Nodes\IStringNode;
use Weew\ConfigSchema\Nodes\IValueNode;
use Weew\ConfigSchema\Nodes\NumericNode;
use Weew\ConfigSchema\Nodes\StringNode;
use Weew\ConfigSchema\Nodes\ValueNode;
use Weew\Validator\IConstraint;
use Weew\Validator\IValidationResult;
use Weew\Validator\IValidator;
use Weew\Validator\Validator;

class ConfigSchema implements IConfigSchema {
    /**
     * @var IConfig
     */
    protected $config;

    /**
     * @var IValidator
     */
    protected $validator;

    /**
     * ConfigSchema constructor.
     *
     * @param IConfig $config
     * @param IValidator $validator
     */
    public function __construct(IConfig $config, IValidator $validator = null) {
        if ( ! $validator instanceof IValidator) {
            $validator = $this->createValidator();
        }

        $this->config = $config;
        $this->validator = $validator;
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return IValueNode
     */
    public function hasValue($key, $message = null) {
        return new ValueNode($this, $key, $message);
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return IStringNode
     */
    public function hasString($key, $message = null) {
        return new StringNode($this, $key, $message);
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return INumericNode
     */
    public function hasNumber($key, $message = null) {
        return new NumericNode($this, $key, $message);
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return IBooleanNode
     */
    public function hasBoolean($key, $message = null) {
        return new BooleanNode($this, $key, $message);
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return IArrayNode
     */
    public function hasArray($key, $message = null) {
        return new ArrayNode($this, $key, $message);
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return IStringNode
     */
    public function hasArrayKeys($key, $message = null) {
        $key = s('%s.#', $key);

        return new StringNode($this, $key, $message);
    }

    /**
     * @param string $key
     * @param string $message
     *
     * @return StringNode
     */
    public function hasArrayValues($key, $message = null) {
        $key = s('%s.*', $key);

        return new StringNode($this, $key, $message);
    }

    /**
     * @throws ConfigValidationException
     */
    public function assert() {
        $check = $this->check();

        if ($check->isFailed()) {
            $message = 'Configuration is not valid. ';

            foreach ($check->getErrors() as $index => $error) {
                $message .= s(
                    "\n%s: %s ",
                    $error->getSubject(),
                    $error->getMessage()
                );
            }

            throw new ConfigValidationException($message, $check);
        }
    }

    /**
     * @return IValidationResult
     */
    public function check() {
        return $this->validator->check(
            $this->config->toArray()
        );
    }

    /**
     * @param string $key
     * @param IConstraint $constraint
     *
     * @return IConfigSchema
     */
    public function constraint($key, IConstraint $constraint) {
        $this->validator->addConstraint($key, $constraint);

        return $this;
    }

    /**
     * @param string $key
     * @param IConstraint[] $constraints
     *
     * @return IConfigSchema
     */
    public function constraints($key, array $constraints) {
        $this->validator->addConstraints($key, $constraints);

        return $this;
    }

    /**
     * @return IValidator
     */
    protected function createValidator() {
        return new Validator();
    }
}


1			<?php
2
3			namespace Weew\ConfigSchema;
4
5			use Weew\Config\IConfig;
6			use Weew\ConfigSchema\Exceptions\ConfigValidationException;
7			use Weew\ConfigSchema\Nodes\ArrayNode;
8			use Weew\ConfigSchema\Nodes\BooleanNode;
9			use Weew\ConfigSchema\Nodes\IArrayNode;
10			use Weew\ConfigSchema\Nodes\IBooleanNode;
11			use Weew\ConfigSchema\Nodes\INumericNode;
12			use Weew\ConfigSchema\Nodes\IStringNode;
13			use Weew\ConfigSchema\Nodes\IValueNode;
14			use Weew\ConfigSchema\Nodes\NumericNode;
15			use Weew\ConfigSchema\Nodes\StringNode;
16			use Weew\ConfigSchema\Nodes\ValueNode;
17			use Weew\Validator\IConstraint;
18			use Weew\Validator\IValidationResult;
19			use Weew\Validator\IValidator;
20			use Weew\Validator\Validator;
21
22			class ConfigSchema implements IConfigSchema {
23			/**
24			* @var IConfig
25			*/
26			protected $config;
27
28			/**
29			* @var IValidator
30			*/
31			protected $validator;
32
33			/**
34			* ConfigSchema constructor.
35			*
36			* @param IConfig $config
37			* @param IValidator $validator
38			*/
39			public function __construct(IConfig $config, IValidator $validator = null) {
40			if ( ! $validator instanceof IValidator) {
41			$validator = $this->createValidator();
42			}
43
44			$this->config = $config;
45			$this->validator = $validator;
46			}
47
48			/**
49			* @param string $key
50			* @param string $message
51			*
52			* @return IValueNode
53			*/
54			public function hasValue($key, $message = null) {
55			return new ValueNode($this, $key, $message);
56			}
57
58			/**
59			* @param string $key
60			* @param string $message
61			*
62			* @return IStringNode
63			*/
64			public function hasString($key, $message = null) {
65			return new StringNode($this, $key, $message);
66			}
67
68			/**
69			* @param string $key
70			* @param string $message
71			*
72			* @return INumericNode
73			*/
74			public function hasNumber($key, $message = null) {
75			return new NumericNode($this, $key, $message);
76			}
77
78			/**
79			* @param string $key
80			* @param string $message
81			*
82			* @return IBooleanNode
83			*/
84			public function hasBoolean($key, $message = null) {
85			return new BooleanNode($this, $key, $message);
86			}
87
88			/**
89			* @param string $key
90			* @param string $message
91			*
92			* @return IArrayNode
93			*/
94			public function hasArray($key, $message = null) {
95			return new ArrayNode($this, $key, $message);
96			}
97
98			/**
99			* @param string $key
100			* @param string $message
101			*
102			* @return IStringNode
103			*/
104			public function hasArrayKeys($key, $message = null) {
105			$key = s('%s.#', $key);
106
107			return new StringNode($this, $key, $message);
108			}
109
110			/**
111			* @param string $key
112			* @param string $message
113			*
114			* @return StringNode
115			*/
116			public function hasArrayValues($key, $message = null) {
117			$key = s('%s.*', $key);
118
119			return new StringNode($this, $key, $message);
120			}
121
122			/**
123			* @throws ConfigValidationException
124			*/
125			public function assert() {
126			$check = $this->check();
127
128			if ($check->isFailed()) {
129			$message = 'Configuration is not valid. ';
130
131			foreach ($check->getErrors() as $index => $error) {
132			$message .= s(
133			"\n%s: %s ",
134			$error->getSubject(),
135			$error->getMessage()
136			);
137			}
138
139			throw new ConfigValidationException($message, $check);
140			}
141			}
142
143			/**
144			* @return IValidationResult
145			*/
146			public function check() {
147			return $this->validator->check(
148			$this->config->toArray()
149			);
150			}
151
152			/**
153			* @param string $key
154			* @param IConstraint $constraint
155			*
156			* @return IConfigSchema
157			*/
158			public function constraint($key, IConstraint $constraint) {
159			$this->validator->addConstraint($key, $constraint);
160
161			return $this;
162			}
163
164			/**
165			* @param string $key
166			* @param IConstraint[] $constraints
167			*
168			* @return IConfigSchema
169			*/
170			public function constraints($key, array $constraints) {
171			$this->validator->addConstraints($key, $constraints);
172
173			return $this;
174			}
175
176			/**
177			* @return IValidator
178			*/
179			protected function createValidator() {
180			return new Validator();
181			}
182			}
183

weew / config-schema

ConfigSchema::constraints() A last analyzed 2016-08-28 20:30 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ConfigSchema::constraints() A
last analyzed 2016-08-28 20:30 UTC