PouchDB is an Open Source JavaScript Database inspired by Apache CouchDB that is designed to run well within the browser.
13 | 14 |PouchDB was created to help web developers build applications that work equally as well offline as they do online. It enables applications to store data locally while offline, and synchronise it with CouchDB and compatible servers when the application is back online, keeping the user's data in sync no matter where they next login.
15 | 16 | 24 | 25 |$ npm install pouchdb away
60 | in node.
61 |
75 |
76 |
87 |
88 |
89 |
90 |
--------------------------------------------------------------------------------
/tests/test.revs_diff.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var adapters = ['http-1', 'local-1'];
4 |
5 | if (typeof module !== undefined && module.exports) {
6 | var PouchDB = require('../lib');
7 | var testUtils = require('./test.utils.js');
8 | }
9 |
10 | adapters.map(function(adapter) {
11 |
12 | QUnit.module("revs diff:" + adapter, {
13 | setup : function () {
14 | this.name = testUtils.generateAdapterUrl(adapter);
15 | PouchDB.enableAllDbs = true;
16 | },
17 | teardown: testUtils.cleanupTestDatabases
18 | });
19 |
20 | asyncTest("Test revs diff", function() {
21 | var revs = [];
22 | testUtils.initTestDB(this.name, function(err, db) {
23 | db.post({test: "somestuff", _id: 'somestuff'}, function (err, info) {
24 | revs.push(info.rev);
25 | db.put({_id: info.id, _rev: info.rev, another: 'test'}, function(err, info2) {
26 | revs.push(info2.rev);
27 | db.revsDiff({'somestuff': revs}, function(err, results) {
28 | ok(!('somestuff' in results), 'werent missing any revs');
29 | revs.push('2-randomid');
30 | db.revsDiff({'somestuff': revs}, function(err, results) {
31 | ok('somestuff' in results, 'listed missing revs');
32 | ok(results.somestuff.missing.length === 1, 'listed currect number of');
33 | start();
34 | });
35 | });
36 | });
37 | });
38 | });
39 | });
40 |
41 | asyncTest('Missing docs should be returned with all revisions being asked for',
42 | function() {
43 | testUtils.initTestDB(this.name, function(err, db) {
44 | // empty database
45 | var revs = ['1-a', '2-a', '2-b'];
46 | db.revsDiff({'foo': revs}, function(err, results) {
47 | ok('foo' in results, 'listed missing revs');
48 | deepEqual(results.foo.missing, revs, 'listed all revs');
49 | start();
50 | });
51 | });
52 | });
53 |
54 | asyncTest('Conflicting revisions that are available should not be marked as' +
55 | ' missing (#939)', function() {
56 | var doc = {_id: '939', _rev: '1-a'};
57 |
58 | function createConflicts(db, callback) {
59 | db.put(doc, {new_edits: false}, function(err, res) {
60 | testUtils.putAfter(db, {_id: '939', _rev: '2-a'}, '1-a', function(err, res) {
61 | testUtils.putAfter(db, {_id: '939', _rev: '2-b'}, '1-a', callback);
62 | });
63 | });
64 | }
65 |
66 | testUtils.initTestDB(this.name, function(err, db) {
67 | createConflicts(db, function() {
68 | db.revsDiff({'939': ['1-a', '2-a', '2-b']}, function(err, results) {
69 | ok(!('939' in results), 'no missing revs');
70 | start();
71 | });
72 | });
73 | });
74 | });
75 |
76 | asyncTest('Deleted revisions that are available should not be marked as' +
77 | ' missing (#935)', function() {
78 |
79 | function createDeletedRevision(db, callback) {
80 | db.put({_id: '935', _rev: '1-a'}, {new_edits: false}, function (err, info) {
81 | testUtils.putAfter(db, {_id: '935', _rev: '2-a', _deleted: true}, '1-a', callback);
82 | });
83 | }
84 |
85 | testUtils.initTestDB(this.name, function(err, db) {
86 | createDeletedRevision(db, function() {
87 | db.revsDiff({'935': ['1-a', '2-a']}, function(err, results) {
88 | ok(!('935' in results), 'should not return the deleted revs');
89 | start();
90 | });
91 | });
92 | });
93 | });
94 | });
95 |
--------------------------------------------------------------------------------
/docs/static/style/noun_project_5618.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/tests/test.design_docs.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var adapters = ['local-1', 'http-1'];
4 |
5 | if (typeof module !== undefined && module.exports) {
6 | var PouchDB = require('../lib');
7 | var testUtils = require('./test.utils.js');
8 | }
9 |
10 | adapters.map(function(adapter) {
11 |
12 | QUnit.module("design_docs: " + adapter, {
13 | setup : function () {
14 | this.name = testUtils.generateAdapterUrl(adapter);
15 | PouchDB.enableAllDbs = true;
16 | },
17 | teardown: testUtils.cleanupTestDatabases
18 | });
19 |
20 | var doc = {
21 | _id: '_design/foo',
22 | views: {
23 | scores: {
24 | map: 'function(doc) { if (doc.score) { emit(null, doc.score); } }',
25 | reduce: 'function(keys, values, rereduce) { return sum(values); }'
26 | }
27 | },
28 | filters: {
29 | even: 'function(doc) { return doc.integer % 2 === 0; }'
30 | }
31 | };
32 |
33 | asyncTest("Test writing design doc", function () {
34 | testUtils.initTestDB(this.name, function(err, db) {
35 | db.post(doc, function (err, info) {
36 | ok(!err, 'Wrote design doc');
37 | db.get('_design/foo', function (err, info) {
38 | ok(!err, 'Read design doc');
39 | start();
40 | });
41 | });
42 | });
43 | });
44 |
45 | asyncTest("Changes filter", function() {
46 |
47 | var docs1 = [
48 | doc,
49 | {_id: "0", integer: 0},
50 | {_id: "1", integer: 1},
51 | {_id: "2", integer: 2},
52 | {_id: "3", integer: 3}
53 | ];
54 |
55 | var docs2 = [
56 | {_id: "4", integer: 4},
57 | {_id: "5", integer: 5},
58 | {_id: "6", integer: 6},
59 | {_id: "7", integer: 7}
60 | ];
61 |
62 | testUtils.initTestDB(this.name, function(err, db) {
63 | var count = 0;
64 | db.bulkDocs({docs: docs1}, function(err, info) {
65 | var changes = db.changes({
66 | filter: 'foo/even',
67 | onChange: function(change) {
68 | count += 1;
69 | if (count === 4) {
70 | ok(true, 'We got all the changes');
71 | changes.cancel();
72 | start();
73 | }
74 | },
75 | continuous: true
76 | });
77 | db.bulkDocs({docs: docs2}, {});
78 | });
79 | });
80 | });
81 |
82 | asyncTest("Basic views", function () {
83 |
84 | var docs1 = [
85 | doc,
86 | {_id: "dale", score: 3},
87 | {_id: "mikeal", score: 5},
88 | {_id: "max", score: 4},
89 | {_id: "nuno", score: 3}
90 | ];
91 |
92 | testUtils.initTestDB(this.name, function(err, db) {
93 | db.bulkDocs({docs: docs1}, function(err, info) {
94 | db.query('foo/scores', {reduce: false}, function(err, result) {
95 | equal(result.rows.length, 4, 'Correct # of results');
96 | db.query('foo/scores', function(err, result) {
97 | equal(result.rows[0].value, 15, 'Reduce gave correct result');
98 | start();
99 | });
100 | });
101 | });
102 | });
103 | });
104 |
105 | asyncTest("Concurrent queries", function() {
106 | testUtils.initTestDB(this.name, function(err, db) {
107 | db.bulkDocs({docs: [doc, {_id: "dale", score: 3}]}, function(err, info) {
108 | var cnt = 0;
109 | db.query('foo/scores', {reduce: false}, function(err, result) {
110 | equal(result.rows.length, 1, 'Correct # of results');
111 | if (cnt++ === 1) {
112 | start();
113 | }
114 | });
115 | db.query('foo/scores', {reduce: false}, function(err, result) {
116 | equal(result.rows.length, 1, 'Correct # of results');
117 | if (cnt++ === 1) {
118 | start();
119 | }
120 | });
121 | });
122 | });
123 | });
124 |
125 | });
126 |
--------------------------------------------------------------------------------
/lib/deps/extend.js:
--------------------------------------------------------------------------------
1 | // Extends method
2 | // (taken from http://code.jquery.com/jquery-1.9.0.js)
3 | // Populate the class2type map
4 | var class2type = {};
5 |
6 | var types = ["Boolean", "Number", "String", "Function", "Array", "Date", "RegExp", "Object", "Error"];
7 | for (var i = 0; i < types.length; i++) {
8 | var typename = types[i];
9 | class2type[ "[object " + typename + "]" ] = typename.toLowerCase();
10 | }
11 |
12 | var core_toString = class2type.toString;
13 | var core_hasOwn = class2type.hasOwnProperty;
14 |
15 | function type(obj) {
16 | if (obj === null) {
17 | return String( obj );
18 | }
19 | return typeof obj === "object" || typeof obj === "function" ?
20 | class2type[core_toString.call(obj)] || "object" :
21 | typeof obj;
22 | };
23 |
24 | function isWindow(obj) {
25 | return obj !== null && obj === obj.window;
26 | }
27 |
28 | function isPlainObject( obj ) {
29 | // Must be an Object.
30 | // Because of IE, we also have to check the presence of the constructor property.
31 | // Make sure that DOM nodes and window objects don't pass through, as well
32 | if ( !obj || type(obj) !== "object" || obj.nodeType || isWindow( obj ) ) {
33 | return false;
34 | }
35 |
36 | try {
37 | // Not own constructor property must be Object
38 | if ( obj.constructor &&
39 | !core_hasOwn.call(obj, "constructor") &&
40 | !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
41 | return false;
42 | }
43 | } catch ( e ) {
44 | // IE8,9 Will throw exceptions on certain host objects #9897
45 | return false;
46 | }
47 |
48 | // Own properties are enumerated firstly, so to speed up,
49 | // if last one is own, then all properties are own.
50 |
51 | var key;
52 | for ( key in obj ) {}
53 |
54 | return key === undefined || core_hasOwn.call( obj, key );
55 | };
56 |
57 |
58 | function isFunction(obj) {
59 | return type(obj) === "function";
60 | };
61 |
62 | var isArray = Array.isArray || function (obj) {
63 | return type(obj) === "array";
64 | };
65 |
66 | function extend() {
67 | var options, name, src, copy, copyIsArray, clone,
68 | target = arguments[0] || {},
69 | i = 1,
70 | length = arguments.length,
71 | deep = false;
72 |
73 | // Handle a deep copy situation
74 | if ( typeof target === "boolean" ) {
75 | deep = target;
76 | target = arguments[1] || {};
77 | // skip the boolean and the target
78 | i = 2;
79 | }
80 |
81 | // Handle case when target is a string or something (possible in deep copy)
82 | if ( typeof target !== "object" && !isFunction (target) ) {
83 | target = {};
84 | }
85 |
86 | // extend jQuery itself if only one argument is passed
87 | if ( length === i ) {
88 | target = this;
89 | --i;
90 | }
91 |
92 | for ( ; i < length; i++ ) {
93 | // Only deal with non-null/undefined values
94 | if ((options = arguments[ i ]) != null) {
95 | // Extend the base object
96 | for ( name in options ) {
97 | src = target[ name ];
98 | copy = options[ name ];
99 |
100 | // Prevent never-ending loop
101 | if ( target === copy ) {
102 | continue;
103 | }
104 |
105 | // Recurse if we're merging plain objects or arrays
106 | if ( deep && copy && ( isPlainObject(copy) || (copyIsArray = isArray(copy)) ) ) {
107 | if ( copyIsArray ) {
108 | copyIsArray = false;
109 | clone = src && isArray(src) ? src : [];
110 |
111 | } else {
112 | clone = src && isPlainObject(src) ? src : {};
113 | }
114 |
115 | // Never move original objects, clone them
116 | target[ name ] = extend( deep, clone, copy );
117 |
118 | // Don't bring in undefined values
119 | } else if ( copy !== undefined ) {
120 | if (!(isArray(options) && isFunction (copy))) {
121 | target[ name ] = copy;
122 | }
123 | }
124 | }
125 | }
126 | }
127 |
128 | // Return the modified object
129 | return target;
130 | };
131 |
132 |
133 | module.exports = extend;
134 |
135 |
--------------------------------------------------------------------------------
/tests/test.slash_id.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var adapters = ['local-1', 'http-1'];
4 | var repl_adapters = [['local-1', 'http-1'],
5 | ['http-1', 'http-2'],
6 | ['http-1', 'local-1'],
7 | ['local-1', 'local-2']];
8 |
9 | if (typeof module !== undefined && module.exports) {
10 | var PouchDB = require('../lib');
11 | var testUtils = require('./test.utils.js');
12 | }
13 |
14 | adapters.map(function(adapter) {
15 | QUnit.module('functions with / in _id: ' + adapter, {
16 | setup : function () {
17 | this.name = testUtils.generateAdapterUrl(adapter);
18 | PouchDB.enableAllDbs = true;
19 | },
20 | teardown: testUtils.cleanupTestDatabases
21 | });
22 |
23 | var binAttDoc = {
24 | _id: "bin_doc",
25 | _attachments:{
26 | "foo.txt": {
27 | content_type:"text/plain",
28 | data: "VGhpcyBpcyBhIGJhc2U2NCBlbmNvZGVkIHRleHQ="
29 | }
30 | }
31 | };
32 |
33 | asyncTest('Insert a doc, putAttachment and allDocs', function() {
34 | testUtils.initTestDB(this.name, function(err, db) {
35 | ok(!err, 'opened the pouch');
36 | var docId = 'doc/with/slashes';
37 | var attachmentId = 'attachment/with/slashes';
38 | var blobData = 'attachment content';
39 | var blob = testUtils.makeBlob(blobData);
40 | var doc = {_id: docId, test: true};
41 | db.put(doc, function(err, info) {
42 | ok(!err, 'saved doc');
43 | strictEqual(info.id, 'doc/with/slashes', 'id is the same as inserted');
44 | db.putAttachment(docId, attachmentId, info.rev, blob, 'text/plain', function(err, res) {
45 | db.getAttachment(docId, attachmentId, function(err, res) {
46 | testUtils.readBlob(res, function(data) {
47 | db.get(docId, function(err, res){
48 | strictEqual(res._id, docId);
49 | ok(attachmentId in res._attachments, 'contains correct attachment');
50 | start();
51 | });
52 | });
53 | });
54 | });
55 | });
56 | });
57 | });
58 |
59 | asyncTest('BulkDocs and changes', function() {
60 | testUtils.initTestDB(this.name, function(err, db) {
61 | var docs = [
62 | {_id: 'part/doc1', int: 1},
63 | {_id: 'part/doc2', int: 2, _attachments: {
64 | 'attachment/with/slash': {
65 | content_type: 'text/plain',
66 | data: 'c29tZSBkYXRh'
67 | }
68 | }},
69 | {_id: 'part/doc3', int: 3}
70 | ];
71 | db.bulkDocs({docs: docs}, function(err, res) {
72 | for(var i = 0; i < 3; i++){
73 | strictEqual(res[i].ok, true, 'correctly inserted ' + docs[i]._id);
74 | }
75 | db.allDocs({include_docs: true, attachments: true}, function(err, res) {
76 | res.rows.sort(function(a, b){return a.doc.int - b.doc.int;});
77 | for(var i = 0; i < 3; i++){
78 | strictEqual(res.rows[i].doc._id, docs[i]._id, '(allDocs) correctly inserted ' + docs[i]._id);
79 | }
80 | strictEqual('attachment/with/slash' in res.rows[1].doc._attachments, true, 'doc2 has attachment');
81 | db.changes({
82 | complete: function(err, res) {
83 | res.results.sort(function(a, b){return a.id.localeCompare(b.id);});
84 | for(var i = 0; i < 3; i++){
85 | strictEqual(res.results[i].id, docs[i]._id, '(changes) correctly inserted ' + docs[i]._id);
86 | }
87 | start();
88 | }
89 | });
90 | });
91 | });
92 | });
93 | });
94 | });
95 |
96 |
97 | repl_adapters.map(function(adapters) {
98 |
99 | QUnit.module('replication with / in _id: ' + adapters[0] + ':' + adapters[1], {
100 | setup : function () {
101 | this.name = testUtils.generateAdapterUrl(adapters[0]);
102 | this.remote = testUtils.generateAdapterUrl(adapters[1]);
103 | }
104 | });
105 |
106 | asyncTest("Attachments replicate", function() {
107 | var binAttDoc = {
108 | _id: "bin_doc/with/slash",
109 | _attachments:{
110 | "foo/with/slash.txt": {
111 | content_type:"text/plain",
112 | data: "VGhpcyBpcyBhIGJhc2U2NCBlbmNvZGVkIHRleHQ="
113 | }
114 | }
115 | };
116 |
117 | var docs1 = [
118 | binAttDoc,
119 | {_id: "0", integer: 0},
120 | {_id: "1", integer: 1},
121 | {_id: "2", integer: 2},
122 | {_id: "3", integer: 3}
123 | ];
124 |
125 | testUtils.initDBPair(this.name, this.remote, function(db, remote) {
126 | remote.bulkDocs({docs: docs1}, function(err, info) {
127 | var replicate = db.replicate.from(remote, function() {
128 | db.get('bin_doc/with/slash', {attachments: true}, function(err, doc) {
129 | equal(binAttDoc._attachments['foo/with/slash.txt'].data,
130 | doc._attachments['foo/with/slash.txt'].data);
131 | start();
132 | });
133 | });
134 | });
135 | });
136 | });
137 | });
138 |
--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | [PouchDB](http://pouchdb.com/) - The Javascript Database that Syncs
2 | ==================================================
3 |
4 | Welcome, so you are thinking about contributing to PouchDB? awesome, this is a great place to start.
5 |
6 | Get in Touch
7 | ------------
8 |
9 | The following documentation should answer most of the common questions about how to get starting contributing, if you have any questions, please feel free to ask on the
10 | [PouchDB Mailing List](https://groups.google.com/forum/#!forum/pouchdb) or in #pouchdb on irc.freenode.net.
11 |
12 | Most project discussions should happen on the Mailing list / Bug Tracker and IRC, however if you are a first time contributor and want some help getting started feel free to send a private email to any of the following maintainers:
13 |
14 | * Dale Harvey (dale@arandomurl.com, daleharvey on IRC)
15 | * Calvin Metcalf (calvin.metcalf@gmail.com)
16 |
17 |
18 | Good First Patch
19 | ----------------
20 |
21 | If you are looking for something to work on, we try to maintain a list of issues that should be suitable for first time contributions, they can be found tagged [goodfirstpatch](https://github.com/daleharvey/pouchdb/issues?labels=goodfirstpatch&state=open).
22 |
23 |
24 | Guide to Contributions
25 | --------------------------------------
26 |
27 | * Almost all Pull Requests for features or bug fixes will need tests
28 | * We follow [Felix's Node.js Style Guide](http://nodeguide.com/style.html)
29 | * Almost all Pull Requests for features or bug fixes will need tests (seriously, its really important)
30 | * Before opening a pull request run `$ npm test` to lint test the changes and run node tests. Preferably run the browser tests as well.
31 | * Commit messages should follow the following style:
32 |
33 | ```
34 | (#99) - A brief one line description < 50 chars
35 |
36 | Followed by further explanation if needed, this should be wrapped at
37 | around 72 characters. Most commits should reference an existing
38 | issue
39 | ```
40 |
41 | Dependencies
42 | --------------------------------------
43 |
44 | PouchDB needs the following to be able to build and test your build, if you havent installed them then best to do do so now, we will wait.
45 |
46 | * [Node.js](http://nodejs.org/)
47 | * [CouchDB](http://couchdb.apache.org/)
48 |
49 | Building PouchDB
50 | --------------------------------------
51 |
52 | All dependancies installed? great, now building PouchDB itself is a breeze:
53 |
54 | $ cd pouchdb
55 | $ npm install
56 | $ npm run build
57 |
58 | You will now have various distributions of PouchDB in your `dist` folder, congratulations.
59 |
60 | Running PouchDB Tests
61 | --------------------------------------
62 |
63 | The PouchDB test suite expects an instance of CouchDB running in Admin Party on http://127.0.0.1:5984, you can configure this by sending the `COUCH_HOST` env var when running the Node tests or the `dev-server`
64 |
65 | ### Node Tests
66 |
67 | Run all tests with:
68 |
69 | $ npm run test-node
70 |
71 | Run an indivitual test:
72 |
73 | $ TEST_FILE=test.basics.js npm run test-node
74 |
75 | ### Browser Tests
76 |
77 | Browser tests require a running HTTP server and a CORS proxy:
78 |
79 | $ npm run dev-server
80 | # or
81 | $ COUCH_HOST=http://user:pass@myname.host.com npm run dev-server
82 |
83 | Now visit http://127.0.0.1:8000/tests/test.html in your browser add ?testFiles=test.basics.js to run single test file. You do not need to manually rebuild PouchDB when you run the `dev-server` target, any changes you make to the source will automatically be built.
84 |
85 | ### All Tests
86 |
87 | To run all tests:
88 |
89 | $ npm test
90 |
91 | Git Essentials
92 | --------------------------------------
93 |
94 | Workflows can vary, but here is a very simple workflow for contributing a bug fix:
95 |
96 | $ git clone git@github.com:myfork/pouchdb.git
97 | $ git remote add pouchdb https://github.com/daleharvey/pouchdb.git
98 |
99 | $ git checkout -b 121-issue-keyword master
100 | # Write tests + code
101 | $ git add src/afile.js
102 | $ git commit -m "(#121) - A brief description of what I changed"
103 | $ git push origin 121-issue-keyword
104 |
105 | Building PouchDB Documentation
106 | --------------------------------------
107 |
108 | The source for the website http://pouchdb.com is stored inside the `docs` directory of the PouchDB repository, you can make changes and submit pull requests as with any other patch. To build and view the website locally you will need to install [jekyll](http://jekyllrb.com/) then:
109 |
110 | $ cd docs
111 | $ jekyll -w serve
112 |
113 | You should now find the documentation at http://127.0.0.1:4000
114 |
115 | Committers!
116 | --------------
117 |
118 | With great power comes great responsibility yada yada yada:
119 |
120 | * Code is peer reviewed, you should (almost) never push your own code.
121 | * Please dont accidently force push to master.
122 | * Cherry Pick / Rebase commits, dont use the big green button.
123 | * Ensure reviewed code follows the above contribution guidelines, if it doesnt feel free to ammend and make note.
124 | * Please try to watch when Pull Requests are made and review and / or commit them in a timely manner.
125 | * Thanks, you are all awesome human beings.
126 |
--------------------------------------------------------------------------------
/tests/qunit/qunit.css:
--------------------------------------------------------------------------------
1 | /**
2 | * QUnit v1.9.0pre - A JavaScript Unit Testing Framework
3 | *
4 | * http://docs.jquery.com/QUnit
5 | *
6 | * Copyright (c) 2012 John Resig, Jörn Zaefferer
7 | * Dual licensed under the MIT (MIT-LICENSE.txt)
8 | * or GPL (GPL-LICENSE.txt) licenses.
9 | */
10 |
11 | /** Font Family and Sizes */
12 |
13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
14 | font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
15 | }
16 |
17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
18 | #qunit-tests { font-size: smaller; }
19 |
20 |
21 | /** Resets */
22 |
23 | #qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
24 | margin: 0;
25 | padding: 0;
26 | }
27 |
28 |
29 | /** Header */
30 |
31 | #qunit-header {
32 | padding: 0.5em 0 0.5em 1em;
33 |
34 | color: #8699a4;
35 | background-color: #0d3349;
36 |
37 | font-size: 1.5em;
38 | line-height: 1em;
39 | font-weight: normal;
40 |
41 | border-radius: 15px 15px 0 0;
42 | -moz-border-radius: 15px 15px 0 0;
43 | -webkit-border-top-right-radius: 15px;
44 | -webkit-border-top-left-radius: 15px;
45 | }
46 |
47 | #qunit-header a {
48 | text-decoration: none;
49 | color: #c2ccd1;
50 | }
51 |
52 | #qunit-header a:hover,
53 | #qunit-header a:focus {
54 | color: #fff;
55 | }
56 |
57 | #qunit-header label {
58 | display: inline-block;
59 | padding-left: 0.5em;
60 | }
61 |
62 | #qunit-banner {
63 | height: 5px;
64 | }
65 |
66 | #qunit-testrunner-toolbar {
67 | padding: 0.5em 0 0.5em 2em;
68 | color: #5E740B;
69 | background-color: #eee;
70 | }
71 |
72 | #qunit-userAgent {
73 | padding: 0.5em 0 0.5em 2.5em;
74 | background-color: #2b81af;
75 | color: #fff;
76 | text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
77 | }
78 |
79 |
80 | /** Tests: Pass/Fail */
81 |
82 | #qunit-tests {
83 | list-style-position: inside;
84 | }
85 |
86 | #qunit-tests li {
87 | padding: 0.4em 0.5em 0.4em 2.5em;
88 | border-bottom: 1px solid #fff;
89 | list-style-position: inside;
90 | }
91 |
92 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running {
93 | display: none;
94 | }
95 |
96 | #qunit-tests li strong {
97 | cursor: pointer;
98 | }
99 |
100 | #qunit-tests li a {
101 | padding: 0.5em;
102 | color: #c2ccd1;
103 | text-decoration: none;
104 | }
105 | #qunit-tests li a:hover,
106 | #qunit-tests li a:focus {
107 | color: #000;
108 | }
109 |
110 | #qunit-tests ol {
111 | margin-top: 0.5em;
112 | padding: 0.5em;
113 |
114 | background-color: #fff;
115 |
116 | border-radius: 15px;
117 | -moz-border-radius: 15px;
118 | -webkit-border-radius: 15px;
119 |
120 | box-shadow: inset 0px 2px 13px #999;
121 | -moz-box-shadow: inset 0px 2px 13px #999;
122 | -webkit-box-shadow: inset 0px 2px 13px #999;
123 | }
124 |
125 | #qunit-tests table {
126 | border-collapse: collapse;
127 | margin-top: .2em;
128 | }
129 |
130 | #qunit-tests th {
131 | text-align: right;
132 | vertical-align: top;
133 | padding: 0 .5em 0 0;
134 | }
135 |
136 | #qunit-tests td {
137 | vertical-align: top;
138 | }
139 |
140 | #qunit-tests pre {
141 | margin: 0;
142 | white-space: pre-wrap;
143 | word-wrap: break-word;
144 | }
145 |
146 | #qunit-tests del {
147 | background-color: #e0f2be;
148 | color: #374e0c;
149 | text-decoration: none;
150 | }
151 |
152 | #qunit-tests ins {
153 | background-color: #ffcaca;
154 | color: #500;
155 | text-decoration: none;
156 | }
157 |
158 | /*** Test Counts */
159 |
160 | #qunit-tests b.counts { color: black; }
161 | #qunit-tests b.passed { color: #5E740B; }
162 | #qunit-tests b.failed { color: #710909; }
163 |
164 | #qunit-tests li li {
165 | margin: 0.5em;
166 | padding: 0.4em 0.5em 0.4em 0.5em;
167 | background-color: #fff;
168 | border-bottom: none;
169 | list-style-position: inside;
170 | }
171 |
172 | /*** Passing Styles */
173 |
174 | #qunit-tests li li.pass {
175 | color: #5E740B;
176 | background-color: #fff;
177 | border-left: 26px solid #C6E746;
178 | }
179 |
180 | #qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; }
181 | #qunit-tests .pass .test-name { color: #366097; }
182 |
183 | #qunit-tests .pass .test-actual,
184 | #qunit-tests .pass .test-expected { color: #999999; }
185 |
186 | #qunit-banner.qunit-pass { background-color: #C6E746; }
187 |
188 | /*** Failing Styles */
189 |
190 | #qunit-tests li li.fail {
191 | color: #710909;
192 | background-color: #fff;
193 | border-left: 26px solid #EE5757;
194 | white-space: pre;
195 | }
196 |
197 | #qunit-tests > li:last-child {
198 | border-radius: 0 0 15px 15px;
199 | -moz-border-radius: 0 0 15px 15px;
200 | -webkit-border-bottom-right-radius: 15px;
201 | -webkit-border-bottom-left-radius: 15px;
202 | }
203 |
204 | #qunit-tests .fail { color: #000000; background-color: #EE5757; }
205 | #qunit-tests .fail .test-name,
206 | #qunit-tests .fail .module-name { color: #000000; }
207 |
208 | #qunit-tests .fail .test-actual { color: #EE5757; }
209 | #qunit-tests .fail .test-expected { color: green; }
210 |
211 | #qunit-banner.qunit-fail { background-color: #EE5757; }
212 |
213 |
214 | /** Result */
215 |
216 | #qunit-testresult {
217 | padding: 0.5em 0.5em 0.5em 2.5em;
218 |
219 | color: #2b81af;
220 | background-color: #D2E0E6;
221 |
222 | border-bottom: 1px solid white;
223 | }
224 | #qunit-testresult .module-name {
225 | font-weight: bold;
226 | }
227 |
228 | /** Fixture */
229 |
230 | #qunit-fixture {
231 | position: absolute;
232 | top: -10000px;
233 | left: -10000px;
234 | width: 1000px;
235 | height: 1000px;
236 | }
237 |
--------------------------------------------------------------------------------
/docs/static/style/pouchdb.css:
--------------------------------------------------------------------------------
1 | /*** GLOBAL TAG DEFINITIONS ***/
2 | * {
3 | box-sizing: border-box;
4 | }
5 |
6 | html {
7 | overflow-y: scroll;
8 | }
9 |
10 | body {
11 | margin: 0;
12 | font-family: 'Helvetica Neue', Helvetica, Arial, Sans-Serif;
13 | line-height: 1.4em;
14 | font-size: 15px;
15 | }
16 |
17 | a {
18 | text-decoration: none;
19 | }
20 |
21 | p {
22 | margin: 0 0 15px 0;
23 | }
24 |
25 | pre {
26 | line-height: 125%;
27 | padding: 10px;
28 | margin: 0;
29 | }
30 |
31 | table {
32 | padding: 0;
33 | border-spacing:0;
34 | border-collapse:collapse;
35 | }
36 |
37 | table td, table th {
38 | padding: 0;
39 | }
40 |
41 | /*** UTILITY CLASSES ***/
42 |
43 | .lineno {
44 | border-right: 1px solid #666;
45 | padding-right: 5px;
46 | font-size: 12px;
47 | }
48 |
49 | div.highlight, div.linenodiv {
50 | margin-bottom: 10px;
51 | }
52 |
53 | div.highlight {
54 | border-radius: 0 5px 5px 0;
55 | }
56 |
57 | div.linenodiv {
58 | border-radius: 5px 0 0 5px;
59 | background-color: rgb(7, 54, 66);
60 | color: #777;
61 | border-right: 1px solid rgba(0, 0, 0, 0.6);
62 | }
63 |
64 | p code {
65 | padding: 0px 3px;
66 | background: none repeat scroll 0% 0% rgb(255, 255, 255);
67 | border: 1px solid rgb(221, 221, 221);
68 | font-size: 12px;
69 | }
70 |
71 | /*** GLOBAL LAYOUT ***/
72 |
73 | #headerwrapper, #footerwrapper, #content {
74 | max-width: 960px;
75 | margin: 0 auto;
76 | }
77 |
78 | header {
79 | background: none repeat scroll 0% 0% rgb(51, 51, 51);
80 | overflow: auto;
81 | }
82 |
83 | header h1 {
84 | line-height: 30px;
85 | }
86 |
87 | header a {
88 | line-height: 30px;
89 | color: #FFF;
90 | }
91 |
92 | nav a {
93 | padding-top: 10px;
94 | padding-bottom: 10px;
95 | padding-left: 20px;
96 | padding-right: 20px;
97 | text-transform: uppercase;
98 | }
99 |
100 | nav li:first-child a {
101 | border-left: 0;
102 | }
103 |
104 | nav a:hover {
105 | background: #000;
106 | }
107 |
108 | header nav {
109 | float: right;
110 | margin-top: 4px;
111 | }
112 |
113 | header ul {
114 | list-style-type: none;
115 | }
116 |
117 | header li {
118 | float: left;
119 | }
120 |
121 | header h1 {
122 | float: left;
123 | }
124 |
125 | footer {
126 | margin-top: 50px;
127 | background: #333;
128 | overflow: auto;
129 | padding-bottom: 40px;
130 | }
131 |
132 | footer section {
133 | min-width: 240px;
134 | float: left;
135 | }
136 |
137 | footer ul {
138 | list-style-type: none;
139 | padding: 0;
140 | margin: 0;
141 | }
142 |
143 | footer a {
144 | color: #FFF;
145 | }
146 |
147 | footer h2 {
148 | color: #999;
149 | line-height: 35px;
150 | font-weight: normal;
151 | margin-bottom: 0px;
152 | }
153 |
154 | #content {
155 | overflow: auto;
156 | }
157 |
158 | #download {
159 | float: left;
160 | }
161 |
162 | #download a {
163 | display: block;
164 | background: #000;
165 | margin-top: 17px;
166 | margin-left: 20px;
167 | line-height: 30px;
168 | padding: 3px 15px;
169 | border-radius: 5px;
170 | }
171 |
172 | #learn-more {
173 | display: block;
174 | width: 100px;
175 | margin: 20px auto;
176 | padding: 10px;
177 | border-radius: 10px;
178 | color: white;
179 | }
180 |
181 | #logos a {
182 | transition: opacity 0.5s;
183 | opacity: 0.3;
184 | display: block;
185 | text-indent: -9999px;
186 | width: 64px;
187 | height: 64px;
188 | float: left;
189 | margin-top: 20px;
190 | margin-right: 10px;
191 | background-size: 100%;
192 | }
193 |
194 | #couchdb_logo {
195 | background: url(couchdb-icon-64px.png);
196 | }
197 |
198 | #github_logo {
199 | background: url(GitHub-Mark-64px.png);
200 | }
201 | #twitter_logo {
202 | background: url(twitter-bird-light-bgs.png);
203 | }
204 |
205 | #logos a:hover {
206 | opacity: 1;
207 | }
208 |
209 |
210 | /*** PAGE LAYOUT - HOME ***/
211 |
212 | #the_database_that_syncs {
213 | font-weight: normal;
214 | font-size: 36px;
215 | text-align: center;
216 | line-height: 60px;
217 | }
218 |
219 | #home1 {
220 | margin-top: 20px;
221 | overflow: auto;
222 | position: relative;
223 | }
224 |
225 | #home1 section {
226 | width: 50%;
227 | float: left;
228 | }
229 |
230 | #home1 section:first-child {
231 | width: calc(50% - 20px);
232 | padding-right: 20px;
233 | }
234 |
235 | #home2 {
236 | margin-top: 30px;
237 | overflow: auto;
238 | }
239 |
240 | #home2 section {
241 | box-sizing: border-box;
242 | width: 23%;
243 | padding: 5%;
244 | float: left;
245 | overflow: hidden;
246 | text-align: center;
247 | }
248 |
249 | #home2 section:last-child {
250 | border-right: 0;
251 | }
252 |
253 | #home2 section h2 {
254 | margin-top: 0;
255 | text-align: center;
256 | font-weight: normal;
257 | }
258 |
259 | #download {
260 | text-align: left;
261 | }
262 |
263 | #home1 ul {
264 | padding: 0px 20px 0px 0;
265 | list-style-type: none;
266 | width: 450px;
267 | }
268 | #home1 li:first-child {
269 | border-top: 0;
270 | }
271 | #home1 li {
272 | border-top: 1px solid #CCC;
273 | padding: 5px 0;
274 | }
275 | #home1 small {
276 | width: 100px;
277 | display: block;
278 | float: right;
279 | text-align: right;
280 | }
281 | #home1 strong {
282 | font-weight: normal;
283 | font-size: 16px;
284 | text-transform: uppercase;
285 | }
286 |
287 | #news {
288 | position: absolute;
289 | bottom: 0;
290 | }
291 |
292 | /*** PAGE LAYOUT - LEARN ***/
293 |
294 | #learn-nav {
295 | width: 200px;
296 | float: left;
297 | }
298 |
299 | #learn-content {
300 | width: 700px;
301 | float: right;
302 | }
303 |
304 | #learn-nav ul {
305 | padding: 0;
306 | list-style-type: none;
307 | border-top: 1px solid #CCC;
308 | }
309 |
310 | #learn-nav a {
311 | display: block;
312 | line-height: 30px;
313 | border-style: solid;
314 | border-width: 0 1px 1px 1px;
315 | border-color: #CCC;
316 | text-indent: 10px;
317 | color: #666;
318 | }
319 |
320 | #learn-nav a:hover {
321 | background: #EEE;
322 | }
--------------------------------------------------------------------------------
/tests/test.auth_replication.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var remote = {host: 'localhost:2020'};
4 | var local = 'test_suite_db';
5 |
6 | if (typeof module !== undefined && module.exports) {
7 | var PouchDB = require('../lib');
8 | var testUtils = require('./test.utils.js');
9 | }
10 |
11 | QUnit.module('auth_replication', {
12 | setup: function () {
13 | this.name = local;
14 | this.remote = 'http://' + remote.host + '/test_suite_db/';
15 | },
16 | teardown: function() {
17 | if (!testUtils.PERSIST_DATABASES) {
18 | Pouch.destroy(this.name);
19 | Pouch.destroy(this.remote);
20 | }
21 | }
22 | });
23 |
24 | function login(username, password, callback) {
25 | Pouch.ajax({
26 | type: 'POST',
27 | url: 'http://' + remote.host + '/_session',
28 | data: {name: username, password: password},
29 | beforeSend: function(xhr) {
30 | xhr.setRequestHeader('Accept', 'application/json');
31 | },
32 | success: function () {
33 | callback();
34 | },
35 | error: function (err) {
36 | callback(err);
37 | }
38 | });
39 | }
40 |
41 | function logout(callback) {
42 | Pouch.ajax({
43 | type: 'DELETE',
44 | url: 'http://' + remote.host + '/_session',
45 | success: function () {
46 | callback();
47 | },
48 | error: function (err) {
49 | callback(err);
50 | }
51 | });
52 | }
53 |
54 | function createAdminUser(callback) {
55 | // create admin user
56 | var adminuser = {
57 | _id: 'org.couchdb.user:adminuser',
58 | name: 'adminuser',
59 | type: 'user',
60 | password: 'password',
61 | roles: []
62 | };
63 |
64 | Pouch.ajax({
65 | url: 'http://' + remote.host + '/_config/admins/adminuser',
66 | type: 'PUT',
67 | data: JSON.stringify(adminuser.password),
68 | contentType: 'application/json',
69 | success: function () {
70 | setTimeout(function() {
71 | login('adminuser', 'password', function (err) {
72 | if (err) {
73 | return callback(err);
74 | }
75 | Pouch.ajax({
76 | url: 'http://' + remote.host + '/_users/' +
77 | 'org.couchdb.user%3Aadminuser',
78 | type: 'PUT',
79 | data: JSON.stringify(adminuser),
80 | contentType: 'application/json',
81 | dataType: 'json',
82 | success: function (data) {
83 | logout(function (err) {
84 | if (err) {
85 | return callback(err);
86 | }
87 | callback(null, adminuser);
88 | });
89 | },
90 | error: function (err) {
91 | callback(null, adminuser);
92 | }
93 | });
94 | });
95 | }, 500);
96 | },
97 | error: function (err) {
98 | callback(err);
99 | }
100 | });
101 | }
102 |
103 | function deleteAdminUser(adminuser, callback) {
104 | Pouch.ajax({
105 | type: 'DELETE',
106 | beforeSend: function (xhr) {
107 | var token = btoa('adminuser:password');
108 | xhr.setRequestHeader("Authorization", "Basic " + token);
109 | },
110 | url: 'http://' + remote.host + '/_config/admins/adminuser',
111 | contentType: 'application/json',
112 | success: function () {
113 | var adminUrl = 'http://' + remote.host + '/_users/' +
114 | 'org.couchdb.user%3Aadminuser';
115 | Pouch.ajax({
116 | type: 'GET',
117 | url: adminUrl,
118 | dataType: 'json',
119 | success: function(doc) {
120 | Pouch.ajax({
121 | type: 'DELETE',
122 | url: 'http://' + remote.host + '/_users/' +
123 | 'org.couchdb.user%3Aadminuser?rev=' + doc._rev,
124 | contentType: 'application/json',
125 | success: function () {
126 | callback();
127 | },
128 | error: function (err) {
129 | callback();
130 | }
131 | });
132 | },
133 | error: function() {
134 | callback();
135 | }
136 | });
137 | },
138 | error: function (err) {
139 | callback(err);
140 | }
141 | });
142 | }
143 |
144 | asyncTest("Replicate from DB as non-admin user", function() {
145 | // SEE: https://github.com/apache/couchdb/blob/master/share/www/script/couch_test_runner.js
146 | // - create new DB
147 | // - push docs to new DB
148 | // - add new admin user
149 | // - login as new admin user
150 | // - add new user (non admin)
151 | // - login as new user
152 | // - replicate from new DB
153 | // - login as admin user
154 | // - delete users and return to admin party
155 | // - delete original DB
156 |
157 | var self = this;
158 |
159 | var docs = [
160 | {_id: 'one', count: 1},
161 | {_id: 'two', count: 2}
162 | ];
163 |
164 | function cleanup() {
165 | deleteAdminUser(self.adminuser, function (err) {
166 | if (err) {
167 | console.error(err);
168 | }
169 | logout(function (err) {
170 | if (err) {
171 | console.error(err);
172 | }
173 | start();
174 | });
175 | });
176 | }
177 |
178 | initDBPair(self.name, self.remote, function(db, remote) {
179 |
180 | // add user
181 | createAdminUser(function (err, adminuser) {
182 | if (err) {
183 | ok(false, 'unable to create admin user');
184 | console.error(err);
185 | return cleanup();
186 | }
187 |
188 | self.adminuser = adminuser;
189 |
190 | login('adminuser', 'password', function (err) {
191 | if (err) {
192 | console.error(err);
193 | }
194 | remote.bulkDocs({docs: docs}, {}, function(err, results) {
195 | Pouch.replicate(self.remote, self.name, {}, function(err, result) {
196 | db.allDocs(function(err, result) {
197 | ok(result.rows.length === docs.length, 'correct # docs exist');
198 | cleanup();
199 | });
200 | });
201 | });
202 | });
203 | });
204 | });
205 |
206 | });
207 |
--------------------------------------------------------------------------------
/tests/qunit/junitlogger.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | var count = 0, suiteCount = 0, currentSuite, currentTest, suites = [], assertCount, start, results = {failed:0, passed:0, total:0, time:0};
3 |
4 | QUnit.jUnitReport = function(data) {
5 | // Gets called when a report is generated
6 | };
7 |
8 | QUnit.moduleStart(function(data) {
9 | currentSuite = {
10 | name: data.name,
11 | tests: [],
12 | failures: 0,
13 | time: 0,
14 | stdout : '',
15 | stderr : ''
16 | };
17 |
18 | suites.push(currentSuite);
19 | });
20 |
21 | QUnit.moduleDone(function(data) {
22 | });
23 |
24 | QUnit.testStart(function(data) {
25 | if(!start){ start = new Date(); }
26 |
27 | assertCount = 0;
28 |
29 | currentTest = {
30 | name: data.name,
31 | failures: [],
32 | start: new Date()
33 | };
34 |
35 | // Setup default suite if no module was specified
36 | if (!currentSuite) {
37 | currentSuite = {
38 | name: "default",
39 | tests: [],
40 | failures: 0,
41 | time: 0,
42 | stdout : '',
43 | stderr : ''
44 | };
45 |
46 | suites.push(currentSuite);
47 | }
48 |
49 | currentSuite.tests.push(currentTest);
50 | });
51 |
52 | QUnit.testDone(function(data) {
53 | currentTest.failed = data.failed;
54 | currentTest.total = data.total;
55 | currentSuite.failures += data.failed;
56 |
57 | results.failed += data.failed;
58 | results.passed += data.passed;
59 | results.total += data.total;
60 | });
61 |
62 | QUnit.log(function(data) {
63 | assertCount++;
64 |
65 | if (!data.result) {
66 | currentTest.failures.push(data.message);
67 |
68 | // Add log message of failure to make it easier to find in jenkins UI
69 | currentSuite.stdout += '[' + currentSuite.name + ', ' + currentTest.name + ', ' + assertCount + '] ' + data.message + '\n';
70 | }
71 | });
72 |
73 | QUnit.done(function(data) {
74 | function ISODateString(d) {
75 | function pad(n) {
76 | return n < 10 ? '0' + n : n;
77 | }
78 |
79 | return d.getUTCFullYear() + '-' +
80 | pad(d.getUTCMonth() + 1)+'-' +
81 | pad(d.getUTCDate()) + 'T' +
82 | pad(d.getUTCHours()) + ':' +
83 | pad(d.getUTCMinutes()) + ':' +
84 | pad(d.getUTCSeconds()) + 'Z';
85 | }
86 |
87 | // Generate XML report
88 | var i, ti, fi, test, suite,
89 | xmlWriter = new XmlWriter({
90 | linebreak_at : "testsuites,testsuite,testcase,failure,system-out,system-err"
91 | }),
92 | now = new Date();
93 |
94 | xmlWriter.start('testsuites');
95 |
96 | for (i = 0; i < suites.length; i++) {
97 | suite = suites[i];
98 |
99 | // Calculate time
100 | for (ti = 0; ti < suite.tests.length; ti++) {
101 | test = suite.tests[ti];
102 |
103 | test.time = (now.getTime() - test.start.getTime()) / 1000;
104 | suite.time += test.time;
105 | }
106 |
107 | xmlWriter.start('testsuite', {
108 | id: "" + i,
109 | name: suite.name,
110 | errors: "0",
111 | failures: suite.failures,
112 | hostname: "localhost",
113 | tests: suite.tests.length,
114 | time: Math.round(suite.time * 1000) / 1000,
115 | timestamp: ISODateString(now)
116 | });
117 |
118 | for (ti = 0; ti < suite.tests.length; ti++) {
119 | test = suite.tests[ti];
120 |
121 | xmlWriter.start('testcase', {
122 | name: test.name,
123 | total: test.total,
124 | failed: test.failed,
125 | time: Math.round(test.time * 1000) / 1000
126 | });
127 |
128 | for (fi = 0; fi < test.failures.length; fi++) {
129 | xmlWriter.start('failure', {type: "AssertionFailedError", message: test.failures[fi]}, true);
130 | }
131 |
132 | xmlWriter.end('testcase');
133 | }
134 |
135 | if (suite.stdout) {
136 | xmlWriter.start('system-out');
137 | xmlWriter.cdata('\n' + suite.stdout);
138 | xmlWriter.end('system-out');
139 | }
140 |
141 | if (suite.stderr) {
142 | xmlWriter.start('system-err');
143 | xmlWriter.cdata('\n' + suite.stderr);
144 | xmlWriter.end('system-err');
145 | }
146 |
147 | xmlWriter.end('testsuite');
148 | }
149 |
150 | xmlWriter.end('testsuites');
151 |
152 | results.time = new Date() - start;
153 |
154 | QUnit.jUnitReport({
155 | suites : suites,
156 | results:results,
157 | xml: xmlWriter.getString()
158 | });
159 | });
160 |
161 | function XmlWriter(settings) {
162 | function addLineBreak(name) {
163 | if (lineBreakAt[name] && data[data.length - 1] !== '\n') {
164 | data.push('\n');
165 | }
166 | }
167 |
168 | function makeMap(items, delim, map) {
169 | var i;
170 |
171 | items = items || [];
172 |
173 | if (typeof(items) === "string") {
174 | items = items.split(',');
175 | }
176 |
177 | map = map || {};
178 |
179 | i = items.length;
180 | while (i--) {
181 | map[items[i]] = {};
182 | }
183 |
184 | return map;
185 | }
186 |
187 | function encode(text) {
188 | var baseEntities = {
189 | '"' : '"',
190 | "'" : ''',
191 | '<' : '<',
192 | '>' : '>',
193 | '&' : '&'
194 | };
195 |
196 | return ('' + text).replace(/[<>&\"\']/g, function(chr) {
197 | return baseEntities[chr] || chr;
198 | });
199 | }
200 |
201 | var data = [], stack = [], lineBreakAt;
202 |
203 | settings = settings || {};
204 | lineBreakAt = makeMap(settings.linebreak_at || 'mytag');
205 |
206 | this.start = function(name, attrs, empty) {
207 | if (!empty) {
208 | stack.push(name);
209 | }
210 |
211 | data.push('<', name);
212 |
213 | for (var aname in attrs) {
214 | data.push(" " + encode(aname), '="', encode(attrs[aname]), '"');
215 | }
216 |
217 | data.push(empty ? ' />' : '>');
218 | addLineBreak(name);
219 | };
220 |
221 | this.end = function(name) {
222 | stack.pop();
223 | addLineBreak(name);
224 | data.push('');
225 | addLineBreak(name);
226 | };
227 |
228 | this.text = function(text) {
229 | data.push(encode(text));
230 | };
231 |
232 | this.cdata = function(text) {
233 | data.push('');
234 | };
235 |
236 | this.comment = function(text) {
237 | data.push('');
238 | };
239 |
240 | this.pi = function(name, text) {
241 | if (text) {
242 | data.push('\n');
243 | } else {
244 | data.push('\n');
245 | }
246 | };
247 |
248 | this.doctype = function(text) {
249 | data.push('\n');
250 | };
251 |
252 | this.getString = function() {
253 | for (var i = stack.length - 1; i >= 0; i--) {
254 | this.end(stack[i]);
255 | }
256 |
257 | stack = [];
258 |
259 | return data.join('').replace(/\n$/, '');
260 | };
261 |
262 | this.reset = function() {
263 | data = [];
264 | stack = [];
265 | };
266 |
267 | this.pi(settings.xmldecl || 'xml version="1.0" encoding="UTF-8"');
268 | }
269 | })();
--------------------------------------------------------------------------------
/lib/setup.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var PouchDB = require("./constructor");
4 |
5 | PouchDB.adapters = {};
6 | PouchDB.plugins = {};
7 |
8 | PouchDB.prefix = '_pouch_';
9 |
10 | PouchDB.parseAdapter = function (name) {
11 | var match = name.match(/([a-z\-]*):\/\/(.*)/);
12 | var adapter;
13 | if (match) {
14 | // the http adapter expects the fully qualified name
15 | name = /http(s?)/.test(match[1]) ? match[1] + '://' + match[2] : match[2];
16 | adapter = match[1];
17 | if (!PouchDB.adapters[adapter].valid()) {
18 | throw 'Invalid adapter';
19 | }
20 | return {name: name, adapter: match[1]};
21 | }
22 |
23 | var preferredAdapters = ['idb', 'leveldb', 'websql'];
24 | for (var i = 0; i < preferredAdapters.length; ++i) {
25 | if (preferredAdapters[i] in PouchDB.adapters) {
26 | adapter = PouchDB.adapters[preferredAdapters[i]];
27 | var use_prefix = 'use_prefix' in adapter ? adapter.use_prefix : true;
28 |
29 | return {
30 | name: use_prefix ? PouchDB.prefix + name : name,
31 | adapter: preferredAdapters[i]
32 | };
33 | }
34 | }
35 |
36 | throw 'No valid adapter found';
37 | };
38 |
39 | PouchDB.destroy = function (name, opts, callback) {
40 | if (typeof opts === 'function' || typeof opts === 'undefined') {
41 | callback = opts;
42 | opts = {};
43 | }
44 |
45 | if (typeof name === 'object') {
46 | opts = name;
47 | name = undefined;
48 | }
49 |
50 | if (typeof callback === 'undefined') {
51 | callback = function () {};
52 | }
53 | var backend = PouchDB.parseAdapter(opts.name || name);
54 | var dbName = backend.name;
55 |
56 | var cb = function (err, response) {
57 | if (err) {
58 | callback(err);
59 | return;
60 | }
61 |
62 | for (var plugin in PouchDB.plugins) {
63 | PouchDB.plugins[plugin]._delete(dbName);
64 | }
65 | //console.log(dbName + ': Delete Database');
66 |
67 | // call destroy method of the particular adaptor
68 | PouchDB.adapters[backend.adapter].destroy(dbName, opts, callback);
69 | };
70 |
71 | // remove PouchDB from allDBs
72 | PouchDB.removeFromAllDbs(backend, cb);
73 | };
74 |
75 | PouchDB.removeFromAllDbs = function (opts, callback) {
76 | // Only execute function if flag is enabled
77 | if (!PouchDB.enableAllDbs) {
78 | callback();
79 | return;
80 | }
81 |
82 | // skip http and https adaptors for allDbs
83 | var adapter = opts.adapter;
84 | if (adapter === "http" || adapter === "https") {
85 | callback();
86 | return;
87 | }
88 |
89 | // remove db from PouchDB.ALL_DBS
90 | new PouchDB(PouchDB.allDBName(opts.adapter), function (err, db) {
91 | if (err) {
92 | // don't fail when allDbs fail
93 | //console.error(err);
94 | callback();
95 | return;
96 | }
97 | // check if db has been registered in PouchDB.ALL_DBS
98 | var dbname = PouchDB.dbName(opts.adapter, opts.name);
99 | db.get(dbname, function (err, doc) {
100 | if (err) {
101 | callback();
102 | } else {
103 | db.remove(doc, function (err, response) {
104 | if (err) {
105 | //console.error(err);
106 | }
107 | callback();
108 | });
109 | }
110 | });
111 | });
112 |
113 | };
114 |
115 | PouchDB.adapter = function (id, obj) {
116 | if (obj.valid()) {
117 | PouchDB.adapters[id] = obj;
118 | }
119 | };
120 |
121 | PouchDB.plugin = function (id, obj) {
122 | PouchDB.plugins[id] = obj;
123 | };
124 |
125 | // flag to toggle allDbs (off by default)
126 | PouchDB.enableAllDbs = false;
127 |
128 | // name of database used to keep track of databases
129 | PouchDB.ALL_DBS = "_allDbs";
130 | PouchDB.dbName = function (adapter, name) {
131 | return [adapter, "-", name].join('');
132 | };
133 | PouchDB.realDBName = function (adapter, name) {
134 | return [adapter, "://", name].join('');
135 | };
136 | PouchDB.allDBName = function (adapter) {
137 | return [adapter, "://", PouchDB.prefix + PouchDB.ALL_DBS].join('');
138 | };
139 |
140 | PouchDB.open = function (opts, callback) {
141 | // Only register pouch with allDbs if flag is enabled
142 | if (!PouchDB.enableAllDbs) {
143 | callback();
144 | return;
145 | }
146 |
147 | var adapter = opts.adapter;
148 | // skip http and https adaptors for allDbs
149 | if (adapter === "http" || adapter === "https") {
150 | callback();
151 | return;
152 | }
153 |
154 | new PouchDB(PouchDB.allDBName(adapter), function (err, db) {
155 | if (err) {
156 | // don't fail when allDb registration fails
157 | //console.error(err);
158 | callback();
159 | return;
160 | }
161 |
162 | // check if db has been registered in PouchDB.ALL_DBS
163 | var dbname = PouchDB.dbName(adapter, opts.name);
164 | db.get(dbname, function (err, response) {
165 | if (err && err.status === 404) {
166 | db.put({
167 | _id: dbname,
168 | dbname: opts.originalName
169 | }, function (err) {
170 | if (err) {
171 | //console.error(err);
172 | }
173 |
174 | callback();
175 | });
176 | } else {
177 | callback();
178 | }
179 | });
180 | });
181 | };
182 |
183 | PouchDB.allDbs = function (callback) {
184 | var accumulate = function (adapters, all_dbs) {
185 | if (adapters.length === 0) {
186 | // remove duplicates
187 | var result = [];
188 | all_dbs.forEach(function (doc) {
189 | var exists = result.some(function (db) {
190 | return db.id === doc.id;
191 | });
192 |
193 | if (!exists) {
194 | result.push(doc);
195 | }
196 | });
197 |
198 | // return an array of dbname
199 | callback(null, result.map(function (row) {
200 | return row.doc.dbname;
201 | }));
202 | return;
203 | }
204 |
205 | var adapter = adapters.shift();
206 |
207 | // skip http and https adaptors for allDbs
208 | if (adapter === "http" || adapter === "https") {
209 | accumulate(adapters, all_dbs);
210 | return;
211 | }
212 |
213 | new PouchDB(PouchDB.allDBName(adapter), function (err, db) {
214 | if (err) {
215 | callback(err);
216 | return;
217 | }
218 | db.allDocs({include_docs: true}, function (err, response) {
219 | if (err) {
220 | callback(err);
221 | return;
222 | }
223 |
224 | // append from current adapter rows
225 | all_dbs.unshift.apply(all_dbs, response.rows);
226 |
227 | // code to clear allDbs.
228 | // response.rows.forEach(function (row) {
229 | // db.remove(row.doc, function () {
230 | // //console.log(arguments);
231 | // });
232 | // });
233 |
234 | // recurse
235 | accumulate(adapters, all_dbs);
236 | });
237 | });
238 | };
239 | var adapters = Object.keys(PouchDB.adapters);
240 | accumulate(adapters, []);
241 | };
242 |
243 | module.exports = PouchDB;
244 |
--------------------------------------------------------------------------------
/lib/deps/ajax.js:
--------------------------------------------------------------------------------
1 | var request = require('request');
2 | var extend = require('./extend.js');
3 | var createBlob = require('./blob.js');
4 | var errors = require('./errors');
5 | function ajax(options, callback) {
6 |
7 | if (typeof options === "function") {
8 | callback = options;
9 | options = {};
10 | }
11 |
12 | function call(fun) {
13 | var args = Array.prototype.slice.call(arguments, 1);
14 | if (typeof fun === typeof Function) {
15 | fun.apply(this, args);
16 | }
17 | };
18 |
19 | var defaultOptions = {
20 | method : "GET",
21 | headers: {},
22 | json: true,
23 | processData: true,
24 | timeout: 10000
25 | };
26 |
27 | options = extend(true, defaultOptions, options);
28 |
29 |
30 | function onSuccess(obj, resp, cb) {
31 | if (!options.binary && !options.json && options.processData &&
32 | typeof obj !== 'string') {
33 | obj = JSON.stringify(obj);
34 | } else if (!options.binary && options.json && typeof obj === 'string') {
35 | try {
36 | obj = JSON.parse(obj);
37 | } catch (e) {
38 | // Probably a malformed JSON from server
39 | call(cb, e);
40 | return;
41 | }
42 | }
43 | if (Array.isArray(obj)) {
44 | obj = obj.map(function(v) {
45 | var obj;
46 | if (v.ok) {
47 | return v;
48 | } else if (v.error&&v.error==='conflict') {
49 | obj = errors.REV_CONFLICT;
50 | obj.id = v.id;
51 | return obj;
52 | } else if (v.missing) {
53 | obj = errors.MISSING_DOC;
54 | obj.missing = v.missing;
55 | return obj;
56 | }
57 | });
58 | }
59 | call(cb, null, obj, resp);
60 | };
61 |
62 | function onError(err, cb){
63 | var errParsed, errObj, errType, key;
64 | try {
65 | errParsed = JSON.parse(err.responseText);
66 | //would prefer not to have a try/catch clause
67 | for(key in errors){
68 | if(errors[key].name === errParsed.error){
69 | errType = errors[key];
70 | break;
71 | }
72 | }
73 | errType = errType || errors.UNKNOWN_ERROR;
74 | errObj = errors.error(errType, errParsed.reason);
75 | } catch(e) {
76 | errObj = errors.UNKNOWN_ERROR;
77 | }
78 | call(cb, errObj);
79 | };
80 |
81 | if (process.browser && typeof XMLHttpRequest !== 'undefined') {
82 | var timer, timedout = false;
83 | var xhr = new XMLHttpRequest();
84 |
85 | xhr.open(options.method, options.url);
86 | xhr.withCredentials = true;
87 |
88 | if (options.json) {
89 | options.headers.Accept = 'application/json';
90 | options.headers['Content-Type'] = options.headers['Content-Type'] ||
91 | 'application/json';
92 | if (options.body && options.processData && typeof options.body !== "string") {
93 | options.body = JSON.stringify(options.body);
94 | }
95 | }
96 |
97 | if (options.binary) {
98 | xhr.responseType = 'arraybuffer';
99 | }
100 |
101 | function createCookie(name,value,days) {
102 | if (days) {
103 | var date = new Date();
104 | date.setTime(date.getTime()+(days*24*60*60*1000));
105 | var expires = "; expires="+date.toGMTString();
106 | } else {
107 | var expires = "";
108 | }
109 | document.cookie = name+"="+value+expires+"; path=/";
110 | }
111 |
112 | for (var key in options.headers) {
113 | if (key === 'Cookie') {
114 | var cookie = options.headers[key].split('=');
115 | createCookie(cookie[0], cookie[1], 10);
116 | } else {
117 | xhr.setRequestHeader(key, options.headers[key]);
118 | }
119 | }
120 |
121 | if (!("body" in options)) {
122 | options.body = null;
123 | }
124 |
125 | function abortReq() {
126 | timedout=true;
127 | xhr.abort();
128 | call(onError, xhr, callback);
129 | };
130 |
131 | xhr.onreadystatechange = function () {
132 | if (xhr.readyState !== 4 || timedout) {
133 | return;
134 | }
135 | clearTimeout(timer);
136 | if (xhr.status >= 200 && xhr.status < 300) {
137 | var data;
138 | if (options.binary) {
139 | data = createBlob([xhr.response || ''], {
140 | type: xhr.getResponseHeader('Content-Type')
141 | });
142 | } else {
143 | data = xhr.responseText;
144 | }
145 | call(onSuccess, data, xhr, callback);
146 | } else {
147 | call(onError, xhr, callback);
148 | }
149 | };
150 |
151 | if (options.timeout > 0) {
152 | timer = setTimeout(abortReq, options.timeout);
153 | xhr.upload.onprogress = xhr.onprogress = function() {
154 | clearTimeout(timer);
155 | timer = setTimeout(abortReq, options.timeout);
156 | };
157 | }
158 | xhr.send(options.body);
159 | return {abort:abortReq};
160 |
161 | } else {
162 |
163 | if (options.json) {
164 | if (!options.binary) {
165 | options.headers.Accept = 'application/json';
166 | }
167 | options.headers['Content-Type'] = options.headers['Content-Type'] ||
168 | 'application/json';
169 | }
170 |
171 | if (options.binary) {
172 | options.encoding = null;
173 | options.json = false;
174 | }
175 |
176 | if (!options.processData) {
177 | options.json = false;
178 | }
179 |
180 | return request(options, function (err, response, body) {
181 | if (err) {
182 | err.status = response ? response.statusCode : 400;
183 | return call(onError, err, callback);
184 | }
185 | var error;
186 | var content_type = response.headers['content-type'];
187 | var data = (body || '');
188 |
189 | // CouchDB doesn't always return the right content-type for JSON data, so
190 | // we check for ^{ and }$ (ignoring leading/trailing whitespace)
191 | if (!options.binary && (options.json || !options.processData) &&
192 | typeof data !== 'object' &&
193 | (/json/.test(content_type) ||
194 | (/^[\s]*\{/.test(data) && /\}[\s]*$/.test(data)))) {
195 | data = JSON.parse(data);
196 | }
197 |
198 | if (response.statusCode >= 200 && response.statusCode < 300) {
199 | call(onSuccess, data, response, callback);
200 | }
201 | else {
202 | if (options.binary) {
203 | data = JSON.parse(data.toString());
204 | }
205 | if (data.reason === 'missing') {
206 | error = errors.MISSING_DOC;
207 | } else if (data.reason === 'no_db_file') {
208 | error = errors.error(errors.DB_MISSING, data.reason);
209 | } else if (data.error === 'conflict'){
210 | error = errors.REV_CONFLICT;
211 | } else {
212 | error = errors.error(errors.UNKNOWN_ERROR, data.reason, data.error);
213 | }
214 | error.status = response.statusCode;
215 | call(callback, error);
216 | }
217 | });
218 | }
219 | };
220 |
221 | module.exports = ajax;
222 |
--------------------------------------------------------------------------------
/lib/deps/md5.js:
--------------------------------------------------------------------------------
1 | /**
2 | *
3 | * MD5 (Message-Digest Algorithm)
4 | *
5 | * For original source see http://www.webtoolkit.info/
6 | * Download: 15.02.2009 from http://www.webtoolkit.info/javascript-md5.html
7 | *
8 | * Licensed under CC-BY 2.0 License
9 | * (http://creativecommons.org/licenses/by/2.0/uk/)
10 | *
11 | **/
12 | var crypto = require('crypto');
13 |
14 | exports.MD5 = function(string) {
15 | if (!process.browser) {
16 | return crypto.createHash('md5').update(string).digest('hex');
17 | }
18 | function RotateLeft(lValue, iShiftBits) {
19 | return (lValue<
23 |
24 |
25 | It's also a good idea to open your browser's console so you can see any errors or confirmation messages.
26 |
27 | # Installing PouchDB
28 |
29 | Open `index.html` and include PouchDB in the app by adding a script tag:
30 |
31 | {% highlight html %}
32 |
33 |
34 |
35 | {% endhighlight %}
36 |
37 | PouchDB is now installed in your app and ready to use! (In production, you should use a local copy of the script.)
38 |
39 | # Creating a database
40 |
41 | The rest of the work will be done inside `app.js`. We will start by creating a database to enter your todos. To create a database simply instantiate a new PouchDB object with the name of the database:
42 |
43 | {% highlight js %}
44 | // EDITING STARTS HERE (you dont need to edit anything above this line)
45 |
46 | var db = new PouchDB('todos');
47 | var remoteCouch = false;
48 | {% endhighlight %}
49 |
50 | You don't need to create a schema for the database. After giving it a name, you can immediately start writing objects to it.
51 |
52 | # Write todos to the database
53 |
54 | The first thing we shall do is start writing items to the database. The main input will call `addTodo` with the current text when the user presses `Enter`. We can complete this function with the following code:
55 |
56 | {% highlight js %}
57 | function addTodo(text) {
58 | var todo = {
59 | _id: new Date().toISOString(),
60 | title: text,
61 | completed: false
62 | };
63 | db.put(todo, function callback(err, result) {
64 | if (!err) {
65 | console.log('Successfully posted a todo!');
66 | }
67 | });
68 | }
69 | {% endhighlight %}
70 |
71 | In PouchDB each document is required to have a unique `_id`. Any subsequent writes to a document with the same `_id` will be considered updates. Here we are using a date string as an `_id`. For our use case, it will be unique, and it can also be used to sort items in the database. You can use `PouchDB.uuids()` or `db.post()` if you want random ids. The `_id` is the only thing required when creating a new document. The rest of the object you can create as you like.
72 |
73 | The `callback` function will be called once the document has been written (or failed to write). If the `err` argument is not null, then it will have an object explaining the error, otherwise the `result` will hold the result.
74 |
75 | # Show items from the database
76 |
77 | We have included a helper function `redrawTodosUI` that takes an array of todos to display, so all we need to do is read the todos from the database. Here we will simply read all the documents using `db.allDocs`. The `include_docs` option tells PouchDB to give us the data within each document, and the `descending` option tells PouchDB how to order the results based on their `_id` field, giving us newest first.
78 |
79 | {% highlight js %}
80 | function showTodos() {
81 | db.allDocs({include_docs: true, descending: true}, function(err, doc) {
82 | redrawTodosUI(doc.rows);
83 | });
84 | }
85 | {% endhighlight %}
86 |
87 | Once you have included this code, you should be able to refresh the page to see any todos you have entered.
88 |
89 | # Update the UI
90 |
91 | We dont want to refresh the page to see new items. More typically you would update the UI manually when you write data to it, however, in PouchDB you may be syncing data remotely, so you want to make sure you update whenever the remote data changes. To do this we will call `db.changes` which subscribes to updates to the database, wherever they come from. You can enter this code between the `remoteCouch` and `addTodo` declaration:
92 |
93 | {% highlight js %}
94 | var remoteCouch = false;
95 |
96 | db.info(function(err, info) {
97 | db.changes({
98 | since: info.update_seq,
99 | continuous: true,
100 | onChange: showTodos
101 | });
102 | });
103 |
104 | // Show the current list of todos by reading them from the database
105 | function addTodo() {
106 | {% endhighlight %}
107 |
108 | So every time an update happens to the database, we redraw the UI to show the new data. The `continuous` flag means this function will continue to run indefinitely. Now try entering a new todo and it should appear immediately.
109 |
110 | # Edit a todo
111 |
112 | When the user checks a checkbox, the `checkboxChanged` function will be called, so we'll fill in the code to edit the object and call `db.put`:
113 |
114 | {% highlight js %}
115 | function checkboxChanged(todo, event) {
116 | todo.completed = event.target.checked;
117 | db.put(todo);
118 | }
119 | {% endhighlight %}
120 |
121 | This is similiar to creating a document, however the document must also contain a `_rev` field (in addition to `_id`), otherwise the write will be rejected. This ensures that you dont accidently overwrite changes to a document.
122 |
123 | You can test that this works by checking a todo item and refreshing the page. It should stay checked.
124 |
125 | # Delete an object
126 |
127 | To delete an object you can call db.remove with the object.
128 |
129 | {% highlight js %}
130 | function deleteButtonPressed(todo) {
131 | db.remove(todo);
132 | }
133 | {% endhighlight %}
134 |
135 | Similiar to editing a document, both the `_id` and `_rev` properties are required. You may notice that we are passing around the full object that we previously read from the database. You can of course manually construct the object, like: `{_id: todo._id, _rev: todo._rev}`, but passing around the existing object is usually more convenient and less error prone.
136 |
137 | # Complete rest of the Todo UI
138 |
139 | `todoBlurred` is called when the user edits a document. Here we'll delete the document if the user has entered a blank title, and we'll update it otherwise.
140 |
141 | {% highlight js %}
142 | function todoBlurred(todo, event) {
143 | var trimmedText = event.target.value.trim();
144 | if (!trimmedText) {
145 | db.remove(todo);
146 | } else {
147 | todo.title = trimmedText;
148 | db.put(todo);
149 | }
150 | }
151 | {% endhighlight %}
152 |
153 | # Installing CouchDB
154 |
155 | Now we'll implement the syncing. You need to have a CouchDB instance, which you can either install yourself [CouchDB(1.3+) locally](http://couchdb.apache.org/) or use with an online provider like [IrisCouch](http://iriscouch.com).
156 |
157 | # Enabling CORS
158 |
159 | To replicate directly with CouchDB, you need to make sure CORS is enabled. Only set the username and password if you have set them previously. By default, CouchDB will be installed in "Admin Party," where username and password are not needed. You will need to replace `myname.iriscouch.com` with your own host (`127.0.0.1:5984` if installed locally):
160 |
161 | {% highlight bash %}
162 | $ export HOST=http://username:password@myname.iriscouch.com
163 | $ curl -X PUT $HOST/_config/httpd/enable_cors -d '"true"'
164 | $ curl -X PUT $HOST/_config/cors/origins -d '"*"'
165 | $ curl -X PUT $HOST/_config/cors/credentials -d '"true"'
166 | $ curl -X PUT $HOST/_config/cors/methods -d '"GET, PUT, POST, HEAD, DELETE"'
167 | $ curl -X PUT $HOST/_config/cors/headers -d \
168 | '"accept, authorization, content-type, origin"'
169 | {% endhighlight %}
170 |
171 | # Implement basic two way sync
172 |
173 | Now we will have the todo list sync. Back in `app.js` we need to specify the address of the remote database. Remember to replace `user`, `pass` and `myname.iriscouch.com` with the credentials of your own CouchDB instance:
174 |
175 | {% highlight js %}
176 | // EDITING STARTS HERE (you dont need to edit anything above this line)
177 |
178 | var db = new PouchDB('todos');
179 | var remoteCouch = 'http://user:pass@mname.iriscouch.com/todos';
180 | {% endhighlight %}
181 |
182 | Then we can implement the sync function like so:
183 |
184 | {% highlight js %}
185 | function sync() {
186 | syncDom.setAttribute('data-sync-state', 'syncing');
187 | var opts = {continuous: true, complete: syncError};
188 | db.replicate.to(remoteCouch, opts);
189 | db.replicate.from(remoteCouch, opts);
190 | }
191 | {% endhighlight %}
192 |
193 | `db.replicate()` tells PouchDB to transfer all the documents `to` or `from` the `remoteCouch`. This can either be a string identifier or a PouchDB object. We call this twice: once to receive remote updates, and once to push local changes. Again, the `continuous` flag is used to tell PouchDB to carry on doing this indefinitely. The `complete` callback will be called whenever this finishes. For continuous replication, this will mean an error has occured, like losing your connection.
194 |
195 | You should be able to open [the todo app](http://127.0.0.1:8000) in another browser and see that the two lists stay in sync with any changes you make to them. You may also want to look at your CouchDB's Futon administration page and see the populated database.
196 |
197 | # Congratulations!
198 |
199 | You've completed your first PouchDB application. This is a basic example, and a real world application will need to integrate more error checking, user signup, etc. But you should now understand the basics you need to start working on your own PouchDB project. If you have any more questions, please get in touch on [IRC](irc://freenode.net#pouchdb) or the [mailing list](https://groups.google.com/forum/#!forum/pouchdb).
200 |
--------------------------------------------------------------------------------