persistence-rails 0.0.1

data/vendor/assets/javascript/persistence.store.sqlite.js

@@ -0,0 +1,123 @@
+//= require persistence.core
+
+/**
+ * This back-end depends on the node.js asynchronous SQLite driver as found on:
+ * https://github.com/orlandov/node-sqlite
+ * Easy install using npm:
+ *   npm install sqlite
+ * @author Eugene Ware
+ */
+var sys = require('sys');
+var sql = require('./persistence.store.sql');
+var sqlite = require('sqlite');
+
+var db, username, password;
+
+function log(o) {
+  sys.print(sys.inspect(o) + "\n");
+}
+
+
+exports.config = function(persistence, dbPath) {
+  exports.getSession = function(cb) {
+    var that = {};
+    cb = cb || function() { };
+    var conn = new sqlite.Database();
+    conn.open(dbPath, cb);
+
+    var session = new persistence.Session(that);
+    session.transaction = function (explicitCommit, fn) {
+      if (typeof arguments[0] === "function") {
+        fn = arguments[0];
+        explicitCommit = false;
+      }
+      var tx = transaction(conn);
+      if (explicitCommit) {
+        tx.executeSql("START TRANSACTION", null, function(){
+          fn(tx)
+        });
+      }
+      else 
+        fn(tx);
+    };
+
+    session.close = function(cb) {
+      cb = cb || function() {};
+      conn.close(cb);
+    };
+    return session;
+  };
+
+  function transaction(conn){
+    var that = {};
+    // TODO: add check for db opened or closed
+    that.executeSql = function(query, args, successFn, errorFn){
+      function cb(err, result){
+        if (err) {
+          log(err.message);
+          that.errorHandler && that.errorHandler(err);
+          errorFn && errorFn(null, err);
+          return;
+        }
+        if (successFn) {
+          successFn(result);
+        }
+      }
+      if (persistence.debug) {
+        sys.print(query + "\n");
+        args && args.length > 0 && sys.print(args.join(",") + "\n")
+      }
+      if (!args) {
+        conn.execute(query, cb);
+      }
+      else {
+        conn.execute(query, args, cb);
+      }
+    }
+    
+    that.commit = function(session, callback){
+      session.flush(that, function(){
+        that.executeSql("COMMIT", null, callback);
+      })
+    }
+    
+    that.rollback = function(session, callback){
+      that.executeSql("ROLLBACK", null, function() {
+        session.clean();
+        callback();
+      });
+    }
+    return that;
+  }
+  
+  ///////////////////////// SQLite dialect
+
+  persistence.sqliteDialect = {
+    // columns is an array of arrays, e.g.
+    // [["id", "VARCHAR(32)", "PRIMARY KEY"], ["name", "TEXT"]]
+    createTable: function(tableName, columns) {
+      var tm = persistence.typeMapper;
+      var sql = "CREATE TABLE IF NOT EXISTS `" + tableName + "` (";
+      var defs = [];
+      for(var i = 0; i < columns.length; i++) {
+        var column = columns[i];
+        defs.push("`" + column[0] + "` " + tm.columnType(column[1]) + (column[2] ? " " + column[2] : ""));
+      }
+      sql += defs.join(", ");
+      sql += ')';
+      return sql;
+    },
+
+    // columns is array of column names, e.g.
+    // ["id"]
+    createIndex: function(tableName, columns, options) {
+      options = options || {};
+      return "CREATE "+(options.unique?"UNIQUE ":"")+"INDEX IF NOT EXISTS `" + tableName + "__" + columns.join("_") + 
+             "` ON `" + tableName + "` (" + 
+             columns.map(function(col) { return "`" + col + "`"; }).join(", ") + ")";
+    }
+  };
+
+  sql.config(persistence, persistence.sqliteDialect);
+};
+

data/vendor/assets/javascript/persistence.store.sqlite3.js

