StrObj::__construct() - Code Metrics - Inspection of "more work on unicode support, not done yet" - garrettw/stringobject - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1d9387...a47b74 )

by Garrett

created 2016-03-20 22:29 UTC

StrObj::__construct() A

↳ Parent: StrObj

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	10
Bugs	1	Features	5

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

<?php

namespace StringObject;

class StrObj extends AnyStrObj implements \ArrayAccess, \Countable, \Iterator
{
    // CONSTANTS

    const NORMAL = 0;
    const START = 0;
    const END = 1;
    const BOTH_ENDS = 2;
    const CASE_INSENSITIVE = 4;
    const REVERSE = 8;
    const EXACT_POSITION = 16;
    const CURRENT_LOCALE = 32;
    const NATURAL_ORDER = 64;
    const FIRST_N = 128;
    const C_STYLE = 256;
    const META = 512;
    const LAZY = 1024;
    const GREEDY = 2048;

    // PROPERTIES

    protected $raw;
    protected $token = false;
    protected $caret = 0;

    // MAGIC METHODS

    /**
     * @return mixed
     */
    public function __get($name)
    {
        return $this->$name;
    }

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

    public function toArray($delim = '', $limit = null)

    {
        if (empty($delim)) {
            return \str_split($this->raw);
        }
        if (is_int($delim)) {
            return \str_split($this->raw, $delim);
        }
        if ($limit === null) {
            return \explode($delim, $this->raw);
        }
        return \explode($delim, $this->raw, $limit);
    }

    // INFORMATIONAL METHODS

    public function charAt($offset)
    {
        return new self($this->raw{$offset});
    }

    /**
     * @param integer $offset
     */
    public function charCodeAt($offset)
    {
        return \ord($this->raw{$offset});
    }

    public function compareTo($str, $flags = self::NORMAL, $length = 1)
    {
        $flagsmap = [
            self::NORMAL => 'strcmp',
            self::CASE_INSENSITIVE => 'strcasecmp',
            self::CURRENT_LOCALE => 'strcoll',
            self::NATURAL_ORDER => 'strnatcmp',
            (self::NATURAL_ORDER | self::CASE_INSENSITIVE) => 'strnatcasecmp',
            self::FIRST_N => 'strncmp',
            (self::FIRST_N | self::CASE_INSENSITIVE) => 'strncasecmp',
        ];

        if ($flags & self::FIRST_N) {
            return \call_user_func($flagsmap[$flags], $this->raw, $str, $length);
        }
        return \call_user_func($flagsmap[$flags], $this->raw, $str);
    }

    public function indexOf($needle, $offset = 0, $flags = self::NORMAL)
    {
        // strip out bits we don't understand
        $flags &= (self::REVERSE | self::CASE_INSENSITIVE);

        $flagsmap = [
            self::NORMAL => 'strpos',
            self::CASE_INSENSITIVE => 'stripos',
            self::REVERSE => 'strrpos',
            (self::REVERSE | self::CASE_INSENSITIVE) => 'strripos',
        ];
        return \call_user_func($flagsmap[$flags], $this->raw, $needle, $offset);
    }

    public function length()
    {
        return \strlen($this->raw);
    }

    // MODIFYING METHODS

    public function append($str)
    {
        return new self($this->raw . $str);
    }

    public function chunk($length = 76, $ending = "\r\n")
    {
        return new self(\chunk_split($this->raw, $length, $ending));
    }

    public function concat($str)
    {
        return $this->append($str);
    }

    public function escape($flags = self::NORMAL, $charlist = '')
    {
        $flagsmap = [
            self::NORMAL => 'addslashes',
            self::C_STYLE => 'addcslashes',
            self::META => 'quotemeta',
        ];
        if ($flags === self::C_STYLE) {
            return new self(\call_user_func($flagsmap[$flags], $this->raw, $charlist));
        }
        return new self(\call_user_func($flagsmap[$flags], $this->raw));
    }

    public function insertAt($str, $offset)
    {
        return $this->replaceSubstr($str, $offset, 0);
    }

    public function nextToken($delim)
    {
        if ($this->token) {
            return new self(\strtok($delim));
        }
        $this->token = true;
        return new self(\strtok($this->raw, $delim));
    }

