Links::links() - Code Metrics - Inspection of "perf improvement" - texthtml/docker-links - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#8)

by Mathieu

created 2016-10-18 12:47 UTC

Links::links() A

↳ Parent: Links

Complexity

Conditions	3
Paths	2

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace TH\Docker;

use ArrayAccess;
use ArrayIterator;
use Countable;
use Iterator;

class Links implements ArrayAccess, Countable, Iterator
{
    private $env;
    private $unique;

    private $links;
    private $iterator;

    public function __construct($env, $unique)
    {
        $this->env = $env;
        $this->unique = $unique;
    }

    public function offsetExists($name) {
        return isset($this->links()[strtoupper($name)]);
    }

    public function offsetGet($name) {
        return $this->links()[strtoupper($name)];
    }

    public function offsetSet($name, $value) {
        throw new \Exception('\TH\Docker\Links is read only');
    }

    public function offsetUnset($name) {
        throw new \Exception('\TH\Docker\Links is read only');
    }

    public function count()
    {
        return count($this->links());
    }

    public function current() {
        return $this->iterator()->current();
    }

    public function key() {
        return $this->iterator()->key();
    }

    public function next() {
        return $this->iterator()->next();
    }

    public function rewind() {
        return $this->iterator()->rewind();
    }

    public function valid() {
        return $this->iterator()->valid();
    }

    public function withEnv($name, $value = null)
    {
        $suffix = "_ENV_".strtoupper($name);
        $n = strlen($suffix);

        $filteredEnv = array_filter($this->env, function ($key) use ($suffix, $n) {
            return substr_compare($key, $suffix, -$n) === 0;
        }, ARRAY_FILTER_USE_KEY);
        if ($value !== null) {
            $filteredEnv = array_filter($filteredEnv, function ($envValue) use ($value) {
                return $envValue === $value;
            });
        }
        $prefixes = array_map(function ($key) use ($n) {
            return substr($key, 0, -$n);
        }, array_keys($filteredEnv));
        $prefixes = array_combine($prefixes, array_map("strlen", $prefixes));
        $env = array_filter($this->env, function ($key) use ($prefixes) {
            foreach ($prefixes as $prefix => $prefixLength) {
                if (substr_compare($key, $prefix, 0, $prefixLength) === 0) {
                    return true;
                }
            }
            return false;
        }, ARRAY_FILTER_USE_KEY);
        return new self($env, $this->unique);
    }

    public static function buildFrom(Array $env, $unique = true)
    {
        return new self($env, $unique);
    }

    private function links() {
        if ($this->links === null) {
            $this->links = [];
            foreach (self::envs($this->env, $this->unique) as $prefixEnv) {
                $link = Link::build($prefixEnv);
                $this->links[strtoupper($link->name())] = $link;
            }
        }
        return $this->links;
    }

    private function iterator() {
        if ($this->iterator === null) {
            $this->iterator = new ArrayIterator($this->links());
        }
        return $this->iterator;
    }

    /**
     * @param  boolean $unique
     */
    private static function envs(Array $env, $unique)
    {
        ksort($env);
        $envs = [];
        reset($env);
        foreach (self::prefixes($env, $unique) as $prefix) {
            while (strpos(key($env), $prefix) === false) {
                next($env);
            }
            $prefixLength = strlen($prefix) + 1;
            $prefixEnv = [];
            do {
                $prefixEnv[substr(key($env), $prefixLength)] = current($env);
                next($env);
            } while (strpos(key($env), $prefix) === 0);
            $envs[] = $prefixEnv;
        }
        return $envs;
    }

    /**
     * @param  boolean $unique
     */
    private static function prefixes(Array $env, $unique)
    {
        return $unique ? self::uniquePrefixes($env) : self::prefixesWithPorts($env);
    }

    private static function uniquePrefixes(Array $env)
    {
        $prefixes = self::prefixesWithPorts($env);
        sort($prefixes);
        return array_reduce($prefixes, function($uniquePrefixes, $prefix) {
            foreach ($uniquePrefixes as $uniqueprefix) {
                if (strpos($prefix, $uniqueprefix) !== false || strpos($uniqueprefix, $prefix) !== false) {
                    return $uniquePrefixes;
                }
            }
            $uniquePrefixes[] = $prefix;
            return $uniquePrefixes;
        }, []);
    }

    private static function prefixesWithPorts(Array $env)
    {
        return array_filter(self::allPrefixes($env), function($prefix) use ($env) {
            return array_key_exists("{$prefix}_PORT", $env);
        });
    }

    private static function allPrefixes(Array $env)
    {
        $prefixes = [];
        foreach ($env as $key => $value) {
            $keyLength = strlen($key);
            if ($keyLength < 6) {
                continue;
            }
            $pos = strrpos($key, '_NAME');
            if ($pos + 5 === $keyLength) {
                $prefixes[] = substr($key, 0, $pos);
            }
        }
        return $prefixes;
    }
}