@@ -0,0 +1,124 @@
+//= require persistence.core
+
+/**
+ * This back-end depends on the node.js asynchronous SQLite3 driver as found on:
+ * https://github.com/developmentseed/node-sqlite3
+ * Easy install using npm:
+ *   npm install sqlite3
+ * @author Eugene Ware
+ * @author Jeff Kunkle
+ * @author Joe Ferner
+ */
+var sys = require('sys');
+var sql = require('./persistence.store.sql');
+var sqlite = require('sqlite3');
+
+var db, username, password;
+
+function log(o) {
+  sys.print(sys.inspect(o) + "\n");
+}
+
+
+exports.config = function(persistence, dbPath) {
+  exports.getSession = function(cb) {
+    var that = {};
+    cb = cb || function() { };
+    var conn = new sqlite.Database(dbPath, cb);
+
+    var session = new persistence.Session(that);
+    session.transaction = function (explicitCommit, fn) {
+      if (typeof arguments[0] === "function") {
+        fn = arguments[0];
+        explicitCommit = false;
+      }
+      var tx = transaction(conn);
+      if (explicitCommit) {
+        tx.executeSql("START TRANSACTION", null, function(){
+          fn(tx)
+        });
+      }
+      else 
+        fn(tx);
+    };
+
+    session.close = function(cb) {
+      cb = cb || function() {};
+      conn.close(cb);
+    };
+    return session;
+  };
+
+  function transaction(conn){
+    var that = {};
+    // TODO: add check for db opened or closed
+    that.executeSql = function(query, args, successFn, errorFn){
+      function cb(err, result){
+        if (err) {
+          log(err.message);
+          that.errorHandler && that.errorHandler(err);
+          errorFn && errorFn(null, err);
+          return;
+        }
+        if (successFn) {
+          successFn(result);
+        }
+      }
+      if (persistence.debug) {
+        sys.print(query + "\n");
+        args && args.length > 0 && sys.print(args.join(",") + "\n")
+      }
+      if (!args) {
+        conn.all(query, cb);
+      }
+      else {
+        conn.all(query, args, cb);
+      }
+    }
+
+    that.commit = function(session, callback){
+      session.flush(that, function(){
+        that.executeSql("COMMIT", null, callback);
+      })
+    }
+
+    that.rollback = function(session, callback){
+      that.executeSql("ROLLBACK", null, function() {
+        session.clean();
+        callback();
+      });
+    }
+    return that;
+  }
+
+  ///////////////////////// SQLite dialect
+
+  persistence.sqliteDialect = {
+    // columns is an array of arrays, e.g.
+    // [["id", "VARCHAR(32)", "PRIMARY KEY"], ["name", "TEXT"]]
+    createTable: function(tableName, columns) {
+      var tm = persistence.typeMapper;
+      var sql = "CREATE TABLE IF NOT EXISTS `" + tableName + "` (";
+      var defs = [];
+      for(var i = 0; i < columns.length; i++) {
+        var column = columns[i];
+        defs.push("`" + column[0] + "` " + tm.columnType(column[1]) + (column[2] ? " " + column[2] : ""));
+      }
+      sql += defs.join(", ");
+      sql += ')';
+      return sql;
+    },
+
+    // columns is array of column names, e.g.
+    // ["id"]
+    createIndex: function(tableName, columns, options) {
+      options = options || {};
+      return "CREATE "+(options.unique?"UNIQUE ":"")+"INDEX IF NOT EXISTS `" + tableName + "__" + columns.join("_") + 
+             "` ON `" + tableName + "` (" + 
+             columns.map(function(col) { return "`" + col + "`"; }).join(", ") + ")";
+    }
+  };
+
+  sql.config(persistence, persistence.sqliteDialect);
+};
+

data/vendor/assets/javascript/persistence.store.titanium.js