    public function pad($newlength, $padding = ' ', $flags = self::END)
    {
        return new self(\str_pad($this->raw, $newlength, $padding, $flags));
    }

    public function prepend($str)
    {
        return new self($str . $this->raw);
    }

    public function remove($str, $flags = self::NORMAL)
    {
        return $this->replace($str, '', $flags);
    }

    public function removeSubstr($start, $length = null)
    {
        return $this->replaceSubstr('', $start, $length);
    }

    public function repeat($times)
    {
        return new self(\str_repeat($this->raw, $times));
    }

    /**
     * @param string $replace
     */
    public function replace($search, $replace, $flags = self::NORMAL)
    {
        if ($flags & self::CASE_INSENSITIVE) {
            return new self(\str_ireplace($search, $replace, $this->raw));
        }
        return new self(\str_replace($search, $replace, $this->raw));
    }

    public function replaceSubstr($replacement, $start, $length = null)
    {
        if ($length === null) {
            $length = $this->length();
        }
        return new self(\substr_replace($this->raw, $replacement, $start, $length));
    }

    public function resetToken()
    {
        $this->token = false;
    }

    public function reverse()
    {
        return new self(\strrev($this->raw));
    }

    public function shuffle()
    {
        return new self(\str_shuffle($this->raw));
    }

    public function substr($start, $length = 'omitted')
    {
        if ($length === 'omitted') {
            return new self(\substr($this->raw, $start));
        }
        return new self(\substr($this->raw, $start, $length));
    }

    public function times($times)
    {
        return $this->repeat($times);
    }

    public function translate($search, $replace = '')
    {
        if (is_array($search)) {
            return new self(\strtr($this->raw, $search));
        }
        return new self(\strtr($this->raw, $search, $replace));
    }

    public function trim($mask = " \t\n\r\0\x0B", $flags = self::BOTH_ENDS)

    {
        $flagsmap = [
            self::START => 'ltrim',
            self::END => 'rtrim',
            self::BOTH_ENDS => 'trim',
        ];
        return new self(\call_user_func($flagsmap[$flags], $this->raw, $mask));
    }

    public function unescape($flags = self::NORMAL)

    {
        $flagsmap = [
            self::NORMAL => 'stripslashes',
            self::C_STYLE => 'stripcslashes',
            self::META => 'stripslashes',
        ];
        return new self(\call_user_func($flagsmap[$flags], $this->raw));
    }

    public function uuDecode()
    {
        return new self(\convert_uudecode($this->raw));
    }

    public function uuEncode()
    {
        return new self(\convert_uuencode($this->raw));
    }

    public function wordwrap($width = 75, $break = "\n")
    {
        return new self(\wordwrap($this->raw, $width, $break, false));
    }

    public function wordwrapBreaking($width = 75, $break = "\n")
    {
        return new self(\wordwrap($this->raw, $width, $break, true));
    }

    // TESTING METHODS

    public function contains($needle, $offset = 0, $flags = self::NORMAL)
    {
        if ($flags & self::EXACT_POSITION) {
            return ($this->indexOf($needle, $offset, $flags) === $offset);
        }
        return ($this->indexOf($needle, $offset, $flags) !== false);
    }

    public function countSubstr($needle, $offset = 0, $length = null)
    {
        if ($length === null) {
            return \substr_count($this->raw, $needle, $offset);
        }
        return \substr_count($this->raw, $needle, $offset, $length);
    }

    public function endsWith($str, $flags = self::NORMAL)
    {
        $flags &= self::CASE_INSENSITIVE;
        $offset = $this->length() - \strlen($str);
        return $this->contains($str, $offset, $flags | self::EXACT_POSITION | self::REVERSE);
    }

    public function equals($str)
    {
        self::testStringableObject($str);

        $str = (string) $str;
        return ($str == $this->raw);
    }

    public function isAscii()
    {
        $len = $this->length();

        for ($i = 0; $i < $len; $i++) {
            if ($this->charCodeAt($i) >= 128) {
                return false;
            }
        }
        return true;
    }

    public function isEmpty()
    {
        return empty($this->raw);
    }

