The php-dba-cache uses the database (dbm-style) abstraction layer to store your PHP data. It depends on
202 | the free space of your disk.
203 |
204 |
205 |
206 |
207 |
General Information
208 |
209 |
210 |
211 |
212 |
DBA Handler In Use
213 |
214 |
215 |
216 |
Available DBA Handlers
217 |
218 |
219 |
220 |
DBA Cache File
221 |
getStorage() ?>
222 |
223 |
224 |
PHP Version
225 |
226 |
227 |
228 |
229 |
230 |
DBA Host
231 |
232 |
233 |
234 |
235 |
236 |
237 |
Server Software
238 |
239 |
240 |
241 |
242 |
Start Time
243 |
getCTime()) ?>
244 |
245 |
246 |
Last Modified Time
247 |
getMTime()) ?>
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
Memory Usage
257 |
258 |
259 |
260 |
261 |
getSize()) ?>
262 |
263 |
Cache file in use size
264 |
265 |
266 |
267 |
268 |
getPath())) ?>
269 |
270 |
Cache directory free size
271 |
272 |
273 |
274 |
275 |
getPath())) ?>
276 |
277 |
Cache directory total size
278 |
279 |
280 |
281 |
282 |
283 |
284 |
285 |
286 |
287 |
Tune Cache
288 |
289 |
293 |
294 |
If you add-remove-substitute keys with data having different content length,
295 | the db continues to grow, wasting space. Sometimes it is necessary, to optimize or synchronize the db in
296 | order to remove unused data from the db itself.
297 |
Sometimes it is necessary to sweep the cache from old entries or to flush it.
347 |
348 |
364 |
365 |
366 |
367 |
368 | Having trouble with PHP DBA Cache Monitor? Please contact gjero@krsteski.de and we’ll help you to sort it out.
370 | Because this GUI development and source control is done through GitHub, anyone is able to make contributions to
371 | it.
372 | Anyone can fix bugs and add features. Fork
373 | it here!
374 |
375 |
376 |
377 |
378 |
379 |
380 |
381 |
--------------------------------------------------------------------------------
/bootstrap.php:
--------------------------------------------------------------------------------
1 | '/Cache.php',
21 | 'PhpDbaCache\\Pack' => '/Pack.php',
22 | 'PhpDbaCache\\Sweep' => '/Sweep.php',
23 | 'PhpDbaCache\\Capsule' => '/Capsule.php',
24 | );
25 |
26 | if (isset($classes[$class])) {
27 | require BASE_PATH . '/src' . $classes[$class];
28 | }
29 |
30 | return false;
31 | }
32 | );
33 |
--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 | "name" : "gjerokrsteski/php-dba-cache",
3 | "description" : "Create a caching with the PHP Database (dbm-style) Abstraction Layer to cache your objects, strings, integers or arrays",
4 | "type" : "library",
5 | "license" : "BSD",
6 | "homepage" : "http://gjerokrsteski.github.io/php-dba-cache/",
7 | "keywords" : ["dba", "cache", "storage", "php", "caching"],
8 | "support" : {
9 | "email" : "gjero@krsteski.de",
10 | "source" : "https://github.com/gjerokrsteski/php-dba-cache"
11 | },
12 | "authors" : [
13 | {
14 | "name" : "Gjero Krsteski",
15 | "email" : "gjero@krsteski.de",
16 | "homepage" : "http://krsteski.de/",
17 | "role" : "Main Developer"
18 | }
19 | ],
20 | "require" : {
21 | "php" : ">=5.4"
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
1 | {
2 | "_readme": [
3 | "This file locks the dependencies of your project to a known state",
4 | "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
5 | "This file is @generated automatically"
6 | ],
7 | "hash": "e9416d2df2a41d5ba9edc05c4e772190",
8 | "content-hash": "b4d44f3760755f1d8e6e06855a360b08",
9 | "packages": [],
10 | "packages-dev": [],
11 | "aliases": [],
12 | "minimum-stability": "stable",
13 | "stability-flags": [],
14 | "prefer-stable": false,
15 | "prefer-lowest": false,
16 | "platform": {
17 | "php": ">=5.4"
18 | },
19 | "platform-dev": []
20 | }
21 |
--------------------------------------------------------------------------------
/make-million.php:
--------------------------------------------------------------------------------
1 | put($key, $value, rand(1, 21600)) . PHP_EOL;
31 | }
32 |
33 | $cache->closeDba();
34 |
35 | die('END');
36 |
--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
1 |
2 |
18 |
19 |
20 |
21 | ./tests
22 |
23 |
24 |
25 |
26 |
27 | ./src
28 |
29 | bootstrap.core.php
30 |
31 |
32 |
33 |
34 |
35 |
43 |
44 |
45 |
46 |
--------------------------------------------------------------------------------
/src/Cache.php:
--------------------------------------------------------------------------------
1 | dba = (true === $persistently)
78 | ? @dba_popen($file, $mode, $handler)
79 | : @dba_open($file, $mode, $handler);
80 |
81 | if ($this->dba === false) {
82 | $err = error_get_last();
83 | throw new \RuntimeException($err['message']);
84 | }
85 |
86 | $this->storage = $file;
87 | $this->handler = $handler;
88 | }
89 |
90 | /**
91 | * Closes an open dba resource
92 | *
93 | * @return void
94 | */
95 | public function __destruct()
96 | {
97 | $this->closeDba();
98 | }
99 |
100 | /**
101 | * @param string $key
102 | * @param mixed $value
103 | * @param int|bool $ltime Lifetime in seconds otherwise cache forever.
104 | *
105 | * @return bool
106 | */
107 | public function put($key, $value, $ltime = false)
108 | {
109 | try {
110 | $value = Pack::wrap($value, $ltime);
111 | } catch (\RuntimeException $ret) {
112 | return false;
113 | }
114 |
115 | if (true === $this->has($key)) {
116 | return dba_replace($key, $value, $this->dba);
117 | }
118 |
119 | return dba_insert($key, $value, $this->dba);
120 | }
121 |
122 | /**
123 | * @param string $key
124 | * @param mixed $value
125 | *
126 | * @return bool
127 | */
128 | public function forever($key, $value)
129 | {
130 | return $this->put($key, $value, false);
131 | }
132 |
133 | /**
134 | * @param string $key
135 | *
136 | * @return bool|object
137 | */
138 | public function get($key)
139 | {
140 | $res = $this->fetch($key);
141 |
142 | if (false === $res) {
143 | return false;
144 | }
145 |
146 | if (false === $res->ltime || (microtime(true) - $res->mtime) < $res->ltime) {
147 | return $res->object;
148 | }
149 |
150 | $this->delete($key);
151 |
152 | return false;
153 | }
154 |
155 | /**
156 | * @return string
157 | */
158 | public function getStorage()
159 | {
160 | return $this->storage;
161 | }
162 |
163 | /**
164 | * @param string $key
165 | *
166 | * @return Capsule|boolean
167 | */
168 | public function fetch($key)
169 | {
170 | $fetched = dba_fetch($key, $this->dba);
171 |
172 | if (false === $fetched) {
173 | return false;
174 | }
175 |
176 | try {
177 | return Pack::unwrap($fetched);
178 | } catch (\RuntimeException $ret) {
179 | return false;
180 | }
181 | }
182 |
183 | /**
184 | * @param string $key
185 | *
186 | * @return boolean
187 | */
188 | public function delete($key)
189 | {
190 | if (false === is_resource($this->dba)) {
191 | return false;
192 | }
193 |
194 | if ($this->erasable()) {
195 | return dba_delete($key, $this->dba);
196 | }
197 |
198 | return true;
199 | }
200 |
201 | /**
202 | * @param string $key
203 | *
204 | * @return boolean
205 | */
206 | public function has($key)
207 | {
208 | return dba_exists($key, $this->dba);
209 | }
210 |
211 | /**
212 | * Close the handler.
213 | */
214 | public function closeDba()
215 | {
216 | if ($this->dba) {
217 | dba_close($this->dba);
218 | $this->dba = null;
219 | }
220 | }
221 |
222 | /**
223 | * @return resource
224 | */
225 | public function getDba()
226 | {
227 | return $this->dba;
228 | }
229 |
230 | /**
231 | * @return \ArrayObject of stored cache ids (string).
232 | */
233 | public function getIds()
234 | {
235 | $ids = new \ArrayObject();
236 | $dba = $this->getDba();
237 | $key = dba_firstkey($dba);
238 |
239 | while ($key !== false && $key !== null) {
240 | $ids->offsetSet(null, $key);
241 | $key = dba_nextkey($dba);
242 | }
243 |
244 | return $ids;
245 | }
246 |
247 | /**
248 | * Return an array of metadata for the given cache id.
249 | *
250 | * - expire = the expire timestamp
251 | * - mtime = timestamp of last modification time
252 | *
253 | * @param string $key cache id
254 | *
255 | * @return array|boolean
256 | */
257 | public function getMetaData($key)
258 | {
259 | $res = $this->fetch($key);
260 |
261 | if ($res instanceof Capsule) {
262 | return array(
263 | 'expire' => $res->mtime + $res->ltime,
264 | 'mtime' => $res->mtime,
265 | );
266 | }
267 |
268 | return false;
269 | }
270 |
271 | /**
272 | * Ensures if a single cache-item can be deleted.
273 | *
274 | * @param null|string $handler
275 | *
276 | * @return bool
277 | */
278 | public function erasable($handler = null)
279 | {
280 | $handler = (!$handler) ? $this->handler : $handler;
281 |
282 | return in_array($handler, array('inifile', 'gdbm', 'qdbm', 'db4'), true);
283 | }
284 | }
285 |
--------------------------------------------------------------------------------
/src/Capsule.php:
--------------------------------------------------------------------------------
1 | fake = $fake;
54 | $this->ltime = $ltime;
55 | $this->mtime = microtime(true);
56 | $this->object = $object;
57 | $this->type = get_class($object);
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/src/Pack.php:
--------------------------------------------------------------------------------
1 | object = $object->asXml();
32 | }
33 |
34 | if (false === ($res = @serialize($capsule))) {
35 | $err = error_get_last();
36 | throw new \RuntimeException($err['message']);
37 | }
38 |
39 | return $res;
40 | }
41 |
42 | /**
43 | * @param $object
44 | *
45 | * @return Capsule
46 | * @throws \RuntimeException If problems on un-serializing
47 | */
48 | public static function unwrap($object)
49 | {
50 | $serialized = (false !== ($capsule = @unserialize(trim($object))));
51 |
52 | if (!$serialized) {
53 | $err = error_get_last();
54 | throw new \RuntimeException($err['message']);
55 | }
56 |
57 | if (true === $capsule->fake) {
58 | if (isset($capsule->object->scalar)) {
59 | $capsule->object = $capsule->object->scalar;
60 | } else {
61 | $capsule->object = (array)$capsule->object;
62 | }
63 | }
64 |
65 | if ($capsule->type == 'SimpleXMLElement') {
66 | $capsule->object = simplexml_load_string($capsule->object);
67 | }
68 |
69 | return $capsule;
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/src/Sweep.php:
--------------------------------------------------------------------------------
1 | cache = $cache;
23 | }
24 |
25 | /**
26 | * Remove all cache entries.
27 | *
28 | * @return void
29 | */
30 | public function all()
31 | {
32 | $this->process();
33 | }
34 |
35 | /**
36 | * Remove too old cache entries.
37 | *
38 | * @return void
39 | */
40 | public function old()
41 | {
42 | $this->process(false);
43 | }
44 |
45 | /**
46 | * Internal cleaning process.
47 | *
48 | * @param boolean $cleanAll
49 | *
50 | * @return void
51 | */
52 | protected function process($cleanAll = true)
53 | {
54 | $key = dba_firstkey($this->cache->getDba());
55 |
56 | while ($key !== false && $key !== null) {
57 | if (true === $cleanAll) {
58 | $this->cache->delete($key);
59 | } else {
60 | $this->cache->get($key);
61 | }
62 |
63 | $key = dba_nextkey($this->cache->getDba());
64 | }
65 |
66 | dba_optimize($this->cache->getDba());
67 | }
68 |
69 | /**
70 | * Flush the whole storage.
71 | *
72 | * @throws \RuntimeException If can not flush file.
73 | * @return bool
74 | */
75 | public function flush()
76 | {
77 | $file = $this->cache->getStorage();
78 |
79 | if (file_exists($file)) {
80 | // close the dba file before delete
81 | // and reopen on next use
82 | $this->cache->closeDba();
83 |
84 | if (!@unlink($file)) {
85 | throw new \RuntimeException("can not flush file '$file'");
86 | }
87 | }
88 |
89 | return true;
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/tests/CacheDefaultTest.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(__FILE__) . '/_drafts/test-cache.flatfile';
13 | $this->generalHandler = 'flatfile';
14 | $this->generalMode = 'c-';
15 | }
16 |
17 | public function testWriteAndReadWithoutPersistentConnection()
18 | {
19 | try {
20 | $cache = new \PhpDbaCache\Cache(
21 | dirname(__FILE__) . '/_drafts/test-cache-pers.flatfile', 'flatfile', 'c-', false
22 | );
23 | } catch (\RuntimeException $e) {
24 | $this->markTestSkipped($e->getMessage());
25 | }
26 |
27 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
28 |
29 | $cache->put($this->identifier, array('rambo' => 123));
30 | $cache->get($this->identifier);
31 |
32 | $res = $cache->get($this->identifier);
33 |
34 | $this->assertInternalType('array', $res);
35 | $this->assertEquals($res, array('rambo' => 123));
36 | }
37 |
38 | public function testHandlingWithSimpleXMLElementIntoFlatfileHandler()
39 | {
40 | $identifier = md5(uniqid());
41 |
42 | // make a xml-file of 1000 nodes.
43 | $string = "
44 | ";
45 | for ($i = 1; $i <= 100; $i++) {
46 | $string .= "
47 | Let us cache
48 | Joe
49 | Jane
50 | Some content here
51 | ";
52 | }
53 | $string .= "";
54 |
55 | $simplexml = simplexml_load_string(
56 | $string, 'SimpleXMLElement', LIBXML_NOERROR | LIBXML_NOWARNING | LIBXML_NONET
57 | );
58 |
59 | $path = dirname(__FILE__) . '/_drafts/test-cache-with-simplexml.flatfile';
60 |
61 | try {
62 | $cache = new \PhpDbaCache\Cache($path);
63 | } catch (\RuntimeException $e) {
64 | $this->markTestSkipped($e->getMessage());
65 | }
66 |
67 | $cache->put($identifier, $simplexml);
68 | $object_from_cache = $cache->get($identifier);
69 | $cache->closeDba();
70 |
71 | $this->assertEquals($simplexml->asXML(), $object_from_cache->asXML());
72 |
73 | @unlink($path);
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/tests/DummyFixtures.php:
--------------------------------------------------------------------------------
1 | moo = new Dummy1();
24 | }
25 | }
--------------------------------------------------------------------------------
/tests/Handlers/CdbReadTest.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-serialised.cdb';
13 | $this->generalHandler = 'cdb';
14 | $this->generalMode = 'r';
15 | $this->identifier = md5('test123');
16 | }
17 |
18 | public function testPuttingForever()
19 | {
20 | $this->markTestSkipped('sorry - this handler is not able to write');
21 | }
22 |
23 |
24 | public function testIfNoDatabaseExists()
25 | {
26 | $path = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/simple-xml-test-cache-on-cdb.db';
27 | try {
28 | new \PhpDbaCache\Cache(
29 | $path, "cdb", "n"
30 | );
31 | @unlink($path);
32 | } catch (\RuntimeException $e) {
33 | $this->markTestSkipped($e->getMessage());
34 | }
35 | }
36 |
37 | public function testWithPersistentConnection()
38 | {
39 | $path = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-serialised.cdb';
40 |
41 | // create handler to read.
42 | try {
43 | $cacheRead = new \PhpDbaCache\Cache($path, 'cdb', 'r');
44 | } catch (\RuntimeException $e) {
45 | $this->markTestSkipped($e->getMessage());
46 | }
47 |
48 | $this->assertTrue($cacheRead->has(md5('test123')));
49 |
50 | $this->assertInstanceOf('\stdClass', $cacheRead->get(md5('test123')));
51 |
52 | $cacheRead->closeDba();
53 | }
54 |
55 | public function testSameIdentifierTwiceTime()
56 | {
57 | $path = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-keyed.cdb';
58 |
59 | try {
60 | $cacheRead = new \PhpDbaCache\Cache($path, 'cdb', 'r');
61 | } catch (\RuntimeException $e) {
62 | $this->markTestSkipped($e->getMessage());
63 | }
64 |
65 | //check if data replaced.
66 | $this->assertEquals('data', $cacheRead->get('key'));
67 |
68 | $cacheRead->closeDba();
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/tests/Handlers/CdbWriteTest.php:
--------------------------------------------------------------------------------
1 | markTestSkipped('sorry - this handler is not able to read');
12 | }
13 |
14 | public function testFetchingMetaData()
15 | {
16 | $this->markTestSkipped('sorry - this handler is not able to read');
17 | }
18 |
19 | public function testWithPersistentConnection()
20 | {
21 | $path = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-serialised.cdb';
22 |
23 | // create handler to write.
24 | try {
25 | $cacheMake = new \PhpDbaCache\Cache($path, 'cdb_make', 'n');
26 | } catch (\RuntimeException $e) {
27 | $this->markTestSkipped($e->getMessage());
28 | }
29 |
30 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cacheMake);
31 |
32 | $this->assertTrue($cacheMake->put(md5('test123'), $this->testObject));
33 |
34 | // for read we close the handler.
35 | $cacheMake->closeDba();
36 | }
37 |
38 | public function testPutSameIdentifierTwiceTime()
39 | {
40 | $path = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-keyed.cdb';
41 |
42 | try {
43 | $cacheMake = new \PhpDbaCache\Cache($path, 'cdb_make', 'n');
44 | } catch (\RuntimeException $e) {
45 | $this->markTestSkipped($e->getMessage());
46 | }
47 |
48 | // first insert.
49 | $this->assertTrue($cacheMake->put('key', 'data'));
50 |
51 | // replace instead of insert.
52 | $this->assertTrue($cacheMake->put('key', 'data-2'));
53 |
54 | // for read we close the handler.
55 | $cacheMake->closeDba();
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/tests/Handlers/Db4Test.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.db4';
14 | $this->generalHandler = 'db4';
15 | }
16 |
17 | public function testWithoutPersistentConnection()
18 | {
19 | try {
20 | $cache = new \PhpDbaCache\Cache($this->generalCacheFile, $this->generalHandler, 'c', false);
21 | } catch (\RuntimeException $e) {
22 | $this->markTestSkipped($e->getMessage());
23 | }
24 |
25 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
26 |
27 | $cache->put($this->identifier, $this->testObject);
28 |
29 | $this->assertInstanceOf('\stdClass', $cache->get($this->identifier));
30 |
31 | $cache->closeDba();
32 | }
33 |
34 | /**
35 | * @depends Db4Test::testWithoutPersistentConnection
36 | */
37 | public function testOracleBerkeleyDb4HandlerBeSupportedWithPersistantConnection()
38 | {
39 | try {
40 | $cache = new \PhpDbaCache\Cache($this->generalCacheFile, $this->generalHandler);
41 | } catch (\RuntimeException $e) {
42 | $this->markTestSkipped($e->getMessage());
43 | }
44 |
45 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
46 |
47 | $cache->put($this->identifier, $this->testObject);
48 |
49 | $this->assertInstanceOf('\stdClass', $cache->get($this->identifier));
50 |
51 | $cache->closeDba();
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/tests/Handlers/FlatfileTest.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.flatfile';
14 | $this->generalHandler = 'flatfile';
15 | $this->generalMode = 'c-';
16 | }
17 |
18 | public function testWriteAndReadWithoutPersistentConnection()
19 | {
20 | try {
21 | $cache = new \PhpDbaCache\Cache(
22 | dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-pers.flatfile', 'flatfile', 'c-', false
23 | );
24 | } catch (\RuntimeException $e) {
25 | $this->markTestSkipped($e->getMessage());
26 | }
27 |
28 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
29 |
30 | $cache->put($this->identifier, array('rambo' => 123));
31 |
32 | $res = $cache->get($this->identifier);
33 |
34 | $this->assertInternalType('array', $res);
35 | $this->assertEquals($res, array('rambo' => 123));
36 | }
37 |
38 | public function testHandlingWithSimpleXMLElementIntoFlatfileHandler()
39 | {
40 | $identifier = md5(uniqid());
41 |
42 | // make a xml-file of 1000 nodes.
43 | $string = "
44 | ";
45 | for ($i = 1; $i <= 100; $i++) {
46 | $string .= "
47 | Let us cache
48 | Joe
49 | Jane
50 | Some content here
51 | ";
52 | }
53 | $string .= "";
54 |
55 | $simplexml = simplexml_load_string(
56 | $string, 'SimpleXMLElement', LIBXML_NOERROR | LIBXML_NOWARNING | LIBXML_NONET
57 | );
58 |
59 | $path = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache-with-simplexml.flatfile';
60 |
61 | try {
62 | $cache = new \PhpDbaCache\Cache($path);
63 | } catch (\RuntimeException $e) {
64 | $this->markTestSkipped($e->getMessage());
65 | }
66 |
67 | $cache->put($identifier, $simplexml);
68 | $object_from_cache = $cache->get($identifier);
69 | $cache->closeDba();
70 |
71 | $this->assertEquals($simplexml->asXML(), $object_from_cache->asXML());
72 |
73 | @unlink($path);
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/tests/Handlers/GdbmTest.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.gdbm';
13 | $this->generalHandler = 'gdbm';
14 | }
15 |
16 | public function testWriteAndReadWithoutPersistentConnection()
17 | {
18 | try {
19 | $cache = new \PhpDbaCache\Cache(
20 | dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.gdbm', 'gdbm', 'c', false
21 | );
22 | } catch (\RuntimeException $e) {
23 | $this->markTestSkipped($e->getMessage());
24 | }
25 |
26 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
27 |
28 | $cache->put($this->identifier, $this->testObject);
29 |
30 | $this->assertInstanceOf('\stdClass', $cache->get($this->identifier));
31 | }
32 |
33 | /**
34 | * @depends CacheHandlersTest::testSupportWithoutPersistentConnection
35 | */
36 | public function testWriteAndReaddWithPersistentConnection()
37 | {
38 | try {
39 | $cache = new \PhpDbaCache\Cache(dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.gdbm', 'gdbm');
40 | } catch (\RuntimeException $e) {
41 | $this->markTestSkipped($e->getMessage());
42 | }
43 |
44 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
45 |
46 | $cache->put($this->identifier, $this->testObject);
47 |
48 | $this->assertInstanceOf('\stdClass', $cache->get($this->identifier));
49 | }
50 |
51 | }
52 |
--------------------------------------------------------------------------------
/tests/Handlers/InifileTest.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.inifile';
13 | $this->generalHandler = 'inifile';
14 | }
15 |
16 | public function testWriteAndReadWithoutPersistentConnection()
17 | {
18 | try {
19 | $cache = new \PhpDbaCache\Cache(
20 | dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.inifile', 'inifile', 'c', false
21 | );
22 | } catch (\RuntimeException $e) {
23 | $this->markTestSkipped($e->getMessage());
24 | }
25 |
26 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
27 |
28 | $cache->put($this->identifier, array('rambo' => 123));
29 |
30 | $res = $cache->get($this->identifier);
31 |
32 | $this->assertInternalType('array', $res);
33 | $this->assertEquals($res, array('rambo' => 123));
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/tests/Handlers/QdbmTest.php:
--------------------------------------------------------------------------------
1 | generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.qdbm';
15 | $this->generalHandler = 'qdbm';
16 | }
17 |
18 | public function testWriteAndReadWithoutPersistentConnection()
19 | {
20 | try {
21 | $cache = new \PhpDbaCache\Cache(
22 | dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.qdbm', 'qdbm', 'c', false
23 | );
24 | } catch (\RuntimeException $e) {
25 | $this->markTestSkipped($e->getMessage());
26 | }
27 |
28 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
29 |
30 | $cache->put($this->identifier, $this->testObject);
31 |
32 | $this->assertInstanceOf('\stdClass', $cache->get($this->identifier));
33 | }
34 |
35 | /**
36 | * @depends CacheHandlersTest::testSupportWithoutPersistentConnection
37 | */
38 | public function testWriteAndReaddWithPersistentConnection()
39 | {
40 | try {
41 | $cache = new \PhpDbaCache\Cache(dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/test-cache.qdbm', 'qdbm');
42 | } catch (\RuntimeException $e) {
43 | $this->markTestSkipped($e->getMessage());
44 | }
45 |
46 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
47 |
48 | $cache->put($this->identifier, $this->testObject);
49 |
50 | $this->assertInstanceOf('\stdClass', $cache->get($this->identifier));
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/tests/Handlers/TestCase.php:
--------------------------------------------------------------------------------
1 | title = 'Zweiundvierz';
42 | $stdClass->from = 'Joe';
43 | $stdClass->to = 'Jane';
44 | $stdClass->body = new \Fixtures\Dummy();
45 |
46 | $this->testObject = $stdClass;
47 | $this->identifier = md5('stdClass' . time());
48 | $this->generalCacheFile = dirname(dirname(dirname(__FILE__))) . '/tests/_drafts/flatfile.db';
49 | }
50 |
51 | /**
52 | * Cleans up the environment after running a test.
53 | */
54 | protected function tearDown()
55 | {
56 | unset($this->testObject, $this->identifier);
57 | parent::tearDown();
58 | }
59 |
60 | public function testPuttingForever()
61 | {
62 | try {
63 | $cache = new \PhpDbaCache\Cache($this->generalCacheFile, $this->generalHandler, $this->generalMode);
64 | } catch (\RuntimeException $e) {
65 | $this->markTestSkipped($e->getMessage());
66 | }
67 |
68 | $cache->forever('forever', array('forever' => 123));
69 |
70 | $res = $cache->getIds();
71 |
72 | $this->assertInstanceOf('\ArrayObject', $res, 'no instance of ArrayObject');
73 | $this->assertNotEmpty($res->getArrayCopy());
74 |
75 | $cache->closeDba();
76 | }
77 |
78 | public function badHandlersProvider()
79 | {
80 | return array(
81 | array('bad-bad-handler'),
82 | array(123),
83 | array(1),
84 | array('0'),
85 | array(' '),
86 | array(null),
87 | array(true),
88 | array(false),
89 | );
90 | }
91 |
92 | /**
93 | * @expectedException \RuntimeException
94 | * @dataProvider badHandlersProvider
95 | */
96 | public function testIfBadHandlerGiven()
97 | {
98 | new \PhpDbaCache\Cache($this->generalCacheFile, 'bad-bad-handler');
99 | }
100 |
101 | /**
102 | * @expectedException \RuntimeException
103 | */
104 | public function testIfBadDbFileGiven()
105 | {
106 | new \PhpDbaCache\Cache('/path/to/bad-bad-file.db', $this->generalHandler, 'r');
107 | }
108 |
109 | }
110 |
--------------------------------------------------------------------------------
/tests/PackTest.php:
--------------------------------------------------------------------------------
1 | assertNotNull(new \PhpDbaCache\Pack());
12 | }
13 |
14 | public function objectsProvider()
15 | {
16 | $stdClass = new \stdClass();
17 | $stdClass->title = 'Zweiundvierz';
18 | $stdClass->from = 'Joe';
19 | $stdClass->to = 'Jane';
20 | $stdClass->body = new \Fixtures\Dummy2();
21 |
22 | return array(
23 | array(new \Fixtures\Dummy2()),
24 | array($stdClass),
25 | array(new \ZipArchive()),
26 | array(new \XMLReader()),
27 | array('i am a string'),
28 | array(123456789),
29 | array(
30 | array(
31 | 'boo' => 1,
32 | 'foo' => 2,
33 | 'laa' => 3
34 | )
35 | )
36 | );
37 | }
38 |
39 | /**
40 | * @depends PackTest::testCreatingNewObject
41 | * @dataProvider objectsProvider
42 | */
43 | public function testSerializingSomeObjects($object)
44 | {
45 | \PhpDbaCache\Pack::wrap($object);
46 | }
47 |
48 | /**
49 | * @depends PackTest::testCreatingNewObject
50 | * @depends PackTest::testSerializingSomeObjects
51 | * @dataProvider objectsProvider
52 | */
53 | public function testUnserializingSomeObjectsAndCompareThemEachOther($object)
54 | {
55 | $serialized = \PhpDbaCache\Pack::wrap($object);
56 |
57 | $userItem = \PhpDbaCache\Pack::unwrap($serialized);
58 |
59 | $this->assertEquals($object, $userItem->object);
60 | }
61 |
62 | public static function provideSerializedTestData()
63 | {
64 | return array(
65 | array(array(21.123, 21.124, 2, 0)),
66 | array((object)array('eee' => 21.123, 'asdfasdf' => 21.124)),
67 | array(new \Fixtures\Dummy2()),
68 | array(new \Fixtures\Dummy1()),
69 | array(new \Fixtures\Dummy()),
70 | );
71 | }
72 |
73 | /**
74 | * @dataProvider provideSerializedTestData
75 | */
76 | public function testIfCanBePackedIn($data)
77 | {
78 | $this->assertInternalType(
79 |
80 | 'string',
81 |
82 | \PhpDbaCache\Pack::wrap($data),
83 |
84 | 'problem on asserting that ' . print_r($data, true) . ' can be serialized'
85 |
86 | );
87 | }
88 |
89 | public static function provideNotAndBadSerializedTestData()
90 | {
91 | return array(
92 | array(null),
93 | array(''),
94 | array(' '),
95 | array('0'),
96 | array(0),
97 | array(true),
98 | array('O:7:"Capsule":5:1 :4:"type";'),
99 | array('{s:7:"forever";i:123;'),
100 | array(array('eee' => 21.123, 'asdfasdf' => 21.124)),
101 | array(array('eee' => 21.123, 'asdfasdf' => 21.124)),
102 | );
103 | }
104 |
105 | /**
106 | * @dataProvider provideNotAndBadSerializedTestData
107 | * @expectedException RuntimeException
108 | */
109 | public function testFailsIfCanNotBePackedOut($data)
110 | {
111 | \PhpDbaCache\Pack::unwrap($data);
112 | }
113 | }
114 |
115 |
--------------------------------------------------------------------------------
/tests/SweepTest.php:
--------------------------------------------------------------------------------
1 | cache = new \PhpDbaCache\Cache($path, 'gdbm');
23 | } catch (\RuntimeException $e) {
24 | $this->markTestSkipped($e->getMessage());
25 | }
26 | }
27 |
28 | /**
29 | * Cleans up the environment after running a test.
30 | */
31 | protected function tearDown()
32 | {
33 | if ($this->cache) {
34 | $this->cache->closeDba();
35 | }
36 | parent::tearDown();
37 | }
38 |
39 |
40 | #tests
41 |
42 |
43 | public function testCreatingNewObject()
44 | {
45 | $sweep = new \PhpDbaCache\Sweep($this->cache);
46 |
47 | $this->assertInstanceOf('\PhpDbaCache\Sweep', $sweep);
48 | }
49 |
50 | /**
51 | * @depends SweepTest::testCreatingNewObject
52 | */
53 | public function testCleanAllFromTheGarbageCollection()
54 | {
55 | // prepare data.
56 | $stdClass = new \stdClass();
57 | $stdClass->title = 'Hi firend, i am cached.';
58 | $stdClass->from = 'Joe';
59 | $stdClass->to = 'Hover';
60 | $stdClass->body = 'Yes, it works!';
61 |
62 | // put some data to the cache.
63 | $this->cache->put(md5('stdClass'), $stdClass, 1);
64 | $this->cache->put(md5('ZipArchive'), new \ZipArchive(), 1);
65 | $this->cache->put(md5('XMLReader'), new \XMLReader(), 1);
66 |
67 | sleep(1);
68 |
69 | $sweep = new \PhpDbaCache\Sweep($this->cache);
70 | $sweep->all();
71 |
72 | $this->assertFalse($this->cache->get(md5('stdClass')));
73 |
74 | $this->assertFalse($this->cache->get(md5('ZipArchive')));
75 |
76 | $this->assertFalse($this->cache->get(md5('XMLReader')));
77 | }
78 |
79 | /**
80 | * @depends SweepTest::testCreatingNewObject
81 | */
82 | public function testCleanTheGarbageCollectionByNotSuitableExpirationTime()
83 | {
84 | // prepare data.
85 | $stdClass = new \stdClass();
86 | $stdClass->title = 'I am cached.';
87 | $stdClass->from = 'Mike';
88 | $stdClass->to = 'Gates';
89 | $stdClass->body = 'Yes, it works fine!';
90 |
91 | // put some data to the cache.
92 | $this->cache->put(md5('stdClass'), $stdClass);
93 | $this->cache->put(md5('ZipArchive'), new \ZipArchive());
94 | $this->cache->put(md5('XMLReader'), new \XMLReader());
95 |
96 | // wait one second to force the expiration-time-calculation.
97 | sleep(1);
98 |
99 | $sweep = new \Sweep($this->cache);
100 | $sweep->old();
101 |
102 | $this->assertInstanceOf('\PhpDbaCache\stdClass', $this->cache->get(md5('stdClass')));
103 | $this->assertInstanceOf('\PhpDbaCache\ZipArchive', $this->cache->get(md5('ZipArchive')));
104 | $this->assertInstanceOf('\PhpDbaCache\XMLReader', $this->cache->get(md5('XMLReader')));
105 | }
106 |
107 | /**
108 | * Tests support for CDB - Tiny Constant Database.
109 | * CDB can not be deleted - clear garbage manually.
110 | */
111 | public function testCleanGarbageCollectionOnCdbHandler()
112 | {
113 | $path = dirname(dirname(__FILE__)) . '/tests/_drafts/test-cache-cdb2.cdb';
114 |
115 | // create cdb-handler to write.
116 | try {
117 | $cacheMake = new \Cache($path, 'cdb_make', 'n');
118 | } catch (\RuntimeException $e) {
119 | $this->markTestSkipped($e->getMessage());
120 | }
121 |
122 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cacheMake);
123 |
124 | $testIdentifier1 = md5('ZipArchive' . time());
125 | $testIdentifier2 = md5('XMLReader' . time());
126 |
127 | $this->assertTrue($cacheMake->put($testIdentifier1, new \ZipArchive()));
128 | $this->assertTrue($cacheMake->put($testIdentifier2, new \XMLReader()));
129 |
130 | // CacheGarbageCollector has no effect.
131 | $sweep = new \PhpDbaCache\Sweep($cacheMake);
132 | $sweep->all();
133 |
134 | // deleting has no effect.
135 | $cacheMake->delete($testIdentifier1);
136 | $cacheMake->delete($testIdentifier2);
137 |
138 | // for read we close the handler.
139 | $cacheMake->closeDba();
140 |
141 | // create cdb-handler to read.
142 | try {
143 | $cacheRead = new \PhpDbaCache\Cache($path, 'cdb', 'r');
144 | } catch (\RuntimeException $e) {
145 | $this->markTestSkipped($e->getMessage());
146 | }
147 |
148 | $this->assertTrue($cacheRead->has($testIdentifier1));
149 | $this->assertTrue($cacheRead->has($testIdentifier2));
150 |
151 | $this->assertInstanceOf('\PhpDbaCache\ZipArchive', $cacheRead->get($testIdentifier1));
152 | $this->assertInstanceOf('\PhpDbaCache\XMLReader', $cacheRead->get($testIdentifier2));
153 |
154 | $cacheRead->closeDba();
155 | }
156 |
157 | /**
158 | * Tests support for DB4 - Oracle Berkeley DB 4.
159 | */
160 | public function testCleanTheGarbageCollectionOnDb4Handler()
161 | {
162 | $path = dirname(dirname(__FILE__)) . '/tests/_drafts/test-cache.db4';
163 |
164 | try {
165 | $cache = new \PhpDbaCache\Cache($path, 'db4', 'c', false);
166 | } catch (\RuntimeException $e) {
167 | $this->markTestSkipped($e->getMessage());
168 | }
169 |
170 | $this->assertInstanceOf('\PhpDbaCache\Cache', $cache);
171 |
172 | $cache->put(md5('ZipArchive'), new \ZipArchive());
173 | $cache->put(md5('XMLReader'), new \XMLReader());
174 |
175 | $this->assertInstanceOf('\PhpDbaCache\ZipArchive', $cache->get(md5('ZipArchive')));
176 | $this->assertInstanceOf('\PhpDbaCache\XMLReader', $cache->get(md5('XMLReader')));
177 |
178 | $sweep = new \PhpDbaCache\Sweep($cache);
179 | $sweep->all();
180 |
181 | $this->assertFalse($cache->get(md5('ZipArchive')));
182 | $this->assertFalse($cache->get(md5('XMLReader')));
183 |
184 | $cache->closeDba();
185 |
186 | @unlink($path);
187 | }
188 |
189 | public function testUtilMethods()
190 | {
191 | $sweep = new \PhpDbaCache\Sweep($this->cache);
192 |
193 | $this->assertTrue($sweep->flush());
194 | }
195 | }
196 |
--------------------------------------------------------------------------------
/tests/_drafts/test-cache-cdb2.cdb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gjerokrsteski/php-dba-cache/c54311733c9e0129be1a769fdb684d6b0a1d4a18/tests/_drafts/test-cache-cdb2.cdb
--------------------------------------------------------------------------------
/vendor/autoload.php:
--------------------------------------------------------------------------------
1 |
7 | * Jordi Boggiano
8 | *
9 | * For the full copyright and license information, please view the LICENSE
10 | * file that was distributed with this source code.
11 | */
12 |
13 | namespace Composer\Autoload;
14 |
15 | /**
16 | * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
17 | *
18 | * $loader = new \Composer\Autoload\ClassLoader();
19 | *
20 | * // register classes with namespaces
21 | * $loader->add('Symfony\Component', __DIR__.'/component');
22 | * $loader->add('Symfony', __DIR__.'/framework');
23 | *
24 | * // activate the autoloader
25 | * $loader->register();
26 | *
27 | * // to enable searching the include path (eg. for PEAR packages)
28 | * $loader->setUseIncludePath(true);
29 | *
30 | * In this example, if you try to use a class in the Symfony\Component
31 | * namespace or one of its children (Symfony\Component\Console for instance),
32 | * the autoloader will first look for the class under the component/
33 | * directory, and it will then fallback to the framework/ directory if not
34 | * found before giving up.
35 | *
36 | * This class is loosely based on the Symfony UniversalClassLoader.
37 | *
38 | * @author Fabien Potencier
39 | * @author Jordi Boggiano
40 | * @see http://www.php-fig.org/psr/psr-0/
41 | * @see http://www.php-fig.org/psr/psr-4/
42 | */
43 | class ClassLoader
44 | {
45 | // PSR-4
46 | private $prefixLengthsPsr4 = array();
47 | private $prefixDirsPsr4 = array();
48 | private $fallbackDirsPsr4 = array();
49 |
50 | // PSR-0
51 | private $prefixesPsr0 = array();
52 | private $fallbackDirsPsr0 = array();
53 |
54 | private $useIncludePath = false;
55 | private $classMap = array();
56 |
57 | private $classMapAuthoritative = false;
58 |
59 | public function getPrefixes()
60 | {
61 | if (!empty($this->prefixesPsr0)) {
62 | return call_user_func_array('array_merge', $this->prefixesPsr0);
63 | }
64 |
65 | return array();
66 | }
67 |
68 | public function getPrefixesPsr4()
69 | {
70 | return $this->prefixDirsPsr4;
71 | }
72 |
73 | public function getFallbackDirs()
74 | {
75 | return $this->fallbackDirsPsr0;
76 | }
77 |
78 | public function getFallbackDirsPsr4()
79 | {
80 | return $this->fallbackDirsPsr4;
81 | }
82 |
83 | public function getClassMap()
84 | {
85 | return $this->classMap;
86 | }
87 |
88 | /**
89 | * @param array $classMap Class to filename map
90 | */
91 | public function addClassMap(array $classMap)
92 | {
93 | if ($this->classMap) {
94 | $this->classMap = array_merge($this->classMap, $classMap);
95 | } else {
96 | $this->classMap = $classMap;
97 | }
98 | }
99 |
100 | /**
101 | * Registers a set of PSR-0 directories for a given prefix, either
102 | * appending or prepending to the ones previously set for this prefix.
103 | *
104 | * @param string $prefix The prefix
105 | * @param array|string $paths The PSR-0 root directories
106 | * @param bool $prepend Whether to prepend the directories
107 | */
108 | public function add($prefix, $paths, $prepend = false)
109 | {
110 | if (!$prefix) {
111 | if ($prepend) {
112 | $this->fallbackDirsPsr0 = array_merge(
113 | (array) $paths,
114 | $this->fallbackDirsPsr0
115 | );
116 | } else {
117 | $this->fallbackDirsPsr0 = array_merge(
118 | $this->fallbackDirsPsr0,
119 | (array) $paths
120 | );
121 | }
122 |
123 | return;
124 | }
125 |
126 | $first = $prefix[0];
127 | if (!isset($this->prefixesPsr0[$first][$prefix])) {
128 | $this->prefixesPsr0[$first][$prefix] = (array) $paths;
129 |
130 | return;
131 | }
132 | if ($prepend) {
133 | $this->prefixesPsr0[$first][$prefix] = array_merge(
134 | (array) $paths,
135 | $this->prefixesPsr0[$first][$prefix]
136 | );
137 | } else {
138 | $this->prefixesPsr0[$first][$prefix] = array_merge(
139 | $this->prefixesPsr0[$first][$prefix],
140 | (array) $paths
141 | );
142 | }
143 | }
144 |
145 | /**
146 | * Registers a set of PSR-4 directories for a given namespace, either
147 | * appending or prepending to the ones previously set for this namespace.
148 | *
149 | * @param string $prefix The prefix/namespace, with trailing '\\'
150 | * @param array|string $paths The PSR-4 base directories
151 | * @param bool $prepend Whether to prepend the directories
152 | *
153 | * @throws \InvalidArgumentException
154 | */
155 | public function addPsr4($prefix, $paths, $prepend = false)
156 | {
157 | if (!$prefix) {
158 | // Register directories for the root namespace.
159 | if ($prepend) {
160 | $this->fallbackDirsPsr4 = array_merge(
161 | (array) $paths,
162 | $this->fallbackDirsPsr4
163 | );
164 | } else {
165 | $this->fallbackDirsPsr4 = array_merge(
166 | $this->fallbackDirsPsr4,
167 | (array) $paths
168 | );
169 | }
170 | } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
171 | // Register directories for a new namespace.
172 | $length = strlen($prefix);
173 | if ('\\' !== $prefix[$length - 1]) {
174 | throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
175 | }
176 | $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
177 | $this->prefixDirsPsr4[$prefix] = (array) $paths;
178 | } elseif ($prepend) {
179 | // Prepend directories for an already registered namespace.
180 | $this->prefixDirsPsr4[$prefix] = array_merge(
181 | (array) $paths,
182 | $this->prefixDirsPsr4[$prefix]
183 | );
184 | } else {
185 | // Append directories for an already registered namespace.
186 | $this->prefixDirsPsr4[$prefix] = array_merge(
187 | $this->prefixDirsPsr4[$prefix],
188 | (array) $paths
189 | );
190 | }
191 | }
192 |
193 | /**
194 | * Registers a set of PSR-0 directories for a given prefix,
195 | * replacing any others previously set for this prefix.
196 | *
197 | * @param string $prefix The prefix
198 | * @param array|string $paths The PSR-0 base directories
199 | */
200 | public function set($prefix, $paths)
201 | {
202 | if (!$prefix) {
203 | $this->fallbackDirsPsr0 = (array) $paths;
204 | } else {
205 | $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
206 | }
207 | }
208 |
209 | /**
210 | * Registers a set of PSR-4 directories for a given namespace,
211 | * replacing any others previously set for this namespace.
212 | *
213 | * @param string $prefix The prefix/namespace, with trailing '\\'
214 | * @param array|string $paths The PSR-4 base directories
215 | *
216 | * @throws \InvalidArgumentException
217 | */
218 | public function setPsr4($prefix, $paths)
219 | {
220 | if (!$prefix) {
221 | $this->fallbackDirsPsr4 = (array) $paths;
222 | } else {
223 | $length = strlen($prefix);
224 | if ('\\' !== $prefix[$length - 1]) {
225 | throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
226 | }
227 | $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
228 | $this->prefixDirsPsr4[$prefix] = (array) $paths;
229 | }
230 | }
231 |
232 | /**
233 | * Turns on searching the include path for class files.
234 | *
235 | * @param bool $useIncludePath
236 | */
237 | public function setUseIncludePath($useIncludePath)
238 | {
239 | $this->useIncludePath = $useIncludePath;
240 | }
241 |
242 | /**
243 | * Can be used to check if the autoloader uses the include path to check
244 | * for classes.
245 | *
246 | * @return bool
247 | */
248 | public function getUseIncludePath()
249 | {
250 | return $this->useIncludePath;
251 | }
252 |
253 | /**
254 | * Turns off searching the prefix and fallback directories for classes
255 | * that have not been registered with the class map.
256 | *
257 | * @param bool $classMapAuthoritative
258 | */
259 | public function setClassMapAuthoritative($classMapAuthoritative)
260 | {
261 | $this->classMapAuthoritative = $classMapAuthoritative;
262 | }
263 |
264 | /**
265 | * Should class lookup fail if not found in the current class map?
266 | *
267 | * @return bool
268 | */
269 | public function isClassMapAuthoritative()
270 | {
271 | return $this->classMapAuthoritative;
272 | }
273 |
274 | /**
275 | * Registers this instance as an autoloader.
276 | *
277 | * @param bool $prepend Whether to prepend the autoloader or not
278 | */
279 | public function register($prepend = false)
280 | {
281 | spl_autoload_register(array($this, 'loadClass'), true, $prepend);
282 | }
283 |
284 | /**
285 | * Unregisters this instance as an autoloader.
286 | */
287 | public function unregister()
288 | {
289 | spl_autoload_unregister(array($this, 'loadClass'));
290 | }
291 |
292 | /**
293 | * Loads the given class or interface.
294 | *
295 | * @param string $class The name of the class
296 | * @return bool|null True if loaded, null otherwise
297 | */
298 | public function loadClass($class)
299 | {
300 | if ($file = $this->findFile($class)) {
301 | includeFile($file);
302 |
303 | return true;
304 | }
305 | }
306 |
307 | /**
308 | * Finds the path to the file where the class is defined.
309 | *
310 | * @param string $class The name of the class
311 | *
312 | * @return string|false The path if found, false otherwise
313 | */
314 | public function findFile($class)
315 | {
316 | // work around for PHP 5.3.0 - 5.3.2 https://bugs.php.net/50731
317 | if ('\\' == $class[0]) {
318 | $class = substr($class, 1);
319 | }
320 |
321 | // class map lookup
322 | if (isset($this->classMap[$class])) {
323 | return $this->classMap[$class];
324 | }
325 | if ($this->classMapAuthoritative) {
326 | return false;
327 | }
328 |
329 | $file = $this->findFileWithExtension($class, '.php');
330 |
331 | // Search for Hack files if we are running on HHVM
332 | if ($file === null && defined('HHVM_VERSION')) {
333 | $file = $this->findFileWithExtension($class, '.hh');
334 | }
335 |
336 | if ($file === null) {
337 | // Remember that this class does not exist.
338 | return $this->classMap[$class] = false;
339 | }
340 |
341 | return $file;
342 | }
343 |
344 | private function findFileWithExtension($class, $ext)
345 | {
346 | // PSR-4 lookup
347 | $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
348 |
349 | $first = $class[0];
350 | if (isset($this->prefixLengthsPsr4[$first])) {
351 | foreach ($this->prefixLengthsPsr4[$first] as $prefix => $length) {
352 | if (0 === strpos($class, $prefix)) {
353 | foreach ($this->prefixDirsPsr4[$prefix] as $dir) {
354 | if (file_exists($file = $dir . DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $length))) {
355 | return $file;
356 | }
357 | }
358 | }
359 | }
360 | }
361 |
362 | // PSR-4 fallback dirs
363 | foreach ($this->fallbackDirsPsr4 as $dir) {
364 | if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
365 | return $file;
366 | }
367 | }
368 |
369 | // PSR-0 lookup
370 | if (false !== $pos = strrpos($class, '\\')) {
371 | // namespaced class name
372 | $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
373 | . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
374 | } else {
375 | // PEAR-like class name
376 | $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
377 | }
378 |
379 | if (isset($this->prefixesPsr0[$first])) {
380 | foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
381 | if (0 === strpos($class, $prefix)) {
382 | foreach ($dirs as $dir) {
383 | if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
384 | return $file;
385 | }
386 | }
387 | }
388 | }
389 | }
390 |
391 | // PSR-0 fallback dirs
392 | foreach ($this->fallbackDirsPsr0 as $dir) {
393 | if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
394 | return $file;
395 | }
396 | }
397 |
398 | // PSR-0 include paths.
399 | if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
400 | return $file;
401 | }
402 | }
403 | }
404 |
405 | /**
406 | * Scope isolated include.
407 | *
408 | * Prevents access to $this/self from included files.
409 | */
410 | function includeFile($file)
411 | {
412 | include $file;
413 | }
414 |
--------------------------------------------------------------------------------
/vendor/composer/LICENSE:
--------------------------------------------------------------------------------
1 | Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
2 | Upstream-Name: Composer
3 | Upstream-Contact: Jordi Boggiano
4 | Source: https://github.com/composer/composer
5 |
6 | Files: *
7 | Copyright: 2016, Nils Adermann
8 | 2016, Jordi Boggiano
9 | License: Expat
10 |
11 | Files: res/cacert.pem
12 | Copyright: 2015, Mozilla Foundation
13 | License: MPL-2.0
14 |
15 | Files: src/Composer/Util/RemoteFilesystem.php
16 | src/Composer/Util/TlsHelper.php
17 | Copyright: 2016, Nils Adermann
18 | 2016, Jordi Boggiano
19 | 2013, Evan Coury
20 | License: Expat and BSD-2-Clause
21 |
22 | License: BSD-2-Clause
23 | Redistribution and use in source and binary forms, with or without modification,
24 | are permitted provided that the following conditions are met:
25 | .
26 | * Redistributions of source code must retain the above copyright notice,
27 | this list of conditions and the following disclaimer.
28 | .
29 | * Redistributions in binary form must reproduce the above copyright notice,
30 | this list of conditions and the following disclaimer in the documentation
31 | and/or other materials provided with the distribution.
32 | .
33 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
34 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
35 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
36 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
37 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
39 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
40 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
41 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
42 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 |
44 | License: Expat
45 | Permission is hereby granted, free of charge, to any person obtaining a copy
46 | of this software and associated documentation files (the "Software"), to deal
47 | in the Software without restriction, including without limitation the rights
48 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
49 | copies of the Software, and to permit persons to whom the Software is furnished
50 | to do so, subject to the following conditions:
51 | .
52 | The above copyright notice and this permission notice shall be included in all
53 | copies or substantial portions of the Software.
54 | .
55 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
56 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
57 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
58 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
59 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
60 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
61 | THE SOFTWARE.
62 |
63 | License: MPL-2.0
64 | 1. Definitions
65 | --------------
66 | .
67 | 1.1. "Contributor"
68 | means each individual or legal entity that creates, contributes to
69 | the creation of, or owns Covered Software.
70 | .
71 | 1.2. "Contributor Version"
72 | means the combination of the Contributions of others (if any) used
73 | by a Contributor and that particular Contributor's Contribution.
74 | .
75 | 1.3. "Contribution"
76 | means Covered Software of a particular Contributor.
77 | .
78 | 1.4. "Covered Software"
79 | means Source Code Form to which the initial Contributor has attached
80 | the notice in Exhibit A, the Executable Form of such Source Code
81 | Form, and Modifications of such Source Code Form, in each case
82 | including portions thereof.
83 | .
84 | 1.5. "Incompatible With Secondary Licenses"
85 | means
86 | .
87 | (a) that the initial Contributor has attached the notice described
88 | in Exhibit B to the Covered Software; or
89 | .
90 | (b) that the Covered Software was made available under the terms of
91 | version 1.1 or earlier of the License, but not also under the
92 | terms of a Secondary License.
93 | .
94 | 1.6. "Executable Form"
95 | means any form of the work other than Source Code Form.
96 | .
97 | 1.7. "Larger Work"
98 | means a work that combines Covered Software with other material, in
99 | a separate file or files, that is not Covered Software.
100 | .
101 | 1.8. "License"
102 | means this document.
103 | .
104 | 1.9. "Licensable"
105 | means having the right to grant, to the maximum extent possible,
106 | whether at the time of the initial grant or subsequently, any and
107 | all of the rights conveyed by this License.
108 | .
109 | 1.10. "Modifications"
110 | means any of the following:
111 | .
112 | (a) any file in Source Code Form that results from an addition to,
113 | deletion from, or modification of the contents of Covered
114 | Software; or
115 | .
116 | (b) any new file in Source Code Form that contains any Covered
117 | Software.
118 | .
119 | 1.11. "Patent Claims" of a Contributor
120 | means any patent claim(s), including without limitation, method,
121 | process, and apparatus claims, in any patent Licensable by such
122 | Contributor that would be infringed, but for the grant of the
123 | License, by the making, using, selling, offering for sale, having
124 | made, import, or transfer of either its Contributions or its
125 | Contributor Version.
126 | .
127 | 1.12. "Secondary License"
128 | means either the GNU General Public License, Version 2.0, the GNU
129 | Lesser General Public License, Version 2.1, the GNU Affero General
130 | Public License, Version 3.0, or any later versions of those
131 | licenses.
132 | .
133 | 1.13. "Source Code Form"
134 | means the form of the work preferred for making modifications.
135 | .
136 | 1.14. "You" (or "Your")
137 | means an individual or a legal entity exercising rights under this
138 | License. For legal entities, "You" includes any entity that
139 | controls, is controlled by, or is under common control with You. For
140 | purposes of this definition, "control" means (a) the power, direct
141 | or indirect, to cause the direction or management of such entity,
142 | whether by contract or otherwise, or (b) ownership of more than
143 | fifty percent (50%) of the outstanding shares or beneficial
144 | ownership of such entity.
145 | .
146 | 2. License Grants and Conditions
147 | --------------------------------
148 | .
149 | 2.1. Grants
150 | .
151 | Each Contributor hereby grants You a world-wide, royalty-free,
152 | non-exclusive license:
153 | .
154 | (a) under intellectual property rights (other than patent or trademark)
155 | Licensable by such Contributor to use, reproduce, make available,
156 | modify, display, perform, distribute, and otherwise exploit its
157 | Contributions, either on an unmodified basis, with Modifications, or
158 | as part of a Larger Work; and
159 | .
160 | (b) under Patent Claims of such Contributor to make, use, sell, offer
161 | for sale, have made, import, and otherwise transfer either its
162 | Contributions or its Contributor Version.
163 | .
164 | 2.2. Effective Date
165 | .
166 | The licenses granted in Section 2.1 with respect to any Contribution
167 | become effective for each Contribution on the date the Contributor first
168 | distributes such Contribution.
169 | .
170 | 2.3. Limitations on Grant Scope
171 | .
172 | The licenses granted in this Section 2 are the only rights granted under
173 | this License. No additional rights or licenses will be implied from the
174 | distribution or licensing of Covered Software under this License.
175 | Notwithstanding Section 2.1(b) above, no patent license is granted by a
176 | Contributor:
177 | .
178 | (a) for any code that a Contributor has removed from Covered Software;
179 | or
180 | .
181 | (b) for infringements caused by: (i) Your and any other third party's
182 | modifications of Covered Software, or (ii) the combination of its
183 | Contributions with other software (except as part of its Contributor
184 | Version); or
185 | .
186 | (c) under Patent Claims infringed by Covered Software in the absence of
187 | its Contributions.
188 | .
189 | This License does not grant any rights in the trademarks, service marks,
190 | or logos of any Contributor (except as may be necessary to comply with
191 | the notice requirements in Section 3.4).
192 | .
193 | 2.4. Subsequent Licenses
194 | .
195 | No Contributor makes additional grants as a result of Your choice to
196 | distribute the Covered Software under a subsequent version of this
197 | License (see Section 10.2) or under the terms of a Secondary License (if
198 | permitted under the terms of Section 3.3).
199 | .
200 | 2.5. Representation
201 | .
202 | Each Contributor represents that the Contributor believes its
203 | Contributions are its original creation(s) or it has sufficient rights
204 | to grant the rights to its Contributions conveyed by this License.
205 | .
206 | 2.6. Fair Use
207 | .
208 | This License is not intended to limit any rights You have under
209 | applicable copyright doctrines of fair use, fair dealing, or other
210 | equivalents.
211 | .
212 | 2.7. Conditions
213 | .
214 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
215 | in Section 2.1.
216 | .
217 | 3. Responsibilities
218 | -------------------
219 | .
220 | 3.1. Distribution of Source Form
221 | .
222 | All distribution of Covered Software in Source Code Form, including any
223 | Modifications that You create or to which You contribute, must be under
224 | the terms of this License. You must inform recipients that the Source
225 | Code Form of the Covered Software is governed by the terms of this
226 | License, and how they can obtain a copy of this License. You may not
227 | attempt to alter or restrict the recipients' rights in the Source Code
228 | Form.
229 | .
230 | 3.2. Distribution of Executable Form
231 | .
232 | If You distribute Covered Software in Executable Form then:
233 | .
234 | (a) such Covered Software must also be made available in Source Code
235 | Form, as described in Section 3.1, and You must inform recipients of
236 | the Executable Form how they can obtain a copy of such Source Code
237 | Form by reasonable means in a timely manner, at a charge no more
238 | than the cost of distribution to the recipient; and
239 | .
240 | (b) You may distribute such Executable Form under the terms of this
241 | License, or sublicense it under different terms, provided that the
242 | license for the Executable Form does not attempt to limit or alter
243 | the recipients' rights in the Source Code Form under this License.
244 | .
245 | 3.3. Distribution of a Larger Work
246 | .
247 | You may create and distribute a Larger Work under terms of Your choice,
248 | provided that You also comply with the requirements of this License for
249 | the Covered Software. If the Larger Work is a combination of Covered
250 | Software with a work governed by one or more Secondary Licenses, and the
251 | Covered Software is not Incompatible With Secondary Licenses, this
252 | License permits You to additionally distribute such Covered Software
253 | under the terms of such Secondary License(s), so that the recipient of
254 | the Larger Work may, at their option, further distribute the Covered
255 | Software under the terms of either this License or such Secondary
256 | License(s).
257 | .
258 | 3.4. Notices
259 | .
260 | You may not remove or alter the substance of any license notices
261 | (including copyright notices, patent notices, disclaimers of warranty,
262 | or limitations of liability) contained within the Source Code Form of
263 | the Covered Software, except that You may alter any license notices to
264 | the extent required to remedy known factual inaccuracies.
265 | .
266 | 3.5. Application of Additional Terms
267 | .
268 | You may choose to offer, and to charge a fee for, warranty, support,
269 | indemnity or liability obligations to one or more recipients of Covered
270 | Software. However, You may do so only on Your own behalf, and not on
271 | behalf of any Contributor. You must make it absolutely clear that any
272 | such warranty, support, indemnity, or liability obligation is offered by
273 | You alone, and You hereby agree to indemnify every Contributor for any
274 | liability incurred by such Contributor as a result of warranty, support,
275 | indemnity or liability terms You offer. You may include additional
276 | disclaimers of warranty and limitations of liability specific to any
277 | jurisdiction.
278 | .
279 | 4. Inability to Comply Due to Statute or Regulation
280 | ---------------------------------------------------
281 | .
282 | If it is impossible for You to comply with any of the terms of this
283 | License with respect to some or all of the Covered Software due to
284 | statute, judicial order, or regulation then You must: (a) comply with
285 | the terms of this License to the maximum extent possible; and (b)
286 | describe the limitations and the code they affect. Such description must
287 | be placed in a text file included with all distributions of the Covered
288 | Software under this License. Except to the extent prohibited by statute
289 | or regulation, such description must be sufficiently detailed for a
290 | recipient of ordinary skill to be able to understand it.
291 | .
292 | 5. Termination
293 | --------------
294 | .
295 | 5.1. The rights granted under this License will terminate automatically
296 | if You fail to comply with any of its terms. However, if You become
297 | compliant, then the rights granted under this License from a particular
298 | Contributor are reinstated (a) provisionally, unless and until such
299 | Contributor explicitly and finally terminates Your grants, and (b) on an
300 | ongoing basis, if such Contributor fails to notify You of the
301 | non-compliance by some reasonable means prior to 60 days after You have
302 | come back into compliance. Moreover, Your grants from a particular
303 | Contributor are reinstated on an ongoing basis if such Contributor
304 | notifies You of the non-compliance by some reasonable means, this is the
305 | first time You have received notice of non-compliance with this License
306 | from such Contributor, and You become compliant prior to 30 days after
307 | Your receipt of the notice.
308 | .
309 | 5.2. If You initiate litigation against any entity by asserting a patent
310 | infringement claim (excluding declaratory judgment actions,
311 | counter-claims, and cross-claims) alleging that a Contributor Version
312 | directly or indirectly infringes any patent, then the rights granted to
313 | You by any and all Contributors for the Covered Software under Section
314 | 2.1 of this License shall terminate.
315 | .
316 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
317 | end user license agreements (excluding distributors and resellers) which
318 | have been validly granted by You or Your distributors under this License
319 | prior to termination shall survive termination.
320 | .
321 | ************************************************************************
322 | * *
323 | * 6. Disclaimer of Warranty *
324 | * ------------------------- *
325 | * *
326 | * Covered Software is provided under this License on an "as is" *
327 | * basis, without warranty of any kind, either expressed, implied, or *
328 | * statutory, including, without limitation, warranties that the *
329 | * Covered Software is free of defects, merchantable, fit for a *
330 | * particular purpose or non-infringing. The entire risk as to the *
331 | * quality and performance of the Covered Software is with You. *
332 | * Should any Covered Software prove defective in any respect, You *
333 | * (not any Contributor) assume the cost of any necessary servicing, *
334 | * repair, or correction. This disclaimer of warranty constitutes an *
335 | * essential part of this License. No use of any Covered Software is *
336 | * authorized under this License except under this disclaimer. *
337 | * *
338 | ************************************************************************
339 | .
340 | ************************************************************************
341 | * *
342 | * 7. Limitation of Liability *
343 | * -------------------------- *
344 | * *
345 | * Under no circumstances and under no legal theory, whether tort *
346 | * (including negligence), contract, or otherwise, shall any *
347 | * Contributor, or anyone who distributes Covered Software as *
348 | * permitted above, be liable to You for any direct, indirect, *
349 | * special, incidental, or consequential damages of any character *
350 | * including, without limitation, damages for lost profits, loss of *
351 | * goodwill, work stoppage, computer failure or malfunction, or any *
352 | * and all other commercial damages or losses, even if such party *
353 | * shall have been informed of the possibility of such damages. This *
354 | * limitation of liability shall not apply to liability for death or *
355 | * personal injury resulting from such party's negligence to the *
356 | * extent applicable law prohibits such limitation. Some *
357 | * jurisdictions do not allow the exclusion or limitation of *
358 | * incidental or consequential damages, so this exclusion and *
359 | * limitation may not apply to You. *
360 | * *
361 | ************************************************************************
362 | .
363 | 8. Litigation
364 | -------------
365 | .
366 | Any litigation relating to this License may be brought only in the
367 | courts of a jurisdiction where the defendant maintains its principal
368 | place of business and such litigation shall be governed by laws of that
369 | jurisdiction, without reference to its conflict-of-law provisions.
370 | Nothing in this Section shall prevent a party's ability to bring
371 | cross-claims or counter-claims.
372 | .
373 | 9. Miscellaneous
374 | ----------------
375 | .
376 | This License represents the complete agreement concerning the subject
377 | matter hereof. If any provision of this License is held to be
378 | unenforceable, such provision shall be reformed only to the extent
379 | necessary to make it enforceable. Any law or regulation which provides
380 | that the language of a contract shall be construed against the drafter
381 | shall not be used to construe this License against a Contributor.
382 | .
383 | 10. Versions of the License
384 | ---------------------------
385 | .
386 | 10.1. New Versions
387 | .
388 | Mozilla Foundation is the license steward. Except as provided in Section
389 | 10.3, no one other than the license steward has the right to modify or
390 | publish new versions of this License. Each version will be given a
391 | distinguishing version number.
392 | .
393 | 10.2. Effect of New Versions
394 | .
395 | You may distribute the Covered Software under the terms of the version
396 | of the License under which You originally received the Covered Software,
397 | or under the terms of any subsequent version published by the license
398 | steward.
399 | .
400 | 10.3. Modified Versions
401 | .
402 | If you create software not governed by this License, and you want to
403 | create a new license for such software, you may create and use a
404 | modified version of this License if you rename the license and remove
405 | any references to the name of the license steward (except to note that
406 | such modified license differs from this License).
407 | .
408 | 10.4. Distributing Source Code Form that is Incompatible With Secondary
409 | Licenses
410 | .
411 | If You choose to distribute Source Code Form that is Incompatible With
412 | Secondary Licenses under the terms of this version of the License, the
413 | notice described in Exhibit B of this License must be attached.
414 | .
415 | Exhibit A - Source Code Form License Notice
416 | -------------------------------------------
417 | .
418 | This Source Code Form is subject to the terms of the Mozilla Public
419 | License, v. 2.0. If a copy of the MPL was not distributed with this
420 | file, You can obtain one at http://mozilla.org/MPL/2.0/.
421 | .
422 | If it is not possible or desirable to put the notice in a particular
423 | file, then You may include the notice in a location (such as a LICENSE
424 | file in a relevant directory) where a recipient would be likely to look
425 | for such a notice.
426 | .
427 | You may add additional accurate notices of copyright ownership.
428 | .
429 | Exhibit B - "Incompatible With Secondary Licenses" Notice
430 | ---------------------------------------------------------
431 | .
432 | This Source Code Form is "Incompatible With Secondary Licenses", as
433 | defined by the Mozilla Public License, v. 2.0.
434 |
--------------------------------------------------------------------------------
/vendor/composer/autoload_classmap.php:
--------------------------------------------------------------------------------
1 | $path) {
28 | $loader->set($namespace, $path);
29 | }
30 |
31 | $map = require __DIR__ . '/autoload_psr4.php';
32 | foreach ($map as $namespace => $path) {
33 | $loader->setPsr4($namespace, $path);
34 | }
35 |
36 | $classMap = require __DIR__ . '/autoload_classmap.php';
37 | if ($classMap) {
38 | $loader->addClassMap($classMap);
39 | }
40 |
41 | $loader->register(true);
42 |
43 | return $loader;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/vendor/composer/installed.json:
--------------------------------------------------------------------------------
1 | []
2 |
--------------------------------------------------------------------------------