Config::hasRequired() - Code Metrics - Inspection of "Add cache client and tests" - ochi51/cybozu-http - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — cache ( 3de9ec )

by Yuichi

created 2016-06-08 10:56 UTC

Config::hasRequired() B

↳ Parent: Config

Complexity

Conditions	6
Paths	9

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	1

Metric	Value
c	5
b	0
f	1
dl	0
loc	13
rs	8.8571
cc	6
eloc	8
nc	9
nop	0

<?php

namespace CybozuHttp;

use CybozuHttp\Exception\NotExistRequiredException;


/**
 * @author ochi51 <[email protected]>
 */
class Config
{

    /**
     * @var array $config
     */
    private $config = [];

    /**
     * @var array $default
     */
    private $default = [
        'domain' => "cybozu.com",
        'use_api_token' => false,
        'use_basic' => false,
        'use_client_cert' => false,
        'base_url' => null,
        'defaults' => [],
        'use_cache' => false,
        'cache_dir' => null,
        'cache_ttl' => 0,
        'debug' => false
    ];

    /**
     * @var array $required
     */
    private $required = [
        'domain',
        'subdomain',
        'use_api_token',
        'use_basic',
        'use_client_cert',
        'base_url',
        'defaults',
        'use_cache',
        'debug'
    ];

    public function __construct(array $config)
    {
        $this->config = $config + $this->default;

        $this->config['base_url'] = $this->getBaseUrl();

        $this->configureDefaults();
    }

    /**
     * configure default options
     */
    private function configureDefaults()
    {
        $this->configureAuth();
        $this->configureBasicAuth();
        $this->configureCert();
    }

    private function configureAuth()
    {
        if ($this->get('use_api_token')) {
            $this->config['defaults']['headers']['X-Cybozu-API-Token'] = $this->get('token');
        } else {
            $this->config['defaults']['headers']['X-Cybozu-Authorization'] =
                base64_encode($this->get('login') . ':' . $this->get('password'));
        }
    }

    private function configureBasicAuth()
    {
        if ($this->get('use_basic')) {
            $this->config['defaults']['auth'] = $this->getBasicAuthOptions();
        }
    }

    private function configureCert()
    {
        if ($this->get('use_client_cert')) {
            $this->config['defaults']['verify'] = true;
            $this->config['defaults']['cert'] = $this->getCertOptions();
        } else {
            $this->config['defaults']['verify'] = false;
        }
    }

    /**
     * @return array
     */
    private function getBasicAuthOptions()
    {
        if ($this->hasRequiredOnBasicAuth()) {
            return [
                $this->get('basic_login'),
                $this->get('basic_password')
            ];
        }
        throw new NotExistRequiredException("kintone.empty_basic_password");
    }

    /**
     * @return array
     */
    private function getCertOptions()
    {
        if ($this->hasRequiredOnCert()) {
            return [
                $this->get('cert_file'),
                $this->get('cert_password')
            ];
        }
        throw new NotExistRequiredException("kintone.empty_cert");
    }

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

    /**
     * @param $key
     * @return string|bool
     */
    public function get($key)
    {
        if (isset($this->config[$key])) {
            return $this->config[$key];
        }

        return false;
    }

    /**
     * @return bool
     */
    public function hasRequired()
    {
        foreach ($this->required as $r) {
            if (!array_key_exists($r, $this->config)) {
                return false;
            }
        }

        return $this->hasRequiredOnAuth()
                && $this->hasRequiredOnBasicAuth()
                && $this->hasRequiredOnCert()
                && $this->hasRequiredOnCache();
    }

    /**
     * @return bool
     */
    private function hasRequiredOnAuth()
    {
        if ($this->get('use_api_token')) {
            return !empty($this->get('token'));
        }

        return $this->get('login') && $this->get('password');
    }

    /**
     * @return bool
     */
    private function hasRequiredOnBasicAuth()
    {
        return $this->hasKeysByUse('use_basic', ['basic_login', 'basic_password']);
    }

    /**
     * @return bool
     */
    private function hasRequiredOnCert()
    {
        return $this->hasKeysByUse('use_client_cert', ['cert_file', 'cert_password']);
    }

    /**
     * @return bool
     */
    private function hasRequiredOnCache()
    {
        return $this->hasKeysByUse('use_cache', ['cache_dir', 'cache_ttl']);
    }