    public function startsWith($str, $flags = self::NORMAL)
    {
        $flags &= self::CASE_INSENSITIVE;
        return $this->contains($str, 0, $flags | self::EXACT_POSITION);
    }

    // INTERFACE IMPLEMENTATION METHODS

    public function count()
    {
        return \strlen($this->raw);
    }

    public function current()
    {
        return $this->raw[$this->caret];
    }

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

    public function next()
    {
        $this->caret++;
    }

    public function rewind()
    {
        $this->caret = 0;
    }

    public function valid()
    {
        return ($this->caret < \strlen($this->raw));
    }

    public function offsetExists($offset)
    {
        $offset = (int) $offset;
        return ($offset >= 0 && $offset < \strlen($this->raw));
    }

    public function offsetGet($offset)
    {
        return $this->raw{$offset};
    }

    public function offsetSet($offset, $value)
    {
        throw new \LogicException('Cannot assign ' . $value . ' to immutable StrObj instance at index ' . $offset);
    }

    public function offsetUnset($offset)
    {
        throw new \LogicException('Cannot unset index ' . $offset . ' on immutable StrObj instance');
    }

    // PRIVATE STATIC FUNCTIONS

    protected static function testStringableObject($thing)
    {
        if (\is_object($thing) && !\method_exists($thing, '__toString')) {
            throw new \InvalidArgumentException(
                'Parameter is an object that does not implement __toString() method'
            );
        }
    }
}