1			<?php
2
3			namespace TH\Docker;
4
5			use ArrayAccess;
6			use ArrayIterator;
7			use Countable;
8			use Iterator;
9
10			class Links implements ArrayAccess, Countable, Iterator
11			{
12			private $env;
13			private $unique;
14
15			private $links;
16			private $iterator;
17
18			public function __construct($env, $unique)
19			{
20			$this->env = $env;
21			$this->unique = $unique;
22			}
23
24			public function offsetExists($name) {
25			return isset($this->links()[strtoupper($name)]);
26			}
27
28			public function offsetGet($name) {
29			return $this->links()[strtoupper($name)];
30			}
31
32			public function offsetSet($name, $value) {
33			throw new \Exception('\TH\Docker\Links is read only');
34			}
35
36			public function offsetUnset($name) {
37			throw new \Exception('\TH\Docker\Links is read only');
38			}
39
40			public function count()
41			{
42			return count($this->links());
43			}
44
45			public function current() {
46			return $this->iterator()->current();
47			}
48
49			public function key() {
50			return $this->iterator()->key();
51			}
52
53			public function next() {
54			return $this->iterator()->next();
55			}
56
57			public function rewind() {
58			return $this->iterator()->rewind();
59			}
60
61			public function valid() {
62			return $this->iterator()->valid();
63			}
64
65			public function withEnv($name, $value = null)
66			{
67			$suffix = "_ENV_".strtoupper($name);
68			$n = strlen($suffix);
69
70			$filteredEnv = array_filter($this->env, function ($key) use ($suffix, $n) {
71			return substr_compare($key, $suffix, -$n) === 0;
72			}, ARRAY_FILTER_USE_KEY);
73			if ($value !== null) {
74			$filteredEnv = array_filter($filteredEnv, function ($envValue) use ($value) {
75			return $envValue === $value;
76			});
77			}
78			$prefixes = array_map(function ($key) use ($n) {
79			return substr($key, 0, -$n);
80			}, array_keys($filteredEnv));
81			$prefixes = array_combine($prefixes, array_map("strlen", $prefixes));
82			$env = array_filter($this->env, function ($key) use ($prefixes) {
83			foreach ($prefixes as $prefix => $prefixLength) {
84			if (substr_compare($key, $prefix, 0, $prefixLength) === 0) {
85			return true;
86			}
87			}
88			return false;
89			}, ARRAY_FILTER_USE_KEY);
90			return new self($env, $this->unique);
91			}
92
93			public static function buildFrom(Array $env, $unique = true)
94			{
95			return new self($env, $unique);
96			}
97
98			private function links() {
99			if ($this->links === null) {
100			$this->links = [];
101			foreach (self::envs($this->env, $this->unique) as $prefixEnv) {
102			$link = Link::build($prefixEnv);
103			$this->links[strtoupper($link->name())] = $link;
104			}
105			}
106			return $this->links;
107			}
108
109			private function iterator() {
110			if ($this->iterator === null) {
111			$this->iterator = new ArrayIterator($this->links());
112			}
113			return $this->iterator;
114			}
115
116			/**
117			* @param boolean $unique
118			*/
119			private static function envs(Array $env, $unique)
120			{
121			ksort($env);
122			$envs = [];
123			reset($env);
124			foreach (self::prefixes($env, $unique) as $prefix) {
125			while (strpos(key($env), $prefix) === false) {
126			next($env);
127			}
128			$prefixLength = strlen($prefix) + 1;
129			$prefixEnv = [];
130			do {
131			$prefixEnv[substr(key($env), $prefixLength)] = current($env);
132			next($env);
133			} while (strpos(key($env), $prefix) === 0);
134			$envs[] = $prefixEnv;
135			}
136			return $envs;
137			}
138
139			/**
140			* @param boolean $unique
141			*/
142			private static function prefixes(Array $env, $unique)
143			{
144			return $unique ? self::uniquePrefixes($env) : self::prefixesWithPorts($env);
145			}
146
147			private static function uniquePrefixes(Array $env)
148			{
149			$prefixes = self::prefixesWithPorts($env);
150			sort($prefixes);
151			return array_reduce($prefixes, function($uniquePrefixes, $prefix) {
152			foreach ($uniquePrefixes as $uniqueprefix) {
153			if (strpos($prefix, $uniqueprefix) !== false \|\| strpos($uniqueprefix, $prefix) !== false) {
154			return $uniquePrefixes;
155			}
156			}
157			$uniquePrefixes[] = $prefix;
158			return $uniquePrefixes;
159			}, []);
160			}
161
162			private static function prefixesWithPorts(Array $env)
163			{
164			return array_filter(self::allPrefixes($env), function($prefix) use ($env) {
165			return array_key_exists("{$prefix}_PORT", $env);
166			});
167			}
168
169			private static function allPrefixes(Array $env)
170			{
171			$prefixes = [];
172			foreach ($env as $key => $value) {
173			$keyLength = strlen($key);
174			if ($keyLength < 6) {
175			continue;
176			}
177			$pos = strrpos($key, '_NAME');
178			if ($pos + 5 === $keyLength) {
179			$prefixes[] = substr($key, 0, $pos);
180			}
181			}
182			return $prefixes;
183			}
184			}
185

texthtml / docker-links

Pull Request — master (#8)

Links::links() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like