    /**
     * @param string $use
     * @param string[] $keys
     * @return bool
     */
    private function hasKeysByUse($use, array $keys)
    {
        if (!$this->get($use)) {
            return true;
        }

        foreach ($keys as $key) {
            if (is_null($this->get($key)) || $this->get($key) === false) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return string
     */
    public function getBaseUrl()
    {
        $subdomain = $this->get('subdomain');
        $uri = "https://" . $subdomain;

        if (strpos($subdomain, '.') === false) {
            if ($this->get('use_client_cert')) {
                $uri .= ".s";
            }

            $uri .= "." . $this->get('domain');
        }

        return $uri;
    }
}

1			<?php
2
3			namespace CybozuHttp;
4
5			use CybozuHttp\Exception\NotExistRequiredException;
6
7
8			/**
9			* @author ochi51 <[email protected]>
10			*/
11			class Config
12			{
13
14			/**
15			* @var array $config
16			*/
17			private $config = [];
18
19			/**
20			* @var array $default
21			*/
22			private $default = [
23			'domain' => "cybozu.com",
24			'use_api_token' => false,
25			'use_basic' => false,
26			'use_client_cert' => false,
27			'base_url' => null,
28			'defaults' => [],
29			'use_cache' => false,
30			'cache_dir' => null,
31			'cache_ttl' => 0,
32			'debug' => false
33			];
34
35			/**
36			* @var array $required
37			*/
38			private $required = [
39			'domain',
40			'subdomain',
41			'use_api_token',
42			'use_basic',
43			'use_client_cert',
44			'base_url',
45			'defaults',
46			'use_cache',
47			'debug'
48			];
49
50			public function __construct(array $config)
51			{
52			$this->config = $config + $this->default;
53
54			$this->config['base_url'] = $this->getBaseUrl();
55
56			$this->configureDefaults();
57			}
58
59			/**
60			* configure default options
61			*/
62			private function configureDefaults()
63			{
64			$this->configureAuth();
65			$this->configureBasicAuth();
66			$this->configureCert();
67			}
68
69			private function configureAuth()
70			{
71			if ($this->get('use_api_token')) {
72			$this->config['defaults']['headers']['X-Cybozu-API-Token'] = $this->get('token');
73			} else {
74			$this->config['defaults']['headers']['X-Cybozu-Authorization'] =
75			base64_encode($this->get('login') . ':' . $this->get('password'));
76			}
77			}
78
79			private function configureBasicAuth()
80			{
81			if ($this->get('use_basic')) {
82			$this->config['defaults']['auth'] = $this->getBasicAuthOptions();
83			}
84			}
85
86			private function configureCert()
87			{
88			if ($this->get('use_client_cert')) {
89			$this->config['defaults']['verify'] = true;
90			$this->config['defaults']['cert'] = $this->getCertOptions();
91			} else {
92			$this->config['defaults']['verify'] = false;
93			}
94			}
95
96			/**
97			* @return array
98			*/
99			private function getBasicAuthOptions()
100			{
101			if ($this->hasRequiredOnBasicAuth()) {
102			return [
103			$this->get('basic_login'),
104			$this->get('basic_password')
105			];
106			}
107			throw new NotExistRequiredException("kintone.empty_basic_password");
108			}
109
110			/**
111			* @return array
112			*/
113			private function getCertOptions()
114			{
115			if ($this->hasRequiredOnCert()) {
116			return [
117			$this->get('cert_file'),
118			$this->get('cert_password')
119			];
120			}
121			throw new NotExistRequiredException("kintone.empty_cert");
122			}
123
124			/**
125			* @return array
126			*/
127			public function toArray()
128			{
129			return $this->config;
130			}
131
132			/**
133			* @param $key
134			* @return string\|bool
135			*/
136			public function get($key)
137			{
138			if (isset($this->config[$key])) {
139			return $this->config[$key];
140			}
141
142			return false;
143			}
144
145			/**
146			* @return bool
147			*/
148			public function hasRequired()
149			{
150			foreach ($this->required as $r) {
151			if (!array_key_exists($r, $this->config)) {
152			return false;
153			}
154			}
155
156			return $this->hasRequiredOnAuth()
157			&& $this->hasRequiredOnBasicAuth()
158			&& $this->hasRequiredOnCert()
159			&& $this->hasRequiredOnCache();
160			}
161
162			/**
163			* @return bool
164			*/
165			private function hasRequiredOnAuth()
166			{
167			if ($this->get('use_api_token')) {
168			return !empty($this->get('token'));
169			}
170
171			return $this->get('login') && $this->get('password');
172			}
173
174			/**
175			* @return bool
176			*/
177			private function hasRequiredOnBasicAuth()
178			{
179			return $this->hasKeysByUse('use_basic', ['basic_login', 'basic_password']);
180			}
181
182			/**
183			* @return bool
184			*/
185			private function hasRequiredOnCert()
186			{
187			return $this->hasKeysByUse('use_client_cert', ['cert_file', 'cert_password']);
188			}
189
190			/**
191			* @return bool
192			*/
193			private function hasRequiredOnCache()
194			{
195			return $this->hasKeysByUse('use_cache', ['cache_dir', 'cache_ttl']);
196			}
197
198			/**
199			* @param string $use
200			* @param string[] $keys
201			* @return bool
202			*/
203			private function hasKeysByUse($use, array $keys)
204			{
205			if (!$this->get($use)) {
206			return true;
207			}
208
209			foreach ($keys as $key) {
210			if (is_null($this->get($key)) \|\| $this->get($key) === false) {
211			return false;
212			}
213			}
214
215			return true;
216			}
217
218			/**
219			* @return string
220			*/
221			public function getBaseUrl()
222			{
223			$subdomain = $this->get('subdomain');
224			$uri = "https://" . $subdomain;
225
226			if (strpos($subdomain, '.') === false) {
227			if ($this->get('use_client_cert')) {
228			$uri .= ".s";
229			}
230
231			$uri .= "." . $this->get('domain');
232			}
233
234			return $uri;
235			}
236			}

ochi51 / cybozu-http

Push — cache ( 3de9ec )

Config::hasRequired() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like