@@ -0,0 +1,193 @@
+//= require persistence.core
+
+try {
+  if(!window) {
+    window = {};
+    //exports.console = console;
+  }
+} catch(e) {
+  window = {};
+  exports.console = console;
+}
+
+var persistence = (window && window.persistence) ? window.persistence : {};
+
+if(!persistence.store) {
+  persistence.store = {};
+}
+
+persistence.store.titanium = {};
+
+persistence.store.titanium.config = function(persistence, dbname) {
+  var conn = null;
+
+  /**
+   * Create a transaction
+   *
+   * @param callback,
+   *            the callback function to be invoked when the transaction
+   *            starts, taking the transaction object as argument
+   */
+  persistence.transaction = function (callback) {
+    if(!conn) {
+      throw new Error("No ongoing database connection, please connect first.");
+    } else {
+      conn.transaction(callback);
+    }
+  };
+
+  ////////// Low-level database interface, abstracting from HTML5 and Gears databases \\\\
+  persistence.db = persistence.db || {};
+
+  persistence.db.conn = null;
+
+  persistence.db.titanium = {};
+
+  persistence.db.titanium.connect = function (dbname) {
+    var that = {};
+    var conn = Titanium.Database.open(dbname);
+
+    that.transaction = function (fn) {
+      fn(persistence.db.titanium.transaction(conn));
+    };
+    return that;
+  };
+
+  persistence.db.titanium.transaction = function (conn) {
+    var that = {};
+    that.executeSql = function (query, args, successFn, errorFn) {
+
+      if(persistence.debug) {
+        console.log(query, args);
+      }
+      try {
+        var executeVarArgs = [query];
+        if (args) {
+          executeVarArgs = executeVarArgs.concat(args);
+        };
+        var rs = Function.apply.call(conn.execute, conn, executeVarArgs);
+        if (successFn) {
+          var results = [];
+          if (rs) {
+            while (rs.isValidRow()) {
+              var result = {};
+              for ( var i = 0; i < rs.fieldCount(); i++) {
+                result[rs.fieldName(i)] = rs.field(i);
+              }
+              results.push(result);
+              rs.next();
+            }
+            rs.close();
+          };
+          successFn(results);
+        }
+      } catch(e) {
+        if (errorFn) {
+          errorFn(null, e);
+        };
+      }
+    };
+    return that;
+  };
+
+  ///////////////////////// SQLite dialect
+
+  persistence.store.titanium.sqliteDialect = {
+    // columns is an array of arrays, e.g.
+    // [["id", "VARCHAR(32)", "PRIMARY KEY"], ["name", "TEXT"]]
+    createTable: function(tableName, columns) {
+      var tm = persistence.typeMapper;
+      var sql = "CREATE TABLE IF NOT EXISTS `" + tableName + "` (";
+      var defs = [];
+      for(var i = 0; i < columns.length; i++) {
+        var column = columns[i];
+        defs.push("`" + column[0] + "` " + tm.columnType(column[1]) + (column[2] ? " " + column[2] : ""));
+      }
+      sql += defs.join(", ");
+      sql += ')';
+      return sql;
+    },
+
+    // columns is array of column names, e.g.
+    // ["id"]
+    createIndex: function(tableName, columns, options) {
+      options = options || {};
+      return "CREATE "+(options.unique?"UNIQUE ":"")+"INDEX IF NOT EXISTS `" + tableName + "__" + columns.join("_") +
+             "` ON `" + tableName + "` (" +
+             columns.map(function(col) { return "`" + col + "`"; }).join(", ") + ")";
+    },
+
+    typeMapper: {
+      idType: persistence.store.sql.defaultTypeMapper.idType,
+      classNameType: persistence.store.sql.defaultTypeMapper.classNameType,
+      inVar: persistence.store.sql.defaultTypeMapper.inVar,
+      outVar: persistence.store.sql.defaultTypeMapper.outVar,
+      outId: persistence.store.sql.defaultTypeMapper.outId,
+      inIdVar: persistence.store.sql.defaultTypeMapper.inIdVar,
+      outIdVar: persistence.store.sql.defaultTypeMapper.outIdVar,
+      entityIdToDbId: persistence.store.sql.defaultTypeMapper.entityIdToDbId,
+      zeroPaddingMap: ['0000000000000000',
+                       '000000000000000',
+                       '00000000000000',
+                       '0000000000000',
+                       '000000000000',
+                       '00000000000',
+                       '0000000000',
+                       '000000000',
+                       '00000000',
+                       '0000000',
+                       '000000',
+                       '00000',
+                       '0000',
+                       '000',
+                       '00',
+                       '0'],
+      zeroPadded: function(val) {
+        var result = val.toString();
+        if (result.length < 16) {
+          return persistence.store.titanium.sqliteDialect.typeMapper.zeroPaddingMap[result.length] + result;
+        } else {
+          return result;
+        };
+      },
+      columnType: function(type) {
+        if (type === 'BIGINT') {
+          return 'TEXT';
+        } else {
+          return persistence.store.sql.defaultTypeMapper.columnType(type);
+        };
+      },
+      dbValToEntityVal: function(val, type){
+        if (val === null || val === undefined) {
+          return val;
+        } else if (type === 'BIGIN') {
+          return parseInt(val);
+        } else {
+          return persistence.store.sql.defaultTypeMapper.dbValToEntityVal(val, type);
+        }
+      },
+      entityValToDbVal: function(val, type){
+        if (val === undefined || val === null) {
+          return null;
+        } else if (type === 'BIGINT') {
+          return persistence.store.titanium.sqliteDialect.typeMapper.zeroPadded(val);
+        } else {
+          return persistence.store.sql.defaultTypeMapper.entityValToDbVal(val, type);
+        };
+      }
+    }
+  };
+
+  // Configure persistence for generic sql persistence, using sqliteDialect
+  persistence.store.sql.config(persistence, persistence.store.titanium.sqliteDialect);
+
+  // Make the connection
+  conn = persistence.db.titanium.connect(dbname);
+  if(!conn) {
+    throw new Error("No supported database found");
+  }
+};
+
+try {
+  exports.persistence = persistence;
+} catch(e) {}