1		<?php
2
3		namespace StringObject;
4
5		class StrObj extends AnyStrObj implements \ArrayAccess, \Countable, \Iterator
6		{
7		// CONSTANTS
8
9		const NORMAL = 0;
10		const START = 0;
11		const END = 1;
12		const BOTH_ENDS = 2;
13		const CASE_INSENSITIVE = 4;
14		const REVERSE = 8;
15		const EXACT_POSITION = 16;
16		const CURRENT_LOCALE = 32;
17		const NATURAL_ORDER = 64;
18		const FIRST_N = 128;
19		const C_STYLE = 256;
20		const META = 512;
21		const LAZY = 1024;
22		const GREEDY = 2048;
23
24		// PROPERTIES
25
26		protected $raw;
27		protected $token = false;
28		protected $caret = 0;
29
30		// MAGIC METHODS
31
32		/**
33		* @return mixed
34		*/
35		public function __get($name)
36		{
37		return $this->$name;
38		}
39
40		/**
41		* @return string
42		*/
43		public function __toString()
44		{
45		return $this->raw;
46		}
47
48	View Code Duplication	public function toArray($delim = '', $limit = null)
		0 ignored issues – show Duplication introduced 2015-12-04 23:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
49		{
50		if (empty($delim)) {
51		return \str_split($this->raw);
52		}
53		if (is_int($delim)) {
54		return \str_split($this->raw, $delim);
55		}
56		if ($limit === null) {
57		return \explode($delim, $this->raw);
58		}
59		return \explode($delim, $this->raw, $limit);
60		}
61
62		// INFORMATIONAL METHODS
63
64		public function charAt($offset)
65		{
66		return new self($this->raw{$offset});
67		}
68
69		/**
70		* @param integer $offset
71		*/
72		public function charCodeAt($offset)
73		{
74		return \ord($this->raw{$offset});
75		}
76
77		public function compareTo($str, $flags = self::NORMAL, $length = 1)
78		{
79		$flagsmap = [
80		self::NORMAL => 'strcmp',
81		self::CASE_INSENSITIVE => 'strcasecmp',
82		self::CURRENT_LOCALE => 'strcoll',
83		self::NATURAL_ORDER => 'strnatcmp',
84		(self::NATURAL_ORDER \| self::CASE_INSENSITIVE) => 'strnatcasecmp',
85		self::FIRST_N => 'strncmp',
86		(self::FIRST_N \| self::CASE_INSENSITIVE) => 'strncasecmp',
87		];
88
89		if ($flags & self::FIRST_N) {
90		return \call_user_func($flagsmap[$flags], $this->raw, $str, $length);
91		}
92		return \call_user_func($flagsmap[$flags], $this->raw, $str);
93		}
94
95		public function indexOf($needle, $offset = 0, $flags = self::NORMAL)
96		{
97		// strip out bits we don't understand
98		$flags &= (self::REVERSE \| self::CASE_INSENSITIVE);
99
100		$flagsmap = [
101		self::NORMAL => 'strpos',
102		self::CASE_INSENSITIVE => 'stripos',
103		self::REVERSE => 'strrpos',
104		(self::REVERSE \| self::CASE_INSENSITIVE) => 'strripos',
105		];
106		return \call_user_func($flagsmap[$flags], $this->raw, $needle, $offset);
107		}
108
109		public function length()
110		{
111		return \strlen($this->raw);
112		}
113
114		// MODIFYING METHODS
115
116		public function append($str)
117		{
118		return new self($this->raw . $str);
119		}
120
121		public function chunk($length = 76, $ending = "\r\n")
122		{
123		return new self(\chunk_split($this->raw, $length, $ending));
124		}
125
126		public function concat($str)
127		{
128		return $this->append($str);
129		}
130
131		public function escape($flags = self::NORMAL, $charlist = '')
132		{
133		$flagsmap = [
134		self::NORMAL => 'addslashes',
135		self::C_STYLE => 'addcslashes',
136		self::META => 'quotemeta',
137		];
138		if ($flags === self::C_STYLE) {
139		return new self(\call_user_func($flagsmap[$flags], $this->raw, $charlist));
140		}
141		return new self(\call_user_func($flagsmap[$flags], $this->raw));
142		}
143
144		public function insertAt($str, $offset)
145		{
146		return $this->replaceSubstr($str, $offset, 0);
147		}
148
149		public function nextToken($delim)
150		{
151		if ($this->token) {
152		return new self(\strtok($delim));
153		}
154		$this->token = true;
155		return new self(\strtok($this->raw, $delim));
156		}
157
158		public function pad($newlength, $padding = ' ', $flags = self::END)
159		{
160		return new self(\str_pad($this->raw, $newlength, $padding, $flags));
161		}
162
163		public function prepend($str)
164		{
165		return new self($str . $this->raw);
166		}
167
168		public function remove($str, $flags = self::NORMAL)
169		{
170		return $this->replace($str, '', $flags);
171		}
172
173		public function removeSubstr($start, $length = null)
174		{
175		return $this->replaceSubstr('', $start, $length);
176		}
177
178		public function repeat($times)
179		{
180		return new self(\str_repeat($this->raw, $times));
181		}
182
183		/**
184		* @param string $replace
185		*/
186		public function replace($search, $replace, $flags = self::NORMAL)
187		{
188		if ($flags & self::CASE_INSENSITIVE) {
189		return new self(\str_ireplace($search, $replace, $this->raw));
190		}
191		return new self(\str_replace($search, $replace, $this->raw));
192		}
193
194		public function replaceSubstr($replacement, $start, $length = null)
195		{
196		if ($length === null) {
197		$length = $this->length();
198		}
199		return new self(\substr_replace($this->raw, $replacement, $start, $length));
200		}
201
202		public function resetToken()
203		{
204		$this->token = false;
205		}
206
207		public function reverse()
208		{
209		return new self(\strrev($this->raw));
210		}
211
212		public function shuffle()
213		{
214		return new self(\str_shuffle($this->raw));
215		}
216
217		public function substr($start, $length = 'omitted')
218		{
219		if ($length === 'omitted') {
220		return new self(\substr($this->raw, $start));
221		}
222		return new self(\substr($this->raw, $start, $length));
223		}
224
225		public function times($times)
226		{
227		return $this->repeat($times);
228		}
229
230		public function translate($search, $replace = '')
231		{
232		if (is_array($search)) {
233		return new self(\strtr($this->raw, $search));
234		}
235		return new self(\strtr($this->raw, $search, $replace));
236		}
237
238	View Code Duplication	public function trim($mask = " \t\n\r\0\x0B", $flags = self::BOTH_ENDS)
		1 ignored issue – show Duplication introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
239		{
240		$flagsmap = [
241		self::START => 'ltrim',
242		self::END => 'rtrim',
243		self::BOTH_ENDS => 'trim',
244		];
245		return new self(\call_user_func($flagsmap[$flags], $this->raw, $mask));
246		}
247
248	View Code Duplication	public function unescape($flags = self::NORMAL)
		1 ignored issue – show Duplication introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
249		{
250		$flagsmap = [
251		self::NORMAL => 'stripslashes',
252		self::C_STYLE => 'stripcslashes',
253		self::META => 'stripslashes',
254		];
255		return new self(\call_user_func($flagsmap[$flags], $this->raw));
256		}
257
258		public function uuDecode()
259		{
260		return new self(\convert_uudecode($this->raw));
261		}
262
263		public function uuEncode()
264		{
265		return new self(\convert_uuencode($this->raw));
266		}
267
268		public function wordwrap($width = 75, $break = "\n")
269		{
270		return new self(\wordwrap($this->raw, $width, $break, false));
271		}
272
273		public function wordwrapBreaking($width = 75, $break = "\n")
274		{
275		return new self(\wordwrap($this->raw, $width, $break, true));
276		}
277
278		// TESTING METHODS
279
280		public function contains($needle, $offset = 0, $flags = self::NORMAL)
281		{
282		if ($flags & self::EXACT_POSITION) {
283		return ($this->indexOf($needle, $offset, $flags) === $offset);
284		}
285		return ($this->indexOf($needle, $offset, $flags) !== false);
286		}
287
288		public function countSubstr($needle, $offset = 0, $length = null)
289		{
290		if ($length === null) {
291		return \substr_count($this->raw, $needle, $offset);
292		}
293		return \substr_count($this->raw, $needle, $offset, $length);
294		}
295
296		public function endsWith($str, $flags = self::NORMAL)
297		{
298		$flags &= self::CASE_INSENSITIVE;
299		$offset = $this->length() - \strlen($str);
300		return $this->contains($str, $offset, $flags \| self::EXACT_POSITION \| self::REVERSE);
301		}
302
303		public function equals($str)
304		{
305		self::testStringableObject($str);
306
307		$str = (string) $str;
308		return ($str == $this->raw);
309		}
310
311		public function isAscii()
312		{
313		$len = $this->length();
314
315		for ($i = 0; $i < $len; $i++) {
316		if ($this->charCodeAt($i) >= 128) {
317		return false;
318		}
319		}
320		return true;
321		}
322
323		public function isEmpty()
324		{
325		return empty($this->raw);
326		}
327
328		public function startsWith($str, $flags = self::NORMAL)
329		{
330		$flags &= self::CASE_INSENSITIVE;
331		return $this->contains($str, 0, $flags \| self::EXACT_POSITION);
332		}
333
334		// INTERFACE IMPLEMENTATION METHODS
335
336		public function count()
337		{
338		return \strlen($this->raw);
339		}
340
341		public function current()
342		{
343		return $this->raw[$this->caret];
344		}
345
346		public function key()
347		{
348		return $this->caret;
349		}
350
351		public function next()
352		{
353		$this->caret++;
354		}
355
356		public function rewind()
357		{
358		$this->caret = 0;
359		}
360
361		public function valid()
362		{
363		return ($this->caret < \strlen($this->raw));
364		}
365
366		public function offsetExists($offset)
367		{
368		$offset = (int) $offset;
369		return ($offset >= 0 && $offset < \strlen($this->raw));
370		}
371
372		public function offsetGet($offset)
373		{
374		return $this->raw{$offset};
375		}
376
377		public function offsetSet($offset, $value)
378		{
379		throw new \LogicException('Cannot assign ' . $value . ' to immutable StrObj instance at index ' . $offset);
380		}
381
382		public function offsetUnset($offset)
383		{
384		throw new \LogicException('Cannot unset index ' . $offset . ' on immutable StrObj instance');
385		}
386
387		// PRIVATE STATIC FUNCTIONS
388
389		protected static function testStringableObject($thing)
390		{
391		if (\is_object($thing) && !\method_exists($thing, '__toString')) {
392		throw new \InvalidArgumentException(
393		'Parameter is an object that does not implement __toString() method'
394		);
395		}
396		}
397		}
398

garrettw / stringobject

Push — master ( 1d9387...a47b74 )

StrObj::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like