RubyGems - middleman - Versions diffs - 2.0.9.pre.2-x86-mingw32 → 2.0.9.pre.3-x86-mingw32 - Mend

middleman 2.0.9.pre.2-x86-mingw32 → 2.0.9.pre.3-x86-mingw32

Files changed (105) hide show

data/lib/middleman/templates/mobile/source/tools/wspl/dbwrapper_gears_test.html ADDED

@@ -0,0 +1,404 @@
+<!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>Gears 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="gearsutils.js"></script>
+<script type="text/javascript" src="dbwrapperapi.js"></script>
+<script type="text/javascript" src="gears_resultset.js"></script>
+<script type="text/javascript" src="gears_transaction.js"></script>
+<script type="text/javascript" src="dbworker.js"></script>
+<script type="text/javascript" src="dbwrapper_gears.js"></script>
+</head>
+<body>
+<script type='text/javascript'>
+var mockControl;
+var callbackMock;
+var dbMock;
+var wp;
+var workerId = 123;
+var transMock;
+function setUp() {
+  mockControl = new MockControl();
+  callbackMock = mockControl.createMock({
+    onSuccess: function(){},
+    onFailure: function(){}
+  });
+  transMock = mockControl.createMock({
+    success: function(){},
+    failure: function(){}
+  });
+  wp = mockControl.createMock({
+    allowCrossOrigin: function(){},
+    createWorkerFromUrl: function(){},
+    sendMessage: function(){}
+  });
+  dbMock = mockControl.createMock({
+    execute: function(){},
+    open: function(){},
+    close: function(){},
+    remove: function(){}
+  });
+  google.wspl.GearsUtils.resultSetToObjectArray = function(rs) {
+    return rs;
+  };
+}
+function buildSyncDatabase() {
+  var database = new google.wspl.gears.Database(true);
+  database.userId_ = 'userId';
+  database.name_ = 'name';
+  database.db_ = dbMock;
+  return database;
+}
+function buildDatabase() {
+  var database = buildSyncDatabase();
+  var type = google.wspl.gears.DbWorker.CommandTypes.OPEN;
+  wp.expects().createWorkerFromUrl('workerUrl').andReturn(workerId);
+  wp.expects().sendMessage(TypeOf.isA(Object), workerId).andStub(function() {
+    assertEquals('Wrong message type.', type, arguments[0].type);
+    assertEquals('Incorrect name.', 'name', arguments[0].name);
+    assertEquals('Incorrect user id.', 'userId', arguments[0].userId);
+  });
+  database.startWorker(wp, 'workerUrl', 0);
+  database.handleStarted_();
+  database.handleOpenSuccessful_();
+  database.useWorker_ = true;
+  return database;
+}
+function testConstructor() {
+  var db = buildSyncDatabase();
+  mockControl.verify();
+}
+function testStartWorker() {
+  var db = buildDatabase();
+  assertTrue('Expected worker to be ready.', db.workerReady_);
+  mockControl.verify();
+}
+function testCreateTransaction() {
+  var db = buildDatabase();
+  var tx;
+  var populateMock = function(txa) {
+    tx = txa;
+    var transactions = db.transactions_;
+    assertEquals('missing transaction', tx, transactions[tx.id_].transaction);
+    assertEquals('missing callback', callbackMock,
+        transactions[tx.id_].callback);
+    assertEquals('database not saved', db, tx.db_);
+    assertTrue('database should be locked', db.locked_);
+  };
+  callbackMock.expects().onSuccess();
+  var transactions = db.transactions_;
+  db.createTransaction(populateMock, callbackMock);
+  assertEquals('failed to clean up transaction', undefined,
+      transactions[tx.id_]);
+  assertFalse('database should not be locked', db.locked_);
+  mockControl.verify();
+}
+function testMultipleTransactions() {
+  var db = buildDatabase();
+  var handler = mockControl.createMock();
+  handler.addMockMethod('populate');
+  handler.addMockMethod('onSuccess');
+  handler.addMockMethod('onFailure');
+  var trans;
+  handler.expects().populate(TypeOf.isA(google.wspl.gears.Transaction)).andStub(
+      function(tx) {
+        trans = tx;
+        tx.numActiveExecutes_ = 1;
+      });
+  db.createTransaction(handler.populate, handler);
+  db.createTransaction(handler.populate, handler);
+  mockControl.verify();
+  handler.expects().onSuccess();
+  handler.expects().populate(TypeOf.isA(google.wspl.gears.Transaction)).andStub(
+      function(tx) {
+        trans = tx;
+        tx.numActiveExecutes_ = 1;
+      });
+  db.handleCommit_(trans.id_);
+  mockControl.verify();
+  handler.expects().onFailure(undefined).andStub(function() {
+    db.createTransaction(handler.populate, handler);
+  });
+  handler.expects().populate(TypeOf.isA(google.wspl.gears.Transaction)).andStub(
+      function(tx) {
+        trans = tx;
+        tx.numActiveExecutes_ = 1;
+      });
+  db.handleRollback_(trans.id_);
+  mockControl.verify();
+  handler.expects().onSuccess();
+  db.handleCommit_(trans.id_);
+  mockControl.verify();
+}
+function testDoBegin() {
+  var db = buildDatabase();
+  var transactionId = 10;
+  var type = google.wspl.gears.DbWorker.CommandTypes.BEGIN;
+  wp.expects().sendMessage(TypeOf.isA(Object), workerId).andStub(function() {
+    assertEquals('wrong message type', type, arguments[0].type);
+    assertNotUndefined('Missing transaction id.', arguments[0].transactionId);
+  });
+  db.doBegin(transactionId);
+  mockControl.verify();
+}
+function testSynchronousBegin() {
+  var db = buildSyncDatabase();
+  dbMock.expects().execute('BEGIN IMMEDIATE');
+  db.doBegin(1);
+  mockControl.verify();
+}
+function testDoExecute() {
+  var statements = [{sql: 's1', params: 'p1'},
+                    {sql: 's2', params: 'p2'},
+                    {sql: 's3', params: 'p3'}];
+  var callbackId = 5;
+  var transactionId = 10;
+  var db = buildDatabase();
+  var type = google.wspl.gears.DbWorker.CommandTypes.EXECUTE;
+  wp.expects().sendMessage(TypeOf.isA(Object), workerId).andStub(function() {
+    assertEquals('wrong message type', type, arguments[0].type);
+    assertEquals('statements do not match', statements.length,
+        arguments[0].statements.length);
+    for (var i = 0; i < statements.length; i++) {
+      assertEquals('a statement sql does not match', statements[i].sql,
+          arguments[0].statements[i].sql);
+      assertEquals('a statement params does not match', statements[i].params,
+          arguments[0].statements[i].params);
+    }
+    assertEquals('missing callback id', callbackId, arguments[0].callbackId);
+    assertEquals('missing trans id', transactionId, arguments[0].transactionId);
+  });
+  db.doExecute(statements, callbackId, transactionId);
+  mockControl.verify();
+}
+function testSynchronousExecute() {
+  var statements = [{sql: 's1', params: 'p1'},
+                    {sql: 's2', params: 'p2'},
+                    {sql: 's3', params: 'p3'}];
+  var callbackId = 5;
+  var transactionId = 10;
+  var db = buildSyncDatabase();
+  for (var i = 0; i < 3; i++) {
+    var stat = statements[i];
+    dbMock.expects().execute(stat.sql, stat.params).andReturn('result' + i);
+  }
+  var handler = mockControl.createMock();
+  handler.addMockMethod('handleResult_');
+  db.handleResult_ = handler.handleResult_;
+  handler.expects().handleResult_(
+      TypeOf.isA(Array), callbackId, transactionId).andStub(function(results) {
+        var expected = ['result0', 'result1', 'result2'];
+        assertArrayEquals('Wrong results.', expected, results);
+      });
+  db.doExecute(statements, callbackId, transactionId);
+  mockControl.verify();
+}
+function testSynchronousExecute_failure() {
+  var statements = [{sql: 's1', params: 'p1'},
+                    {sql: 's2', params: 'p2'},
+                    {sql: 's3', params: 'p3'}];
+  var callbackId = 5;
+  var transactionId = 10;
+  var db = buildSyncDatabase();
+  dbMock.expects().execute('s1', 'p1').andReturn('result0');
+  dbMock.expects().execute('s2', 'p2').andThrow(Error('db error'));
+  var handler = mockControl.createMock();
+  handler.addMockMethod('handleFailure_');
+  db.handleFailure_ = handler.handleFailure_;
+  handler.expects().handleFailure_(
+      TypeOf.isA(Error), callbackId, transactionId);
+  db.doExecute(statements, callbackId, transactionId);
+  mockControl.verify();
+}
+function testDoCommit() {
+  var transactionId = 10;
+  var db = buildDatabase();
+  var type = google.wspl.gears.DbWorker.CommandTypes.COMMIT;
+  wp.expects().sendMessage(TypeOf.isA(Object), workerId).andStub(function() {
+    assertEquals('wrong message type', type, arguments[0].type);
+    assertEquals('missing trans id', transactionId, arguments[0].transactionId);
+  });
+  db.doCommit(transactionId);
+  mockControl.verify();
+}
+function testSynchronousCommit() {
+  var db = buildSyncDatabase();
+  dbMock.expects().execute('COMMIT');
+  db.doCommit(1);
+  mockControl.verify();
+}
+function testDoRollback() {
+  var transactionId = 10;
+  var db = buildDatabase();
+  var type = google.wspl.gears.DbWorker.CommandTypes.ROLLBACK;
+  wp.expects().sendMessage(TypeOf.isA(Object), workerId).andStub(function() {
+    assertEquals('wrong message type', type, arguments[0].type);
+    assertEquals('missing trans id', transactionId, arguments[0].transactionId);
+  });
+  db.doRollback(transactionId);
+  mockControl.verify();
+}
+function testSynchronousRollback() {
+  var db = buildSyncDatabase();
+  dbMock.expects().execute('ROLLBACK');
+  db.doRollback(1);
+  mockControl.verify();
+}
+function testHandleCommit() {
+  var db = buildDatabase();
+  db.transactions_[5] = {transaction: 'tx', callback: callbackMock};
+  callbackMock.expects().onSuccess();
+  db.handleCommit_(5);
+  assertUndefined('failed to remove transaction', db.transactions_[5]);
+  mockControl.verify();
+}
+function testHandleRollback() {
+  var db = buildDatabase();
+  db.transactions_[5] = {
+    transaction: 'tx',
+    callback: callbackMock,
+    error: Error('error')
+  };
+  callbackMock.expects().onFailure(TypeOf.isA(Error)).andStub(function() {
+    assertEquals('did not pass error', 'error', arguments[0].message);
+  });
+  db.handleRollback_(5);
+  assertUndefined('failed to remove transaction', db.transactions_[5]);
+  mockControl.verify();
+}
+function testHandleResult() {
+  var db = buildDatabase();
+  transMock.expects().success(TypeOf.isA(google.wspl.gears.ResultSet),
+      22).andStub(function() {
+        assertEquals('result not set', 'result1', arguments[0].resultArray_);
+      });
+  transMock.expects().success(TypeOf.isA(google.wspl.gears.ResultSet),
+      22).andStub(function() {
+        assertEquals('result not set', 'result2', arguments[0].resultArray_);
+      });
+  db.transactions_[5] = {transaction: transMock, callback: 'cb'};
+  db.handleResult_(['result1', 'result2'], 22, 5);
+  mockControl.verify();
+}
+function testHandleFailure() {
+  var db = buildDatabase();
+  transMock.expects().failure(TypeOf.isA(Error), 22).andStub(function() {
+      assertEquals('error not set', 'error', arguments[0].message);
+  });
+  db.transactions_[5] = {transaction: transMock, callback: 'cb'};
+  db.handleFailure_(Error('error'), 22, 5);
+  assertEquals('failed to save error', 'error',
+      db.transactions_[5].error.message);
+  mockControl.verify();
+}
+function testHandleStarted() {
+  var db = buildDatabase();
+  var type = google.wspl.gears.DbWorker.CommandTypes.OPEN;
+  wp.expects().sendMessage(TypeOf.isA(Object), workerId).andStub(function() {
+    assertEquals('wrong message type', type, arguments[0].type);
+    assertEquals('wrong db userId', 'userId', arguments[0].userId);
+    assertEquals('wrong db name', 'name', arguments[0].name);
+  });
+  db.handleStarted_();
+  mockControl.verify();
+}
+function testHandleStarted_afterTimeout() {
+  var db = buildDatabase();
+  db.handleTimeout_();
+  // This should do nothing.
+  db.handleStarted_();
+  mockControl.verify();
+}
+function testHandleTimeout() {
+  var db = buildDatabase();
+  db.handleTimeout_();
+  mockControl.verify();
+}
+function testHandleOpenSuccessful() {
+  var db = buildDatabase();
+  db.handleOpenSuccessful_();
+  assertTrue('Worker should be ready.', db.workerReady_);
+  mockControl.verify();
+}
+function testHandleOpenFailed() {
+  var db = buildDatabase();
+  db.handleOpenFailed_('error');
+  mockControl.verify();
+}
+</script>
+</body>
+</html>

