AnyString::escape()

Completed

Push — master ( 34d315...a20938 )

by Garrett

created 2016-05-11 21:06 UTC

↳ Parent: AnyString

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	1
nc	1

<?php

namespace StringObject;

abstract class AnyString
{
    protected $raw;

    public function __construct($thing)
    {
        self::testStringableObject($thing);
        $this->raw = (string) $thing;
    }

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

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

    abstract public function compareTo($str, $mode = self::NORMAL, $length = 1);


    abstract public function escape($mode = self::NORMAL, $charlist = '');


    abstract public function nextToken($delim);


    abstract public function remove($str, $mode = self::NORMAL);


    abstract public function repeat($times);


    /**
     * @param string $replace
     */
    abstract public function replace($search, $replace, $mode = self::NORMAL);


    abstract public function replaceWhole($replacement = '');


    abstract public function resetToken();


    abstract public function times($times);


    abstract public function translate($search, $replace = '');


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


    abstract public function unescape($mode = self::NORMAL);


    abstract public function uuDecode();


    abstract public function uuEncode();


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

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

    abstract public function isAscii();


    abstract public function isEmpty();


    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'
            );
        } elseif (\is_array($thing)) {
            throw new \InvalidArgumentException('Unsure of how to convert array to string');
        }
    }
}


1			<?php
2
3			namespace StringObject;
4
5			abstract class AnyString
6			{
7			protected $raw;
8
9			public function __construct($thing)
10			{
11			self::testStringableObject($thing);
12			$this->raw = (string) $thing;
13			}
14
15			/**
16			* @return mixed
17			*/
18			public function __get($name)
19			{
20			return $this->$name;
21			}
22
23			/**
24			* @return string
25			*/
26			public function __toString()
27			{
28			return $this->raw;
29			}
30
31			abstract public function compareTo($str, $mode = self::NORMAL, $length = 1);
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
32
33			abstract public function escape($mode = self::NORMAL, $charlist = '');
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
34
35			abstract public function nextToken($delim);
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
36
37			abstract public function remove($str, $mode = self::NORMAL);
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
38
39			abstract public function repeat($times);
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
40
41			/**
42			* @param string $replace
43			*/
44			abstract public function replace($search, $replace, $mode = self::NORMAL);
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
45
46			abstract public function replaceWhole($replacement = '');
			0 ignored issues – show Documentation introduced 2016-05-11 21:16 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
47
48			abstract public function resetToken();
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
49
50			abstract public function times($times);
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
51
52			abstract public function translate($search, $replace = '');
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
53
54			abstract public function trim($mask = " \t\n\r\0\x0B", $mode = self::BOTH_ENDS);
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
55
56			abstract public function unescape($mode = self::NORMAL);
			0 ignored issues – show Documentation introduced 2016-03-20 22:57 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
57
58			abstract public function uuDecode();
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
59
60			abstract public function uuEncode();
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
61
62			public function equals($str)
63			{
64			self::testStringableObject($str);
65
66			$str = (string) $str;
67			return ($str == $this->raw);
68			}
69
70			abstract public function isAscii();
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
71
72			abstract public function isEmpty();
			0 ignored issues – show Documentation introduced 2016-03-20 22:38 UTC by Report Bug Copy Issue Report For interfaces and abstract methods it is generally a good practice to add a `@return` annotation even if it is just `@return void` or `@return null`, so that implementors know what to do in the overridden method. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
73
74			protected static function testStringableObject($thing)
75			{
76			if (\is_object($thing) && !\method_exists($thing, '__toString')) {
77			throw new \InvalidArgumentException(
78			'Parameter is an object that does not implement __toString() method'
79			);
80			} elseif (\is_array($thing)) {
81			throw new \InvalidArgumentException('Unsure of how to convert array to string');
82			}
83			}
84			}
85

garrettw / stringobject

Push — master ( 34d315...a20938 )

AnyString::escape()

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like