View GitHub Repository jaxion

Schedule Inspection
Subscribe
Completed
Pull Request — master (#16)
by James
04:06
created
Status
Category
Toggle Patches
src/Contract/Axolotl/Collection.php 1 patch
Spacing   +27 added lines, -27 removed lines patch added patch discarded remove patch 
@@ -23,7 +23,7 @@  discard block
 
 block discarded – undo
23 23 
 	 * @return Collection
24 24 
 	 * @throws InvalidArgumentException
25 25 
 	 */
26 
-	public function add( $element );
26 
+	public function add($element);
27 27
28 28 
 	/**
29 29 
 	 * Removes every element from the collection.
 
@@ -39,7 +39,7 @@  discard block
 
 block discarded – undo
39 39 
 	 * @param callable $condition
40 40 
 	 * @return bool
41 41 
 	 */
42 
-	public function contains( $condition );
42 
+	public function contains($condition);
43 43
44 44 
 	/**
45 45 
 	 * Returns the first element in the collection that satisfies
 
@@ -48,7 +48,7 @@  discard block
 
 block discarded – undo
48 48 
 	 * @param callable $condition
49 49 
 	 * @return mixed
50 50 
 	 */
51 
-	public function find( $condition );
51 
+	public function find($condition);
52 52
53 53 
 	/**
54 54 
 	 * Returns the index of the first element in the collection that satisfies
 
@@ -57,7 +57,7 @@  discard block
 
 block discarded – undo
57 57 
 	 * @param callable $condition
58 58 
 	 * @return int
59 59 
 	 */
60 
-	public function find_index( $condition );
60 
+	public function find_index($condition);
61 61
62 62 
 	/**
63 63 
 	 * Returns the element in the collection at $index.
 
@@ -66,7 +66,7 @@  discard block
 
 block discarded – undo
66 66 
 	 * @return mixed
67 67 
 	 * @throws OutOfRangeException
68 68 
 	 */
69 
-	public function at( $index );
69 
+	public function at($index);
70 70
71 71 
 	/**
72 72 
 	 * Returns true if $index is within the collection's range and returns false
 
@@ -76,7 +76,7 @@  discard block
 
 block discarded – undo
76 76 
 	 * @return bool
77 77 
 	 * @throws InvalidArgumentException
78 78 
 	 */
79 
-	public function index_exists( $index );
79 
+	public function index_exists($index);
80 80
81 81 
 	/**
82 82 
 	 * Returns the number of elements in the collection.
 
@@ -92,7 +92,7 @@  discard block
 
 block discarded – undo
92 92 
 	 * @param callable $condition
93 93 
 	 * @return Collection
94 94 
 	 */
95 
-	public function filter( $condition );
95 
+	public function filter($condition);
96 96
97 97 
 	/**
98 98 
 	 * Returns the last element in the collection that satisfies $condition,
 
@@ -101,7 +101,7 @@  discard block
 
 block discarded – undo
101 101 
 	 * @param callable $condition
102 102 
 	 * @return mixed
103 103 
 	 */
104 
-	public function find_last( $condition );
104 
+	public function find_last($condition);
105 105
106 106 
 	/**
107 107 
 	 * Returns the index of the last element in the collection that satisfies
 
@@ -110,7 +110,7 @@  discard block
 
 block discarded – undo
110 110 
 	 * @param callable $condition
111 111 
 	 * @return int
112 112 
 	 */
113 
-	public function find_last_index( $condition );
113 
+	public function find_last_index($condition);
114 114
115 115 
 	/**
116 116 
 	 * Returns a collection that contains the subset of elements ranging from the
 
@@ -121,7 +121,7 @@  discard block
 
 block discarded – undo
121 121 
 	 * @return Collection
122 122 
 	 * @throws InvalidArgumentException
123 123 
 	 */
124 
-	public function slice( $start, $end );
124 
+	public function slice($start, $end);
125 125
126 126 
 	/**
127 127 
 	 * Inserts $element at $index.
 
@@ -132,7 +132,7 @@  discard block
 
 block discarded – undo
132 132 
 	 * @throws InvalidArgumentException
133 133 
 	 * @throws OutOfRangeException
134 134 
 	 */
135 
-	public function insert( $index, $element );
135 
+	public function insert($index, $element);
136 136
137 137 
 	/**
138 138 
 	 * Inserts the range $elements at $index.
 
@@ -142,7 +142,7 @@  discard block
 
 block discarded – undo
142 142 
 	 * @return Collection
143 143 
 	 * @throws OutOfRangeException
144 144 
 	 */
145 
-	public function insert_range( $index, array $elements );
145 
+	public function insert_range($index, array $elements);
146 146
147 147 
 	/**
148 148 
 	 * Removes all of the elements that satisfy $condition.
 
@@ -150,7 +150,7 @@  discard block
 
 block discarded – undo
150 150 
 	 * @param  callable $condition
151 151 
 	 * @return Collection
152 152 
 	 */
153 
-	public function reject( $condition );
153 
+	public function reject($condition);
154 154
155 155 
 	/**
156 156 
 	 * Removes the element at $index.
 
@@ -159,7 +159,7 @@  discard block
 
 block discarded – undo
159 159 
 	 * @return Collection
160 160 
 	 * @throws OutOfRangeException
161 161 
 	 */
162 
-	public function remove_at( $index );
162 
+	public function remove_at($index);
163 163
164 164 
 	/**
165 165 
 	 * Reverses the order of the elements in the collection.
 
@@ -175,7 +175,7 @@  discard block
 
 block discarded – undo
175 175 
 	 * @param callable $callback
176 176 
 	 * @return Collection
177 177 
 	 */
178 
-	public function sort( $callback );
178 
+	public function sort($callback);
179 179
180 180 
 	/**
181 181 
 	 * Returns an array containing the elements in the collection.
 
@@ -192,7 +192,7 @@  discard block
 
 block discarded – undo
192 192 
 	 * @param null     $initial
193 193 
 	 * @return mixed
194 194 
 	 */
195 
-	public function reduce( $callable, $initial = null );
195 
+	public function reduce($callable, $initial = null);
196 196
197 197 
 	/**
198 198 
 	 * Returns true if every element in the collection satisfies $condition,
 
@@ -201,7 +201,7 @@  discard block
 
 block discarded – undo
201 201 
 	 * @param callable $condition
202 202 
 	 * @return bool
203 203 
 	 */
204 
-	public function every( $condition );
204 
+	public function every($condition);
205 205
206 206 
 	/**
207 207 
 	 * Removes all of the elements in the collection starting at index $num.
 
@@ -210,7 +210,7 @@  discard block
 
 block discarded – undo
210 210 
 	 * @return Collection
211 211 
 	 * @throws InvalidArgumentException
212 212 
 	 */
213 
-	public function drop( $num );
213 
+	public function drop($num);
214 214
215 215 
 	/**
216 216 
 	 * Removes all of the elements in the collectioin between index 0 and $num.
 
@@ -219,7 +219,7 @@  discard block
 
 block discarded – undo
219 219 
 	 * @return Collection
220 220 
 	 * @throws InvalidArgumentException
221 221 
 	 */
222 
-	public function drop_right( $num );
222 
+	public function drop_right($num);
223 223
224 224 
 	/**
225 225 
 	 * Iteratively drops elements in the collection that satisfy $condition until
 
@@ -228,7 +228,7 @@  discard block
 
 block discarded – undo
228 228 
 	 * @param callable $condition
229 229 
 	 * @return Collection
230 230 
 	 */
231 
-	public function drop_while( $condition );
231 
+	public function drop_while($condition);
232 232
233 233 
 	/**
234 234 
 	 * Removes the first element in the collection.
 
@@ -245,7 +245,7 @@  discard block
 
 block discarded – undo
245 245 
 	 * @return Collection
246 246 
 	 * @throws InvalidArgumentException
247 247 
 	 */
248 
-	public function take( $num );
248 
+	public function take($num);
249 249
250 250 
 	/**
251 251 
 	 * Removes all of the elements in the collection before index $num.
 
@@ -254,7 +254,7 @@  discard block
 
 block discarded – undo
254 254 
 	 * @return Collection
255 255 
 	 * @throws InvalidArgumentException
256 256 
 	 */
257 
-	public function take_right( $num );
257 
+	public function take_right($num);
258 258
259 259 
 	/**
260 260 
 	 * Iterates through the collection until an element is encountered that does
 
@@ -264,14 +264,14 @@  discard block
 
 block discarded – undo
264 264 
 	 * @param callable $condition
265 265 
 	 * @return Collection
266 266 
 	 */
267 
-	public function take_while( $condition );
267 
+	public function take_while($condition);
268 268
269 269 
 	/**
270 270 
 	 * Applies the callback function $callable to each element in the collection.
271 271 
 	 *
272 272 
 	 * @param callable $callable
273 273 
 	 */
274 
-	public function each( $callable );
274 
+	public function each($callable);
275 275
276 276 
 	/**
277 277 
 	 * Returns a new instance of the collection with the callback function
 
@@ -280,7 +280,7 @@  discard block
 
 block discarded – undo
280 280 
 	 * @param callable $callable
281 281 
 	 * @return Collection
282 282 
 	 */
283 
-	public function map( $callable );
283 
+	public function map($callable);
284 284
285 285 
 	/**
286 286 
 	 * Iteratively reduces the collection to a single value using the callback
 
@@ -290,7 +290,7 @@  discard block
 
 block discarded – undo
290 290 
 	 * @param null     $initial
291 291 
 	 * @return mixed
292 292 
 	 */
293 
-	public function reduce_right( $callable, $initial = null );
293 
+	public function reduce_right($callable, $initial = null);
294 294
295 295 
 	/**
296 296 
 	 * Randomly reorders the elements in the collection.
 
@@ -306,7 +306,7 @@  discard block
 
 block discarded – undo
306 306 
 	 * @return Collection
307 307 
 	 * @throws InvalidArgumentException
308 308 
 	 */
309 
-	public function merge( $elements );
309 
+	public function merge($elements);
310 310
311 311 
 	/**
312 312 
 	 * Get first element of the collection
Please login to merge, or discard this patch.
src/Axolotl/Collection.php 1 patch
Spacing   +141 added lines, -141 removed lines patch added patch discarded remove patch 
@@ -42,19 +42,19 @@  discard block
 
 block discarded – undo
42 42 
 	 * @param string $type
43 43 
 	 * @param array  $elements
44 44 
 	 */
45 
-	public function __construct( $type, array $elements = array() ) {
46 
-		$this->type = new Type( $type );
45 
+	public function __construct($type, array $elements = array()) {
46 
+		$this->type = new Type($type);
47 47
48 
-		if ( $this->type->is_model() ) {
49 
-			foreach ( $elements as $idx => $element ) {
50 
-				if ( is_array( $element ) ) {
51 
-					$elements[ $idx ] = $this->type->create_model( $element );
48 
+		if ($this->type->is_model()) {
49 
+			foreach ($elements as $idx => $element) {
50 
+				if (is_array($element)) {
51 
+					$elements[$idx] = $this->type->create_model($element);
52 52 
 				}
53 53 
 			}
54 54 
 		}
55 55
56 
-		if ( $elements ) {
57 
-			$this->type->validate_elements( $elements );
56 
+		if ($elements) {
57 
+			$this->type->validate_elements($elements);
58 58 
 		}
59 59
60 60 
 		$this->elements = $elements;
 
@@ -78,18 +78,18 @@  discard block
 
 block discarded – undo
78 78 
 	 *
79 79 
 	 * @throws InvalidArgumentException
80 80 
 	 */
81 
-	public function add( $element ) {
82 
-		if ( $this->type->is_model() && is_array( $element ) ) {
83 
-			$element = $this->type->create_model( $element );
81 
+	public function add($element) {
82 
+		if ($this->type->is_model() && is_array($element)) {
83 
+			$element = $this->type->create_model($element);
84 84 
 		}
85 85
86 
-		$this->type->validate_element( $element );
86 
+		$this->type->validate_element($element);
87 87
88 88 
 		$elements   = $this->elements;
89 89 
 		$elements[] = $element;
90 90
91 
-		$collection = new static( $this->get_type() );
92 
-		$collection->set_from_trusted( $elements );
91 
+		$collection = new static($this->get_type());
92 
+		$collection->set_from_trusted($elements);
93 93
94 94 
 		return $collection;
95 95 
 	}
 
@@ -100,7 +100,7 @@  discard block
 
 block discarded – undo
100 100 
 	 * @return Collection
101 101 
 	 */
102 102 
 	public function clear() {
103 
-		return new static( $this->get_type() );
103 
+		return new static($this->get_type());
104 104 
 	}
105 105
106 106 
 	/**
 
@@ -110,8 +110,8 @@  discard block
 
 block discarded – undo
110 110 
 	 *
111 111 
 	 * @return bool
112 112 
 	 */
113 
-	public function contains( $condition ) {
114 
-		return (bool) $this->find( $condition );
113 
+	public function contains($condition) {
114 
+		return (bool) $this->find($condition);
115 115 
 	}
116 116
117 117 
 	/**
 
@@ -121,10 +121,10 @@  discard block
 
 block discarded – undo
121 121 
 	 *
122 122 
 	 * @return mixed
123 123 
 	 */
124 
-	public function find( $condition ) {
125 
-		$index = $this->find_index( $condition );
124 
+	public function find($condition) {
125 
+		$index = $this->find_index($condition);
126 126
127 
-		return -1 === $index ? null : $this->elements[ $index ];
127 
+		return -1 === $index ? null : $this->elements[$index];
128 128 
 	}
129 129
130 130 
 	/**
 
@@ -134,11 +134,11 @@  discard block
 
 block discarded – undo
134 134 
 	 *
135 135 
 	 * @return int
136 136 
 	 */
137 
-	public function find_index( $condition ) {
137 
+	public function find_index($condition) {
138 138 
 		$index = -1;
139 139
140 
-		for ( $i = 0, $count = count( $this->elements ); $i < $count; $i++ ) {
141 
-			if ( call_user_func( $condition, ($this->at( $i ) ) ) ) {
140 
+		for ($i = 0, $count = count($this->elements); $i < $count; $i++) {
141 
+			if (call_user_func($condition, ($this->at($i)))) {
142 142 
 				$index = $i;
143 143 
 				break;
144 144 
 			}
 
@@ -156,10 +156,10 @@  discard block
 
 block discarded – undo
156 156 
 	 *
157 157 
 	 * @throws OutOfRangeException
158 158 
 	 */
159 
-	public function at( $index ) {
160 
-		$this->validate_index( $index );
159 
+	public function at($index) {
160 
+		$this->validate_index($index);
161 161
162 
-		return $this->elements[ $index ];
162 
+		return $this->elements[$index];
163 163 
 	}
164 164
165 165 
 	/**
 
@@ -171,13 +171,13 @@  discard block
 
 block discarded – undo
171 171 
 	 *
172 172 
 	 * @throws InvalidArgumentException
173 173 
 	 */
174 
-	public function index_exists( $index ) {
175 
-		if ( ! is_int( $index ) ) {
176 
-			throw new InvalidArgumentException( 'Index must be an integer' );
174 
+	public function index_exists($index) {
175 
+		if (!is_int($index)) {
176 
+			throw new InvalidArgumentException('Index must be an integer');
177 177 
 		}
178 178
179 
-		if ( $index < 0 ) {
180 
-			throw new InvalidArgumentException( 'Index must be a non-negative integer' );
179 
+		if ($index < 0) {
180 
+			throw new InvalidArgumentException('Index must be a non-negative integer');
181 181 
 		}
182 182
183 183 
 		return $index < $this->count();
 
@@ -190,16 +190,16 @@  discard block
 
 block discarded – undo
190 190 
 	 *
191 191 
 	 * @return mixed
192 192 
 	 */
193 
-	public function filter( $condition ) {
193 
+	public function filter($condition) {
194 194 
 		$elements = array();
195 195
196 
-		foreach ( $this->elements as $element ) {
197 
-			if ( call_user_func( $condition, $element ) ) {
196 
+		foreach ($this->elements as $element) {
197 
+			if (call_user_func($condition, $element)) {
198 198 
 				$elements[] = $element;
199 199 
 			}
200 200 
 		}
201 201
202 
-		return $this->new_from_trusted( $elements );
202 
+		return $this->new_from_trusted($elements);
203 203 
 	}
204 204 
 	/**
205 205 
 	 * {@inheritdoc}
 
@@ -208,10 +208,10 @@  discard block
 
 block discarded – undo
208 208 
 	 *
209 209 
 	 * @return mixed
210 210 
 	 */
211 
-	public function find_last( $condition ) {
212 
-		$index = $this->find_last_index( $condition );
211 
+	public function find_last($condition) {
212 
+		$index = $this->find_last_index($condition);
213 213
214 
-		return -1 === $index ? null : $this->elements[ $index ];
214 
+		return -1 === $index ? null : $this->elements[$index];
215 215 
 	}
216 216
217 217 
 	/**
 
@@ -220,11 +220,11 @@  discard block
 
 block discarded – undo
220 220 
 	 * @param  callable $condition
221 221 
 	 * @return int
222 222 
 	 */
223 
-	public function find_last_index( $condition ) {
223 
+	public function find_last_index($condition) {
224 224 
 		$index = -1;
225 225
226 
-		for ( $i = count( $this->elements ) - 1; $i >= 0; $i-- ) {
227 
-			if ( call_user_func( $condition, $this->elements[ $i ] ) ) {
226 
+		for ($i = count($this->elements) - 1; $i >= 0; $i--) {
227 
+			if (call_user_func($condition, $this->elements[$i])) {
228 228 
 				$index = $i;
229 229 
 				break;
230 230 
 			}
 
@@ -243,26 +243,26 @@  discard block
 
 block discarded – undo
243 243 
 	 *
244 244 
 	 * @throws InvalidArgumentException
245 245 
 	 */
246 
-	public function slice( $start, $end ) {
247 
-		if ( $start < 0 || ! is_int( $start ) ) {
248 
-			throw new InvalidArgumentException( 'Start must be a non-negative integer' );
246 
+	public function slice($start, $end) {
247 
+		if ($start < 0 || !is_int($start)) {
248 
+			throw new InvalidArgumentException('Start must be a non-negative integer');
249 249 
 		}
250 250
251 
-		if ( $end < 0 || ! is_int( $end ) ) {
252 
-			throw new InvalidArgumentException( 'End must be a positive integer' );
251 
+		if ($end < 0 || !is_int($end)) {
252 
+			throw new InvalidArgumentException('End must be a positive integer');
253 253 
 		}
254 254
255 
-		if ( $start > $end ) {
256 
-			throw new InvalidArgumentException( 'End must be greater than start' );
255 
+		if ($start > $end) {
256 
+			throw new InvalidArgumentException('End must be greater than start');
257 257 
 		}
258 258
259 
-		if ( $end > $this->count() + 1 ) {
260 
-			throw new InvalidArgumentException( 'End must be less than the count of the items in the Collection' );
259 
+		if ($end > $this->count() + 1) {
260 
+			throw new InvalidArgumentException('End must be less than the count of the items in the Collection');
261 261 
 		}
262 262
263 263 
 		$length = $end - $start + 1;
264 264
265 
-		return $this->new_from_trusted( array_slice( $this->elements, $start, $length ) );
265 
+		return $this->new_from_trusted(array_slice($this->elements, $start, $length));
266 266 
 	}
267 267
268 268 
 	/**
 
@@ -276,16 +276,16 @@  discard block
 
 block discarded – undo
276 276 
 	 * @throws InvalidArgumentException
277 277 
 	 * @throws OutOfRangeException
278 278 
 	 */
279 
-	public function insert( $index, $element ) {
280 
-		$this->validate_index( $index );
281 
-		$this->type->validate_element( $element );
279 
+	public function insert($index, $element) {
280 
+		$this->validate_index($index);
281 
+		$this->type->validate_element($element);
282 282
283 
-		$a = array_slice( $this->elements, 0, $index );
284 
-		$b = array_slice( $this->elements, $index, count( $this->elements ) );
283 
+		$a = array_slice($this->elements, 0, $index);
284 
+		$b = array_slice($this->elements, $index, count($this->elements));
285 285
286 286 
 		$a[] = $element;
287 287
288 
-		return $this->new_from_trusted( array_merge( $a, $b ) );
288 
+		return $this->new_from_trusted(array_merge($a, $b));
289 289 
 	}
290 290
291 291 
 	/**
 
@@ -298,19 +298,19 @@  discard block
 
 block discarded – undo
298 298 
 	 *
299 299 
 	 * @throws OutOfRangeException
300 300 
 	 */
301 
-	public function insert_range( $index, array $elements ) {
302 
-		$this->validate_index( $index );
303 
-		$this->type->validate_elements( $elements );
301 
+	public function insert_range($index, array $elements) {
302 
+		$this->validate_index($index);
303 
+		$this->type->validate_elements($elements);
304 304
305 
-		if ( $index < 0 ) {
305 
+		if ($index < 0) {
306 306 
 			$index = $this->count() + $index + 1;
307 307 
 		}
308 308
309 309 
 		return $this->new_from_trusted(
310 310 
 			array_merge(
311 
-				array_slice( $this->elements, 0, $index ),
311 
+				array_slice($this->elements, 0, $index),
312 312 
 				$elements,
313 
-				array_slice( $this->elements, $index, count( $this->elements ) )
313 
+				array_slice($this->elements, $index, count($this->elements))
314 314 
 			)
315 315 
 		);
316 316 
 	}
 
@@ -322,12 +322,12 @@  discard block
 
 block discarded – undo
322 322 
 	 *
323 323 
 	 * @return Collection
324 324 
 	 */
325 
-	public function reject( $condition ) {
326 
-		$inverse = function ( $element ) use ( $condition ) {
327 
-			return ! call_user_func( $condition, $element );
325 
+	public function reject($condition) {
326 
+		$inverse = function($element) use ($condition) {
327 
+			return !call_user_func($condition, $element);
328 328 
 		};
329 329
330 
-		return $this->filter( $inverse );
330 
+		return $this->filter($inverse);
331 331 
 	}
332 332
333 333 
 	/**
 
@@ -339,15 +339,15 @@  discard block
 
 block discarded – undo
339 339 
 	 *
340 340 
 	 * @throws OutOfRangeException
341 341 
 	 */
342 
-	public function remove_at( $index ) {
343 
-		$this->validate_index( $index );
342 
+	public function remove_at($index) {
343 
+		$this->validate_index($index);
344 344
345 345 
 		$elements = $this->elements;
346 346
347 347 
 		return $this->new_from_trusted(
348 348 
 			array_merge(
349 
-				array_slice( $elements, 0, $index ),
350 
-				array_slice( $elements, $index + 1, count( $elements ) )
349 
+				array_slice($elements, 0, $index),
350 
+				array_slice($elements, $index + 1, count($elements))
351 351 
 			)
352 352 
 		);
353 353 
 	}
 
@@ -358,7 +358,7 @@  discard block
 
 block discarded – undo
358 358 
 	 */
359 359 
 	public function reverse() {
360 360 
 		return $this->new_from_trusted(
361 
-			array_reverse( $this->elements )
361 
+			array_reverse($this->elements)
362 362 
 		);
363 363 
 	}
364 364 
 
@@ -369,10 +369,10 @@  discard block
 
 block discarded – undo
369 369 
 	 *
370 370 
 	 * @return Collection
371 371 
 	 */
372 
-	public function sort( $callback ) {
372 
+	public function sort($callback) {
373 373 
 		$elements = $this->elements;
374 
-		usort( $elements, $callback );
375 
-		return $this->new_from_trusted( $elements );
374 
+		usort($elements, $callback);
375 
+		return $this->new_from_trusted($elements);
376 376 
 	}
377 377
378 378 
 	/**
 
@@ -393,8 +393,8 @@  discard block
 
 block discarded – undo
393 393 
 	 *
394 394 
 	 * @return mixed
395 395 
 	 */
396 
-	public function reduce( $callable, $initial = null ) {
397 
-		return array_reduce( $this->elements, $callable, $initial );
396 
+	public function reduce($callable, $initial = null) {
397 
+		return array_reduce($this->elements, $callable, $initial);
398 398 
 	}
399 399
400 400 
 	/**
 
@@ -404,13 +404,13 @@  discard block
 
 block discarded – undo
404 404 
 	 *
405 405 
 	 * @return bool
406 406 
 	 */
407 
-	public function every( $condition ) {
407 
+	public function every($condition) {
408 408 
 		$response = true;
409 409
410 
-		foreach ( $this->elements as $element ) {
411 
-			$result = call_user_func( $condition, $element );
410 
+		foreach ($this->elements as $element) {
411 
+			$result = call_user_func($condition, $element);
412 412
413 
-			if ( false === $result ) {
413 
+			if (false === $result) {
414 414 
 				$response = false;
415 415 
 				break;
416 416 
 			}
 
@@ -428,12 +428,12 @@  discard block
 
 block discarded – undo
428 428 
 	 *
429 429 
 	 * @throws InvalidArgumentException
430 430 
 	 */
431 
-	public function drop( $num ) {
432 
-		if ( $num > $this->count() ) {
431 
+	public function drop($num) {
432 
+		if ($num > $this->count()) {
433 433 
 			$num = $this->count();
434 434 
 		}
435 435
436 
-		return $this->slice( $num, $this->count() );
436 
+		return $this->slice($num, $this->count());
437 437 
 	}
438 438
439 439 
 	/**
 
@@ -445,9 +445,9 @@  discard block
 
 block discarded – undo
445 445 
 	 *
446 446 
 	 * @throws InvalidArgumentException
447 447 
 	 */
448 
-	public function drop_right( $num ) {
448 
+	public function drop_right($num) {
449 449 
 		return $num !== $this->count()
450 
-			? $this->slice( 0, $this->count() - $num - 1 )
450 
+			? $this->slice(0, $this->count() - $num - 1)
451 451 
 			: $this->clear();
452 452 
 	}
453 453 
 
@@ -458,9 +458,9 @@  discard block
 
 block discarded – undo
458 458 
 	 *
459 459 
 	 * @return Collection
460 460 
 	 */
461 
-	public function drop_while( $condition ) {
462 
-		$count = $this->count_while_true( $condition );
463 
-		return $count ? $this->drop( $count ) : $this;
461 
+	public function drop_while($condition) {
462 
+		$count = $this->count_while_true($condition);
463 
+		return $count ? $this->drop($count) : $this;
464 464 
 	}
465 465 
 	/**
466 466 
 	 * {@inheritdoc}
 
@@ -470,7 +470,7 @@  discard block
 
 block discarded – undo
470 470 
 	 * @throws InvalidArgumentException
471 471 
 	 */
472 472 
 	public function tail() {
473 
-		return $this->slice( 1, $this->count() );
473 
+		return $this->slice(1, $this->count());
474 474 
 	}
475 475
476 476 
 	/**
 
@@ -482,8 +482,8 @@  discard block
 
 block discarded – undo
482 482 
 	 *
483 483 
 	 * @throws InvalidArgumentException
484 484 
 	 */
485 
-	public function take( $num ) {
486 
-		return $this->slice( 0, $num - 1 );
485 
+	public function take($num) {
486 
+		return $this->slice(0, $num - 1);
487 487 
 	}
488 488
489 489 
 	/**
 
@@ -495,8 +495,8 @@  discard block
 
 block discarded – undo
495 495 
 	 *
496 496 
 	 * @throws InvalidArgumentException
497 497 
 	 */
498 
-	public function take_right( $num ) {
499 
-		return $this->slice( $this->count() - $num, $this->count() );
498 
+	public function take_right($num) {
499 
+		return $this->slice($this->count() - $num, $this->count());
500 500 
 	}
501 501
502 502 
 	/**
 
@@ -506,10 +506,10 @@  discard block
 
 block discarded – undo
506 506 
 	 *
507 507 
 	 * @return Collection
508 508 
 	 */
509 
-	public function take_while( $condition ) {
510 
-		$count = $this->count_while_true( $condition );
509 
+	public function take_while($condition) {
510 
+		$count = $this->count_while_true($condition);
511 511
512 
-		return $count ? $this->take( $count ) : $this->clear();
512 
+		return $count ? $this->take($count) : $this->clear();
513 513 
 	}
514 514
515 515 
 	/**
 
@@ -517,9 +517,9 @@  discard block
 
 block discarded – undo
517 517 
 	 *
518 518 
 	 * @param callable $callable Callback function.
519 519 
 	 */
520 
-	public function each( $callable ) {
521 
-		foreach ( $this->elements as $element ) {
522 
-			call_user_func( $callable, $element );
520 
+	public function each($callable) {
521 
+		foreach ($this->elements as $element) {
522 
+			call_user_func($callable, $element);
523 523 
 		}
524 524 
 	}
525 525 
 
@@ -530,24 +530,24 @@  discard block
 
 block discarded – undo
530 530 
 	 *
531 531 
 	 * @return Collection
532 532 
 	 */
533 
-	public function map( $callable ) {
533 
+	public function map($callable) {
534 534 
 		$elements = array();
535 535 
 		$type = null;
536 
-		foreach ( $this->elements as $element ) {
537 
-			$result = call_user_func( $callable, $element );
536 
+		foreach ($this->elements as $element) {
537 
+			$result = call_user_func($callable, $element);
538 538
539 
-			if ( null === $type ) {
540 
-				$type = gettype( $result );
539 
+			if (null === $type) {
540 
+				$type = gettype($result);
541 541
542 
-				if ( 'object' === $type ) {
543 
-					$type = get_class( $result );
542 
+				if ('object' === $type) {
543 
+					$type = get_class($result);
544 544 
 				}
545 545 
 			}
546 546
547 547 
 			$elements[] = $result;
548 548 
 		}
549 549
550 
-		return $this->new_from_trusted( $elements, $type ? : $this->get_type() );
550 
+		return $this->new_from_trusted($elements, $type ?: $this->get_type());
551 551 
 	}
552 552
553 553 
 	/**
 
@@ -558,9 +558,9 @@  discard block
 
 block discarded – undo
558 558 
 	 *
559 559 
 	 * @return mixed
560 560 
 	 */
561 
-	public function reduce_right( $callable, $initial = null ) {
561 
+	public function reduce_right($callable, $initial = null) {
562 562 
 		return array_reduce(
563 
-			array_reverse( $this->elements ),
563 
+			array_reverse($this->elements),
564 564 
 			$callable,
565 565 
 			$initial
566 566 
 		);
 
@@ -573,9 +573,9 @@  discard block
 
 block discarded – undo
573 573 
 	 */
574 574 
 	public function shuffle() {
575 575 
 		$elements = $this->elements;
576 
-		shuffle( $elements );
576 
+		shuffle($elements);
577 577
578 
-		return $this->new_from_trusted( $elements );
578 
+		return $this->new_from_trusted($elements);
579 579 
 	}
580 580
581 581 
 	/**
 
@@ -587,19 +587,19 @@  discard block
 
 block discarded – undo
587 587 
 	 *
588 588 
 	 * @throws InvalidArgumentException
589 589 
 	 */
590 
-	public function merge( $elements ) {
591 
-		if ( $elements instanceof static ) {
590 
+	public function merge($elements) {
591 
+		if ($elements instanceof static) {
592 592 
 			$elements = $elements->to_array();
593 593 
 		}
594 594
595 
-		if ( ! is_array( $elements ) ) {
596 
-			throw new InvalidArgumentException( 'Merge must be given array or Collection' );
595 
+		if (!is_array($elements)) {
596 
+			throw new InvalidArgumentException('Merge must be given array or Collection');
597 597 
 		}
598 598
599 
-		$this->type->validate_elements( $elements );
599 
+		$this->type->validate_elements($elements);
600 600
601 601 
 		return $this->new_from_trusted(
602 
-			array_merge( $this->elements, $elements )
602 
+			array_merge($this->elements, $elements)
603 603 
 		);
604 604 
 	}
605 605 
 
@@ -611,11 +611,11 @@  discard block
 
 block discarded – undo
611 611 
 	 * @throws OutOfBoundsException
612 612 
 	 */
613 613 
 	public function first() {
614 
-		if ( empty( $this->elements ) ) {
615 
-			throw new OutOfBoundsException( 'Cannot get first element of empty Collection' );
614 
+		if (empty($this->elements)) {
615 
+			throw new OutOfBoundsException('Cannot get first element of empty Collection');
616 616 
 		}
617 617
618 
-		return reset( $this->elements );
618 
+		return reset($this->elements);
619 619 
 	}
620 620
621 621 
 	/**
 
@@ -626,11 +626,11 @@  discard block
 
 block discarded – undo
626 626 
 	 * @throws OutOfBoundsException
627 627 
 	 */
628 628 
 	public function last() {
629 
-		if ( empty( $this->elements ) ) {
630 
-			throw new OutOfBoundsException( 'Cannot get last element of empty Collection' );
629 
+		if (empty($this->elements)) {
630 
+			throw new OutOfBoundsException('Cannot get last element of empty Collection');
631 631 
 		}
632 632
633 
-		return end( $this->elements );
633 
+		return end($this->elements);
634 634 
 	}
635 635
636 636 
 	/**
 
@@ -639,7 +639,7 @@  discard block
 
 block discarded – undo
639 639 
 	 * @return int
640 640 
 	 */
641 641 
 	public function count() {
642 
-		return count( $this->elements );
642 
+		return count($this->elements);
643 643 
 	}
644 644
645 645 
 	/**
 
@@ -648,8 +648,8 @@  discard block
 
 block discarded – undo
648 648 
 	 * @return array
649 649 
 	 */
650 650 
 	public function serialize() {
651 
-		return $this->map(function( $element ) {
652 
-			if ( $element instanceof Serializes ) {
651 
+		return $this->map(function($element) {
652 
+			if ($element instanceof Serializes) {
653 653 
 				return $element->serialize();
654 654 
 			}
655 655 
 
@@ -663,14 +663,14 @@  discard block
 
 block discarded – undo
663 663 
 	 * @return mixed
664 664 
 	 */
665 665 
 	public function current() {
666 
-		return $this->at( $this->position );
666 
+		return $this->at($this->position);
667 667 
 	}
668 668
669 669 
 	/**
670 670 
 	 * Move forward to next element.
671 671 
 	 */
672 672 
 	public function next() {
673 
-		$this->position ++;
673 
+		$this->position++;
674 674 
 	}
675 675
676 676 
 	/**
 
@@ -688,7 +688,7 @@  discard block
 
 block discarded – undo
688 688 
 	 * @return bool
689 689 
 	 */
690 690 
 	public function valid() {
691 
-		return isset( $this->elements[ $this->position ] );
691 
+		return isset($this->elements[$this->position]);
692 692 
 	}
693 693
694 694 
 	/**
 
@@ -707,9 +707,9 @@  discard block
 
 block discarded – undo
707 707 
 	 *
708 708 
 	 * @return static
709 709 
 	 */
710 
-	protected function new_from_trusted( array $elements, $type = null ) {
711 
-		$collection = new static( null !== $type ? $type : $this->get_type() );
712 
-		$collection->set_from_trusted( $elements );
710 
+	protected function new_from_trusted(array $elements, $type = null) {
711 
+		$collection = new static(null !== $type ? $type : $this->get_type());
712 
+		$collection->set_from_trusted($elements);
713 713
714 714 
 		return $collection;
715 715 
 	}
 
@@ -719,7 +719,7 @@  discard block
 
 block discarded – undo
719 719 
 	 *
720 720 
 	 * @param array $elements Pre-validated elements to set.
721 721 
 	 */
722 
-	protected function set_from_trusted( array $elements ) {
722 
+	protected function set_from_trusted(array $elements) {
723 723 
 		$this->elements = $elements;
724 724 
 	}
725 725 
 
@@ -729,11 +729,11 @@  discard block
 
 block discarded – undo
729 729 
 	 * @param callable $condition Condition to check.
730 730 
 	 * @return int
731 731 
 	 */
732 
-	protected function count_while_true( $condition ) {
732 
+	protected function count_while_true($condition) {
733 733 
 		$count = 0;
734 734
735 
-		foreach ( $this->elements as $element ) {
736 
-			if ( ! $condition($element) ) {
735 
+		foreach ($this->elements as $element) {
736 
+			if (!$condition($element)) {
737 737 
 				break;
738 738 
 			}
739 739 
 			$count++;
 
@@ -749,11 +749,11 @@  discard block
 
 block discarded – undo
749 749 
 	 *
750 750 
 	 * @throws OutOfRangeException
751 751 
 	 */
752 
-	protected function validate_index( $index ) {
753 
-		$exists = $this->index_exists( $index );
752 
+	protected function validate_index($index) {
753 
+		$exists = $this->index_exists($index);
754 754
755 
-		if ( ! $exists ) {
756 
-			throw new OutOfRangeException( 'Index out of bounds of collection' );
755 
+		if (!$exists) {
756 
+			throw new OutOfRangeException('Index out of bounds of collection');
757 757 
 		}
758 758 
 	}
759 759 
 }
Please login to merge, or discard this patch.