RubyGems - middleman-core-x86-mingw32 - Versions diffs - 3.0.1.pre - Mend

middleman-core-x86-mingw32 3.0.1.pre

Files changed (401) hide show

data/lib/middleman-core/templates/mobile/source/tools/wspl/dbwrapper_html5_test.html ADDED Viewed

@@ -0,0 +1,468 @@
+<!DOCTYPE html>
+<!--
+  Copyright 2009 Google Inc.
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<html>
+<head>
+<title>Database wrapper tests</title>
+<script type="text/javascript" src="../jsunit/app/jsUnitCore.js"></script>
+<script type="text/javascript" src="jsmock.js"></script>
+<script type="text/javascript" src="global_functions.js"></script>
+<script type="text/javascript" src="dbwrapperapi.js"></script>
+<script type="text/javascript" src="dbwrapper_html5.js"></script>
+</head>
+<body>
+<script type='text/javascript'>
+var mockControl;
+var html5Tx;
+var callbackMock;
+var html5Window;
+var html5Db;
+var populateMock;
+function setUp() {
+  mockControl = new MockControl();
+  html5Tx = mockControl.createMock({executeSql: function(){}});
+  callbackMock = mockControl.createMock({onSuccess: function(){},
+      onFailure: function(){}});
+  html5Window = mockControl.createMock({openDatabase: function(){}});
+  html5Db = mockControl.createMock({transaction: function(){}});
+  populateMock = mockControl.createMock({populate: function(){}});
+  dbTx = mockControl.createMock({execute: function(){}, executeAll:
+      function(){}});
+  dbRows = mockControl.createMock({item: function(){}});
+}
+function testConstructTransaction() {
+  var trans = new google.wspl.html5.Transaction('foo');
+  assertEquals('transaction instance not set correctly', 'foo', trans.tx_);
+}
+function testTransactionExecuteAll() {
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  try {
+    trans.executeAll([], callbackMock);
+    fail('Should never get here');
+  } catch(e) {
+    assertEquals(
+        'did not exception fault on empty statement list',
+        'Error: Possibly silly attempt to execute empty statement list.',
+        e.toString());
+  }
+  mockControl.verify();
+}
+/*
+  The sequence of digits at the end of the test names indicate as boolean
+  variables the success or failure of each statement.
+*/
+function testTransactionExecuteAll_1() {
+  var stat1 = new google.wspl.Statement('stat1');
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  var successCallback = null;
+  var failureCallback = null;
+  html5Tx.expects().executeSql('stat1', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback = arguments[2];
+      });
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset', arguments[1].result_)});
+  trans.executeAll([stat1], callbackMock);
+  successCallback(html5Tx, 'resultset');
+  mockControl.verify();
+}
+function testTransactionExecuteAll_11() {
+  var stat1 = new google.wspl.Statement('stat1');
+  var stat2 = new google.wspl.Statement('stat2', [1]);
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  var successCallback1 = null;
+  var successCallback2 = null;
+  var failureCallback = null;
+  html5Tx.expects().executeSql('stat1', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback1 = arguments[2];
+      });
+  html5Tx.expects().executeSql('stat2', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback2 = arguments[2];
+        var params = arguments[1];
+        assertEquals('incorrect params to sql', 1, params[0]);
+      });
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset1', arguments[1].result_)});
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset2', arguments[1].result_)});
+  trans.executeAll([stat1, stat2], callbackMock);
+  successCallback1(html5Tx, 'resultset1');
+  successCallback2(html5Tx, 'resultset2');
+  mockControl.verify();
+}
+function testTransactionExecuteAll_111() {
+  var stat1 = new google.wspl.Statement('stat1');
+  var stat2 = new google.wspl.Statement('stat2', [1]);
+  var stat3 = new google.wspl.Statement('stat3', [2,  3]);
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  var successCallback1 = null;
+  var successCallback2 = null;
+  var successCallback3 = null;
+  var failureCallback = null;
+  html5Tx.expects().executeSql('stat1', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback1 = arguments[2];
+      });
+  html5Tx.expects().executeSql('stat2', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback2 = arguments[2];
+        var params = arguments[1];
+        assertEquals('incorrect params to sql', 1, params[0]);
+      });
+  html5Tx.expects().executeSql('stat3', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback3 = arguments[2];
+        var params = arguments[1];
+        assertEquals('incorrect params to sql', 2, params[0]);
+        assertEquals('incorrect params to sql', 3, params[1]);
+      });
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset1', arguments[1].result_)});
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset2', arguments[1].result_)});
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset3', arguments[1].result_)});
+  trans.executeAll([stat1, stat2, stat3], callbackMock);
+  successCallback1(html5Tx, 'resultset1');
+  successCallback2(html5Tx, 'resultset2');
+  successCallback3(html5Tx, 'resultset3');
+  mockControl.verify();
+}
+function testTransactionExecuteAll_noCallback_111() {
+  var stat1 = new google.wspl.Statement('stat1');
+  var stat2 = new google.wspl.Statement('stat2', [1]);
+  var stat3 = new google.wspl.Statement('stat3', [2,  3]);
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  var successCallback1 = null;
+  var successCallback2 = null;
+  var successCallback3 = null;
+  var failureCallback = null;
+  html5Tx.expects().executeSql('stat1', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback1 = arguments[2];
+      });
+  html5Tx.expects().executeSql('stat2', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(
+      function() { successCallback2 = arguments[2];
+          var params = arguments[1];
+          assertEquals('incorrect params to sql', 1, params[0]);
+      });
+  html5Tx.expects().executeSql('stat3', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(
+      function() { successCallback3 = arguments[2];
+          var params = arguments[1];
+          assertEquals('incorrect params to sql', 2, params[0]);
+          assertEquals('incorrect params to sql', 3, params[1]);
+     });
+  trans.executeAll([stat1, stat2, stat3]);
+  successCallback1(html5Tx, 'resultset1');
+  successCallback2(html5Tx, 'resultset2');
+  successCallback3(html5Tx, 'resultset3');
+  mockControl.verify();
+}
+function testTransactionExecuteAll_110() {
+  var stat1 = new google.wspl.Statement('stat1');
+  var stat2 = new google.wspl.Statement('stat2', [1]);
+  var stat3 = new google.wspl.Statement('stat3', [2,  3]);
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  var successCallback1 = null;
+  var successCallback2 = null;
+  var successCallback3 = null;
+  var failureCallback3 = null;
+  html5Tx.expects().executeSql('stat1', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback1 = arguments[2];
+      });
+  html5Tx.expects().executeSql('stat2', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback2 = arguments[2];
+        var params = arguments[1];
+        assertEquals('incorrect params to sql', 1, params[0]);
+      });
+  html5Tx.expects().executeSql('stat3', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback3 = arguments[2];
+        failureCallback3 = arguments[3];
+        var params = arguments[1];
+        assertEquals('incorrect params to sql', 2, params[0]);
+        assertEquals('incorrect params to sql', 3, params[1]);
+      });
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset1', arguments[1].result_)});
+  callbackMock.expects().onSuccess(trans,
+      TypeOf.isA(google.wspl.html5.ResultSet)).andStub(function() {
+    assertEquals('result not returned', 'resultset2', arguments[1].result_)});
+  callbackMock.expects().onFailure('error3');
+  trans.executeAll([stat1, stat2, stat3], callbackMock);
+  successCallback1(html5Tx, 'resultset1');
+  successCallback2(html5Tx, 'resultset2');
+  assertTrue('failure case callback not terminating transaction',
+      failureCallback3(html5Tx, 'error3'));
+  mockControl.verify();
+}
+function testTransactionExecute_nocallback() {
+  var stat1 = new google.wspl.Statement('stat1');
+  var trans = new google.wspl.html5.Transaction(html5Tx);
+  var successCallback = null;
+  var failureCallback = null;
+  html5Tx.expects().executeSql('stat1', TypeOf.isA(Array),
+      TypeOf.isA(Function), TypeOf.isA(Function)).andStub(function() {
+        successCallback = arguments[2];
+      });
+  trans.execute(stat1);
+  successCallback(html5Tx, 'resultset');
+  mockControl.verify();
+}
+function buildDatabase() {
+  html5Window.expects().openDatabase('name', '', 'name',
+      google.wspl.LARGEST_SUPPORTED_DATABASE).
+      andReturn(html5Db);
+  return new google.wspl.html5.Database('name', html5Window);
+}
+function testConstructDatabase() {
+  var db = buildDatabase();
+  mockControl.verify();
+  assertEquals('did not set db_ correctly', db.db_, html5Db);
+}
+function testConstructDatabase_null() {
+  html5Window.expects().openDatabase('name', '', 'name',
+      google.wspl.LARGEST_SUPPORTED_DATABASE).
+      andReturn(null);
+  try {
+    var db = google.wspl.html5.Database('name', html5Window);
+    fail('Should never get here');
+  } catch (e) {
+    if (e.isJsUnitException) {
+      throw e;
+    }
+  }
+  mockControl.verify();
+}
+function testConstructDatabase_undefined() {
+  html5Window.expects().openDatabase('name', '', 'name',
+      google.wspl.LARGEST_SUPPORTED_DATABASE).
+      andReturn(undefined);
+  try {
+    var db = google.wspl.html5.Database('name', html5Window);
+    fail('Should never get here');
+  } catch (e) {
+    if (e.isJsUnitException) {
+      throw e;
+    }
+  }
+  mockControl.verify();
+}
+function createTransactionCore() {
+  var db = buildDatabase();
+  var fun1 = null;
+  var failure = null;
+  var success = null;
+  html5Db.expects().transaction(TypeOf.isA(Function), TypeOf.isA(Function),
+      TypeOf.isA(Function)).andStub(function() {
+        fun1 = arguments[0];
+        failure = arguments[1];
+        success = arguments[2];
+      });
+  var tx = null;
+  var populateMock = function(txa) {
+    tx = txa;
+  };
+  db.createTransaction(populateMock, callbackMock);
+  fun1('transactionTest');
+  assertEquals('transaction not saved', 'transactionTest', tx.tx_);
+  assertEquals('did not set db_ correctly', db.db_, html5Db);
+  return {failure: failure, success: success};
+}
+function testCreateTransaction_success() {
+  cbs = createTransactionCore();
+  callbackMock.expects().onSuccess();
+  cbs.success('success');
+  mockControl.verify();
+}
+function testCreateTransaction_failure() {
+  cbs = createTransactionCore();
+  callbackMock.expects().onFailure('error');
+  cbs.failure('error');
+  mockControl.verify();
+}
+function testCreateTransaction_onlyPopulate() {
+  cbs = createTransactionCore();
+  mockControl.verify();
+}
+function testDatabaseExecute_nocallback() {
+  var db = buildDatabase();
+  dbTx.expects().execute('statementText', null);
+  db.execute('statementText');
+}
+function testDatabaseExecute_nocallback() {
+  var db = buildDatabase();
+  dbTx.expects().execute('statementText', null);
+  db.execute('statementText');
+}
+function testDatabaseExecuteAll() {
+  var db = buildDatabase();
+  dbTx.expects().executeAll(TypeOf.isA(Array));
+}
+function testResultSetNext() {
+  var res = {rows: {length: 4}};
+  var result = new google.wspl.html5.ResultSet(res);
+  for (var i = 0; i < 4; i++) {
+    assertTrue('expected valid row', result.isValidRow());
+    result.next();
+  }
+  assertFalse('expected invalid row', result.isValidRow());
+}
+function testResultSetIsValidRow() {
+  var res = {rows: {length: 0}};
+  var result = new google.wspl.html5.ResultSet(res);
+  assertFalse('expected invalid row', result.isValidRow());
+  res.rows.length = 1;
+  assertTrue('expected valid row', result.isValidRow());
+  result.next();
+  assertFalse('expected invalid row', result.isValidRow());
+}
+function testResultSetGetRow() {
+  var res = {rows: {
+    length: 3,
+    item: function(index) {
+      assertEquals('expected index of 1', 1, index);
+      return {h0: 'value0', h1: 'value1', h2: 'value2'};
+    }
+  }};
+  var result = new google.wspl.html5.ResultSet(res);
+  result.next();
+  var row = result.getRow();
+  assertEquals('first field is not valid', 'value0', row.h0);
+  assertEquals('first field is not valid', 'value1', row.h1);
+  assertEquals('first field is not valid', 'value2', row.h2);
+}
+function testHasInflightTransactions() {
+  var fakeTime = 1000;
+  var db = buildDatabase();
+  var dummyPopulate = function() {};
+  db.getCurrentTime = function() {return fakeTime;};
+  // Create a transaction, make sure it's kept track of.
+  var transId = db.sequenceNum_;
+  db.createTransaction(dummyPopulate);
+  assertEquals('There should be an inflight request.',
+      fakeTime, db.inflightTransactions_[transId]);
+  // Haven't advanced time, so hasInflightTransactions should return false.
+  assertFalse('Expected hasInflightTransactions=false.',
+      db.hasInflightTransactions(100));
+  // Advance time, now hasInflightTransactions should return true.
+  fakeTime += 10000;
+  var faqs = db.hasInflightTransactions(100);
+  assertTrue('Expected hasInflightTransactions=true.',
+      db.hasInflightTransactions(100));
+  // Now now have the transaction completed, hasInflightTransactions
+  // should return false.
+  delete db.inflightTransactions_[transId];
+  assertFalse('Expected hasInflightTransactions=false.',
+      db.hasInflightTransactions(100));
+};
+</script>
+</body>
+</html>

