Tasks
10 |Hello!
11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /docs/jquery.md: -------------------------------------------------------------------------------- 1 | # persistence.jquery.js 2 | 3 | `persistence.jquery.js` is a jquery plugin for `persistence.js` that 4 | allows the usage of jquery notation for crossbrowser-access of 5 | persistencejs entities. 6 | 7 | Example 8 | ------- 9 | 10 | Simple example: 11 | 12 | var User = persistence.define('User', { 13 | firstname: "TEXT", 14 | lastname: "TEXT" 15 | }); 16 | 17 | var user = new User({firstname: "Joe", lastname: "Doo"}); 18 | 19 | // setter 20 | $(user).data('firstname', "Mike") 21 | 22 | // getter 23 | console.log($(user).data('firstname')); // => Mike 24 | 25 | You can find more examples in `test/test.persistence-jquery.js`. -------------------------------------------------------------------------------- /test/browser/tasks.client.js: -------------------------------------------------------------------------------- 1 | 2 | // Data model 3 | var Task = persistence.define('Task', { 4 | name: "TEXT", 5 | done: "BOOL", 6 | lastChange: "DATE" 7 | }); 8 | 9 | persistence.connect('taskdemo', 'database', 5 * 1024 * 1024, '1.0'); 10 | persistence.schemaSync(); 11 | 12 | function syncAll() { 13 | persistence.sync.synchronize('/recentChanges', Task, function(conflicts, updatesToPush, callback) { 14 | console.log(conflicts); 15 | callback(); 16 | }); 17 | } 18 | 19 | 20 | function addTask() { 21 | var t = new Task(); 22 | t.name = "Some new local task"; 23 | t.done = false; 24 | t.lastChange = new Date(); 25 | persistence.add(t); 26 | persistence.flush(); 27 | } 28 | -------------------------------------------------------------------------------- /test/titanium/Resources/test/tests_to_run.js: -------------------------------------------------------------------------------- 1 | //setting up stuff so that the environment kind of looks like a browser 2 | var window = {}; 3 | var console = { 4 | log: function() { 5 | Titanium.API.debug(arguments[0]); 6 | } 7 | }; 8 | var document = null; 9 | $ = function(document) { 10 | return {ready: function(f) {f();}}; 11 | }; 12 | 13 | //requiring persistencejs 14 | Titanium.include('lib/persistence.js', 15 | 'lib/persistence.store.sql.js', 16 | 'lib/persistence.store.titanium.js'); 17 | var persistence = window.persistence; 18 | //allows us to run unmodified browser tests in titanium 19 | persistence.store.websql = persistence.store.titanium; 20 | 21 | 22 | // Tests to run 23 | Titanium.include('test/browser/test.persistence.js'); 24 | //Titanium.include('test/browser/util.js'); 25 | //Titanium.include('test/browser/test.migrations.js'); 26 | -------------------------------------------------------------------------------- /test/node/test.store.config.js: -------------------------------------------------------------------------------- 1 | // $ expresso test.store.config.js 2 | 3 | var assert = require('assert'); 4 | var persistence = require('../../lib/persistence').persistence; 5 | 6 | var config = { 7 | adaptor: '', 8 | database: 'test', 9 | host: 'localhost', 10 | port: 3306, 11 | user: 'root', 12 | password: '' 13 | }; 14 | 15 | module.exports = { 16 | memory: function() { 17 | config.adaptor = 'memory'; 18 | var persistenceStore = require('../../lib/persistence.store.config').init(persistence, config); 19 | var session = persistenceStore.getSession(); 20 | session.close(); 21 | }, 22 | mysql: function() { 23 | config.adaptor = 'mysql'; 24 | var persistenceStore = require('../../lib/persistence.store.config').init(persistence, config); 25 | var session = persistenceStore.getSession(); 26 | session.close(); 27 | }, 28 | default: function() { 29 | var persistenceStore = require('../../lib/persistence.store.config').init(persistence, config); 30 | var session = persistenceStore.getSession(); 31 | session.close(); 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /test/browser/test.migrations.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 |persistence.js migrations plugin
18 | 19 | 20 |persistence.js sync tests
19 | 20 | 21 |persistence.js search tests
19 | 20 | 21 |persistence.js mixin tests
19 | 20 | 21 |persistence.js core tests
19 | 20 | 21 |persistence.js core tests with jquery-plugin
20 | 21 | 22 |persistence.js core tests with uki MVC framework
21 | 22 | 23 |
9 |
10 |
23 |
24 |
25 |
--------------------------------------------------------------------------------
/docs/search.md:
--------------------------------------------------------------------------------
1 | persistence.search.js
2 | ==============
3 | `persistence.search.js` is a light-weight extension of the
4 | `persistence.js` library that adds full-text search through a simple
5 | API.
6 |
7 | Initialization:
8 |
9 | persistence.search.config(persistence, persistence.store.websql.sqliteDialect);
10 |
11 | Example usage:
12 |
13 | var Note = persistence.define('Note', {
14 | name: "TEXT",
15 | text: "TEXT",
16 | status: "TEXT"
17 | });
18 | Note.textIndex('name');
19 | Note.textIndex('text');
20 |
21 | This sample defines a `Note` entity with three properties of which
22 | `name` and `text` are full-text indexed. For this a new database table
23 | will be created that stores the index.
24 |
25 | Searching is done as follows:
26 |
27 | Note.search("note").list(tx, function(results) {
28 | console.log(results);
29 | });
30 |
31 | or you can paginate your results using `limit` and `skip` (similar
32 | to `limit` and `skip` in QueryCollections).
33 |
34 | Note.search("note").limit(10).skip(10).list(null, function(results) {
35 | console.log(results);
36 | });
37 |
38 | Query language
39 | --------------
40 |
41 | Queries can contain regular words. In addition the `*` wildcard can be
42 | used anywhere with a word. The `property:` notation can be used to
43 | search only a particular field. Examples:
44 |
45 | * `note`
46 | * `name: note`
47 | * `interesting`
48 | * `inter*`
49 | * `important essential`
50 |
51 | Note that currently a result is return when _any_ word matches.
52 | Results are ranked by number of occurences of one of the words in the
53 | text.
54 |
--------------------------------------------------------------------------------
/demo/jquerymobile/docs/text_and_images.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
11 |
13 |
14 | Text only
12 |
15 |
21 |
22 | jQuery’s mobile strategy can be summarized simply: Delivering top-of-the-line JavaScript in a unified User Interface that works across the most-used smartphone web browsers and tablet form factors.
16 | 17 |The critical difference with our approach is the wide variety of mobile platforms we’re targeting with jQuery Mobile. We’ve been working hard at bringing jQuery support to all mobile browsers that are sufficiently-capable and have at least a nominal amount of market share. In this way, we’re treating mobile web browsers exactly how we treat desktop web browsers.
18 | 19 |To make this broad support possible, all pages in jQuery Mobile are built on a foundation of clean, semantic HTML to ensure compatibility with pretty much any web-enabled device. In devices that interpret CSS and JavaScript, jQuery Mobile applies progressive enhancement techniques to unobtrusively transform the semantic page into a rich, interactive experience that leverages the power of jQuery and CSS. Accessibility features such as WAI-ARIA are tightly integrated throughout the framework to provide support for screen readers and other assistive technologies.
20 |
9 |
10 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/test/node/test.sqlite.store.js:
--------------------------------------------------------------------------------
1 | // $ expresso -s test.sqlite.store.js
2 |
3 | var assert = require('assert');
4 | var persistence = require('../../lib/persistence').persistence;
5 | var persistenceStore = require('../../lib/persistence.store.sqlite');
6 |
7 | var dbPath = __dirname + '/test.db';
8 | persistenceStore.config(persistence, dbPath);
9 |
10 | var Task = persistence.define('Task', {
11 | username: 'TEXT'
12 | });
13 |
14 | var data = {
15 | username: 'test'
16 | };
17 |
18 | var task, session;
19 |
20 | // remove test database
21 | function removeDb() {
22 | try {
23 | require('fs').unlinkSync(dbPath);
24 | } catch (err) {
25 | }
26 | }
27 |
28 | module.exports = {
29 | init: function(done) {
30 | removeDb();
31 | session = persistenceStore.getSession(function () {
32 | session.schemaSync(done);
33 | });
34 | },
35 | add: function(done) {
36 | task = new Task(session, data);
37 | session.add(task);
38 | session.flush(function(result, err) {
39 | assert.ifError(err);
40 | done();
41 | });
42 | },
43 | get: function(done) {
44 | Task.findBy(session, 'id', task.id, function(task) {
45 | assert.equal(task.username, data.username);
46 | done();
47 | });
48 | },
49 | update: function(done) {
50 | task.username = 'test2';
51 | Task.findBy(session, 'id', task.id, function(task) {
52 | assert.equal(task.username, 'test2');
53 | done();
54 | });
55 | },
56 | remove: function(done) {
57 | session.remove(task);
58 | session.flush(function(result, err) {
59 | assert.ifError(err);
60 | Task.findBy(session, 'id', task.id, function(task) {
61 | assert.equal(task, null);
62 | done();
63 | });
64 | });
65 | },
66 | afterAll: function(done) {
67 | session.close(function() {
68 | removeDb();
69 | done();
70 | });
71 | }
72 | };
73 |
--------------------------------------------------------------------------------
/docs/DEVELOPMENT.md:
--------------------------------------------------------------------------------
1 | Documentation for developers
2 | ============================
3 |
4 | Constructor functions
5 | ---------------------
6 |
7 | var Task = persistence.define('Task', {
8 | name: "TEXT",
9 | done: "BOOL"
10 | });
11 | var Category = persistence.define('Category', {
12 | name: "TEXT"
13 | });
14 | Task.hasOne('category', Category);
15 |
16 | `Task` is a constructor function that is used to create new instances of the `Task` entity, but also can be used to retrieve meta data from, using `Task.meta`. This `meta` field provides the following information:
17 |
18 | * `name`, the name of the entity as set as first argument of `define`
19 | * `fields`, the field object passed to the original `define`,
20 | consisting of property names as keys and textual column types as
21 | values.
22 | * `hasOne`, an object with relation names as keys and relationship
23 | objects as values. The relationship object currently has one field:
24 | `type`: which links to the constructor function of the type of the
25 | relation. Example: `Task.hasOne.category.type` will equal the
26 | `Category` constructor.
27 | * `hasMany`, an object with relation anmes as keys and relationship objects as values. The relationship has the following fields:
28 | * `type`: the constructor function of the relationship entity
29 | * `inverseProperty`: the property name of the inverse relation
30 | * `manyToMany`: a boolean value indicating if this is a manyToMany
31 | relationship or not (then it's a one-tomany)
32 | * `tableName`: name of the utility coupling table used for a
33 | many-to-many relationship
34 |
35 | Extension hooks
36 | ----------------
37 |
38 | * `persistence.entityDecoratorHooks`: a list of functions (with the
39 | constructor function as argument) to be called to decorate. Useful to
40 | add new functionality to constructo functions, such as `Task.index`.
41 | * `persistence.flushHooks`: a list of functions to be called before flushing.
42 | * `persistence.schemaSyncHooks`: a list of functions to be called before syncing the schema.
43 |
44 |
--------------------------------------------------------------------------------
/docs/jquery.mobile.md:
--------------------------------------------------------------------------------
1 | # persistence.jquery.mobile.js
2 |
3 | `persistence.jquery.mobile.js` is a plugin for `persistence.js` and [jQuery mobile](http://jquerymobile.com) that
4 | allows ajax request re-routing to persitencejs for:
5 |
6 | * Html text: caches ajax-loaded HTML pages in local DB.
7 | * Images (in `img` tags of ajax-loaded HTML pages): grabs/encodes them via `canvas` and caches them as data-URL strings in local DB.
8 | * Form submission (only POST requests).
9 |
10 | For ajax-loaded HTML pages and images, the content-providing entities get
11 | their name from user-overwritable default values. For form submissions, the entity
12 | is matched according to the following URL pattern:
13 |
14 | entity-name / path1/path2/../pathN
15 |
16 | Ajax re-routing to persitencejs only takes place if the required entities exist.
17 |
18 | Global settings (and it's default values):
19 |
20 | persistence.jquery.mobile.pageEntityName = "Page"; // Html page entity name
21 | persistence.jquery.mobile.imageEntityName = "Image"; // Image entity name
22 | persistence.jquery.mobile.pathField = "path"; // Entity path-field name
23 | persistence.jquery.mobile.dataField = "data"; // Entity data-field name
24 |
25 |
26 | Optional Regular Expression to exclude URLs from re-routing to persistencejs:
27 |
28 | persistence.jquery.mobile.urlExcludeRx
29 |
30 | Example: `persistence.jquery.mobile.urlExcludeRx = /^\/admin\//;`
31 | (all URL paths starting with "/admin/" are excluded)
32 |
33 |
34 | Ajax page loading example:
35 |
36 | URL: "about/intro.html"
37 | => entity name: "Page"
38 | => entity path field: "about/intro.html"
39 | => entity data field: (the HTML content of the page)
40 | Images: (all images contained in the page specified above)
41 | => entity name: "Image"
42 | => entity path field: (src attribute value of IMG tag)
43 | => entity data field: (the imgae data as Base64 encoded dataURL)
44 |
45 | Ajax form submission examples:
46 |
47 | URL (POST): "order/response.html"
48 | => entity name: "Order"
49 | => entity fields (other than path): retrieved from POST data
50 |
51 | You can find a demo at `demo/jquerymobile/index.html` (you must load it from a server).
--------------------------------------------------------------------------------
/test/node/test.error.handling.js:
--------------------------------------------------------------------------------
1 | // $ expresso -s test/test.error.handling.js
2 |
3 | var assert = require('assert');
4 | var persistence = require('../lib/persistence').persistence;
5 | var persistenceStore = require('../lib/persistence.store.mysql');
6 |
7 | persistenceStore.config(persistence, 'localhost', 3306, 'nodejs_mysql', 'test', 'test');
8 |
9 | var InexistentTable = persistence.define('inexistent_table', {
10 | name: "TEXT"
11 | });
12 |
13 | var session = persistenceStore.getSession();
14 |
15 | var create = function(data, cb) {
16 | var inexistent_table = new InexistentTable(data);
17 | session.add(inexistent_table);
18 | session.flush(function(result, err) {
19 | cb && cb(err, inexistent_table);
20 | });
21 | };
22 |
23 | var remove = function(inexistent_table, cb) {
24 | session.remove(inexistent_table);
25 | session.flush(function(result, err) {
26 | cb && cb(err, result);
27 | });
28 | };
29 |
30 | var temp;
31 |
32 | module.exports = {
33 | 'beforeAll': function(done) {
34 | session.transaction(function(tx) {
35 | tx.executeSql('FLUSH TABLES WITH READ LOCK;', function() {
36 | done();
37 | });
38 | });
39 | },
40 | 'schemaSync fail': function(done) {
41 | session.schemaSync(function(tx, err) {
42 | assert.isDefined(err);
43 | done();
44 | });
45 | },
46 | 'create fail': function(done) {
47 | create({
48 | name: 'test'
49 | }, function(err, result) {
50 | assert.isDefined(err);
51 | temp = result;
52 | done();
53 | });
54 | },
55 | 'remove fail': function(done) {
56 | remove(temp, function(err, result) {
57 | assert.isDefined(err);
58 | done();
59 | });
60 | },
61 | 'destroyAll fail': function(done) {
62 | InexistentTable.all(session).destroyAll(function(result, err) {
63 | assert.isDefined(err);
64 | done();
65 | });
66 | },
67 | 'reset fail': function(done) {
68 | session.reset(function(result, err) {
69 | assert.isDefined(err);
70 | done();
71 | });
72 | },
73 | afterAll: function(done) {
74 | session.transaction(function(tx) {
75 | tx.executeSql('UNLOCK TABLES;', function() {
76 | session.close();
77 | done();
78 | });
79 | });
80 | }
81 | };
82 |
--------------------------------------------------------------------------------
/test/browser/test.search.js:
--------------------------------------------------------------------------------
1 | $(document).ready(function(){
2 | persistence.store.websql.config(persistence, 'searchtest', 'My db', 5 * 1024 * 1024);
3 | persistence.search.config(persistence, persistence.store.websql.sqliteDialect);
4 | persistence.debug = true;
5 |
6 | var Note = persistence.define('Note', {
7 | title: "TEXT",
8 | text: "TEXT"
9 | });
10 |
11 | Note.textIndex('title');
12 | Note.textIndex('text');
13 |
14 | module("Setup");
15 |
16 | asyncTest("setting up database", 1, function() {
17 | persistence.reset(function() {
18 | persistence.schemaSync(function(tx){
19 | ok(tx.executeSql, 'schemaSync passed transaction as argument to callback');
20 | start();
21 | });
22 | });
23 | });
24 |
25 | module("Search test");
26 |
27 | asyncTest("Create some sample data", function() {
28 | persistence.add(new Note({title: "My first note", text: "This is my first note. It has a rather high duplication quotient, or whatever."}));
29 | persistence.add(new Note({title: "My second note", text: "This is my second note. Isn't it a cool note? Third, fourth."}));
30 | persistence.add(new Note({title: "My third note", text: "Nothing here yet"}));
31 | persistence.add(new Note({title: "Unrelated", text: "Under contruction."}));
32 | persistence.flush(function() {
33 | start();
34 | });
35 | });
36 |
37 | asyncTest("Searching", function() {
38 | Note.search("note").list(function(results) {
39 | equals(results.length, 3, "returned correct number of results");
40 | equals(results[0].title, "My second note", "Found most relevant result");
41 | Note.search("title: third").list(function(results) {
42 | equals(results.length, 1, "returned correct number of results");
43 | equals(results[0].title, "My third note", "Searched in only title");
44 | Note.search("thi*").list(function(results) {
45 | equals(results.length, 3, "wildcard search");
46 | Note.search("thi*").limit(1).list(function(results) {
47 | equals(results.length, 1, "limit number of search results");
48 | start();
49 | });
50 | });
51 | });
52 | });
53 | });
54 |
55 | });
56 |
--------------------------------------------------------------------------------
/test/node/test.sqlite3.store.js:
--------------------------------------------------------------------------------
1 | // $ expresso -s test.sqlite3.store.js
2 |
3 | var assert = require('assert');
4 | var persistence = require('../../lib/persistence').persistence;
5 | var persistenceStore = require('../../lib/persistence.store.sqlite3');
6 |
7 | var dbPath = __dirname + '/test-sqlite3.db';
8 | persistenceStore.config(persistence, dbPath);
9 |
10 | var Task = persistence.define('Task', {
11 | username: 'TEXT'
12 | });
13 |
14 | var data = {
15 | username: 'test'
16 | };
17 |
18 | var data2 = {
19 | username: 'test2'
20 | };
21 |
22 | var task, task2, session;
23 |
24 | // remove test database
25 | function removeDb() {
26 | try {
27 | require('fs').unlinkSync(dbPath);
28 | } catch (err) {
29 | }
30 | }
31 |
32 | module.exports = {
33 | init: function(done) {
34 | removeDb();
35 | session = persistenceStore.getSession(function () {
36 | session.schemaSync(done);
37 | });
38 | },
39 | add: function(done) {
40 | task = new Task(session, data);
41 | session.add(task);
42 | session.flush(function(result, err) {
43 | assert.ifError(err);
44 | done();
45 | });
46 | },
47 | get: function(done) {
48 | Task.findBy(session, 'id', task.id, function(task) {
49 | assert.equal(task.username, data.username);
50 | done();
51 | });
52 | },
53 | update: function(done) {
54 | task.username = 'test2';
55 | Task.findBy(session, 'id', task.id, function(task) {
56 | assert.equal(task.username, 'test2');
57 | done();
58 | });
59 | },
60 | remove: function(done) {
61 | session.remove(task);
62 | session.flush(function(result, err) {
63 | assert.ifError(err);
64 | Task.findBy(session, 'id', task.id, function(task) {
65 | assert.equal(task, null);
66 | done();
67 | });
68 | });
69 | },
70 | addMultiple: function(done) {
71 | task = new Task(session, data);
72 | session.add(task);
73 | task2 = new Task(session, data2);
74 | session.add(task2);
75 | session.flush(function(result, err) {
76 | assert.ifError(err);
77 | var count = 0;
78 | Task.all(session).order('username', true).each(function(row) {
79 | count++;
80 | if (count == 1) {
81 | assert.equal(row.username, data.username);
82 | }
83 | if (count == 2) {
84 | assert.equal(row.username, data2.username);
85 | done();
86 | }
87 | });
88 | });
89 | },
90 | afterAll: function(done) {
91 | session.close(function() {
92 | removeDb();
93 | done();
94 | });
95 | }
96 | };
97 |
--------------------------------------------------------------------------------
/test/browser/uki/uki-persistence.js:
--------------------------------------------------------------------------------
1 | // Original file at: http://github.com/rsaccon/uki/tree/master/src/uki-persistence/persistence.js
2 |
3 |
4 | /**
5 | * persistencejs integration (http://www.persistencejs.org)
6 | *
7 | **/
8 |
9 | // Example
10 | // =======
11 | // // persistence engine
12 | // include('path/to/persistence.js');
13 | // include('path/to/persistence.store.sql.js');
14 | // include('path/to/persistence.store.websql.js');
15 | // include('path/to/persistence.store.memory.js');
16 | // include('path/to/persistence.sync.js'); // optional
17 | // include('path/to/persistence.search.js'); // optional
18 | // include('path/to/persistence.migrations.js'); // optional
19 | // include('path/to/uki-data/uki-persistence.js');
20 | //
21 | // if (window.openDatabase) {
22 | // persistence.store.websql.config(persistence, 'myDbName', 'database', 5 * 1024 * 1024);
23 | // } else {
24 | // persistence.store.memory.config(persistence);
25 | // }
26 | //
27 | // var User = uki.persistence.define('User', {
28 | // firstname: "TEXT",
29 | // lastname: "TEXT"
30 | // });
31 | //
32 | // var aUser = new User({firstname: "Joe", lastname: "Doo"});
33 | //
34 | // aUser.firstname("Mike") ;
35 | //
36 | // console.log(aUser.firstname()); // => Mike
37 | //
38 | // persistence.add(aUser);
39 | //
40 | // persistence.flush();
41 |
42 |
43 | /**
44 | * uki implementation for entity-property
45 | */
46 | persistence.defineProp = function(scope, field, setterCallback, getterCallback) {
47 | scope[field] = function(value) {
48 | if (value === undefined) {
49 | return getterCallback();
50 | } else {
51 | setterCallback(value);
52 | return scope;
53 | }
54 | };
55 | };
56 |
57 | /**
58 | * uki implementation for entity-property setter
59 | */
60 | persistence.set = function(scope, fieldName, value) {
61 | if (persistence.isImmutable(fieldName)) throw "immutable field: "+fieldName;
62 | scope[fieldName](value);
63 | return scope;
64 | };
65 |
66 | /**
67 | * uki implementation for entity-property getter
68 | */
69 | persistence.get = function(arg1, arg2) {
70 | var val = (arguments.length == 1) ? arg1 : arg1[arg2];
71 | return (typeof val === "function") ? val() : val;
72 | };
73 |
74 | /**
75 | * uki ajax implementation
76 | */
77 | if (persistence.sync) {
78 | uki.extend(persistence.sync, {
79 | getJSON: function(url, callback) {
80 | uki.getJSON(url, null, callback);
81 | },
82 | postJSON: function(url, data, callback) {
83 | uki.ajax({
84 | url: url,
85 | type: 'POST',
86 | data: data,
87 | dataType: 'json',
88 | success: function(response) {
89 | callback(JSON.parse(response));
90 | }
91 | });
92 | }
93 | });
94 | }
--------------------------------------------------------------------------------
/test/titanium/Resources/qunit/titanium_adaptor.js:
--------------------------------------------------------------------------------
1 | Titanium.include('qunit/qunit.js');
2 |
3 | // =============================================================================
4 | // Uncomment the following lines in order to get jsMockito support for mocking
5 | // (after following jsMockito install instructions)
6 | // =============================================================================
7 |
8 | // Titanium.include('qunit/jshamcrest.js');
9 | // Titanium.include('qunit/jsmockito-1.0.2.js');
10 | // JsHamcrest.Integration.QUnit();
11 | // JsMockito.Integration.importTo(this);
12 |
13 | var logger = function(failures, message) {
14 | if (failures) {
15 | Titanium.API.error(message);
16 | } else {
17 | Titanium.API.info(message);
18 | }
19 | };
20 | // QUnit.testStart(name) is called whenever a new test batch of assertions starts running. name is the string name of the test batch.
21 | QUnit.testStart = function(name) {
22 | logger(false, '>> >> >>TEST START: '+name);
23 | };
24 | // QUnit.testDone(name, failures, total) is called whenever a batch of assertions finishes running. name is the string name of the test batch. failures is the number of test failures that occurred. total is the total number of test assertions that occurred.
25 | QUnit.testDone = function(name, failures, total) {
26 | logger(failures, '<< << <
11 |
13 |
14 | Text and image
12 |
15 | 
19 |
20 |
21 | jQuery’s mobile strategy can be summarized simply: Delivering top-of-the-line JavaScript in a unified User Interface that works across the most-used smartphone web browsers and tablet form factors.
16 |The critical difference with our approach is the wide variety of mobile platforms we’re targeting with jQuery Mobile. We’ve been working hard at bringing jQuery support to all mobile browsers that are sufficiently-capable and have at least a nominal amount of market share. In this way, we’re treating mobile web browsers exactly how we treat desktop web browsers.
17 |To make this broad support possible, all pages in jQuery Mobile are built on a foundation of clean, semantic HTML to ensure compatibility with pretty much any web-enabled device. In devices that interpret CSS and JavaScript, jQuery Mobile applies progressive enhancement techniques to unobtrusively transform the semantic page into a rich, interactive experience that leverages the power of jQuery and CSS. Accessibility features such as WAI-ARIA are tightly integrated throughout the framework to provide support for screen readers and other assistive technologies.
18 |
19 |
65 |
80 |
81 |
66 |
67 |
70 | 
Touch-Optimized Web Framework for Smartphones & Tablets - now with PersistenceJS integration
68 |Alpha Release
69 |
71 |
78 | Reset DB
79 | -
72 |
- Local persistence demos 73 |
- Text only 74 |
- Text and images 75 |
- Form submission 76 |
82 |
102 |
103 |
104 |
--------------------------------------------------------------------------------
/lib/persistence.store.mysql.js:
--------------------------------------------------------------------------------
1 | /**
2 | * This back-end depends on the node.js asynchronous MySQL driver as found on:
3 | * http://github.com/felixge/node-mysql/
4 | * Easy install using npm:
5 | * npm install mysql
6 | */
7 | var sys = require('sys');
8 | var sql = require('./persistence.store.sql');
9 | var mysql = require('mysql');
10 |
11 | var db, username, password;
12 |
13 | function log(o) {
14 | sys.print(sys.inspect(o) + "\n");
15 | }
16 |
17 |
18 | exports.config = function(persistence, hostname, port, db, username, password) {
19 | exports.getSession = function(cb) {
20 | var that = {};
21 | var opts = {
22 | host: hostname,
23 | port: port,
24 | database: db,
25 | user: username,
26 | password: password
27 | };
28 | var client;
29 | function handleDisconnect() {
30 | connection = mysql.createConnection(opts);
31 | }
32 | if(typeof(mysql.createConnection)=='undefined'){
33 | client = mysql.createClient(opts);
34 | }else{
35 | client = new mysql.createConnection(opts);
36 | client.connect(function(err) {
37 | if(err){
38 | console.error(err);
39 | setTimeout(handleDisconnect, 2000);
40 | }
41 | });
42 | client.on('error', function(err) {
43 | console.error(err);
44 | if(err.code === 'PROTOCOL_CONNECTION_LOST') {
45 | handleDisconnect();
46 | } else {
47 | throw err;
48 | }
49 | });
50 | }
51 |
52 | var session = new persistence.Session(that);
53 | session.transaction = function (explicitCommit, fn) {
54 | if (typeof arguments[0] === "function") {
55 | fn = arguments[0];
56 | explicitCommit = false;
57 | }
58 | var tx = transaction(client);
59 | if (explicitCommit) {
60 | tx.executeSql("START TRANSACTION", null, function(){
61 | fn(tx)
62 | });
63 | }
64 | else
65 | fn(tx);
66 | };
67 |
68 | session.close = function() {
69 | client.end();
70 | //conn._connection.destroy();
71 | };
72 | session.client = client;
73 | return session;
74 | };
75 |
76 | function transaction(conn){
77 | var that = {};
78 | if(conn.ending) {
79 | throw new Error("Connection has been closed, cannot execute query.");
80 | }
81 | that.executeSql = function(query, args, successFn, errorFn){
82 | function cb(err, result){
83 | if (err) {
84 | log(err.message);
85 | that.errorHandler && that.errorHandler(err);
86 | errorFn && errorFn(null, err);
87 | return;
88 | }
89 | if (successFn) {
90 | successFn(result);
91 | }
92 | }
93 | if (persistence.debug) {
94 | sys.print(query + "\n");
95 | args && args.length > 0 && sys.print(args.join(",") + "\n")
96 | }
97 | if (!args) {
98 | conn.query(query, cb);
99 | }
100 | else {
101 | conn.query(query, args, cb);
102 | }
103 | }
104 |
105 | that.commit = function(session, callback){
106 | session.flush(that, function(){
107 | that.executeSql("COMMIT", null, callback);
108 | })
109 | }
110 |
111 | that.rollback = function(session, callback){
112 | that.executeSql("ROLLBACK", null, function() {
113 | session.clean();
114 | callback && callback();
115 | });
116 | }
117 | return that;
118 | }
119 |
120 | exports.mysqlDialect = {
121 | // columns is an array of arrays, e.g.
122 | // [["id", "VARCHAR(32)", "PRIMARY KEY"], ["name", "TEXT"]]
123 | createTable: function(tableName, columns) {
124 | var tm = persistence.typeMapper;
125 | var sql = "CREATE TABLE IF NOT EXISTS `" + tableName + "` (";
126 | var defs = [];
127 | for(var i = 0; i < columns.length; i++) {
128 | var column = columns[i];
129 | defs.push("`" + column[0] + "` " + tm.columnType(column[1]) + (column[2] ? " " + column[2] : ""));
130 | }
131 | sql += defs.join(", ");
132 | sql += ') ENGINE=InnoDB DEFAULT CHARSET=utf8';
133 | return sql;
134 | },
135 |
136 | // columns is array of column names, e.g.
137 | // ["id"]
138 | createIndex: function(tableName, columns, options) {
139 | options = options || {};
140 | return "CREATE "+(options.unique?"UNIQUE ":"")+"INDEX `" + tableName + "__" + columns.join("_") +
141 | "` ON `" + tableName + "` (" +
142 | columns.map(function(col) { return "`" + col + "`"; }).join(", ") + ")";
143 | }
144 | };
145 |
146 | sql.config(persistence, exports.mysqlDialect);
147 | };
148 |
149 |
--------------------------------------------------------------------------------
/docs/sync.md:
--------------------------------------------------------------------------------
1 | persistence.sync.js
2 | ===================
3 |
4 | `persystence.sync.js` is a `persistence.js` plug-in that adds data
5 | synchronization with remote servers. It comes with a client-side
6 | component (`persistence.sync.js`) and a sample server-side component
7 | (`persistence.sync.server.js`) for use with
8 | [node.js](http://nodejs.org). It should be fairly easy to implement
9 | server-components using other languages, any contributions there
10 | are welcome.
11 |
12 | Client-side usage
13 | -----------------
14 |
15 | After including both `persistence.js` and `persistence.sync.js` in
16 | your page, you can enable syncing on entities individually:
17 |
18 | var Task = persistence.define("Task", {
19 | name: "TEXT",
20 | done: "BOOL"
21 | });
22 |
23 | Task.enableSync('/taskChanges');
24 |
25 | The argument passed to `enableSync` is the URI of the sync server
26 | component.
27 |
28 | To initiate a sync, the `EntityName.syncAll(..)` method is used. The method signature
29 | is the following:
30 |
31 | EntityName.syncAll(conflictHandler, successCallback, errorCallback)
32 |
33 | successCallback and errorCallback are optional. successCallback occurs after a
34 | successful sync errorCallback occurs on error (I.E. a non-200 response code).
35 |
36 | conflictHandler is called in the event of a conflict between local and remote data:
37 |
38 | function conflictHandler(conflicts, updatesToPush, callback) {
39 | // Decide what to do with the conflicts here, possibly add to updatesToPush
40 | callback();
41 | }
42 |
43 | EntityName.syncAll(conflictHandler, function() {
44 | alert('Done!');
45 | }, errorHandler);
46 |
47 | There are two sample conflict handlers:
48 |
49 | 1. `persistence.sync.preferLocalConflictHandler`, which in case of a
50 | data conflict will always pick the local changes.
51 | 2. `persistence.sync.preferRemoteConflictHandler`, which in case of a
52 | data conflict will always pick the remote changes.
53 |
54 | For instance:
55 |
56 | EntityName.syncAll(persistence.sync.preferLocalConflictHandler, function() {
57 | alert('Done!');
58 | }, errorCallback);
59 |
60 | Note that you are responsible for syncing all entities and that there
61 | are no database consistencies after a sync, e.g. if you only sync `Task`s that
62 | refer to a `Project` object and that `Project` object has not (yet) been synced,
63 | the database will be (temporarily) inconsistent.
64 |
65 | Server-side (Java, Slim3, AppEngine)
66 | ------------------------------------
67 |
68 | Roberto Saccon developed a [Java server-side implementation of
69 | persistence sync using the Slim3
70 | framework](http://github.com/rsaccon/Slim3PersistenceSync).
71 |
72 | Server-side (node.js)
73 | ---------------------
74 |
75 | The server must expose a resource located at the given URI that responds to:
76 |
77 | * `GET` requests with a `since=
83 |
85 | Form submission
84 |
86 |
100 |
101 | Home'); 68 | res.write(""); 69 | } 70 | 71 | // Actions 72 | 73 | function initDatabase(session, tx, req, res, callback) { 74 | htmlHeader(res, "Initializing database."); 75 | session.schemaSync(tx, function() { 76 | res.write("Done."); 77 | htmlFooter(res); 78 | callback(); 79 | }); 80 | } 81 | 82 | function resetDatabase(session, tx, req, res, callback) { 83 | htmlHeader(res, "Dropping all tables"); 84 | session.reset(tx, function() { 85 | res.write('All tables dropped, Click here to create fresh ones'); 86 | htmlFooter(res); 87 | callback(); 88 | }); 89 | } 90 | 91 | function showItems(session, tx, req, res, callback) { 92 | htmlHeader(res, "Blog"); 93 | res.write('
Latest Posts
'); 94 | Post.all(session).order("date", false).list(tx, function(posts) { 95 | for(var i = 0; i < posts.length; i++) { 96 | var post = posts[i]; 97 | res.write('' + post.title + '
'); 98 | res.write(post.text); 99 | res.write(''); 100 | res.write('Posted ' + post.date); 101 | } 102 | res.write('
Create new post
'); 103 | res.write(''); 108 | htmlFooter(res); 109 | callback(); 110 | }); 111 | } 112 | 113 | function showItem(session, tx, req, res, callback) { 114 | htmlHeader(res, "Blog"); 115 | var query = parseUrl(req.url, true).query; 116 | Post.load(session, tx, query.id, function(post) { 117 | res.write('' + post.title + '
'); 118 | res.write(post.text); 119 | res.write(''); 120 | res.write('Posted ' + post.date); 121 | res.write('
Comments
'); 122 | post.comments.order('date', true).list(tx, function(comments) { 123 | for(var i = 0; i < comments.length; i++) { 124 | var comment = comments[i]; 125 | res.write('By ' + comment.author + '
'); 126 | res.write(comment.text); 127 | res.write(''); 128 | res.write('Posted ' + post.date); 129 | } 130 | res.write('
Add a comment
'); 131 | res.write(''); 137 | htmlFooter(res); 138 | callback(); 139 | }); 140 | }); 141 | } 142 | 143 | function post(session, tx, req, res, callback) { 144 | htmlHeader(res, "Created new post"); 145 | var query = parseUrl(req.url, true).query; 146 | var post = new Post(session, {title: query.title, text: query.text, date: new Date()}); 147 | session.add(post); 148 | session.flush(tx, function() { 149 | res.write('Post added.
'); 150 | res.write('Go back'); 151 | htmlFooter(res); 152 | callback(); 153 | }); 154 | } 155 | 156 | function postComment(session, tx, req, res, callback) { 157 | htmlHeader(res, "Created new comment"); 158 | var query = parseUrl(req.url, true).query; 159 | var comment = new Comment(session, {text: query.text, author: query.author, date: new Date()}); 160 | Post.load(session, tx, query.post, function(post) { 161 | post.comments.add(comment); 162 | session.flush(tx, function() { 163 | res.write('Comment added.
'); 164 | res.write('Go back'); 165 | htmlFooter(res); 166 | callback(); 167 | }); 168 | }); 169 | } 170 | 171 | var urlMap = { 172 | '/init': initDatabase, 173 | '/reset': resetDatabase, 174 | '/post': post, 175 | '/postComment': postComment, 176 | '/show': showItem, 177 | '/': showItems 178 | }; 179 | 180 | var http = require('http'); 181 | http.createServer(function (req, res) { 182 | res.writeHead(200, {'Content-Type': 'text/html'}); 183 | var parsed = parseUrl(req.url, true); 184 | var fn = urlMap[parsed.pathname]; 185 | if(fn) { 186 | var session = persistenceStore.getSession(); 187 | session.transaction(function(tx) { 188 | fn(session, tx, req, res, function() { 189 | session.close(); 190 | res.end(); 191 | }); 192 | }); 193 | } else { 194 | res.end("Not found: " + req.url); 195 | } 196 | }).listen(8888, "127.0.0.1"); 197 | console.log('Server running at http://127.0.0.1:8888/'); 198 | -------------------------------------------------------------------------------- /lib/persistence.store.cordovasql.js: -------------------------------------------------------------------------------- 1 | try { 2 | if (!window) { 3 | window = {}; 4 | //exports.console = console; 5 | } 6 | } catch (e) { 7 | window = {}; 8 | exports.console = console; 9 | } 10 | 11 | var persistence = (window && window.persistence) ? window.persistence : {}; 12 | 13 | if (!persistence.store) { 14 | persistence.store = {}; 15 | } 16 | 17 | persistence.store.cordovasql = {}; 18 | 19 | /** 20 | * Configure the database connection (either sqliteplugin or websql) 21 | * 22 | * @param persistence 23 | * @param dbname 24 | * @param dbversion 25 | * @param description 26 | * @param size 27 | * @param backgroundProcessing 28 | * @param iOSLocation 29 | */ 30 | persistence.store.cordovasql.config = function (persistence, dbname, dbversion, description, size, backgroundProcessing, iOSLocation) { 31 | var conn = null; 32 | 33 | /** 34 | * Create a transaction 35 | * 36 | * @param callback 37 | * the callback function to be invoked when the transaction 38 | * starts, taking the transaction object as argument 39 | */ 40 | persistence.transaction = function (callback) { 41 | if (!conn) { 42 | throw new Error("No ongoing database connection, please connect first."); 43 | } else { 44 | conn.transaction(callback); 45 | } 46 | }; 47 | 48 | persistence.db = persistence.db || {}; 49 | persistence.db.implementation = "unsupported"; 50 | persistence.db.conn = null; 51 | 52 | /* Find out if sqliteplugin is loaded. Otherwise, we'll fall back to WebSql */ 53 | if (window && 'sqlitePlugin' in window) { 54 | persistence.db.implementation = 'sqliteplugin'; 55 | } else if (window && window.openDatabase) { 56 | persistence.db.implementation = "websql"; 57 | } else { 58 | // Well, we are stuck! 59 | } 60 | 61 | /* 62 | * Cordova SqlitePlugin 63 | */ 64 | persistence.db.sqliteplugin = {}; 65 | 66 | /** 67 | * Connect to Sqlite plugin database 68 | * 69 | * @param dbname 70 | * @param backgroundProcessing 71 | * @param iOSLocation 72 | * @returns {{}} 73 | */ 74 | persistence.db.sqliteplugin.connect = function (dbname, backgroundProcessing, iOSLocation) { 75 | var that = {}; 76 | var conn = window.sqlitePlugin.openDatabase({name: dbname, bgType: backgroundProcessing, location: (iOSLocation || 0)}); 77 | 78 | that.transaction = function (fn) { 79 | return conn.transaction(function (sqlt) { 80 | return fn(persistence.db.websql.transaction(sqlt)); 81 | }); 82 | }; 83 | return that; 84 | }; 85 | 86 | /** 87 | * Run transaction on Sqlite plugin database 88 | * 89 | * @param t 90 | * @returns {{}} 91 | */ 92 | persistence.db.sqliteplugin.transaction = function (t) { 93 | var that = {}; 94 | that.executeSql = function (query, args, successFn, errorFn) { 95 | if (persistence.debug) { 96 | console.log(query, args); 97 | } 98 | t.executeSql(query, args, function (_, result) { 99 | if (successFn) { 100 | var results = []; 101 | for (var i = 0; i < result.rows.length; i++) { 102 | results.push(result.rows.item(i)); 103 | } 104 | successFn(results); 105 | } 106 | }, errorFn); 107 | }; 108 | return that; 109 | }; 110 | 111 | /* 112 | * WebSQL 113 | */ 114 | persistence.db.websql = {}; 115 | 116 | /** 117 | * Connect to the default WebSQL database 118 | * 119 | * @param dbname 120 | * @param dbversion 121 | * @param description 122 | * @param size 123 | * @returns {{}} 124 | */ 125 | persistence.db.websql.connect = function (dbname, dbversion, description, size) { 126 | var that = {}; 127 | var conn = openDatabase(dbname, dbversion, description, size); 128 | 129 | that.transaction = function (fn) { 130 | return conn.transaction(function (sqlt) { 131 | return fn(persistence.db.websql.transaction(sqlt)); 132 | }); 133 | }; 134 | return that; 135 | }; 136 | 137 | /** 138 | * Run transaction on WebSQL database 139 | * 140 | * @param t 141 | * @returns {{}} 142 | */ 143 | persistence.db.websql.transaction = function (t) { 144 | var that = {}; 145 | that.executeSql = function (query, args, successFn, errorFn) { 146 | if (persistence.debug) { 147 | console.log(query, args); 148 | } 149 | t.executeSql(query, args, function (_, result) { 150 | if (successFn) { 151 | var results = []; 152 | for (var i = 0; i < result.rows.length; i++) { 153 | results.push(result.rows.item(i)); 154 | } 155 | successFn(results); 156 | } 157 | }, errorFn); 158 | }; 159 | return that; 160 | }; 161 | 162 | /** 163 | * Connect() wrapper 164 | * 165 | * @param dbname 166 | * @param dbversion 167 | * @param description 168 | * @param size 169 | * @param backgroundProcessing 170 | * @param iOSLocation 171 | * @returns {*} 172 | */ 173 | persistence.db.connect = function (dbname, dbversion, description, size, backgroundProcessing, iOSLocation) { 174 | if (persistence.db.implementation == "sqliteplugin") { 175 | return persistence.db.sqliteplugin.connect(dbname, backgroundProcessing, iOSLocation); 176 | } else if (persistence.db.implementation == "websql") { 177 | return persistence.db.websql.connect(dbname, dbversion, description, size); 178 | } 179 | 180 | return null; 181 | }; 182 | 183 | /** 184 | * Set the sqlite dialect 185 | * 186 | * @type {{createTable: createTable, createIndex: createIndex}} 187 | */ 188 | persistence.store.cordovasql.sqliteDialect = { 189 | 190 | /** 191 | * columns is an array of arrays, e.g. [["id", "VARCHAR(32)", "PRIMARY KEY"], ["name", "TEXT"]] 192 | * 193 | * @param tableName 194 | * @param columns 195 | * @returns {string} 196 | */ 197 | createTable: function (tableName, columns) { 198 | var tm = persistence.typeMapper; 199 | var sql = "CREATE TABLE IF NOT EXISTS `" + tableName + "` ("; 200 | var defs = []; 201 | for (var i = 0; i < columns.length; i++) { 202 | var column = columns[i]; 203 | defs.push("`" + column[0] + "` " + tm.columnType(column[1]) + (column[2] ? " " + column[2] : "")); 204 | } 205 | sql += defs.join(", "); 206 | sql += ')'; 207 | return sql; 208 | }, 209 | 210 | /** 211 | * columns is array of column names, e.g. ["id"] 212 | * @param tableName 213 | * @param columns 214 | * @param options 215 | * @returns {string} 216 | */ 217 | createIndex: function (tableName, columns, options) { 218 | options = options || {}; 219 | return "CREATE " + (options.unique ? "UNIQUE " : "") + "INDEX IF NOT EXISTS `" + tableName + "__" + columns.join("_") + 220 | "` ON `" + tableName + "` (" + 221 | columns.map(function (col) { 222 | return "`" + col + "`"; 223 | }).join(", ") + ")"; 224 | } 225 | }; 226 | 227 | // Configure persistence for generic sql persistence, using sqliteDialect 228 | persistence.store.sql.config(persistence, persistence.store.cordovasql.sqliteDialect); 229 | 230 | // Make the connection 231 | conn = persistence.db.connect(dbname, dbversion, description, size, backgroundProcessing, iOSLocation); 232 | if (!conn) { 233 | throw new Error("No supported database found in this browser."); 234 | } 235 | }; 236 | 237 | try { 238 | exports.persistence = persistence; 239 | } catch (e) { 240 | } 241 | -------------------------------------------------------------------------------- /lib/persistence.sync.server.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) 2010 Zef Hemel