data/lib/middleman/templates/mobile/source/tools/wspl/dbwrapper_html5.js ADDED

@@ -0,0 +1,203 @@
+/*
+  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.
+ */
+google.wspl.html5 = google.wspl.html5 || {};
+/**
+ * Specification's default largest database size in HTML5 databases.
+ * @type{number}
+ */
+google.wspl.LARGEST_SUPPORTED_DATABASE = 1024 * 1024 * 4;
+/**
+ * Creates an HTML5 Transaction object.
+ * @see google.wspl.Transaction#Transaction
+ *
+ * @constructor
+ * @extends google.wspl.Transaction
+ *
+ * @param {SQLTransaction} html5tx The HTML5 implementation of transactions.
+ */
+google.wspl.html5.Transaction = function(html5tx) {
+  this.tx_ = html5tx;
+};
+google.inherits(google.wspl.html5.Transaction, google.wspl.Transaction);
+/**
+ * Runs an array of statements in a single database transaction.
+ * Invokes the onSuccess callback once for each succeesfully executed
+ *     statement and
+ * once for the first failed statement.
+ *
+ * @param {Array.<google.wspl.Statement>} statements The statements to
+ *     execute.
+ * @param {Object?} opt_callback An object containing onSuccess and onFailure
+ *     handlers.
+ */
+google.wspl.html5.Transaction.prototype.executeAll = function(statements,
+    opt_callback) {
+  if (statements.length == 0) {
+    throw Error('Possibly silly attempt to execute empty statement list.');
+  }
+  var self = this;
+  for (var i = 0; i < statements.length; ++i) {
+    var statement = statements[i];
+    google.logger('SQL: ' + statement.sql + ' PARAMS: ' + statement.params);
+    this.tx_.executeSql(statement.sql, statement.params,
+        function(tx, result) {
+          if (opt_callback && opt_callback.onSuccess) {
+            var resultSet = new google.wspl.html5.ResultSet(result);
+            opt_callback.onSuccess(self, resultSet);
+          }
+        },
+        function(tx, error) {
+          if (opt_callback && opt_callback.onFailure) {
+            opt_callback.onFailure(error);
+          }
+          // fail the whole transaction if any step fails
+          return true;
+        });
+  }
+};
+/**
+ * @see google.wspl.Database#Database
+ * @param {string} name The name for this database.
+ * @param {window} opt_window A window object for dependency injection.
+ * @constructor
+ * @extends google.wspl.Database
+ */
+google.wspl.html5.Database = function(name, opt_window) {
+  /**
+   * Sequence number for transactions.
+   * @type {number}
+   * @private
+   */
+  this.sequenceNum_ = 1;
+  /**
+   * Map of transactionIds -> transaction start time in millis.
+   * @type {Object}
+   * @private
+   */
+  this.inflightTransactions_ = {};
+  var win = opt_window || window;
+  this.db_ = win.openDatabase(name, '',
+      name, google.wspl.LARGEST_SUPPORTED_DATABASE);
+  if (this.db_ == null) {
+    throw Error('The returned database was null.');
+  }
+};
+google.inherits(google.wspl.html5.Database, google.wspl.Database);
+/**
+ * @see google.wspl.Database#createTransaction
+ */
+google.wspl.html5.Database.prototype.createTransaction = function(populate,
+    opt_callback) {
+  var transactionCallback = opt_callback || {
+    onSuccess: function() {},
+    onFailure: function() {}
+  };
+  var transactionId = this.sequenceNum_++;
+  var inflightTransactions = this.inflightTransactions_;
+  inflightTransactions[transactionId] = this.getCurrentTime();
+  this.db_.transaction(
+      function(tx) {
+        // Delete the transaction before the executing it because our
+        // definition of an 'in-flight' transaction is the time between
+        // when the request was made and when the database starts to
+        // execute the transaction.
+        delete inflightTransactions[transactionId];
+        populate(new google.wspl.html5.Transaction(tx));
+      },
+      function(error) {transactionCallback.onFailure(error);},
+      function() {transactionCallback.onSuccess();});
+};
+/**
+ * Determine if there is an in-flight database transaction that's older than
+ * the given time period.
+ * @param {number} olderThanMillis The time period.
+ * @return {boolean} True if the database has an in-flight transaction older
+ *     than the given time period, false otherwise.
+ */
+google.wspl.html5.Database.prototype.hasInflightTransactions =
+    function(olderThanMillis) {
+  for (var transactionId in this.inflightTransactions_) {
+    var startTime = this.inflightTransactions_[transactionId];
+    if (this.getCurrentTime() - startTime > olderThanMillis) {
+      return true;
+    }
+  }
+  return false;
+};
+/**
+ * Returns the current time.
+ * @return {number} The current time in millis.
+ */
+google.wspl.html5.Database.prototype.getCurrentTime = function() {
+  // The iPhone does not support Date.now()
+  var d = new Date();
+  return d.getTime();
+};
+/**
+ * Creates an HTML5 ResultSet object.
+ * @see google.wspl.ResultSet#ResultSet
+ *
+ * @constructor
+ * @extends google.wspl.ResultSet
+ *
+ * @param {Object} html5_result The HTML5 implementation of result set.
+ */
+google.wspl.html5.ResultSet = function(html5_result) {
+  this.result_ = html5_result;
+  this.index_ = 0;
+};
+google.inherits(google.wspl.html5.ResultSet, google.wspl.ResultSet);
+/**
+ * @see google.wspl.ResultSet#isValidRow
+ */
+google.wspl.html5.ResultSet.prototype.isValidRow = function() {
+  return this.index_ >= 0 && this.index_ < this.result_.rows.length;
+};
+/**
+ * @see google.wspl.ResultSet#next
+ */
+google.wspl.html5.ResultSet.prototype.next = function() {
+  this.index_ ++;
+};
+/**
+ * @see google.wspl.ResultSet#getRow
+ */
+google.wspl.html5.ResultSet.prototype.getRow = function() {
+  return this.result_.rows.item(this.index_);
+};