data/lib/middleman-core/templates/mobile/source/tools/wspl/dbwrapperapi.js ADDED Viewed

@@ -0,0 +1,202 @@
+/*
+  Copyright 2009 Google Inc.
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+/**
+ * @fileoverview Generic Database API.
+ *
+ * A small set of classes to define how we interact with databases that can
+ * easily be implemented on top of HTML5 and Gears.  The classes in this file
+ * should be extended to provide the missing method implementations and more
+ * sophisticated constructors where applicable.
+ *
+ */
+/**
+ * Constructs a Statement object.  A Statement is an SQL statement paired
+ * with the parameters needed to execute it.
+ *
+ * @constructor
+ * @param {!string} sql The SQL statement.
+ * @param {Array.<Object>?} opt_params The parameters for the SQL statement.
+ */
+google.wspl.Statement = function(sql, opt_params) {
+  /**
+   * The SQL statement with '?' in place of parameters.
+   * @type {string}
+   */
+  this.sql = sql;
+  /**
+   * The parameters to use with the SQL statement.
+   * @type {!Array}
+   */
+  this.params = opt_params || [];
+};
+/**
+ * Returns a new statement object from the given statement with the parameters
+ * set as specified.
+ * @param {Array.<Object>} params The array of values for ? placeholders.
+ * @return {!google.wspl.Statement} The created Statement.
+ */
+google.wspl.Statement.prototype.createStatement = function(params) {
+  return new google.wspl.Statement(this.sql, params);
+};
+/**
+ * Constructs a Transaction object.  Transaction objects
+ * group together a series of statements into a single atomic
+ * action on the database.
+ *
+ * @constructor
+ */
+google.wspl.Transaction = function() {
+};
+/**
+ * Takes a statement and an optional callback object and
+ * runs the statement on the database. The callback can be used to
+ * add more statements to the same transaction, or execute can be
+ * called repeatedly and the transactions will later execute in the
+ * order provided.
+ *
+ * @param {google.wspl.Statement} statement The statement to execute.
+ * @param {Object} opt_callback An object containing onSuccess and onFailure
+ *     handlers.
+ */
+google.wspl.Transaction.prototype.execute = function(statement,
+    opt_callback) {
+  this.executeAll([statement], opt_callback);
+};
+/**
+ * Runs an array of statements in a single database transaction.
+ * Invokes the onSuccess callback once for each successfully executed
+ * statement and once for the first failed statement. The callback can be
+ * used to add more statements to the same transaction, or executeAll can
+ * be called repeatedly and each block of statements given will execute
+ * in the same order as the sequence of calls to executeAll.
+ *
+ * @param {Array.<google.wspl.Statement>} statements The statements to
+ *     execute.
+ * @param {Object?} opt_callback An object containing onSuccess and onFailure
+ *     handlers.
+ */
+google.wspl.Transaction.prototype.executeAll = function(statements,
+    opt_callback) {
+  throw Error('executeAll not implemented');
+};
+/**
+ * Constructs a Database object. Database objects are handles that allow
+ * access to a database (and create the corresponding database if it doesn't
+ * already exist). To open the database, pass the name of the needed
+ * database to the constructor, and then execute transactions on it using
+ * the execute method.
+ *
+ * @constructor
+ */
+google.wspl.Database = function() {
+};
+/**
+ * Creates a transaction object that can execute a series of SQL statements
+ * atomically.
+ *
+ * @param {Function} populate A callback to run execute calls on the
+ *     transaction.
+ * @param {Object?} opt_callback An optional success/failure callback that is
+ *     called when the entire transaction is finished executing.
+ */
+google.wspl.Database.prototype.createTransaction = function(populate,
+    opt_callback) {
+  throw Error('createTransaction not implemented');
+};
+/**
+ * Executes an array of statements on the database, invoking the optional
+ * callback after statement execution and the optional transactionCallback upon
+ * completion of the transaction.
+ *
+ * @param {google.wspl.Statement} statement the statement to execute
+ * @param {Object?} opt_callback object that defines onSuccess and onFailure
+ * @param {Object?} opt_transactionCallback object that defines onSuccess and
+ *    onFailure
+ */
+google.wspl.Database.prototype.execute = function(statement,
+                                                  opt_callback,
+                                                  opt_transactionCallback) {
+  this.createTransaction(function(tx) {
+    tx.execute(statement, opt_callback);
+  }, opt_transactionCallback);
+};
+/**
+ * Executes an array of statements on the database, invoking the optional
+ * callback for each statement in the transaction.  In the case of a statement
+ * failure, only the first failed statement will be reported and the transaction
+ * will be rolled back.  This method invokes the optional transactionCallback
+ * upon completion of the transaction.
+ *
+ * @param {Array.<google.wspl.Statement>} statements the statements to execute
+ * @param {Object?} opt_callback object that defines onSuccess and onFailure
+ * @param {Object?} opt_transactionCallback object that defines onSuccess and
+ *     onFailure
+ */
+google.wspl.Database.prototype.executeAll = function(statements,
+                                                     opt_callback,
+                                                     opt_transactionCallback) {
+  this.createTransaction(function(tx) {
+    tx.executeAll(statements, opt_callback);
+  }, opt_transactionCallback);
+};
+/**
+ * An immutable set of results that is returned from a single successful query
+ * on the database.
+ *
+ * @constructor
+ */
+google.wspl.ResultSet = function() {
+};
+/**
+ * Returns true if next() will advance to a valid row in the result set.
+ *
+ * @return {boolean} if next() will advance to a valid row in the result set
+ */
+google.wspl.ResultSet.prototype.isValidRow = function() {
+  throw Error('isValidRow not implemented');
+};
+/**
+ * Advances to the next row in the results.
+ */
+google.wspl.ResultSet.prototype.next = function() {
+  throw Error('next not implemented');
+};
+/**
+ * Returns the current row as an object with a property for each field returned
+ * by the database.  The property will have the name of the column and the value
+ * of the cell.
+ *
+ * @return {Object} The current row
+ */
+google.wspl.ResultSet.prototype.getRow = function() {
+  throw Error('getRow not implemented');
+};