levelmeup will run through a series of Node.js databases workshops. Starting with the basic operations of [LevelUP](https://github.com/Level/levelup) and moving on to more advanced exercises.
15 |
16 | ### Contributors
17 |
18 | levelmeup is proudly brought to you by the following Node.js database hackers:
19 |
20 | *<Your name here>*
21 |
22 | | Rod Vagg | GitHub/rvagg | Twitter/@rvagg |
|---|---|---|
| Eugene Ware | GitHub/eugeneware | Twitter/@eugeneware |
| James Halliday | GitHub/substack | Twitter/@substack |
| Jake Verbaten | GitHub/raynos | Twitter/@raynos |
| Julian Gruber | GitHub/juliangruber | Twitter/@juliangruber |
| Robert Kowalski | GitHub/robertkowalski | Twitter/@robinson_k |
| Lars-Magnus Skog | GitHub/ralphtheninja |
313 |
338 |
339 |
350 |
363 |
364 |
365 |
366 |
370 |
371 |
372 |
--------------------------------------------------------------------------------
/docs/leveldown.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Level
314 |
Fast & simple storage - a Node.js-style LevelDB wrapper**
316 |
This is a convenience package that bundles the current release of LevelUP and LevelDOWN and exposes LevelUP on its export.
318 |Use this package to avoid having to explicitly install LevelDOWN when you just want plain old LevelDB from LevelUP.
319 |var level = require('level')
320 |
321 | // 1) Create our database, supply location and options.
322 | // This will create or open the underlying LevelDB store.
323 | var db = level('./mydb')
324 |
325 | // 2) put a key & value
326 | db.put('name', 'Level', function (err) {
327 | if (err) return console.log('Ooops!', err) // some kind of I/O error
328 |
329 | // 3) fetch by key
330 | db.get('name', function (err, value) {
331 | if (err) return console.log('Ooops!', err) // likely the key was not found
332 |
333 | // ta da!
334 | console.log('name=' + value)
335 | })
336 | })
337 | See LevelUP and LevelDOWN for more details.
340 | 341 |Contributing
342 |Level is an OPEN Open Source Project. This means that:
343 |344 |346 |Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.
345 |
See the CONTRIBUTING.md file for more details.
347 |Contributors
348 |Level, including LevelUP & LevelDOWN, is only possible due to the excellent work of the following contributors:
349 || Rod Vagg | GitHub/rvagg | Twitter/@rvagg |
|---|---|---|
| John Chesley | GitHub/chesles | Twitter/@chesles |
| Jake Verbaten | GitHub/raynos | Twitter/@raynos2 |
| Dominic Tarr | GitHub/dominictarr | Twitter/@dominictarr |
| Max Ogden | GitHub/maxogden | Twitter/@maxogden |
| Lars-Magnus Skog | GitHub/ralphtheninja | Twitter/@ralphtheninja |
| David Björklund | GitHub/kesla | Twitter/@david_bjorklund |
| Julian Gruber | GitHub/juliangruber | Twitter/@juliangruber |
| Paolo Fragomeni | GitHub/hij1nx | Twitter/@hij1nx |
| Anton Whalley | GitHub/No9 | Twitter/@antonwhalley |
| Matteo Collina | GitHub/mcollina | Twitter/@matteocollina |
| Pedro Teixeira | GitHub/pgte | Twitter/@pgte |
Licence & copyright
367 |Copyright (c) 2012-2013 Level contributors (listed above).
368 |Level is licensed under an MIT +no-false-attribs license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.
369 |
313 |
352 | 353 |
356 | 357 |
361 |
389 | 390 |
393 | 394 |
398 |
401 | 402 |
406 |
415 | 416 |
420 |
423 | 424 |
427 |
430 | 431 |
436 | 437 |
449 | 450 |
453 |
475 | 476 |
491 | 492 |
495 | 496 |
531 |
544 |
545 |
553 |
554 |
555 |
--------------------------------------------------------------------------------
/docs/sublevel.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | LevelDOWN
314 |
A Low-level Node.js LevelDB binding
316 |
LevelDOWN was extracted from LevelUP and now serves as a stand-alone binding for LevelDB.
319 |It is strongly recommended that you use LevelUP in preference to LevelDOWN unless you have measurable performance reasons to do so. LevelUP is optimised for usability and safety. Although we are working to improve the safety of the LevelDOWN interface it is still easy to crash your Node process if you don't do things in just the right way.
320 |See the section on safety below for details of known unsafe operations with LevelDOWN.
321 | 322 |Tested & supported platforms
323 |-
324 |
- Linux (including ARM platforms such as Raspberry Pi and Kindle!) 325 |
- Mac OS 326 |
- Solaris (SmartOS & Nodejitsu) 327 |
- Windows 331 | 332 |
API
335 |-
336 |
leveldown()
337 | leveldown#open()
338 | leveldown#close()
339 | leveldown#put()
340 | leveldown#get()
341 | leveldown#del()
342 | leveldown#batch()
343 | leveldown#approximateSize()
344 | leveldown#getProperty()
345 | leveldown#iterator()
346 | iterator#next()
347 | iterator#end()
348 | leveldown.destroy()
349 | leveldown.repair()
350 |
352 | 353 |
leveldown(location)
354 |leveldown() returns a new LevelDOWN instance. location is a String pointing to the LevelDB location to be opened.
356 | 357 |
leveldown#open([options, ]callback)
358 |open() is an instance method on an existing database object.
The callback function will be called with no arguments when the database has been successfully opened, or with a single error argument if the open operation failed for any reason.
options
361 | The optional options argument may contain:
-
363 |
364 |'createIfMissing'(boolean, default:true): Iftrue, will initialise an empty database at the specified location if one doesn't already exist. Iffalseand a database doesn't exist you will receive an error in youropen()callback and your database won't open.
365 |
366 |'errorIfExists'(boolean, default:false): Iftrue, you will receive an error in youropen()callback if the database exists at the specified location.
367 |
368 |'compression'(boolean, default:true): Iftrue, all compressible data will be run through the Snappy compression algorithm before being stored. Snappy is very fast and shouldn't gain much speed by disabling so leave this on unless you have good reason to turn it off.
369 |
370 |'cacheSize'(number, default: `8 1024 1024` = 8MB): The size (in bytes) of the in-memory LRU cache with frequently used uncompressed block contents.
371 |
Advanced options
373 |The following options are for advanced performance tuning. Modify them only if you can prove actual benefit for your particular application.
374 |-
375 |
'writeBufferSize'(number, default: `4 1024 1024` = 4MB): The maximum size (in bytes) of the log (in memory and stored in the .log file on disk). Beyond this size, LevelDB will convert the log data to the first level of sorted table files. From the LevelDB documentation:
376 |
378 |380 |Larger values increase performance, especially during bulk loads. Up to two write buffers may be held in memory at the same time, so you may wish to adjust this parameter to control memory usage. Also, a larger write buffer will result in a longer recovery time the next time the database is opened.
379 |
-
381 |
382 |'blockSize'(number, default4096= 4K): The approximate size of the blocks that make up the table files. The size related to uncompressed data (hence "approximate"). Blocks are indexed in the table file and entry-lookups involve reading an entire block and parsing to discover the required entry.
383 |
384 |'maxOpenFiles'(number, default:1000): The maximum number of files that LevelDB is allowed to have open at a time. If your data store is likely to have a large working set, you may increase this value to prevent file descriptor churn. To calculate the number of files required for your working set, divide your total data by 2MB, as each table file is a maximum of 2MB.
385 |
386 |'blockRestartInterval'(number, default:16): The number of entries before restarting the "delta encoding" of keys within blocks. Each "restart" point stores the full key for the entry, between restarts, the common prefix of the keys for those entries is omitted. Restarts are similar to the concept of keyframs in video encoding and are used to minimise the amount of space required to store keys. This is particularly helpful when using deep namespacing / prefixing in your keys.
387 |
389 | 390 |
leveldown#close(callback)
391 |close() is an instance method on an existing database object. The underlying LevelDB database will be closed and the callback function will be called with no arguments if the operation is successful or with a single error argument if the operation failed for any reason.
393 | 394 |
leveldown#put(key, value[, options], callback)
395 |put() is an instance method on an existing database object, used to store new entries, or overwrite existing entries in the LevelDB store.
The key and value objects may either be Strings or Node.js Buffer objects and cannot be undefined or null. Other object types are converted to JavaScript Strings with the toString() method and the resulting String may not be a zero-length. A richer set of data-types are catered for in LevelUP.
options
398 | The only property currently available on the options object is 'sync' (boolean, default: false). If you provide a 'sync' value of true in your options object, LevelDB will perform a synchronous write of the data; although the operation will be asynchronous as far as Node is concerned. Normally, LevelDB passes the data to the operating system for writing and returns immediately, however a synchronous write will use fsync() or equivalent so your callback won't be triggered until the data is actually on disk. Synchronous filesystem writes are significantly slower than asynchronous writes but if you want to be absolutely sure that the data is flushed then you can use 'sync': true.
The callback function will be called with no arguments if the operation is successful or with a single error argument if the operation failed for any reason.
401 | 402 |
leveldown#get(key[, options], callback)
403 |get() is an instance method on an existing database object, used to fetch individual entries from the LevelDB store.
The key object may either be a String or a Node.js Buffer object and cannot be undefined or null. Other object types are converted to JavaScript Strings with the toString() method and the resulting String may not be a zero-length. A richer set of data-types are catered for in LevelUP.
options
406 | The optional options object may contain:
-
408 |
409 |'fillCache'(boolean, default:true): LevelDB will by default fill the in-memory LRU Cache with data from a call to get. Disabling this is done by settingfillCachetofalse.
410 |
411 |'asBuffer'(boolean, default:true): Used to determine whether to return thevalueof the entry as aStringor a Node.jsBufferobject. Note that converting from aBufferto aStringincurs a cost so if you need aString(and thevaluecan legitimately become a UFT8 string) then you should fetch it as one withasBuffer: trueand you'll avoid this conversion cost.
412 |
The callback function will be called with a single error if the operation failed for any reason. If successful the first argument will be null and the second argument will be the value as a String or Buffer depending on the asBuffer option.
415 | 416 |
leveldown#del(key[, options], callback)
417 |del() is an instance method on an existing database object, used to delete entries from the LevelDB store.
The key object may either be a String or a Node.js Buffer object and cannot be undefined or null. Other object types are converted to JavaScript Strings with the toString() method and the resulting String may not be a zero-length. A richer set of data-types are catered for in LevelUP.
options
420 | The only property currently available on the options object is 'sync' (boolean, default: false). See leveldown#put() for details about this option.
The callback function will be called with no arguments if the operation is successful or with a single error argument if the operation failed for any reason.
423 | 424 |
leveldown#batch(operations[, options], callback)
425 |batch() is an instance method on an existing database object. Used for very fast bulk-write operations (both put and delete). The operations argument should be an Array containing a list of operations to be executed sequentially, although as a whole they are performed as an atomic operation inside LevelDB. Each operation is contained in an object having the following properties: type, key, value, where the type is either 'put' or 'del'. In the case of 'del' the 'value' property is ignored. Any entries with a 'key' of null or undefined will cause an error to be returned on the callback and any 'type': 'put' entry with a 'value' of null or undefined will return an error. See LevelUP for full documentation on how this works in practice.
options
427 | The only property currently available on the options object is 'sync' (boolean, default: false). See leveldown#put() for details about this option.
The callback function will be called with no arguments if the operation is successful or with a single error argument if the operation failed for any reason.
430 | 431 |
leveldown#approximateSize(start, end, callback)
432 |approximateSize() is an instance method on an existing database object. Used to get the approximate number of bytes of file system space used by the range [start..end). The result may not include recently written data.
The start and end parameters may be either String or Node.js Buffer objects representing keys in the LevelDB store.
The callback function will be called with no arguments if the operation is successful or with a single error argument if the operation failed for any reason.
436 | 437 |
leveldown#getProperty(property)
438 |getProperty can be used to get internal details from LevelDB. When issued with a valid property string, a readable string will be returned (this method is synchronous).
Currently, the only valid properties are:
440 |-
441 |
442 |'leveldb.num-files-at-levelN': return the number of files at level N, where N is an integer representing a valid level (e.g. "0").
443 |
444 |'leveldb.stats': returns a multi-line string describing statistics about LevelDB's internal operation.
445 |
446 |'leveldb.sstables': returns a multi-line string describing all of the sstables that make up contents of the current database.
447 |
449 | 450 |
leveldown#iterator([options])
451 |iterator() is an instance method on an existing database object. It returns a new Iterator instance.
options
453 | The optional options object may contain:
-
455 |
456 |'start': the key you wish to start the read at. By default it will start at the beginning of the store. Note that the start doesn't have to be an actual key that exists, LevelDB will simply find the next key, greater than the key you provide.
457 |
458 |'end': the key you wish to end the read on. By default it will continue until the end of the store. Again, the end doesn't have to be an actual key as an (inclusive)<=-type operation is performed to detect the end. You can also use thedestroy()method instead of supplying an'end'parameter to achieve the same effect.
459 |
460 |'reverse'(boolean, default:false): a boolean, set to true if you want the stream to go in reverse order. Beware that due to the way LevelDB works, a reverse seek will be slower than a forward seek.
461 |
462 |'keys'(boolean, default:true): whether the callback to thenext()method should receive a non-nullkey. There is a small efficiency gain if you ultimately don't care what the keys are as they don't need to be converted and copied into JavaScript.
463 |
464 |'values'(boolean, default:true): whether the callback to thenext()method should receive a non-nullvalue. There is a small efficiency gain if you ultimately don't care what the values are as they don't need to be converted and copied into JavaScript.
465 |
466 |'limit'(number, default:-1): limit the number of results collected by this iterator. This number represents a maximum number of results and may not be reached if you get to the end of the store or your'end'value first. A value of-1means there is no limit.
467 |
468 |'fillCache'(boolean, default:false): wheather LevelDB's LRU-cache should be filled with data read.
469 |
470 |'keyAsBuffer'(boolean, default:true): Used to determine whether to return thekeyof each entry as aStringor a Node.jsBufferobject. Note that converting from aBufferto aStringincurs a cost so if you need aString(and thevaluecan legitimately become a UFT8 string) then you should fetch it as one.
471 |
472 |'valueAsBuffer'(boolean, default:true): Used to determine whether to return thevalueof each entry as aStringor a Node.jsBufferobject.
473 |
475 | 476 |
iterator#next(callback)
477 |next() is an instance method on an existing iterator object, used to increment the underlying LevelDB iterator and return the entry at that location.
the callback function will be called with no arguments in any of the following situations:
-
480 |
- the iterator comes to the end of the store 481 |
- the
endkey has been reached; or
482 | - the
limithas been reached
483 |
Otherwise, the callback function will be called with the following 3 arguments:
-
486 |
error- any error that occurs while incrementing the iterator.
487 | key- either aStringor a Node.jsBufferobject depending on thekeyAsBufferargument when theiterator()was called.
488 | value- either aStringor a Node.jsBufferobject depending on thevalueAsBufferargument when theiterator()was called.
489 |
491 | 492 |
iterator#end(callback)
493 |end() is an instance method on an existing iterator object. The underlying LevelDB iterator will be deleted and the callback function will be called with no arguments if the operation is successful or with a single error argument if the operation failed for any reason.
495 | 496 |
leveldown.destroy(location, callback)
497 |destroy() is used to completely remove an existing LevelDB database directory. You can use this function in place of a full directory rm if you want to be sure to only remove LevelDB-related files. If the directory only contains LevelDB files, the directory itself will be removed as well. If there are additional, non-LevelDB files in the directory, those files, and the directory, will be left alone.
The callback will be called when the destroy operation is complete, with a possible error argument.
leveldown.repair(location, callback)
501 |repair() can be used to attempt a restoration of a damaged LevelDB store. From the LevelDB documentation:
503 |505 |If a DB cannot be opened, you may attempt to call this method to resurrect as much of the contents of the database as possible. Some data may be lost, so be careful when calling this function on a database that contains important information.
504 |
You will find information on the repair operation in the LOG file inside the store directory.
506 |A repair() can also be used to perform a compaction of the LevelDB log into table files.
The callback will be called when the repair operation is complete, with a possible error argument.
Safety
510 |Database state
511 |Currently LevelDOWN does not track the state of the underlying LevelDB instance. This means that calling open() on an already open database may result in an error. Likewise, calling any other operation on a non-open database may result in an error.
LevelUP currently tracks and manages state and will prevent out-of-state operations from being send to LevelDOWN. If you use LevelDOWN directly then you must track and manage state for yourself.
513 | 514 |Getting support
515 |There are multiple ways you can find help in using LevelDB in Node.js:
516 |-
517 |
- IRC: you'll find an active group of LevelUP users in the ##leveldb channel on Freenode, including most of the contributors to this project. 518 |
- Mailing list: there is an active Node.js LevelDB Google Group. 519 |
- GitHub: you're welcome to open an issue here on this GitHub repository if you have a question. 520 |
Contributing
523 |LevelDOWN is an OPEN Open Source Project. This means that:
524 |525 |527 |Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.
526 |
See the CONTRIBUTING.md file for more details.
528 |Contributors
529 |LevelDOWN is only possible due to the excellent work of the following contributors:
530 || Rod Vagg | GitHub/rvagg | Twitter/@rvagg |
|---|---|---|
| John Chesley | GitHub/chesles | Twitter/@chesles |
| Jake Verbaten | GitHub/raynos | Twitter/@raynos2 |
| Dominic Tarr | GitHub/dominictarr | Twitter/@dominictarr |
| Max Ogden | GitHub/maxogden | Twitter/@maxogden |
| Lars-Magnus Skog | GitHub/ralphtheninja | Twitter/@ralphtheninja |
| David Björklund | GitHub/kesla | Twitter/@david_bjorklund |
| Julian Gruber | GitHub/juliangruber | Twitter/@juliangruber |
| Paolo Fragomeni | GitHub/hij1nx | Twitter/@hij1nx |
| Anton Whalley | GitHub/No9 | Twitter/@antonwhalley |
| Matteo Collina | GitHub/mcollina | Twitter/@matteocollina |
| Pedro Teixeira | GitHub/pgte | Twitter/@pgte |
Windows
546 |A large portion of the Windows support comes from code by Krzysztof Kowalczyk @kjk, see his Windows LevelDB port here. If you're using LevelUP on Windows, you should give him your thanks!
547 | 548 |Licence & copyright
549 |Copyright (c) 2012-2013 LevelDOWN contributors (listed above).
550 |LevelDOWN is licensed under an MIT +no-false-attribs license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.
551 |LevelDOWN builds on the excellent work of the LevelDB and Snappy teams from Google and additional contributors. LevelDB and Snappy are both issued under the New BSD Licence.
552 |
313 |
340 |
341 |
372 |
373 |
387 |
388 |
391 |
392 |
393 |
--------------------------------------------------------------------------------
/exercises/all_your_base/exercise.js:
--------------------------------------------------------------------------------
1 | var sample = require('lodash.sample')
2 | var values = [
3 | [ 'BASE', 'US' ],
4 | [ 'LANDS AND POSESSIONS', 'VIKINGS OF WESTERN NORWAY' ],
5 | [ 'INDEPENDENCE', 'KING HENRY VIII' ],
6 | [ 'INTERNET COMMUNICATIONS', 'THE NSA' ],
7 | [ 'TICKS', 'LIBUV' ]
8 | ]
9 |
10 | module.exports = require('../../lib/exercise')({
11 | dir: __dirname,
12 | init: function () {
13 | var value = sample(values)
14 | return {
15 | prepare: function (db, callback) {
16 | setImmediate(callback)
17 | },
18 | exec: function (dir, mod, callback) {
19 | if (typeof mod !== 'function') {
20 | throw String('{error.mod.not_function}')
21 | }
22 | if (mod.length < 3) {
23 | throw String('{error.mod.not_long_enough}')
24 | }
25 | mod(value[0], value[1], callback)
26 | }
27 | }
28 | }
29 | })
30 |
--------------------------------------------------------------------------------
/exercises/all_your_base/problem.en.md:
--------------------------------------------------------------------------------
1 | To get into the rhythm, let's do a simple _hello world_.
2 |
3 | Write a Node module with three arguments:
4 |
5 | ```javascript
6 | module.exports = function (X, Y, callback) {
7 | /* your code here */
8 | callback(error, result)
9 | }
10 | ```
11 |
12 | This module should use **X** and **Y** and call the `callback` with the
13 | following result:
14 |
15 | ALL YOUR {X} ARE BELONG TO {Y}
16 |
17 | Where `X` and `Y` are filled in with the arguments. When you have completed
18 | your program, you can run it in the test environment with:
19 |
20 | {appname} run program.js
21 |
22 | And once you are happy that it is correct then run:
23 |
24 | {appname} verify program.js
25 |
26 | And your submission will be verified for correctness. After you have
27 | a correct solution, run **`{appname}`** again and select the next problem!
28 |
--------------------------------------------------------------------------------
/exercises/all_your_base/problem.ja.md:
--------------------------------------------------------------------------------
1 | 簡単な_hello world_でリズムに乗りましょう。
2 |
3 | ３つの引数を取るNodeモジュールを書きましょう。
4 |
5 | ```javascript
6 | module.exports = function (X, Y, callback) {
7 | /* your code here */
8 | callback(error, result)
9 | }
10 | ```
11 |
12 | **X**と**Y**を使い、Callbackを下記のような結果を使って実行
13 | するようにして下さい。
14 |
15 | ALL YOUR {X} ARE BELONG TO {Y}
16 |
17 | 上記の中で、`X`と`Y`はそれぞれ引数の値で置き換えて下さい。
18 | プログラムが出来たら実行してみましょう。以下のコマンドを使って
19 | テスト環境で実行することができます。
20 |
21 | {appname} run program.js
22 |
23 | もし結果に問題が無ければ、以下を実行しましょう。
24 |
25 | {appname} verify program.js
26 |
27 | 正しいかどうか、検証が行われます。もし正解なら再度**`{appname}`**を
28 | 実行して次の課題に取り組みましょう！
29 |
--------------------------------------------------------------------------------
/exercises/all_your_base/solution.js:
--------------------------------------------------------------------------------
1 | module.exports = function (X, Y, callback) {
2 | callback(null, 'ALL YOUR ' + X + ' ARE BELONG TO ' + Y)
3 | }
4 |
--------------------------------------------------------------------------------
/exercises/basics_batch/exercise.js:
--------------------------------------------------------------------------------
1 | var gibberish = require('../../lib/gibberish')
2 | var generate = require('../../lib/generate')
3 |
4 | module.exports = require('../../lib/exercise')({
5 | dir: __dirname,
6 | init: function () {
7 | var del = generate(5 + (Math.random() * 20 | 0))
8 | var mod = generate(5 + (Math.random() * 20 | 0))
9 | var put = generate(5 + (Math.random() * 20 | 0))
10 | var ops = []
11 | Object.keys(del).forEach(function (key) {
12 | ops.push({
13 | type: 'put',
14 | key: key,
15 | value: del[key]
16 | })
17 | })
18 | Object.keys(mod).forEach(function (key) {
19 | ops.push({
20 | type: 'put',
21 | key: key,
22 | value: gibberish()
23 | })
24 | put[key] = mod[key]
25 | })
26 |
27 | var changes = {
28 | del: Object.keys(del),
29 | put: put
30 | }
31 | return {
32 | prepare: function (db, callback) {
33 | db.batch(ops, callback)
34 | },
35 | exec: function (dir, mod, callback) {
36 | if (typeof mod !== 'function') {
37 | throw String('{error.mod.not_function}')
38 | }
39 | if (mod.length < 3) {
40 | throw String('{error.mod.not_long_enough}')
41 | }
42 | mod(dir, changes, function () {
43 | require('../../lib/read-db')(dir, 'utf8', callback)
44 | })
45 | }
46 | }
47 | }
48 | })
49 |
--------------------------------------------------------------------------------
/exercises/basics_batch/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a program that opens a LevelDB data-store using **`level`** and reads a few keys.
2 |
3 | Your program should be written as Node.js module with 3 arguments.
4 |
5 | ```javascript
6 | module.exports = function (databaseDir, changes, callback) {
7 | // your code...
8 | callback(error, values)
9 | }
10 | ```
11 |
12 | `changes` is an Object that contains a `del` property with an array of keys to
13 | delete. It also contains a `put` property with an object that contains keys
14 | and values to add to the leveldb.
15 |
16 | For example:
17 |
18 | ```
19 | {
20 | del: [ '@darachennis' ],
21 | put: {
22 | '@izs': 'Isaac Z. Schlueter',
23 | '@tmpvar': 'Elijah Insua',
24 | '@mrbruning': 'Max Bruning'
25 | }
26 | }
27 | ```
28 |
29 | In this case, you have 3 new entries to add, mapping twitter handles
30 | to real names, and one entry to remove.
31 |
32 | You are encouraged to use the `batch()` method for this exercise. A
33 | _batch_ operation is an atomic, and efficient mechanism for
34 | performing multiple writes (put and delete).
35 |
36 | ---
37 |
38 | ## Hints:
39 |
40 | The `batch()` method has two forms:
41 |
42 | ### The `Array` form
43 |
44 | The `Array` form lets you provide an array containing your operations
45 | followed by an optional callback. The array must contain objects of the
46 | form:
47 |
48 | ```javascript
49 | { type: 'put', key: 'foo', value: 'bar' }
50 | ```
51 |
52 | or:
53 |
54 | ```javascript
55 | { type: 'del', key: 'foo' }
56 | ```
57 |
58 | ### The _chained form_
59 |
60 | The chained form is closer to the way that LevelDB exposes its batch
61 | operation. Calling `batch()` with no arguments returns a `Batch` object
62 | that you can use to build your complete set of writes and then submit when
63 | ready. It has the following methods:
64 |
65 | ```javascript
66 | batch.put('key', 'value')
67 | batch.del('key')
68 | batch.write(callback)
69 | ```
70 |
71 | You can't use the chained form of batch until the LevelUP instance is
72 | _"ready"_, you can determine this by either providing a callback to the
73 | main `level()` function or by listening to a "ready" event on the
74 | resulting LevelUP object. See the LevelUP documentation for more details.
75 |
76 | ### Atomicity
77 | Batch writes are "atomic" in that either all writes succeed or they all fail.
78 | If you receive an error on your callback then you can safely assume that your
79 | whole batch failed.
80 |
81 | To get output for debugging when running `{appname} run program.js`
82 | you should use console.error instead of console.log.
83 |
--------------------------------------------------------------------------------
/exercises/basics_batch/problem.ja.md:
--------------------------------------------------------------------------------
1 | **`level`**をつかって、LevelDBのデータストアをオープンし、いくつかのエントリを
2 | 更新するモジュールを書きましょう。
3 |
4 | ３つの引数を取るNodeモジュールとしてプログラムを書いて下さい。
5 |
6 | ```javascript
7 | module.exports = function (databaseDir, changes, callback) {
8 | // your code...
9 | callback(error, values)
10 | }
11 | ```
12 | `changes`はデータベースに対する変更内容を持ったオブジェクトです。
13 | `del`プロパティは削除対象キーの配列です。
14 | `put`プロパティは追加対象のキーと値を持つオブジェクトです。
15 |
16 | 例えば:
17 |
18 | ```
19 | {
20 | del: [ '@darachennis' ],
21 | put: {
22 | '@izs': 'Isaac Z. Schlueter',
23 | '@tmpvar': 'Elijah Insua',
24 | '@mrbruning': 'Max Bruning'
25 | }
26 | }
27 | ```
28 |
29 | この場合、あなたは３つの新しいエントリ（Twitterハンドルと実名のマップ）を
30 | 追加し、１つのエントリを削除する必要があります。
31 |
32 | このエクササイズでは`batch()`メソッドを使うと良いでしょう。_batch_
33 | オペレーションはアトミックで、複数回の書き込み（追加・削除）を行うのに効率的な
34 | メカニズムです。
35 |
36 | ---
37 |
38 | ## ヒント:
39 |
40 | `batch()`メソッドは２つの形式を持っています。
41 |
42 | ### 配列形式
43 |
44 | 配列形式では、必要なオペレーション配列にして渡します。オプションで
45 | callbackを渡すことも出来ます。配列の各要素は以下の様な形式のオブジェクト
46 | となります。
47 |
48 | ```javascript
49 | { type: 'put', key: 'foo', value: 'bar' }
50 | ```
51 |
52 | あるいは、
53 |
54 | ```javascript
55 | { type: 'del', key: 'foo' }
56 | ```
57 |
58 | ### チェーン形式
59 |
60 | チェーン系式はLevelDBが提供するバッチオペレーションにより近いものと
61 | なっています。`batch()`を引数無しでコールすると、`Batch`オブジェクトが
62 | 返されます。そのオブジェクトを使用することで一連の書き込みオペレー
63 | ションを構築し、サブミットすることが出来ます。このオブジェクトは以下の
64 | ようなメソッドを持っています。
65 |
66 | ```javascript
67 | batch.put('key', 'value')
68 | batch.del('key')
69 | batch.write(callback)
70 | ```
71 |
72 | LevelUPインスタンスが_"ready"_となるまで、チェーン系式のバッチは使用
73 | できません。_"ready"_はcallbackをメインの`level()`関数に渡す、あるいは
74 | "ready"イベントをListenすることで判定することが出来ます。詳しい情報は
75 | LevelUPドキュメントを参照して下さい。
76 |
77 | ### アトミック性
78 |
79 | バッチの書き込みはアトミックで、全ての書き込みが成功するか、全て失敗
80 | するかのどちらかです。もしcallbackがエラーを受け取った場合は、全ての
81 | 書き込みが失敗したとみなして問題ありません。
82 |
83 | デバッグで`levelmeup run program.js`を使用しますが、その際に出力を見たい
84 | 場合はconsole.logではなく、console.errorを使用して下さい。
85 |
--------------------------------------------------------------------------------
/exercises/basics_batch/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 |
3 | module.exports = function (databaseDir, changes, callback) {
4 | var db = level(databaseDir)
5 | var error
6 | db.on('error', function (err) {
7 | error = err
8 | })
9 | var ops = changes.del.map(function (key) {
10 | return {
11 | type: 'del',
12 | key: key
13 | }
14 | }).concat(Object.keys(changes.put).map(function (key) {
15 | return {
16 | type: 'put',
17 | key: key,
18 | value: changes.put[key]
19 | }
20 | }))
21 | db.batch(ops, function (err) {
22 | if (err) {
23 | error = err
24 | }
25 | db.close(function (err) {
26 | callback(error || err)
27 | })
28 | })
29 | }
30 |
--------------------------------------------------------------------------------
/exercises/basics_get/exercise.js:
--------------------------------------------------------------------------------
1 | var gibberish = require('../../lib/gibberish')
2 |
3 | module.exports = require('../../lib/exercise')({
4 | dir: __dirname,
5 | init: function () {
6 | var ops = []
7 | for (var i = 0; i < 10; ++i) {
8 | ops.push({
9 | type: 'put',
10 | key: 'key' + Math.floor(Math.random() * (i === 1 ? 10 : 100)),
11 | value: gibberish()
12 | })
13 | }
14 | return {
15 | prepare: function (db, callback) {
16 | db.batch(ops, callback)
17 | },
18 | exec: function (dir, mod, callback) {
19 | if (typeof mod !== 'function') {
20 | throw String('{error.mod.not_function}')
21 | }
22 | if (mod.length < 2) {
23 | throw String('{error.mod.not_long_enough}')
24 | }
25 | mod(dir, callback)
26 | }
27 | }
28 | }
29 | })
30 |
--------------------------------------------------------------------------------
/exercises/basics_get/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a module with one argument that opens a LevelDB data-store using
2 | **`level`**.
3 |
4 | The store will contain up to 10 entries with keys in the form:
5 |
6 | 'key' + i
7 |
8 | Where _'i'_ is an integer between 0 and 100.
9 |
10 | You must find those entries and return them in the callback as an, ordered
11 | by _'i'_, ascending. Your module could look like:
12 |
13 | ```javascript
14 | module.exports = function (databaseDir, callback) {
15 | var result = []
16 | // your code...
17 | result.push()
18 | // more code...
19 | callback(null, result)
20 | }
21 | ```
22 |
23 | The full path to the data-store will be provided to your program as
24 | the first argument.
25 |
26 | ---
27 |
28 | ## Hints:
29 |
30 | When you perform a `.get()` operation, if the entry does not exist
31 | your callback will receive an error object as the first argument.
32 |
33 | It is also possible to receive I/O errors but you can differentiate
34 | a `NotFoundError` by checking `err.type == 'NotFoundError'` or by
35 | checking for a `err.notFound` boolean.
36 |
37 | Using `.get()` is recommended for this exercise but if you're tempted
38 | to use a ReadStream to solve this problem, beware that the sorting
39 | may be a problem.
40 |
--------------------------------------------------------------------------------
/exercises/basics_get/problem.ja.md:
--------------------------------------------------------------------------------
1 | **`level`**をつかって、LevelDBのデータストアをオープンし、エントリを
2 | 探しだすモジュールを書きましょう。
3 |
4 | このデータストアは10個のエントリをもち、それぞれ以下の形式のキーに関連
5 | 付けられています。
6 |
7 | key[X]
8 |
9 | ここで_'[X]'_は0から100までの整数です。
10 |
11 | これらのエントリを探し、一つのリストを作成し、コールバックに渡してください。
12 | そのリストは_'[X]'_で昇順にソートされていなければなりません。あたなの作る
13 | モジュールは下記のようなものになるでしょう。
14 |
15 | ```javascript
16 | module.exports = function (databaseDir, callback) {
17 | var result = []
18 | // your code...
19 | result.push()
20 | // more code...
21 | callback(null, result)
22 | }
23 | ```
24 |
25 | データストアのディレクトリへの絶対パスは第１引数として渡されます。
26 |
27 | ---
28 |
29 | ## ヒント:
30 |
31 | `.get()`メソッドを実行した時に対象エントリが存在していなかった場合、
32 | callbackの第１引数にはエラーオブジェクトが渡されます。
33 |
34 | I/Oエラーが渡される可能性もありますが、`NotFoundError`かどうかは
35 | 以下の２通りの方法で判別することが出来ます。
36 |
37 | * `err.type == 'NotFoundError'`をチェックする
38 | * `err.notFound`のBool値をチェックする
39 |
40 |
41 | `.get()`メソッドを使用することを推奨します。ReadStreamを使用する
42 | 場合はソートの問題に注意して下さい。
43 |
--------------------------------------------------------------------------------
/exercises/basics_get/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 |
3 | module.exports = function (databaseDir, callback) {
4 | var db = level(databaseDir)
5 | var error
6 | db.on('error', function (err) {
7 | error = err
8 | })
9 | var result = []
10 |
11 | var fetchNext = function fetchNext (i) {
12 | var key = 'key' + i
13 | db.get(key, function (err, value) {
14 | if (err) {
15 | if (!err.notFound) {
16 | error = err
17 | }
18 | } else {
19 | result.push(value)
20 | }
21 |
22 | if (i < 100 && !error) {
23 | fetchNext(i + 1)
24 | } else {
25 | db.close(function (err) {
26 | callback(error || err, result)
27 | })
28 | }
29 | })
30 | }
31 | fetchNext(0)
32 | }
33 |
--------------------------------------------------------------------------------
/exercises/basics_put/exercise.js:
--------------------------------------------------------------------------------
1 | var generate = require('../../lib/generate')
2 |
3 | module.exports = require('../../lib/exercise')({
4 | dir: __dirname,
5 | init: function () {
6 | var data = generate(5 + (Math.random() * 20 | 0))
7 | return {
8 | prepare: function (db, callback) {
9 | callback()
10 | },
11 | exec: function (dir, mod, callback) {
12 | if (typeof mod !== 'function') {
13 | throw String('{error.mod.not_function}')
14 | }
15 | if (mod.length < 3) {
16 | throw String('{error.mod.not_long_enough}')
17 | }
18 | mod(dir, data, function () {
19 | require('../../lib/read-db')(dir, 'utf8', callback)
20 | })
21 | }
22 | }
23 | }
24 | })
25 |
--------------------------------------------------------------------------------
/exercises/basics_put/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a module that opens a LevelDB data-store using **`level`**.
2 |
3 | Your module should be written as Node.js module with 3 arguments.
4 |
5 | ```javascript
6 | module.exports = function (databaseDir, obj, callback) {
7 | // your code...
8 | callback(error)
9 | }
10 | ```
11 |
12 | The second argument contains an object. **put** each property of the
13 | object as key and value into a level store.
14 |
15 | Your solution will be verified by reading the data-store and checking
16 | against the object that was provided to you.
17 |
18 | ---
19 |
20 | ## Hints:
21 |
22 | The `put()` method in LevelUP is very simple, you just need to supply
23 | the key and value. An optional callback may be passed if you need
24 | to know when the data has been committed to the store or to
25 | properly catch any errors (otherwise errors will be thrown):
26 |
27 | ```javascript
28 | var db = level('/path/to/db/')
29 | db.put('foo', 'bar', function (err) {
30 | if (err) {
31 | return callback(error)
32 | }
33 | })
34 | ```
35 |
36 | You may also call `db.close()` after all your callbacks have returned,
37 | however this is optional as the data-store will be automatically
38 | closed when your program exits. An open LevelDB store will not keep
39 | your program running indefinitely.
40 |
41 | To get output for debugging when running `levelmeup run program.js`
42 | you should use console.error instead of console.log.
43 |
--------------------------------------------------------------------------------
/exercises/basics_put/problem.ja.md:
--------------------------------------------------------------------------------
1 | **`level`**をつかって、LevelDBのデータストアをオープンし、エントリを
2 | **`put`**するモジュールを書きましょう。
3 |
4 | ３つの引数を取るNodeモジュールとしてプログラムを書いて下さい。
5 |
6 | ```javascript
7 | module.exports = function (databaseDir, obj, callback) {
8 | // your code...
9 | callback(error)
10 | }
11 | ```
12 |
13 | 第２引数にはオブジェクトが渡されます。オブジェクトのプロパティをそれぞれキーと値
14 | としてlevelのデータストアに**put**して下さい。
15 |
16 | プログラムの検証時には、更新されたデータストアの値とオブジェクトのプロパティが
17 | 比較されます。
18 |
19 | ---
20 |
21 | ## ヒント:
22 |
23 | LevelUPの`put()`メソッドはとてもシンプルで、キーと値を渡すだけで使えます。
24 | オプションでCallbackを渡すこともできます。Callbackを渡すことで、データの
25 | コミットが完了したことを知ることが出来ます。あるいは、エラーをcatchすることが
26 | 出来ます。（CatchしなければErrorはthrowされてしまいます）
27 |
28 | ```javascript
29 | var db = level('/path/to/db/')
30 | db.put('foo', 'bar', function (err) {
31 | if (err) {
32 | return callback(error)
33 | }
34 | })
35 | ```
36 |
37 | 全てのcallbackが終了すれば、あなたは`db.close()`も実行するかもしれません。
38 | プログラムの実行が終了すればデータストアは自動的にクローズされるので、この
39 | 関数の実行はオプショナルです。オープンしたままのLevelDBのデータストアが
40 | 存在したとしても、あなたのプログラムが無限ループに陥ることはありません。
41 |
42 | デバッグで`levelmeup run program.js`を使用しますが、その際に出力を見たい
43 | 場合はconsole.logではなく、console.errorを使用して下さい。
44 |
--------------------------------------------------------------------------------
/exercises/basics_put/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 |
3 | module.exports = function (databaseDir, obj, callback) {
4 | var db = level(databaseDir)
5 | var error
6 |
7 | for (var key in obj) {
8 | db.put(key, obj[key])
9 | }
10 | db.on('error', function (err) {
11 | error = err
12 | })
13 | db.close(function (err) {
14 | callback(error || err)
15 | })
16 | }
17 |
--------------------------------------------------------------------------------
/exercises/get_your_level_on/exercise.js:
--------------------------------------------------------------------------------
1 | var sample = require('lodash.sample')
2 | var values = [
3 | 'You have been LEVELED UP!',
4 | 'A LEVEL UP for you!',
5 | 'More LEVELS for you!',
6 | 'Your LEVEL has gone UP!',
7 | 'One LEVEL for you!',
8 | 'LEVELS and LEVELS for you!',
9 | 'Another one has a LEVEL!',
10 | 'LEVEL increased!',
11 | 'You have got another LEVEL!',
12 | 'Your LEVEL was just a raised!',
13 | "Hey you've made it to the next LEVEL!",
14 | 'You are a LEVEL explorer!',
15 | 'Here is a bag of LEVELS!',
16 | 'LEVELED you up for the win!'
17 | ]
18 |
19 | module.exports = require('../../lib/exercise')({
20 | dir: __dirname,
21 | init: function () {
22 | var key = 'levelmeup_' + Date.now().toString(32) + '_' + (Math.random() * 1000 | 0)
23 | var value = sample(values)
24 | return {
25 | prepare: function (db, callback) {
26 | db.put(key, value)
27 | setImmediate(callback)
28 | },
29 | exec: function (dir, mod, callback) {
30 | if (typeof mod !== 'function') {
31 | throw String('{error.mod.not_function}')
32 | }
33 | if (mod.length < 3) {
34 | throw String('{error.mod.not_long_enough}')
35 | }
36 | mod(dir, key, callback)
37 | }
38 | }
39 | }
40 | })
41 |
--------------------------------------------------------------------------------
/exercises/get_your_level_on/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a program that opens a **`level`** directory and reads a key from it.
2 |
3 | Your program should be written as Node.js module with 3 arguments.
4 |
5 | ```javascript
6 | module.exports = function (databaseDir, key, callback) {
7 | // your code...
8 | callback(error, value)
9 | }
10 | ```
11 |
12 | The `database_dir` contains the data to be read by the `leveldb`. Your program
13 | should then retrieve the value of `key` and pass it to the callback.
14 |
15 | _Note: You have to close the database before returning the key!_
16 |
17 | ---
18 |
19 | ## Hints
20 |
21 | **`level`** is a package that bundles both **`levelup`**, the Node-friendly
22 | data-store API and **`leveldown`**, the low-level LevelDB binding.
23 |
24 | Read more about Level and LevelUP: http://npmjs.com/levelup
25 |
26 | Or off-line on your local filesystem:
27 |
28 | {rootdir}/docs/levelup.html
29 |
30 | You will need to `npm install level` to get started with this
31 | exercise.
32 |
33 | If you don't have an Internet connection, simply make a `node_modules`
34 | directory and copy the following directory into it:
35 |
36 | {rootdir}/node_modules/level/
37 |
38 | You can open an existing data-store, or create a new one, by invoking
39 | `level()` and passing in a path to a directory. The function returns
40 | a new _LevelUP_ instance.
41 |
42 | All LevelUP methods are asynchronous. To _get_ a value out of
43 | the data-store, use the `.get(key, callback)` method:
44 |
45 | ```javascript
46 | var level = require('level')
47 | var db = level('/path/to/db/')
48 | db.get('foo', function (err, value) {
49 | console.log('foo =', value)
50 | })
51 | ```
52 |
--------------------------------------------------------------------------------
/exercises/get_your_level_on/problem.ja.md:
--------------------------------------------------------------------------------
1 | **`level`**ディレクトリを開いて、そこからキーを読みだすプログラム
2 | を作りましょう。
3 |
4 | ３つの引数を取るNodeモジュールとしてプログラムを書いて下さい。
5 |
6 | ```javascript
7 | module.exports = function (databaseDir, key, callback) {
8 | // your code...
9 | callback(error, value)
10 | }
11 | ```
12 |
13 | `database_dir`は`leveldb`のデータを持ったディレクトリです。
14 | `key`の値をLevelDBから取り出し、その値をcallbackに渡してください。
15 |
16 | _注意: キーの値を返す前に、データベースをクローズする必要があります！_
17 |
18 | ---
19 |
20 | ## ヒント
21 |
22 | **`level`**パッケージはNodeフレンドリな **`levelup`**と、低レベルな
23 | LevelDBバインディングである**`leveldown`**の両方を含んでいます。
24 |
25 | LevelとLevelUPについての詳しい情報はここを読んで下さい。: http://npmjs.com/levelup
26 |
27 | オフラインで参照する場合は、あなたのPCの以下のパスを参照して下さい。
28 |
29 | {rootdir}/docs/levelup.html
30 |
31 | このエクササイズを始める前に、 `npm install level`を実行する必要が
32 | あります。
33 |
34 | もしインターネットに接続されていないのであれば、`node_modules`
35 | ディレクトリを作成し、そこに以下のディレクトリをコピーして下さい。
36 |
37 | {rootdir}/node_modules/level/
38 |
39 | `level()`をディレクトリのパスを指定して実行することで、既存の
40 | データベースを開く、あるいは新たにデータベースを作ることが出来ます。
41 | この関数は_LevelUP_インスタンスを新たに作成して返します。
42 |
43 | 全てのLevelUPメソッドは非同期です。データストアから値を取得するときは、
44 | `.get(key, callback)`メソッドを使用して下さい。
45 |
46 | ```javascript
47 | var level = require('level')
48 | var db = level('/path/to/db/')
49 | db.get('foo', function (err, value) {
50 | console.log('foo =', value)
51 | })
52 | ```
53 |
--------------------------------------------------------------------------------
/exercises/get_your_level_on/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 |
3 | module.exports = function (dir, key, callback) {
4 | var db = level(dir)
5 | db.get(key, function (error, value) {
6 | db.close(function (err) {
7 | callback(error || err, value)
8 | })
9 | })
10 | }
11 |
--------------------------------------------------------------------------------
/exercises/horse_js_count/exercise.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../lib/exercise')({
2 | dir: __dirname,
3 | init: function () {
4 | var horseJs = require('../../data/horse_js.json')
5 | var start = new Date(horseJs[0].key)
6 | var end = new Date(horseJs[horseJs.length - 1].key)
7 | var newDate = function () {
8 | var mark = new Date(start.getTime() + Math.floor(Math.random() * (end.getTime() - start.getTime())))
9 | return mark.getFullYear() + '-' + (mark.getUTCMonth() < 9 ? '0' : '') + (mark.getUTCMonth() + 1) + '-' + (mark.getUTCDate() < 9 ? '0' : '') + (mark.getUTCDate() + 1)
10 | }
11 | var startDates = [newDate(), newDate(), newDate(), newDate()]
12 | return {
13 | prepare: function (db, callback) {
14 | db.batch(horseJs, callback)
15 | },
16 | exec: function (dbDir, mod, callback) {
17 | if (typeof mod !== 'function') {
18 | throw String('{error.mod.not_function}')
19 | }
20 | if (mod.length < 3) {
21 | throw String('{error.mod.not_long_enough}')
22 | }
23 | var dates = startDates.concat()
24 | var result = []
25 | var next = function () {
26 | mod(dbDir, dates.shift(), function (err, data) {
27 | result.push(data)
28 | if (dates.length === 0 || err) {
29 | callback(err, result)
30 | } else {
31 | next()
32 | }
33 | })
34 | }
35 | next()
36 | }
37 | }
38 | }
39 | })
40 |
--------------------------------------------------------------------------------
/exercises/horse_js_count/problem.en.md:
--------------------------------------------------------------------------------
1 | You have been provided with a rich and valuable data-set that you
2 | need to provide a simple query interface to.
3 |
4 | In this exercise you will be given a LevelDB store that contains
5 | over 2,000 tweets from [@horse_js](https://twitter.com/horse_js).
6 | Your job is to query this dataset and return the number of tweets
7 | that occur from a given date to the _end_ of the data set.
8 |
9 | Each entry is a single tweet. The key is the exact time that the
10 | tweet was sent, in standard ISO date format (i.e. the format
11 | generated by the `Date` object's `toISOString()` method.) The value
12 | of the entry is simply a String representing the tweet's content.
13 |
14 | Write a **module** that exports a single function that
15 | accepts three arguments: an instance of an existing LevelUP database,
16 | a date string, of the form `YYYY-MM-DD` and a callback function.
17 |
18 | The first argument returned on the callback should be an Error if one
19 | occurred or null. The second argument, if there was no error, should
20 | be an integer, representing the number of tweets since that date.
21 |
22 | Your solution will be checked against the official solution to ensure
23 | that your query is targeting the exact range (see details below).
24 | The output will include the number of "streamed entries".
25 |
26 | ---
27 |
28 | ## Hints:
29 |
30 | Use this boilerplate to get started with your module file:
31 |
32 | ```javascript
33 | module.exports = function (databaseDir, date, callback) {
34 | // .. your code here
35 | callback(error, tweetCount)
36 | }
37 | ```
38 |
39 | The ISO date format will always sort lexicographically, which means
40 | that our tweets appear in date/time order in our data store without
41 | any special work required on your part.
42 |
43 | In this exercise, you will need to use the `createReadStream()`
44 | method but you will need to restrict the range of entries to just the
45 | data you need, i.e. you must perform a "range query".
46 |
47 | By default, the range is the whole store, but you can narrow it down
48 | to a start and/or end key. For this exercise you want to start at
49 | a particular date and continue to the end of the store.
50 |
51 | Some of the power of range queries comes from the fact that your
52 | start and end keys need not even exist. If your start key does not
53 | exist then the data will start from the entry with a key that
54 | would come next in the sorted order.
55 |
56 | When you call `createReadStream()`, provide an options object with
57 | the property 'gte' (greater than or equal). The value of this property can simply be the
58 | original date string since YYYY-MM-DD is how the ISO format starts
59 | and this will make the ReadStream jump to the first key that begins
60 | with that prefix, i.e. the first tweet on that day.
61 |
62 | ```javascript
63 | db.createReadStream({ gte: '...' })...
64 | ```
65 |
66 | The rest of the solution will involve incrementing a counter for each
67 | 'data' event you receive and then returning the total count as the
68 | second argument on the callback.
69 |
--------------------------------------------------------------------------------
/exercises/horse_js_count/problem.ja.md:
--------------------------------------------------------------------------------
1 | とても有益なデータベースが与えられるので、それに対する簡単なクエリインターフェースを
2 | 作らなくてはなりません。
3 |
4 | このエクササイズでは[@horse_js](https://twitter.com/horse_js)から２０００以上の
5 | ツイートを保存したLevelDBのデータを使用します。
6 | データベースから指定した日付以降のツイートの数を取り出すのが課題です。
7 |
8 | エントリにツイートが１つずつ保存されています。ツイートが投稿された日時がキーになっています。
9 | 日時はISO形式で保存されています。
10 | （例えば`Date`オブジェクトの`toISOString()`メソッドによって作られたような形式です。)
11 | エントリの値はツイートの内容を表す文字列です。
12 |
13 | 引数を３つ取る関数を１つだけエクスポートした**module**を作成してください。
14 | １つ目の引数はLevelUPデータベースインスタンスのディレクトリパス、2つ目の引数は`YYYY-MM-DD`形式の日付の文字列、
15 | 3つ目の引数はコールバック関数です。
16 |
17 | コールバック関数の最初の引数はエラーまたはnullを持つようにしてください。
18 | 2つ目の引数には指定した日付以降に投稿されたツイート数を表す整数を持つようにしてください。
19 |
20 | あなたの解答が正確な範囲（詳細は以下）を対象にしているかチェックされます。
21 |
22 | ---
23 |
24 | ## ヒント
25 |
26 | 以下のboilerplateを利用してみましょう。
27 |
28 | ```javascript
29 | module.exports = function (databaseDir, date, callback) {
30 | // .. your code here
31 | callback(error, tweetCount)
32 | }
33 | ```
34 |
35 | ISO形式の日時フォーマットは常に辞書順で並んでおり、
36 | 特別な操作をしなくとも、データストアの中でツイートは日付・時間の順番で現れます。
37 |
38 | このエクササイズでは、`createReadStream()`メソッドを使用します。
39 | しかし、エントリは必要な範囲のみに絞らなければなりません。
40 |
41 | デフォルトでは全てのデータストアが対象範囲となりますが、startキーとendキー、
42 | またはどちらか１つを使用して範囲を絞ることができます。
43 | このエクササイズでは指定した日付からデータストアの最後までのツイートに
44 | 範囲を限定したいと思うでしょう。
45 |
46 | この範囲指定のクエリが強力なのは、指定したstartキーとendキーがデータストアに
47 | 存在していなくても良い、という点にあります。
48 | startキーが存在していない場合、ソートされた順番においてstartキーの次に現れる
49 | キーからデータが始まります。
50 |
51 | `createReadStream()`をコールする際、'start'プロパティを持つオブジェクトを引数に設定してください。
52 | このプロパティの値はシンプルにISO形式で始まるYYYY-MM-DDの文字列にすることができます。
53 | そうすることで、その文字列を接辞頭に持つ最初のキー、例えばその日の最初のツイート、へReadStreamオブジェクトはジャンプします。
54 |
55 | ```javascript
56 | db.createReadStream({ start: '...' })...
57 | ```
58 |
59 | 最後に取得した'data'の数を数えて、その総数をコールバック関数の２つ目の引数に設定して終了してください。
60 |
--------------------------------------------------------------------------------
/exercises/horse_js_count/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 | module.exports = function (dir, date, callback) {
3 | var db = level(dir)
4 | var tweets = 0
5 | var error
6 | db.createReadStream({ gte: date })
7 | .on('data', function (data) {
8 | tweets++
9 | })
10 | .on('error', function (err) {
11 | error = err
12 | })
13 | .on('end', function () {
14 | db.close(function (err) {
15 | callback(error || err, tweets)
16 | })
17 | })
18 | }
19 |
--------------------------------------------------------------------------------
/exercises/horse_js_tweets/exercise.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../lib/exercise')({
2 | dir: __dirname,
3 | init: function () {
4 | var horseJs = require('../../data/horse_js.json')
5 | var start = new Date(horseJs[0].key)
6 | var end = new Date(horseJs[horseJs.length - 1].key)
7 | var newDate = function () {
8 | var mark = new Date(start.getTime() + Math.floor(Math.random() * (end.getTime() - start.getTime())))
9 | return mark.getFullYear() + '-' + (mark.getUTCMonth() < 9 ? '0' : '') + (mark.getUTCMonth() + 1) + '-' + (mark.getUTCDate() < 9 ? '0' : '') + (mark.getUTCDate() + 1)
10 | }
11 | var startDates = [ '2013-06-01', newDate(), '2013-07-11', newDate() ]
12 | return {
13 | prepare: function (db, callback) {
14 | db.batch(horseJs, callback)
15 | },
16 | exec: function (dbDir, mod, callback) {
17 | if (typeof mod !== 'function') {
18 | throw String('{error.mod.not_function}')
19 | }
20 | if (mod.length < 3) {
21 | throw String('{error.mod.not_long_enough}')
22 | }
23 | var dates = startDates.concat()
24 | var result = []
25 | var next = function () {
26 | mod(dbDir, dates.shift(), function (err, data) {
27 | result.push(data)
28 | if (dates.length === 0 || err) {
29 | callback(err, result)
30 | } else {
31 | next()
32 | }
33 | })
34 | }
35 | next()
36 | }
37 | }
38 | }
39 | })
40 |
--------------------------------------------------------------------------------
/exercises/horse_js_tweets/problem.en.md:
--------------------------------------------------------------------------------
1 | In this exercise you will be provided with a LevelDB store that
2 | contains over 2,000 tweets from [@horse_js](https://twitter.com/horse_js).
3 | Your job is to query this data set for tweets that were made on a particular
4 | date.
5 |
6 | Each entry is a single tweet. The key is the exact time that the
7 | tweet was sent, in standard ISO date format (i.e. the format
8 | generated by the Date object's `toISOString()` method.) The value
9 | of the entry is simply a String representing the tweet's content.
10 |
11 | Write a **module** that exports a single function that
12 | accepts three arguments: an instance of the levelup database, a date string, of
13 | the form YYYY-MM-DD and a callback function.
14 |
15 | The first argument to the callback should be an Error if one occurred
16 | or null.
17 |
18 | The second argument, if there was no error, should be an
19 | **array where each element is the String text of a tweet**.
20 |
21 | The array should contain ordered tweets for the **single day** given
22 | as the first argument to your function. You must not return tweets
23 | for any other day.
24 |
25 | Your solution will be checked against the official solution to ensure
26 | that your query is targeting the exact range (see details below).
27 | The output will include the number of "streamed entries".
28 |
29 | ---
30 | ## Hints:
31 |
32 | The ISO date format will always sort lexicographically, which means
33 | that our tweets appear in date/time order in our data store without
34 | any special work on our part.
35 |
36 | In this exercise, you will need to use the `createReadStream()`
37 | method but you will need to restrict the range of entries to just the
38 | data you need, i.e. you must perform a "range query".
39 |
40 | By default the range is the whole store, but you can narrow it down
41 | to a start and/or end key. For this exercise you want to start at
42 | the first tweet on the given day and end at the last tweet of that
43 | day.
44 |
45 | Some of the power of range queries comes from the fact that your
46 | start and end keys need not even exist. If your start key does not
47 | exist then the data will start from the entry with a key that
48 | would come next in the sorted order. If your end key does not exist
49 | then your query will end at the entry with a key that would come
50 | before your end key in sorted order.
51 |
52 | To target a range, you supply an options object to
53 | `createReadStream()` with `gte` (greater than or equal) and/or `lte` (less than
54 | or equal) properties that define your range keys:
55 |
56 | ```javascript
57 | db.createReadStream({ gte: 'bar', lte: 'foo' })...
58 | ```
59 |
60 | Keep in mind that since your range keys need not exist you only need
61 | to supply any prefix of the keys you are looking for, e.g. `2010`
62 | will jump to the first key starting with `2010`, which might end up
63 | matching `2010-09-04T03:51:30.929Z`.
64 |
65 | Because the `lte` key of your range will be inclusive, you will need
66 | to create a pseudo-key that would match only the keys you want.
67 | Consider that if you used a `gte` of `2010` and `lte` of `2011` you would
68 | get all entries that start with both `2010` and `2011`. The idiomatic
69 | way _(but not the only way)_ to do this with LevelUP is to append `'\xff'`
70 | to the end of your key, this is the last ASCII character. So, `gte`
71 | of `2010` and `lte` of `2010\xff` would only match keys starting with
72 | `2010`.
73 |
--------------------------------------------------------------------------------
/exercises/horse_js_tweets/problem.ja.md:
--------------------------------------------------------------------------------
1 | このエクササイズでは[@horse_js](https://twitter.com/horse_js)から２０００以上の
2 | ツイートを保存したLevelDBのデータを使用します。
3 | ある特定の日付に投稿されたツイートを取得するクエリを投げるのが課題です。
4 |
5 | エントリにツイートが１つずつ保存されています。ツイートが投稿された日時がキーになっています。
6 | 日時はISO形式で保存されています。
7 | （例えば`Date`オブジェクトの`toISOString()`メソッドによって作られたような形式です。)
8 | エントリの値はツイートの内容を表す文字列です。
9 |
10 | 引数を３つ取る関数を１つだけエクスポートした**module**を作成してください。
11 | １つ目の引数はLevelUPデータベースインスタンスのディレクトリパス、2つ目の引数は`YYYY-MM-DD`形式の日付の文字列、
12 | 3つ目の引数はコールバック関数です。
13 |
14 | コールバック関数の最初の引数はエラーまたはnullを持つようにしてください。
15 |
16 | 2つ目の引数には**ツイートのテキストが要素の配列**を持つようにしてください。
17 |
18 | 1つ目の引数として与えられる**1日**のツイートを配列は含んでいなければいけません。
19 | 他の日付のツイートを返してはいけません。
20 |
21 | あなたの解答が正解な範囲（詳細は以下）を対象にしているかチェックされます。
22 |
23 | ---
24 | ## ヒント:
25 |
26 | ISO形式の日時フォーマットは常に辞書順で並んでおり、
27 | 特別な操作をしなくとも、データストアの中でツイートは日付・時間の順番で現れます。
28 |
29 | このエクササイズでは、`createReadStream()`メソッドを使用します。
30 | しかし、エントリは必要な範囲のみに絞らなければなりません。
31 |
32 | デフォルトでは全てのデータストアを範囲としますが、startキーとendキー、
33 | またはどちらか１つを使用して範囲を絞ることができます。
34 | このエクササイズでは指定した日付の最初から最後までのツイートを
35 | 対象にしたいと思うでしょう。
36 |
37 | この範囲指定のクエリが強力なのは、指定したstartキーとendキーがデータストアに
38 | 存在していなくても良い、という点にあります。
39 | startキーが存在していない場合、ソートされた順番においてstartキーの次に現れる
40 | キーからデータが始まります。
41 | endキーが存在していない場合、ソートされた順番においてendキーの前に現れるキーで
42 | データが終了します。
43 |
44 | 範囲を絞るために'start'と'end'またはどちらか1つプロパティを持つオブジェクトを`createReadStream()`の引数に設定してください。
45 |
46 | ```javascript
47 | db.createReadStream({ start: 'bar', end: 'foo' })...
48 | ```
49 |
50 | 指定する範囲の両キーが存在する必要はなく、見つけたいキーの接頭辞の指定さえあれば良い、
51 | という点を忘れないで下さい。
52 | 例えば、`2010`は`2010`から始まる最初のキーへジャンプします。それは`2010-09-04T03：51：30.929Z`にマッチするという結果になるかもしれません。
53 |
54 | 範囲指定クエリの結果は、`end`キーそのもののエントリが含まれるので、所望のキーだけに
55 | マッチする擬似キーを作成する必要があります。
56 | もし`start`に`2010`、`end`に`2011`を使用する場合、`2010`と`2011`の両方から始まるすべてのエントリを取得します。
57 | LevelUPを使用してこれを実現する(唯一ではないが)慣用的な方法は`'\xff'`をキーの最後に付加することです。
58 | これは最後のASCII文字を意味します。ですから、`2010`の`start`と `2010\xff` の`end`は`2010`から始まるキーにだけマッチします。
59 |
--------------------------------------------------------------------------------
/exercises/horse_js_tweets/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 | module.exports = function (databaseDir, day, callback) {
3 | var tweets = []
4 | var db = level(databaseDir)
5 | var error
6 | db.createReadStream({ gte: day, lte: day + '\xff' })
7 | .on('data', function (data) {
8 | tweets.push(data.value)
9 | })
10 | .on('error', function (err) {
11 | error = err
12 | })
13 | .on('end', function () {
14 | db.close(function (err) {
15 | callback(error || err, tweets)
16 | })
17 | })
18 | }
19 |
--------------------------------------------------------------------------------
/exercises/keywise/exercise.js:
--------------------------------------------------------------------------------
1 | var keywiseFileName = require.resolve('../../data/keywise.json')
2 |
3 | module.exports = require('../../lib/exercise')({
4 | dir: __dirname,
5 | init: function () {
6 | return {
7 | prepare: function (db, callback) {
8 | callback()
9 | },
10 | exec: function (dbDir, mod, callback) {
11 | if (typeof mod !== 'function') {
12 | throw String('{error.mod.not_function}')
13 | }
14 | if (mod.length < 3) {
15 | throw String('{error.mod.not_long_enough}')
16 | }
17 | mod(dbDir, keywiseFileName, function () {
18 | require('../../lib/read-db')(dbDir, 'json', callback)
19 | })
20 | }
21 | }
22 | }
23 | })
24 |
--------------------------------------------------------------------------------
/exercises/keywise/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a **module** that exports a single function that
2 | accepts three arguments: an instance of an existing LevelUP database,
3 | a file path that points to a JSON file and a callback function.
4 |
5 | ## The **module** should
6 |
7 | Write a module that reads in a JSON file containing mappings of
8 | usernames to their GitHub repositories and store them in a LevelUP
9 | data-store such that they can be searched.
10 |
11 | Your first command-line argument will be the full path to the LevelUP
12 | store where you need to write the data.
13 |
14 | You will be given the path to a JSON file as the second command-line
15 | argument, you can use `require(jsonPath)` to load and parse
16 | it into a JavaScript object.
17 |
18 | The JSON file is an array with two kinds of rows, some are users:
19 |
20 | ```javascript
21 | {
22 | type: "user",
23 | name: "maxogden"
24 | }
25 | ```
26 |
27 | And some are repositories:
28 |
29 | ```javascript
30 | {
31 | type: "repo",
32 | name: "mux-demux",
33 | user: "dominictarr"
34 | }
35 | ```
36 |
37 | You must write all of the entries in this file to the data-store.
38 |
39 | Open the data-store and write data with `!` as a delimiter such that
40 | the verify script will be able to read the **repos for each user** by
41 | doing the following range query:
42 |
43 | ```javascript
44 | db.createReadStream({
45 | start: 'rvagg!',
46 | end: 'rvagg!~'
47 | })
48 | ```
49 |
50 | The user data should also be fetchable with:
51 |
52 | ```javascript
53 | db.get('rvagg', function (err, user) { ... })
54 | ```
55 |
56 | The value of each entry of the data-store should be the same as the
57 | original JSON object from the data file.
58 |
59 | ---
60 |
61 | ## Hints:
62 |
63 | To simplify the use of JSON here you can open your LevelUP store
64 | with the option: `valueEncoding: 'json'`, i.e.
65 |
66 | ```javascript
67 | var db = level(databaseDir, { valueEncoding: 'json' })
68 | ```
69 |
70 | You can then write values as objects directly to the store without
71 | having to do a JSON conversion yourself. This also means that read
72 | operations will receive a recomposed object.
73 |
74 | To get output for debugging when running `levelmeup run program.js`
75 | you should use console.error instead of console.log.
76 |
--------------------------------------------------------------------------------
/exercises/keywise/problem.ja.md:
--------------------------------------------------------------------------------
1 | 引数を３つ取る関数を１つだけエクスポートした**module**を作成してください。
2 | 引数はLevelUPデータベースのインスタンスが存在するディレクトリ、JSONファイルのファイルパス、
3 | コールバック関数となっています。
4 |
5 | ## **module**の仕様
6 |
7 | GitHubリポジトリとユーザーネームのマッピングが書かれたJSONファイルを読み出し、
8 | それらのデータを検索できるようにLevelUPデータストアに保存するモジュールを書きましょう。
9 |
10 | １つ目のコマンドライン引数はデータを書き込むLevelUPデータベースのパスになります。
11 |
12 | ２つ目のコマンドライン引数はJSONファイルへのパスになります。JSONを読み込みJavascriptオブジェクトに変換するために
13 | `require(JSONファイルのパス)`が使えます。
14 |
15 | JSONファイルは２種類の行を持つ配列です。１つはユーザーです。
16 |
17 | ```javascript
18 | {
19 | type: "user",
20 | name: "maxogden"
21 | }
22 | ```
23 |
24 | もう１つはリポジトリです。
25 |
26 | ```javascript
27 | {
28 | type: "repo",
29 | name: "mux-demux",
30 | user: "dominictarr"
31 | }
32 | ```
33 |
34 | このファイルのすべてのエントリをデータストアに書き込まなければいけません。
35 |
36 | データストアを開き、`!`を区切り文字としてデータを書き込んでください。そうすることで検証用スクリプトは
37 | 以下の範囲問い合わせを実行し、**各ユーザーのリポジトリ**を読み込むことができます。
38 |
39 | ```javascript
40 | db.createReadStream({
41 | start: 'rvagg!',
42 | end: 'rvagg!~'
43 | })
44 | ```
45 |
46 | ユーザーデータは以下の方法で取得できるようにして下さい。
47 |
48 | ```javascript
49 | db.get('rvagg', function (err, user) { ... })
50 | ```
51 |
52 | データストアの各エントリの値はファイルから取得したオリジナルのJSONオブジェクトと同じでなけれななりません。
53 |
54 | ---
55 |
56 | ## ヒント:
57 |
58 | JSONの扱いを簡単にするために、`valueEncoding: 'json'`のオプションを使用しLevelUPストアを
59 | 開くことができます。以下は例です。
60 |
61 | ```javascript
62 | var db = level(databaseDir, { valueEncoding: 'json' })
63 | ```
64 |
65 | こうすることでオブジェクトをデータとして直接ストアに書き込むことが出来、自分でJSONデータの
66 | 変換をする必要が無くなります。
67 | これは同様に、読み込み処理は再構成されたオブジェクトを受け取ることを意味します。
68 |
69 | `levelmeup run program.js`を実行する時にデバッグ用の出力を取得したい場合は、
70 | console.logの代わりにconsole.errorを使用してください。
71 |
--------------------------------------------------------------------------------
/exercises/keywise/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 |
3 | module.exports = function (databaseDir, keywiseFile, callback) {
4 | var db = level(databaseDir, { valueEncoding: 'json' })
5 | var data = require(keywiseFile)
6 |
7 | var operations = data.map(function (row) {
8 | var key
9 | if (row.type === 'user') {
10 | key = row.name
11 | } else if (row.type === 'repo') {
12 | key = row.user + '!' + row.name
13 | }
14 | return {
15 | type: 'put',
16 | key: key,
17 | value: row
18 | }
19 | })
20 |
21 | db.batch(operations, function (error) {
22 | db.close(function (err) {
23 | callback(error || err)
24 | })
25 | })
26 | }
27 |
--------------------------------------------------------------------------------
/exercises/multilevel/exercise.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 | var net = require('net')
3 | var multilevel = require('multilevel')
4 |
5 | module.exports = require('../../lib/exercise')({
6 | dir: __dirname,
7 | init: function () {
8 | return {
9 | prepare: function (db, callback) {
10 | db.put('multilevelmeup', '`Twas brillig, and the slithy toves\n\tDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\n\tAnd the mome raths outgrabe.', callback)
11 | },
12 | exec: function (dbDir, mod, callback) {
13 | if (typeof mod !== 'function') {
14 | throw String('{error.mod.not_function}')
15 | }
16 | if (mod.length < 1) {
17 | throw String('{error.mod.not_long_enough}')
18 | }
19 | var db = level(dbDir)
20 | var server = net
21 | .createServer(function (con) {
22 | con.pipe(multilevel.server(db)).pipe(con)
23 | })
24 | .listen(4545, function (conn) {
25 | mod(function (error, data) {
26 | server.close(function () {
27 | db.close(function (err) {
28 | callback(error || err, data)
29 | })
30 | })
31 | })
32 | })
33 | }
34 | }
35 | }
36 | })
37 |
--------------------------------------------------------------------------------
/exercises/multilevel/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a module that uses multilevel to fetch a value from a server
2 | running on your computer.
3 |
4 | Create a TCP connection with the core `net` module to port **4545**
5 | on localhost. Pipe this connection through a multilevel RPC stream and
6 | back to the connection. Your code should look like:
7 |
8 | ```javascript
9 | var multilevel = require('multilevel')
10 | var net = require('net')
11 |
12 | module.exports = function (callback) {
13 | var db = multilevel.client()
14 | var connection = net.connect(4545)
15 | connection.pipe(db.createRpcStream()).pipe(connection)
16 |
17 | // your code ...
18 | callback(null, value)
19 | }
20 | ```
21 |
22 | You will then have a `db` object that you can interact with like a
23 | LevelUP object.
24 |
25 | Fetch the value from the data store with the key `multilevelmeup`
26 | and return it to the provided callback.
27 |
28 | **You must close the connection using `connection.end(..)` after you
29 | have fetched the value but before you execute the callback!**
30 |
31 | ---
32 |
33 | ## Hints:
34 |
35 | Read more about multilevel here:
36 |
37 | http://npmjs.com/multilevel
38 |
39 | Or off-line on your local filesystem:
40 |
41 | {rootdir}/docs/multilevel.html
42 |
43 | You will need to `npm install multilevel` to get started with this
44 | exercise.
45 |
46 | If you don't have an Internet connection, simply make a `node_modules`
47 | directory and copy the following directory into it:
48 |
49 | {rootdir}/node_modules/multilevel/
50 |
--------------------------------------------------------------------------------
/exercises/multilevel/problem.ja.md:
--------------------------------------------------------------------------------
1 | あなたのコンピューター上で動くサーバーから値を取得するためにmultilevelを使用するモジュールを
2 | 書いてください。
3 |
4 | ローカルホスト上でポート番号**4545**を使用する`net`モジュールを使用してTCPコネクションを作成してください。
5 | このコネクションをmultilevelのRPCストリームにパイプでつなぎ、コネクションに返してください。
6 | 以下のようなコードになるでしょう。
7 |
8 | ```javascript
9 | var multilevel = require('multilevel')
10 | var net = require('net')
11 |
12 | module.exports = function (callback) {
13 | var db = multilevel.client()
14 | var connection = net.connect(4545)
15 | connection.pipe(db.createRpcStream()).pipe(connection)
16 |
17 | // あなたのコード ...
18 | callback(null, value)
19 | }
20 | ```
21 |
22 | `db`オブジェクトはLevelUPオブジェクトのように使用できるものになります。
23 |
24 | `multilevelmeup`というキーを使用してデータストアから値を取得し、
25 | コールバックに渡してください。
26 |
27 | **値を取得した後コールバックを呼ぶ前に必ずコネクションを
28 | `connection.end(..)`で閉じてください！**
29 |
30 | ---
31 |
32 | ## ヒント:
33 |
34 | multilevelに関しての詳細は以下のページで読めます。
35 |
36 | http://npmjs.com/multilevel
37 |
38 | または以下に配置されているローカルのファイルからオフラインでも読めます。
39 |
40 | {rootdir}/docs/multilevel.html
41 |
42 | このエクササイズを始めるために`npm install multilevel`を実行しなければいけません。
43 |
44 | インターネットに接続できない場合、`node_modules`というディレクトリを作成し以下のディレクトリを作成した
45 | ディレクトリ内にコピーしてください。
46 |
47 | {rootdir}/node_modules/multilevel/
48 |
--------------------------------------------------------------------------------
/exercises/multilevel/solution.js:
--------------------------------------------------------------------------------
1 | var multilevel = require('multilevel')
2 | var net = require('net')
3 |
4 | module.exports = function (callback) {
5 | var db = multilevel.client()
6 | var con = net.connect(4545)
7 | con.pipe(db.createRpcStream()).pipe(con)
8 |
9 | db.get('multilevelmeup', function (err, value) {
10 | con.end(function () {
11 | callback(err, value)
12 | })
13 | })
14 | }
15 |
--------------------------------------------------------------------------------
/exercises/short_scrabble_words/exercise.js:
--------------------------------------------------------------------------------
1 | var fs = require('fs')
2 | var path = require('path')
3 | var through2 = require('through2')
4 | var sample = require('lodash.sample')
5 | var level = require('level')
6 |
7 | function loadWords (file) {
8 | return fs.readFileSync(path.join(__dirname, '../../data/', file), 'utf8').split(/\s|\n/g)
9 | }
10 |
11 | var twoLetter = loadWords('sowpods_2.dat')
12 | var threeLetter = loadWords('sowpods_3.dat')
13 | var fourLetter = loadWords('sowpods_4.dat')
14 | var words = []
15 | .concat(twoLetter)
16 | .concat(threeLetter)
17 | .concat(fourLetter)
18 | .filter(Boolean)
19 |
20 | module.exports = require('../../lib/exercise')({
21 | dir: __dirname,
22 | init: function () {
23 | var queries = [
24 | sample(twoLetter).substr(0, 1) + '*',
25 | sample(twoLetter),
26 | sample(threeLetter).substr(0, 1) + '**',
27 | sample(threeLetter).substr(0, 2) + '*',
28 | sample(threeLetter),
29 | sample(fourLetter).substr(0, 1) + '***',
30 | sample(fourLetter).substr(0, 2) + '**',
31 | sample(fourLetter).substr(0, 3) + '*',
32 | sample(fourLetter),
33 | 'NODE'
34 | ]
35 | return {
36 | prepare: function (db, callback) {
37 | callback()
38 | },
39 | exec: function (dbDir, mod, callback) {
40 | if (typeof mod !== 'object') {
41 | throw String('{error.mod.not_object}')
42 | }
43 | if (typeof mod.init !== 'function') {
44 | throw String('{error.mod.init_missing}')
45 | }
46 | if (typeof mod.query !== 'function') {
47 | throw String('{error.mod.query_missing}')
48 | }
49 | var db = level(dbDir)
50 | mod.init(db, words, function (error) {
51 | if (error) {
52 | return db.close(callback.bind(null, error))
53 | }
54 | var _createReadStream = db.createReadStream
55 | db.createReadStream = function () {
56 | return _createReadStream.apply(db, arguments).pipe(through2({ objectMode: true },
57 | function (chunk, enc, callback) {
58 | result.count += 1
59 | callback(null, chunk)
60 | }
61 | ))
62 | }
63 | var result
64 | var runQueries = queries.concat()
65 | var next = function () {
66 | var query = runQueries.shift()
67 | result = {
68 | data: {},
69 | count: 0
70 | }
71 | mod.query(db, query, function (err, data) {
72 | if (!err) {
73 | result.data[query] = data
74 | }
75 | if (err || runQueries.length === 0) {
76 | return db.close(callback.bind(null, err, result))
77 | }
78 | next()
79 | })
80 | }
81 | next()
82 | })
83 | }
84 | }
85 | }
86 | })
87 |
--------------------------------------------------------------------------------
/exercises/short_scrabble_words/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a module that stores valid 2, 3 and 4 character Scrabble words
2 | and is able to retrieve them according to basic prefix-queries.
3 |
4 | Your module should export an `init()` function that accepts 3
5 | arguments: a LevelUP `db` object for an empty database, an array of
6 | 2, 3 and 4 character Scrabble words and callback that you must call
7 | once you have finished initialising the database.
8 |
9 | Your module should also export a `query()` method that also accepts
10 | 3 arguments: a LevelUP `db` object (the same store that you
11 | initialised with `init()`), a `word` string containing the query, and
12 | a callback that you must call with two arguments. The first argument
13 | should be null, or an error object if one occurred. The second
14 | argument should be an array of all the words in the database which
15 | match the query.
16 |
17 | Here is a boilerplate module that you can extend for your solution:
18 |
19 | ```javascript
20 | module.exports.init = function (db, words, callback) {
21 | // insert each word in the words array here
22 | // then call `callback()` when you are done inserting words
23 | }
24 |
25 | module.exports.query = function (db, word, callback) {
26 | // `word` may have '*' chars to denote single-letter wildcards
27 | // call callback(err, results) with an array of matching words
28 | }
29 | ```
30 |
31 | The `word` query may be a complete word, e.g. 'RUN', or a prefix of a
32 | word with `*` characters filling in the blanks, e.g. `RU*` or `R**`.
33 | The `.length` will tell you how long the word should be, your results
34 | should only include words of that length. The `*` characters are
35 | wild-cards that can match any character.
36 |
37 | For simplicity, the wild-cards will only be on the **end** of a query.
38 | You will always be given either a complete word or a word prefix. You
39 | must limit your results to words of the same length and with the same
40 | prefix.
41 |
42 | Your solution will be tested against the official solution, you must
43 | use a ReadStream that **only** returns the exact words that your query
44 | needs to match, and no more.
45 |
46 | ---
47 |
48 | ## Hints:
49 |
50 | This exercise is about coming up with a key schema that is going to be
51 | useful for retrieving results according to the queries you can expect.
52 | You will need to come up with a key structure that will let you limit
53 | your search to only words of the correct number of characters without
54 | including words that have a different number of characters.
55 |
56 | Your `init()` function should translate words into appropriate keys,
57 | and your `query()` function should be able to translate a query into
58 | a `start` and `end` for your ReadStream.
59 |
--------------------------------------------------------------------------------
/exercises/short_scrabble_words/problem.ja.md:
--------------------------------------------------------------------------------
1 | ２、3、4文字のスクラブルワードを保存するモジュールを作成します。
2 | また、基本的なprefix（接頭辞）クエリにしたがって保存した言葉を取り出せる
3 | ようにします。
4 |
5 | > 〜〜〜 スクラブル 〜〜〜
6 | > アルファベットの書かれたコマを並べて単語を作るボードゲーム
7 | > クロスワードパズル的要素がある
8 | > ウィキペディア → https://ja.wikipedia.org/wiki/スクラブル
9 |
10 | 3つの引数を持つ`init()`関数がエクスポートされたモジュールを書いてください。
11 | 1つ目の引数は空のデータベースのLevelUP`db`オブジェクト、2つ目の引数は2、3、4文字のスクラブルワードの配列、
12 | 最後の引数はデータベースを初期化した後に実行するコールバックです。
13 |
14 | さらに、3つの引数を持つ`query()`関数もエクスポートして下さい。
15 | 1つ目の引数は`init()`関数で初期化されたデータベースと同じ`db`オブジェクト、
16 | 2つ目の引数はクエリ文字列、最後の引数は2つの引数を持つコールバック関数です。
17 | コールバック関数の最初の引数はnullまたはエラーが発生した場合のエラーオブジェクトです。
18 | コールバック関数の2つ目の引数はクエリに合致するデータベース内のすべての単語の配列です。
19 |
20 | 以下のボイラープレートを拡張して答えを書いてください。
21 |
22 | ```javascript
23 | module.exports.init = function (db, words, callback) {
24 | // words配列の各ワードをここで書き込む
25 | // 全ての単語の書き込みが終われば、callbackを実行
26 | }
27 |
28 | module.exports.query = function (db, word, callback) {
29 | // `word`は'*'を含む文字列。'*'は１文字をあわらすワイルドカード
30 | // callback(err, results)を一致した単語の配列を設定して実行
31 | }
32 | ```
33 |
34 | `word`に設定するクエリは'RUN'のような完全な単語、または`RU*`や`R**`のように
35 | 前方一致のための接頭辞と`*`を組み合わせた単語でなければいけません。
36 | `.length`で目的の単語の文字数を知ることが出来、その文字数の単語のみを含む
37 | 結果を返さなければいけません。
38 | `*`はいかなる文字にもマッチするワイルドカードです。
39 |
40 | 簡単のため、ワイルドカードはクエリの**最後**にのみ付加します。
41 | 常に完全一致の単語または接頭辞のどちらかを与えられます。
42 | 同じ文字数で同じ接頭辞を持つ単語のみ結果としてください。
43 |
44 | あなたの解答はオフィシャルな解答に対してテストされます。
45 | ReadStreamを使い、問い合わせクエリに正確にマッチする結果**だけ**を返し、それ以上は返さないでください。
46 |
47 | ---
48 |
49 | ## ヒント:
50 |
51 | あなたが想定するクエリにしたがって結果を抽出する際に役立つであろうキースキーマを
52 | 考えだす、ということがこのエクササイズの目的になります。
53 | 対象外の文字数を持つ単語を含めずに、目的の文字数の単語だけを検索できるキー構造を
54 | を導きださなければいけません。
55 |
56 | `init()`関数は単語を適切なキーに変換し、
57 | `query()`関数はクエリをReadStreamの適切な`start`と`end`に変換するように
58 | してください。
59 |
--------------------------------------------------------------------------------
/exercises/short_scrabble_words/solution.js:
--------------------------------------------------------------------------------
1 | module.exports.init = function (db, words, callback) {
2 | var batch = words.map(function (word) {
3 | // length-prefixed keys, separated by a '!' so we
4 | // can query by length
5 | var key = word.length + '!' + word
6 | return { type: 'put', key: key, value: word }
7 | })
8 | db.batch(batch, callback)
9 | }
10 |
11 | module.exports.query = function (db, word, callback) {
12 | var words = []
13 | var key = word.length + '!' + word.replace(/\*/g, '')
14 | var error
15 | db.createReadStream({ start: key, end: key + '\xff' })
16 | .on('data', function (data) {
17 | words.push(data.value)
18 | })
19 | .on('error', function (err) {
20 | error = err
21 | })
22 | .on('end', function () {
23 | callback(error, words)
24 | })
25 | }
26 |
--------------------------------------------------------------------------------
/exercises/streaming/exercise.js:
--------------------------------------------------------------------------------
1 | var generate = require('../../lib/generate')
2 | var isStream = require('is-stream')
3 |
4 | module.exports = require('../../lib/exercise')({
5 | dir: __dirname,
6 | init: function () {
7 | var data = generate(5 + (Math.random() * 20 | 0))
8 | var ops = []
9 |
10 | Object.keys(data).forEach(function (key) {
11 | ops.push({
12 | type: 'put',
13 | key: key,
14 | value: data[key]
15 | })
16 | })
17 | return {
18 | prepare: function (db, callback) {
19 | db.batch(ops, callback)
20 | },
21 | exec: function (dir, mod, callback) {
22 | if (typeof mod !== 'function') {
23 | throw String('{error.mod.not_function}')
24 | }
25 | if (mod.length < 1) {
26 | throw String('{error.mod.not_long_enough}')
27 | }
28 | var result = mod(dir)
29 | if (!isStream(result)) {
30 | throw String('{error.result_no_stream}')
31 | }
32 | var data = []
33 | var error
34 | result.on('data', function (entry) {
35 | data.push(entry)
36 | })
37 | result.on('error', function (err) {
38 | error = err
39 | })
40 | result.on('end', function () {
41 | callback(error, data)
42 | })
43 | }
44 | }
45 | }
46 | })
47 |
--------------------------------------------------------------------------------
/exercises/streaming/problem.en.md:
--------------------------------------------------------------------------------
1 | Write a program that opens a LevelDB data-store using **`level`** and reads a
2 | few keys.
3 |
4 | Your program should be written as Node.js module with 1 argument that returns
5 | a stream.
6 |
7 | ```javascript
8 | module.exports = function (databaseDir) {
9 | var resultStream
10 | // your code...
11 | return resultStream
12 | }
13 | ```
14 |
15 |
16 | The resulting stream should be transformed to a stream of strings with one chunk per entry formatted as `{key}={value}`.
17 |
18 | ---
19 |
20 | ## Hints:
21 |
22 | Since you don't know what the keys are in this exercise you can't
23 | use `get()`. Instead, you'll need to query the data store using
24 | a ReadStream.
25 |
26 | The `createReadStream()` method creates a standard Node object-
27 | stream where each chunk, or `data` event, is an entry in the data
28 | store. Each data object has both `key` and `value` properties for
29 | the entry.
30 |
31 | You can therefore stream the entire contents of the data store with:
32 |
33 | ```javascript
34 | db.createReadStream().on('data', function (data) {
35 | // data.key and data.value
36 | })
37 | ```
38 |
39 | There is still the need to `.close` the database after the stream has
40 | ended!
41 |
42 | You can use `through2` to process the stream.
43 |
44 | npm i through2
45 |
46 | or if you have no connection to
47 |
48 | file://{rootdir}/node_modules/through2
49 |
50 | Also note that the 'error' event may also be emitted if there is an
51 | I/O error.
52 |
--------------------------------------------------------------------------------
/exercises/streaming/problem.ja.md:
--------------------------------------------------------------------------------
1 | **`level`**をつかって、LevelDBのデータストアをオープンし、エントリを
2 | 全て取り出すモジュールを書きましょう。
3 |
4 | 引数を１つだけ取り、ストリームを返すNodeモジュールとしてプログラムを
5 | 書いて下さい。
6 |
7 | ```javascript
8 | module.exports = function (databaseDir) {
9 | var resultStream
10 | // your code...
11 | return resultStream
12 | }
13 | ```
14 |
15 | LevelDB中のエントリをそれぞれ`{key}={value}`の形式でチャンクに分けた
16 | ストリームを作成して下さい。
17 |
18 | ---
19 |
20 | ## ヒント:
21 |
22 | 今回はキーが分からない状態ですので、`get()`を使うことは出来ません。
23 | その代わり、ReadStreamを使ってデータストアに問い合わせることになります。
24 |
25 | `createReadStream()`メソッドはNodeの標準的なオブジェクトストリームを
26 | 作成します。このオブジェクトストリームのチャンク（あるいはデータイベント）
27 | はLevelDBのデータストアの各エントリとなります。データオブジェクトはエントリ
28 | に対応する`key`プロパティと`value`プロバティを持ちます。
29 |
30 | あなたは以下のようなコードでデータストアの全コンテンツのストリームを
31 | 作成することが出来ます。
32 |
33 | ```javascript
34 | db.createReadStream().on('data', function (data) {
35 | // data.key and data.value
36 | })
37 | ```
38 |
39 | ストリームが終了したあと、データベースを`.close`する必要があることを
40 | 忘れないで下さい！
41 |
42 | `through2`を使用すると良いでしょう。
43 |
44 | npm i through2
45 |
46 | もしオフラインであれば、以下のパスのものを使用して下さい。
47 |
48 | file://{rootdir}/node_modules/through2
49 |
50 | I/Oエラーにより'error'イベントが発生する可能性があることに注意して下さい。
51 |
--------------------------------------------------------------------------------
/exercises/streaming/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 | var through2 = require('through2')
3 |
4 | module.exports = function (databaseDir) {
5 | var db = level(databaseDir)
6 | return db.createReadStream()
7 | .pipe(through2({objectMode: true}, function (data, enc, next) {
8 | this.push(data.key + '=' + data.value)
9 | next()
10 | }, function (next) {
11 | db.close(next)
12 | }))
13 | }
14 |
--------------------------------------------------------------------------------
/exercises/sublevel/exercise.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../lib/exercise')({
2 | dir: __dirname,
3 | init: function () {
4 | return {
5 | prepare: function (db, callback) {
6 | callback()
7 | },
8 | exec: function (dbDir, mod, callback) {
9 | if (typeof mod !== 'function') {
10 | throw String('{error.mod.not_function}')
11 | }
12 | if (mod.length < 2) {
13 | throw String('{error.mod.not_long_enough}')
14 | }
15 | mod(dbDir, function () {
16 | require('../../lib/read-db')(dbDir, 'utf8', callback)
17 | })
18 | }
19 | }
20 | }
21 | })
22 |
--------------------------------------------------------------------------------
/exercises/sublevel/problem.en.md:
--------------------------------------------------------------------------------
1 | Sometimes you just need a clean namespace to fill up with junk without
2 | worrying about conflicting with existing keys in use.
3 |
4 | You can use **sublevel** for creating clean namespaces!
5 |
6 | You can extend a db handle to use sublevel by doing:
7 |
8 | ```javascript
9 | var db = sub(level(...))
10 | ```
11 |
12 | Then you can call `db.sublevel()` to make a new sublevel.
13 |
14 | Just call `db.sublevel()` with a name and you get an object that acts
15 | just like a normal db handle except it lives in a namespace:
16 |
17 | ```javascript
18 | var wizards = db.sublevel('wizards')
19 | ```
20 |
21 | To level up on this adventure, you will get a database path as the
22 | first module argument. Create 2 sublevels, one called "robots"
23 | and the other called "dinosaurs".
24 |
25 | For each sublevel, create a key called "slogan". Set the _slogan_ for
26 | the dinosaurs sublevel to `'rawr'` and set the _slogan_ for the robots
27 | sublevel to `'beep boop'`.
28 |
29 | ---
30 |
31 | # Hints:
32 |
33 | Read more about sublevel here:
34 |
35 | http://npmjs.com/level-sublevel
36 |
37 | Or off-line on your local filesystem:
38 |
39 | {appDir}/docs/sublevel.html
40 |
41 | You will need to `npm install level-sublevel` to get started with this
42 | exercise.
43 |
44 | If you don't have an Internet connection, simply make a `node_modules`
45 | directory and copy the following directory into it:
46 |
47 | {appDir}/node_modules/level-sublevel/
48 |
49 | To get output for debugging when running `{appname} run program.js`
50 | you should use console.error instead of console.log.
51 |
--------------------------------------------------------------------------------
/exercises/sublevel/problem.ja.md:
--------------------------------------------------------------------------------
1 | 使用中のキーとの衝突を気にせずジャンクを埋めつくせるような、クリーンな名前空間が
2 | たまに必要になります。
3 |
4 | クリーンな名前空間を作成するために**sublevel**を使用できます。
5 |
6 | 以下のようにsublevelを使用するためにデータベースハンドルを拡張できます。
7 |
8 | ```javascript
9 | var db = sub(level(...))
10 | ```
11 |
12 | その後、`db.sublevel()`を呼び出すことで新しいsublevelを作成できます。
13 |
14 | `db.sublevel()`を名前渡して呼ぶだけで、通常のデータベースハンドルと
15 | （ある名前空間内に存在しているということ以外は）同じように振る舞う
16 | オブジェクトを取得することができます。
17 |
18 | ```javascript
19 | var wizards = db.sublevel('wizards')
20 | ```
21 |
22 | このアドベンチャーでレベルアップするために、1つ目の引数としてデータ
23 | ベースのパスを受け取ります。
24 | 2つのsublevelを作成してください。1つは"robots"という名前で、
25 | もう1つは"dinosaurs"という名前です。
26 |
27 | 各sublevelのために"slogan"と言う名のキーを作成してください。
28 | dinosaursと呼ばれるsublevelの _slogan_ を`'rawr'`に設定し、
29 | robotsと呼ばれるsublevelの _slogan_ を`'beep boop'`に設定してください。
30 |
31 | ---
32 |
33 | # ヒント:
34 |
35 | sublevelに関しての詳細は以下のページで読めます。
36 |
37 | http://npmjs.com/level-sublevel
38 |
39 | または以下に配置されているローカルのファイルからオフラインでも読めます。
40 |
41 | {appDir}/docs/sublevel.html
42 |
43 | このエクササイズを始めるために`npm install level-sublevel`を実行しなければいけません。
44 |
45 | インターネットに接続できない場合、`node_modules`というディレクトリを作成し以下のディレクトリを作成した
46 | ディレクトリ内にコピーしてください。
47 |
48 | {appdir}/node_modules/level-sublevel/
49 |
50 | デバッグのために`{appname} run program.js`を実行して出力を取得するために、
51 | console.logの代わりにconsole.errorを使用してください。
52 |
--------------------------------------------------------------------------------
/exercises/sublevel/solution.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 | module.exports = function (databaseDir, callback) {
3 | var sub = require('level-sublevel')
4 | var db = sub(level(databaseDir))
5 | var error
6 | db.on('error', function (err) {
7 | error = err
8 | })
9 |
10 | var robots = db.sublevel('robots')
11 | robots.put('slogan', 'beep boop')
12 |
13 | var dinosaurs = db.sublevel('dinosaurs')
14 | dinosaurs.put('slogan', 'rawr')
15 |
16 | db.close(function (err) {
17 | callback(error || err)
18 | })
19 | }
20 |
--------------------------------------------------------------------------------
/i18n/en.json:
--------------------------------------------------------------------------------
1 | {
2 | "title": "LEVEL ME UP SCOTTY!",
3 | "subtitle": "Learn You Some Node.js Databases",
4 | "exercise": {
5 | "all_your_base": "ALL YOUR BASE",
6 | "get_your_level_on": "Get Your Level On!",
7 | "basics_get": "Basics: GET",
8 | "basics_put": "Basics: PUT",
9 | "basics_batch": "Basics: BATCH",
10 | "streaming": "Streaming",
11 | "horse_js_count": "@horse_js Count",
12 | "horse_js_tweets": "@horse_js Tweets",
13 | "keywise": "Keywise",
14 | "short_scrabble_words": "Short Scrabble Words",
15 | "sublevel": "Sublevel",
16 | "multilevel": "Multilevel"
17 | },
18 | "diff": {
19 | "unexpected": "Unexpected property",
20 | "missing": "Missing",
21 | "expected": "Expected",
22 | "expected_tobe": "to be",
23 | "expected_got": "but got"
24 | },
25 | "error": {
26 | "mod": {
27 | "broken": "An error occured while loading the module",
28 | "not_long_enough": "The module doesn't have enough arguments, it has to look like:\n\n function (db, key, callback) {...}",
29 | "not_function": "The module doesn't return a function",
30 | "unexpected": "An error occured while executing the module",
31 | "not_object": "The module doesn't return an object",
32 | "init_missing": "'init' is not a function",
33 | "query_missing": "'query' is not a function"
34 | },
35 | "timeout": "Timeout: The module didn't respond after 10 seconds.",
36 | "not_same": "The output of the module doesn't match the expected output",
37 | "db": {
38 | "not_closed": "The database directory is still locked!\n\nClose it with `db.close(function () {})`"
39 | }
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/i18n/help/en.md:
--------------------------------------------------------------------------------
1 | # Having trouble with a {appname} exercise?
2 |
3 | A team of expert helper elves is eagerly waiting to assist you in
4 | mastering the basics of Node.js, or Level* / Node Databases in
5 | particular, simply go to:
6 |
7 | https://github.com/nodeschool/discussions/issues
8 |
9 | and add a **New Issue** and let us know what you're having trouble
10 | with. There are no __dumb__ questions! You may be
11 | redirected to one of the support channels below, depending on how
12 | complex your question is.
13 |
14 | If you have a specific question about LevelUP or one of the level*
15 | packages used in {appname}, you could consider one of the following
16 | support channels instead:
17 |
18 | - Visit ##leveldb on Freenode IRC
19 | - Submit your question to the Node.js Level* Google Group:
20 | https://groups.google.com/forum/#!forum/node-levelup
21 | - Open a new issue @ https://github.com/workshopper/node-levelup
22 |
23 | # Found a bug with {appname} or just want to contribute?
24 |
25 | The official repository for {appname} is:
26 |
27 | https://github.com/workshopper/levelmeup/
28 |
29 | Feel free to file a bug report or (preferably) a pull request.
30 |
--------------------------------------------------------------------------------
/i18n/help/ja.md:
--------------------------------------------------------------------------------
1 | # {appname} の課題で問題がありましたか？
2 |
3 | あなたがNode.jsの基本、あるいはLevel* / Node データベースを
4 | マスターすることに関して、エキスパート達が「是非サポートしたい！」
5 | と待っています。
6 | 以下のURLに行ってみましょう。
7 |
8 | https://github.com/nodeschool/discussions/issues
9 |
10 | **New Issue**を追加して、あなたが直面している問題を教えて下さい。
11 | 意味のない質問なんてありません！
12 | 込み入った質問の場合、下の方に記載されているチャンネルのどこかに
13 | 質問が転送されるかもしれません。
14 |
15 | もしあなたの質問がLevelUP、あるいは{appname}で使われている
16 | level*パッケージ特有のものであれば、以下のサポートチャンネルの
17 | 何れかを使うことを検討してみて下さい。
18 |
19 | - Freenode IRCの ##leveldb を訪れてみて下さい。
20 | - Node.js Level* Google Groupに質問してみて下さい。:
21 | https://groups.google.com/forum/#!forum/node-levelup
22 | - https://github.com/workshopper/node-levelup にIssueを作ってみて下さい。
23 |
24 | # {appname} のバグを見つけた、あるいは貢献して見たい場合
25 |
26 | {appname} の公式レポジトリは以下です。
27 |
28 | https://github.com/workshopper/levelmeup/
29 |
30 | 気軽にバグレポートを下さい。
31 | プルリクエストでもOKです。（こっちの方がいい！）
32 |
--------------------------------------------------------------------------------
/i18n/ja.json:
--------------------------------------------------------------------------------
1 | {
2 | "title": "LEVEL ME UP SCOTTY!",
3 | "subtitle": "Node.jsでのデータベースについて",
4 | "exercise": {
5 | "all_your_base": "ALL YOUR BASE",
6 | "get_your_level_on": "Get Your Level On!",
7 | "basics_get": "基礎: GET",
8 | "basics_put": "基礎: PUT",
9 | "basics_batch": "基礎: BATCH",
10 | "streaming": "ストリーミング",
11 | "horse_js_count": "@horse_js カウント",
12 | "horse_js_tweets": "@horse_js ツイート",
13 | "keywise": "キー的な話",
14 | "short_scrabble_words": "スクラブルワード",
15 | "sublevel": "Sublevel",
16 | "multilevel": "Multilevel"
17 | },
18 | "error": {
19 | "mod": {
20 | "broken": "モジュールのロード中にエラーが発生しました",
21 | "not_long_enough": "モジュールの引数の数が不足しています。以下の形式にして下さい。\n\n function (db, key, callback) {...}",
22 | "not_function": "モジュールが関数を返していません",
23 | "unexpected": "モジュールの実行中にエラーが発生しました",
24 | "not_object": "モジュールがオブジェクトを返していません",
25 | "init_missing": "'init'関数がありません",
26 | "query_missing": "'query'関数がありません"
27 | },
28 | "timeout": "タイムアウト: １０秒以上モジュールから反応がありません",
29 | "not_same": "モジュールの出力が期待する結果と一致しません",
30 | "db": {
31 | "not_closed": "データベースディレクトリがロックされたままです！\n\n`db.close(function () {})`を使ってクローズして下さい。"
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/levelmeup.js:
--------------------------------------------------------------------------------
1 | var workshopper = require('workshopper-adventure')
2 | var levelMeUp = workshopper({
3 | appDir: __dirname,
4 | menu: {
5 | bg: 'green'
6 | },
7 | languages: ['en', 'ja'],
8 | header: require('workshopper-adventure/default/header'),
9 | footer: require('workshopper-adventure/default/footer'),
10 | fail: require('workshopper-adventure/default/fail'),
11 | pass: require('workshopper-adventure/default/pass'),
12 | help: {
13 | file: './i18n/help/{lang}.md'
14 | }
15 | })
16 |
17 | levelMeUp.addAll([
18 | 'all_your_base',
19 | 'get_your_level_on',
20 | 'basics_get',
21 | 'basics_put',
22 | 'basics_batch',
23 | 'streaming',
24 | 'horse_js_count',
25 | 'horse_js_tweets',
26 | 'keywise',
27 | 'short_scrabble_words',
28 | 'sublevel',
29 | 'multilevel'
30 | ])
31 |
32 | module.exports = levelMeUp
33 |
--------------------------------------------------------------------------------
/levelmeup.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/workshopper/levelmeup/b4462bfb522fc7ad45b189a060a6e2b4908c2d89/levelmeup.png
--------------------------------------------------------------------------------
/lib/exercise.js:
--------------------------------------------------------------------------------
1 | var path = require('path')
2 | var os = require('os')
3 | var level = require('level')
4 | var rimraf = require('rimraf')
5 | var deepDiff = require('deep-diff')
6 | var execModule = require('exec-module')
7 | var formatDiff = require('./formatDiff')
8 |
9 | function setupDb (name) {
10 | // eslint-disable-next-line node/no-deprecated-api
11 | var dir = path.join(os.tmpdir ? os.tmpdir() : os.tmpDir(), '~levelmeup_' + name + '_' + process.pid)
12 | rimraf.sync(dir)
13 | return dir
14 | }
15 |
16 | function exec (opts, file, callback) {
17 | var dbDir = setupDb('1')
18 | execModule(file, {
19 | setUp: function (file, opt, callback) {
20 | var db = level(dbDir)
21 | opts.prepare(db, function (err) {
22 | if (err) {
23 | return callback(err)
24 | }
25 | db.close(callback)
26 | })
27 | },
28 | exec: function (file, opt, mod, callback) {
29 | opts.exec(dbDir, mod, callback)
30 | },
31 | timeout: 5000,
32 | tearDown: function (file, opt, err, data, callback) {
33 | var db = level(dbDir, function (err) {
34 | if (err && err.type === 'OpenError') {
35 | return callback(new Error(file + '\n\n{error.db.not_closed}'))
36 | } else if (err) {
37 | return callback(new Error(file + '\n\n{error.mod.unexpected}:\n\n```\n' + ((err && err.stack) || err) + '\n```'))
38 | }
39 | db.close(function () {
40 | try {
41 | rimraf.sync(dbDir)
42 | } catch (e) {
43 | // eat rimraf errors
44 | }
45 | callback(null, data)
46 | })
47 | })
48 | }
49 | }, callback)
50 | }
51 |
52 | module.exports = function (opt) {
53 | return {
54 | problem: {
55 | file: path.join(opt.dir, 'problem.{lang}.md')
56 | },
57 | solution: {
58 | file: path.join(opt.dir, 'solution.js'),
59 | type: 'js'
60 | },
61 | verify: function (args, callback) {
62 | var cmd = opt.init()
63 | var finish = function (err) {
64 | if (err) {
65 | callback(null, false, err)
66 | }
67 | callback(null, true)
68 | }
69 | exec(cmd, path.join(opt.dir, 'solution.js'), function (err, data) {
70 | if (err) {
71 | return finish('Error in this workshopper!\n\n```\n' + err.stack + '\n```')
72 | }
73 | exec(cmd, path.resolve(process.cwd(), args[0]), function (err, data2) {
74 | if (err) {
75 | return finish('```\n' + err.stack + '\n```')
76 | }
77 | var diffs = deepDiff(data, data2)
78 | if (diffs === undefined) {
79 | return finish()
80 | }
81 | try {
82 | finish('{error.not_same}:\n' + formatDiff(diffs))
83 | } catch (e) {
84 | console.log(e)
85 | }
86 | })
87 | })
88 | },
89 | run: function (args, callback) {
90 | var cmd = opt.init()
91 | exec(cmd, path.resolve(process.cwd(), args[0]), function (err, data) {
92 | if (err) {
93 | return callback(err, false)
94 | }
95 | console.log(JSON.stringify(data, null, 2))
96 | callback(null, true)
97 | })
98 | }
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/lib/formatDiff.js:
--------------------------------------------------------------------------------
1 | function formatNew (diff) {
2 | return '{diff.unexpected}: ' + diff.path.join('.')
3 | }
4 |
5 | function formatDeleted (diff) {
6 | return '{diff.missing}: ' + diff.path.join('.')
7 | }
8 |
9 | function formatEdited (diff) {
10 | return '{diff.expected} `' + (diff.path.join('.') || 'result') + '` {diff.expected_tobe} \n\n```\n' + JSON.stringify(diff.lhs, null, 2) + '\n```\n{diff.expected_got}\n```\n' + JSON.stringify(diff.rhs, null, 2) + '```\n\n'
11 | }
12 |
13 | function formatArray (diff) {
14 | diff.item.path = [diff.path.join('.') + '[' + diff.index + ']']
15 | return formatChange(diff.item)
16 | }
17 |
18 | function formatChange (diff) {
19 | if (!diff.path) {
20 | diff.path = []
21 | }
22 | if (diff.kind === 'N') {
23 | return formatNew(diff)
24 | }
25 | if (diff.kind === 'D') {
26 | return formatDeleted(diff)
27 | }
28 | if (diff.kind === 'E') {
29 | return formatEdited(diff)
30 | }
31 | if (diff.kind === 'A') {
32 | return formatArray(diff)
33 | }
34 | return ''
35 | }
36 |
37 | function formatChanges (changes) {
38 | return changes.map(formatChange).join('\n')
39 | }
40 |
41 | module.exports = function (diffs) {
42 | return '\n\n' + formatChanges(diffs) + '\n'
43 | }
44 |
--------------------------------------------------------------------------------
/lib/generate.js:
--------------------------------------------------------------------------------
1 | var gibberish = require('./gibberish')
2 |
3 | module.exports = function (i) {
4 | var key = 'level_' + Date.now().toString(32) + '_' + (Math.random() * 1000 | 0)
5 | var data = {}
6 | while (i-- > 0) {
7 | data[key + i] = gibberish()
8 | }
9 | return data
10 | }
11 |
--------------------------------------------------------------------------------
/lib/gibberish.js:
--------------------------------------------------------------------------------
1 | var path = require('path')
2 | module.exports = require('echomunge/dir2gibberish').bind(null, path.join(__dirname, '../node_modules/level/'))
3 |
--------------------------------------------------------------------------------
/lib/read-db.js:
--------------------------------------------------------------------------------
1 | var level = require('level')
2 |
3 | module.exports = function (dir, valueEncoding, callback) {
4 | level(dir, { valueEncoding: valueEncoding }, function (err, db) {
5 | if (err) {
6 | if (err.type === 'OpenError') {
7 | return callback(new Error(dir + '\n\n{error.db.not_closed}'))
8 | } else {
9 | return callback(new Error(dir + '\n\n{error.mod.unexpected}:\n\n```\n' + ((err && err.stack) || err) + '\n```'))
10 | }
11 | }
12 | var result = {}
13 | var stream = db.readStream()
14 | var error
15 | stream.on('data', function (entry) {
16 | result[entry.key] = entry.value
17 | })
18 | stream.on('error', function (err) {
19 | error = err
20 | })
21 | stream.on('end', function () {
22 | db.close(function (err) {
23 | callback(error || err, result)
24 | })
25 | })
26 | })
27 | }
28 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "levelmeup",
3 | "version": "1.0.1",
4 | "description": "Level Me Up Scotty! An intro to Node.js databases via a set of self-guided workshops.",
5 | "author": "Rod Vagg level-sublevel
314 |Separate sections of levelup, with hooks!
315 |
This module allows you to create seperate sections of a 317 | levelup database, 318 | kinda like tables in an sql database, but evented, and ranged, 319 | for real-time changing data.
320 |Stability
321 |Unstable: Expect patches and features, possible api changes.
322 |This is module is working well, but may change in the future as it's use is futher explored.
323 |Example
324 |var LevelUp = require('levelup')
325 | var Sublevel = require('level-sublevel')
326 |
327 | var db = Sublevel(LevelUp('/tmp/sublevel-example'))
328 | var sub = db.sublevel('stuff')
329 |
330 | //put a key into the main levelup
331 | db.put(key, value, function () {
332 |
333 | })
334 |
335 | //put a key into the sub-section!
336 | sub.put(key2, value, function () {
337 |
338 | })
339 | Sublevel prefixes each subsection so that it will not collide 342 | with the outer db when saving or reading!
343 |Hooks
344 |Hooks are specially built into Sublevel so that you can 345 | do all sorts of clever stuff, like generating views or 346 | logs when records are inserted!
347 |Records added via hooks will be atomically with the triggering change.
348 |Hooks Example
349 |Whenever a record is inserted, 350 | save an index to it by the time it was inserted.
351 |var sub = db.sublevel('SEQ')
352 |
353 | db.pre(function (ch, add) {
354 | add({
355 | key: ''+Date.now(),
356 | value: ch.key,
357 | type: 'put',
358 | prefix: sub //NOTE pass the destination db to add
359 | //and the value will end up in that subsection!
360 | })
361 | })
362 |
363 | db.put('key', 'VALUE', function (err) {
364 |
365 | //read all the records inserted by the hook!
366 |
367 | sub.createReadStream()
368 | .on('data', console.log)
369 |
370 | })
371 | Notice that sub is the second argument to add,
374 | which tells the hook to save the new record in the sub section.
Batches
376 |In sublevel batches also support a prefix: subdb property,
377 | if set, this row will be inserted into that database section,
378 | instead of the current section.
var sub1 = db.sublevel('SUB_1')
380 | var sub2 = db.sublevel('SUM_2')
381 |
382 | sub.batch([
383 | {key: 'key', value: 'Value', type: 'put'},
384 | {key: 'key', value: 'Value', type: 'put', prefix: sub2},
385 | ], function (err) {...})
386 | License
389 |MIT
390 |