View GitHub Repository jaxion

Schedule Inspection
Subscribe
Completed
Pull Request — master (#15)
by James
04:04
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( callable $condition );
42 
+	public function contains(callable $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( callable $condition );
51 
+	public function find(callable $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( callable $condition );
60 
+	public function find_index(callable $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( callable $condition );
95 
+	public function filter(callable $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( callable $condition );
104 
+	public function find_last(callable $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( callable $condition );
113 
+	public function find_last_index(callable $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 without( callable $condition );
153 
+	public function without(callable $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( callable $callback );
178 
+	public function sort(callable $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 $callable, $initial = null );
195 
+	public function reduce(callable $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( callable $condition );
204 
+	public function every(callable $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( callable $condition );
231 
+	public function drop_while(callable $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( callable $condition );
267 
+	public function take_while(callable $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 $callable );
274 
+	public function each(callable $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 $callable );
283 
+	public function map(callable $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 $callable, $initial = null );
293 
+	public function reduce_right(callable $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   +140 added lines, -140 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( callable $condition ) {
114 
-		return (bool) $this->find( $condition );
113 
+	public function contains(callable $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( callable $condition ) {
125 
-		$index = $this->find_index( $condition );
124 
+	public function find(callable $condition) {
125 
+		$index = $this->find_index($condition);
126 126
127 
-		return -1 === $index ? false : $this->elements[ $index ];
127 
+		return -1 === $index ? false : $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( callable $condition ) {
137 
+	public function find_index(callable $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( callable $condition ) {
193 
+	public function filter(callable $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( callable $condition ) {
212 
-		$index = $this->find_last_index( $condition );
211 
+	public function find_last(callable $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( callable $condition ) {
223 
+	public function find_last_index(callable $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 without( callable $condition ) {
326 
-		$inverse = function ( $element ) use ( $condition ) {
327 
-			return ! call_user_func( $condition, $element );
325 
+	public function without(callable $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( callable $callback ) {
372 
+	public function sort(callable $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 $callable, $initial = null ) {
397 
-		return array_reduce( $this->elements, $callable, $initial );
396 
+	public function reduce(callable $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( callable $condition ) {
407 
+	public function every(callable $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,8 +428,8 @@  discard block
 
 block discarded – undo
428 428 
 	 *
429 429 
 	 * @throws InvalidArgumentException
430 430 
 	 */
431 
-	public function drop( $num ) {
432 
-		return $this->slice( $num, $this->count() );
431 
+	public function drop($num) {
432 
+		return $this->slice($num, $this->count());
433 433 
 	}
434 434
435 435 
 	/**
 
@@ -441,9 +441,9 @@  discard block
 
 block discarded – undo
441 441 
 	 *
442 442 
 	 * @throws InvalidArgumentException
443 443 
 	 */
444 
-	public function drop_right( $num ) {
444 
+	public function drop_right($num) {
445 445 
 		return $num !== $this->count()
446 
-			? $this->slice( 0, $this->count() - $num - 1 )
446 
+			? $this->slice(0, $this->count() - $num - 1)
447 447 
 			: $this->clear();
448 448 
 	}
449 449 
 
@@ -454,9 +454,9 @@  discard block
 
 block discarded – undo
454 454 
 	 *
455 455 
 	 * @return Collection
456 456 
 	 */
457 
-	public function drop_while( callable $condition ) {
458 
-		$count = $this->count_while_true( $condition );
459 
-		return $count ? $this->drop( $count ) : $this;
457 
+	public function drop_while(callable $condition) {
458 
+		$count = $this->count_while_true($condition);
459 
+		return $count ? $this->drop($count) : $this;
460 460 
 	}
461 461 
 	/**
462 462 
 	 * {@inheritdoc}
 
@@ -466,7 +466,7 @@  discard block
 
 block discarded – undo
466 466 
 	 * @throws InvalidArgumentException
467 467 
 	 */
468 468 
 	public function tail() {
469 
-		return $this->slice( 1, $this->count() );
469 
+		return $this->slice(1, $this->count());
470 470 
 	}
471 471
472 472 
 	/**
 
@@ -478,8 +478,8 @@  discard block
 
 block discarded – undo
478 478 
 	 *
479 479 
 	 * @throws InvalidArgumentException
480 480 
 	 */
481 
-	public function take( $num ) {
482 
-		return $this->slice( 0, $num - 1 );
481 
+	public function take($num) {
482 
+		return $this->slice(0, $num - 1);
483 483 
 	}
484 484
485 485 
 	/**
 
@@ -491,8 +491,8 @@  discard block
 
 block discarded – undo
491 491 
 	 *
492 492 
 	 * @throws InvalidArgumentException
493 493 
 	 */
494 
-	public function take_right( $num ) {
495 
-		return $this->slice( $this->count() - $num, $this->count() );
494 
+	public function take_right($num) {
495 
+		return $this->slice($this->count() - $num, $this->count());
496 496 
 	}
497 497
498 498 
 	/**
 
@@ -502,10 +502,10 @@  discard block
 
 block discarded – undo
502 502 
 	 *
503 503 
 	 * @return Collection
504 504 
 	 */
505 
-	public function take_while( callable $condition ) {
506 
-		$count = $this->count_while_true( $condition );
505 
+	public function take_while(callable $condition) {
506 
+		$count = $this->count_while_true($condition);
507 507
508 
-		return $count ? $this->take( $count ) : $this->clear();
508 
+		return $count ? $this->take($count) : $this->clear();
509 509 
 	}
510 510
511 511 
 	/**
 
@@ -513,9 +513,9 @@  discard block
 
 block discarded – undo
513 513 
 	 *
514 514 
 	 * @param callable $callable Callback function.
515 515 
 	 */
516 
-	public function each( callable $callable ) {
517 
-		foreach ( $this->elements as $element ) {
518 
-			call_user_func( $callable, $element );
516 
+	public function each(callable $callable) {
517 
+		foreach ($this->elements as $element) {
518 
+			call_user_func($callable, $element);
519 519 
 		}
520 520 
 	}
521 521 
 
@@ -526,24 +526,24 @@  discard block
 
 block discarded – undo
526 526 
 	 *
527 527 
 	 * @return Collection
528 528 
 	 */
529 
-	public function map( callable $callable ) {
529 
+	public function map(callable $callable) {
530 530 
 		$elements = array();
531 531 
 		$type = null;
532 
-		foreach ( $this->elements as $element ) {
533 
-			$result = call_user_func( $callable, $element );
532 
+		foreach ($this->elements as $element) {
533 
+			$result = call_user_func($callable, $element);
534 534
535 
-			if ( null === $type ) {
536 
-				$type = gettype( $result );
535 
+			if (null === $type) {
536 
+				$type = gettype($result);
537 537
538 
-				if ( 'object' === $type ) {
539 
-					$type = get_class( $result );
538 
+				if ('object' === $type) {
539 
+					$type = get_class($result);
540 540 
 				}
541 541 
 			}
542 542
543 543 
 			$elements[] = $result;
544 544 
 		}
545 545
546 
-		return $this->new_from_trusted( $elements, $type ? : $this->get_type() );
546 
+		return $this->new_from_trusted($elements, $type ?: $this->get_type());
547 547 
 	}
548 548
549 549 
 	/**
 
@@ -554,9 +554,9 @@  discard block
 
 block discarded – undo
554 554 
 	 *
555 555 
 	 * @return mixed
556 556 
 	 */
557 
-	public function reduce_right( callable $callable, $initial = null ) {
557 
+	public function reduce_right(callable $callable, $initial = null) {
558 558 
 		return array_reduce(
559 
-			array_reverse( $this->elements ),
559 
+			array_reverse($this->elements),
560 560 
 			$callable,
561 561 
 			$initial
562 562 
 		);
 
@@ -569,9 +569,9 @@  discard block
 
 block discarded – undo
569 569 
 	 */
570 570 
 	public function shuffle() {
571 571 
 		$elements = $this->elements;
572 
-		shuffle( $elements );
572 
+		shuffle($elements);
573 573
574 
-		return $this->new_from_trusted( $elements );
574 
+		return $this->new_from_trusted($elements);
575 575 
 	}
576 576
577 577 
 	/**
 
@@ -583,19 +583,19 @@  discard block
 
 block discarded – undo
583 583 
 	 *
584 584 
 	 * @throws InvalidArgumentException
585 585 
 	 */
586 
-	public function merge( $elements ) {
587 
-		if ( $elements instanceof static ) {
586 
+	public function merge($elements) {
587 
+		if ($elements instanceof static) {
588 588 
 			$elements = $elements->to_array();
589 589 
 		}
590 590
591 
-		if ( ! is_array( $elements ) ) {
592 
-			throw new InvalidArgumentException( 'Merge must be given array or Collection' );
591 
+		if (!is_array($elements)) {
592 
+			throw new InvalidArgumentException('Merge must be given array or Collection');
593 593 
 		}
594 594
595 
-		$this->type->validate_elements( $elements );
595 
+		$this->type->validate_elements($elements);
596 596
597 597 
 		return $this->new_from_trusted(
598 
-			array_merge( $this->elements, $elements )
598 
+			array_merge($this->elements, $elements)
599 599 
 		);
600 600 
 	}
601 601 
 
@@ -607,11 +607,11 @@  discard block
 
 block discarded – undo
607 607 
 	 * @throws OutOfBoundsException
608 608 
 	 */
609 609 
 	public function first() {
610 
-		if ( empty( $this->elements ) ) {
611 
-			throw new OutOfBoundsException( 'Cannot get first element of empty Collection' );
610 
+		if (empty($this->elements)) {
611 
+			throw new OutOfBoundsException('Cannot get first element of empty Collection');
612 612 
 		}
613 613
614 
-		return reset( $this->elements );
614 
+		return reset($this->elements);
615 615 
 	}
616 616
617 617 
 	/**
 
@@ -622,11 +622,11 @@  discard block
 
 block discarded – undo
622 622 
 	 * @throws OutOfBoundsException
623 623 
 	 */
624 624 
 	public function last() {
625 
-		if ( empty( $this->elements ) ) {
626 
-			throw new OutOfBoundsException( 'Cannot get last element of empty Collection' );
625 
+		if (empty($this->elements)) {
626 
+			throw new OutOfBoundsException('Cannot get last element of empty Collection');
627 627 
 		}
628 628
629 
-		return end( $this->elements );
629 
+		return end($this->elements);
630 630 
 	}
631 631
632 632 
 	/**
 
@@ -635,7 +635,7 @@  discard block
 
 block discarded – undo
635 635 
 	 * @return int
636 636 
 	 */
637 637 
 	public function count() {
638 
-		return count( $this->elements );
638 
+		return count($this->elements);
639 639 
 	}
640 640
641 641 
 	/**
 
@@ -644,8 +644,8 @@  discard block
 
 block discarded – undo
644 644 
 	 * @return array
645 645 
 	 */
646 646 
 	public function serialize() {
647 
-		return $this->map(function( $element ) {
648 
-			if ( $element instanceof Serializes ) {
647 
+		return $this->map(function($element) {
648 
+			if ($element instanceof Serializes) {
649 649 
 				return $element->serialize();
650 650 
 			}
651 651 
 
@@ -659,14 +659,14 @@  discard block
 
 block discarded – undo
659 659 
 	 * @return mixed
660 660 
 	 */
661 661 
 	public function current() {
662 
-		return $this->at( $this->position );
662 
+		return $this->at($this->position);
663 663 
 	}
664 664
665 665 
 	/**
666 666 
 	 * Move forward to next element.
667 667 
 	 */
668 668 
 	public function next() {
669 
-		$this->position ++;
669 
+		$this->position++;
670 670 
 	}
671 671
672 672 
 	/**
 
@@ -684,7 +684,7 @@  discard block
 
 block discarded – undo
684 684 
 	 * @return bool
685 685 
 	 */
686 686 
 	public function valid() {
687 
-		return isset( $this->elements[ $this->position ] );
687 
+		return isset($this->elements[$this->position]);
688 688 
 	}
689 689
690 690 
 	/**
 
@@ -703,9 +703,9 @@  discard block
 
 block discarded – undo
703 703 
 	 *
704 704 
 	 * @return static
705 705 
 	 */
706 
-	protected function new_from_trusted( array $elements, $type = null ) {
707 
-		$collection = new static( null !== $type ? $type : $this->get_type() );
708 
-		$collection->set_from_trusted( $elements );
706 
+	protected function new_from_trusted(array $elements, $type = null) {
707 
+		$collection = new static(null !== $type ? $type : $this->get_type());
708 
+		$collection->set_from_trusted($elements);
709 709
710 710 
 		return $collection;
711 711 
 	}
 
@@ -715,7 +715,7 @@  discard block
 
 block discarded – undo
715 715 
 	 *
716 716 
 	 * @param array $elements Pre-validated elements to set.
717 717 
 	 */
718 
-	protected function set_from_trusted( array $elements ) {
718 
+	protected function set_from_trusted(array $elements) {
719 719 
 		$this->elements = $elements;
720 720 
 	}
721 721 
 
@@ -725,11 +725,11 @@  discard block
 
 block discarded – undo
725 725 
 	 * @param callable $condition Condition to check.
726 726 
 	 * @return int
727 727 
 	 */
728 
-	protected function count_while_true( callable $condition ) {
728 
+	protected function count_while_true(callable $condition) {
729 729 
 		$count = 0;
730 730
731 
-		foreach ( $this->elements as $element ) {
732 
-			if ( ! $condition($element) ) {
731 
+		foreach ($this->elements as $element) {
732 
+			if (!$condition($element)) {
733 733 
 				break;
734 734 
 			}
735 735 
 			$count++;
 
@@ -745,11 +745,11 @@  discard block
 
 block discarded – undo
745 745 
 	 *
746 746 
 	 * @throws OutOfRangeException
747 747 
 	 */
748 
-	protected function validate_index( $index ) {
749 
-		$exists = $this->index_exists( $index );
748 
+	protected function validate_index($index) {
749 
+		$exists = $this->index_exists($index);
750 750
751 
-		if ( ! $exists ) {
752 
-			throw new OutOfRangeException( 'Index out of bounds of collection' );
751 
+		if (!$exists) {
752 
+			throw new OutOfRangeException('Index out of bounds of collection');
753 753 
 		}
754 754 
 	}
755 755 
 }
Please login to merge, or discard this patch.