data/vendor/assets/javascript/persistence.store.websql.js

@@ -0,0 +1,218 @@
+//= require persistence.core
+
+try {
+  if(!window) {
+    window = {};
+    //exports.console = console;
+  }
+} catch(e) {
+  window = {};
+  exports.console = console;
+}
+
+var persistence = (window && window.persistence) ? window.persistence : {}; 
+
+if(!persistence.store) {
+  persistence.store = {};
+}
+
+persistence.store.websql = {};
+
+
+persistence.store.websql.config = function(persistence, dbname, description, size) {
+  var conn = null;
+
+  /**
+   * Create a transaction
+   * 
+   * @param callback,
+   *            the callback function to be invoked when the transaction
+   *            starts, taking the transaction object as argument
+   */
+  persistence.transaction = function (callback) {
+    if(!conn) {
+      throw new Error("No ongoing database connection, please connect first.");
+    } else {
+      conn.transaction(callback);
+    }
+  };
+
+  ////////// Low-level database interface, abstracting from HTML5 and Gears databases \\\\
+  persistence.db = persistence.db || {};
+
+  persistence.db.implementation = "unsupported";
+  persistence.db.conn = null;
+
+  // window object does not exist on Qt Declarative UI (http://doc.trolltech.org/4.7-snapshot/declarativeui.html)
+  if (window && window.openDatabase) {
+    persistence.db.implementation = "html5";
+  } else if (window && window.google && google.gears) {
+    persistence.db.implementation = "gears";
+  } else {
+    try {
+      if (openDatabaseSync) {
+        // TODO: find a browser that implements openDatabaseSync and check out if
+        //       it is attached to the window or some other object
+        persistence.db.implementation = "html5-sync";
+      }
+    } catch(e) {
+    }
+  }
+
+  persistence.db.html5 = {};
+
+  persistence.db.html5.connect = function (dbname, description, size) {
+    var that = {};
+    var conn = openDatabase(dbname, '1.0', description, size);
+
+    that.transaction = function (fn) {
+      return conn.transaction(function (sqlt) {
+          return fn(persistence.db.html5.transaction(sqlt));
+        });
+    };
+    return that;
+  };
+
+  persistence.db.html5.transaction = function (t) {
+    var that = {};
+    that.executeSql = function (query, args, successFn, errorFn) {
+      if(persistence.debug) {
+        console.log(query, args);
+      }
+      t.executeSql(query, args, function (_, result) {
+          if (successFn) {
+            var results = [];
+            for ( var i = 0; i < result.rows.length; i++) {
+              results.push(result.rows.item(i));
+            }
+            successFn(results);
+          }
+        }, errorFn);
+    };
+    return that;
+  };
+
+  persistence.db.html5Sync = {};
+
+  persistence.db.html5Sync.connect = function (dbname, description, size) {
+    var that = {};
+    var conn = openDatabaseSync(dbname, '1.0', description, size);
+
+    that.transaction = function (fn) {
+      return conn.transaction(function (sqlt) {
+          return fn(persistence.db.html5Sync.transaction(sqlt));
+        });
+    };
+    return that;
+  };
+
+  persistence.db.html5Sync.transaction = function (t) {
+    var that = {};
+    that.executeSql = function (query, args, successFn, errorFn) {
+      if (args == null) args = [];
+
+      if(persistence.debug) {
+        console.log(query, args);
+      }
+
+      var result = t.executeSql(query, args);
+      if (result) {
+        if (successFn) {
+          var results = [];
+          for ( var i = 0; i < result.rows.length; i++) {
+            results.push(result.rows.item(i));
+          }
+          successFn(results);
+        }
+      }
+    };
+    return that;
+  };
+
+  persistence.db.gears = {};
+
+  persistence.db.gears.connect = function (dbname) {
+    var that = {};
+    var conn = google.gears.factory.create('beta.database');
+    conn.open(dbname);
+
+    that.transaction = function (fn) {
+      fn(persistence.db.gears.transaction(conn));
+    };
+    return that;
+  };
+
+  persistence.db.gears.transaction = function (conn) {
+    var that = {};
+    that.executeSql = function (query, args, successFn, errorFn) {
+      if(persistence.debug) {
+        console.log(query, args);
+      }
+      var rs = conn.execute(query, args);
+      if (successFn) {
+        var results = [];
+        while (rs.isValidRow()) {
+          var result = {};
+          for ( var i = 0; i < rs.fieldCount(); i++) {
+            result[rs.fieldName(i)] = rs.field(i);
+          }
+          results.push(result);
+          rs.next();
+        }
+        successFn(results);
+      }
+    };
+    return that;
+  };
+
+  persistence.db.connect = function (dbname, description, size) {
+    if (persistence.db.implementation == "html5") {
+      return persistence.db.html5.connect(dbname, description, size);
+    } else if (persistence.db.implementation == "html5-sync") {
+      return persistence.db.html5Sync.connect(dbname, description, size);
+    } else if (persistence.db.implementation == "gears") {
+      return persistence.db.gears.connect(dbname);
+    }
+  };
+
+  ///////////////////////// SQLite dialect
+
+  persistence.store.websql.sqliteDialect = {
+    // columns is an array of arrays, e.g.
+    // [["id", "VARCHAR(32)", "PRIMARY KEY"], ["name", "TEXT"]]
+    createTable: function(tableName, columns) {
+      var tm = persistence.typeMapper;
+      var sql = "CREATE TABLE IF NOT EXISTS `" + tableName + "` (";
+      var defs = [];
+      for(var i = 0; i < columns.length; i++) {
+        var column = columns[i];
+        defs.push("`" + column[0] + "` " + tm.columnType(column[1]) + (column[2] ? " " + column[2] : ""));
+      }
+      sql += defs.join(", ");
+      sql += ')';
+      return sql;
+    },
+
+    // columns is array of column names, e.g.
+    // ["id"]
+    createIndex: function(tableName, columns, options) {
+      options = options || {};
+      return "CREATE "+(options.unique?"UNIQUE ":"")+"INDEX IF NOT EXISTS `" + tableName + "__" + columns.join("_") + 
+             "` ON `" + tableName + "` (" + 
+             columns.map(function(col) { return "`" + col + "`"; }).join(", ") + ")";
+    }
+  };
+
+  // Configure persistence for generic sql persistence, using sqliteDialect
+  persistence.store.sql.config(persistence, persistence.store.websql.sqliteDialect);
+
+  // Make the connection
+  conn = persistence.db.connect(dbname, description, size);
+  if(!conn) {
+    throw new Error("No supported database found in this browser.");
+  }
+};
+
+try {
+  exports.persistence = persistence;
+} catch(e) {}