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/simplenotes/index.html ADDED

@@ -0,0 +1,347 @@
+<!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.
+-->
+<!--
+  A simple application showing the use of the web storage portability layer
+  code and cache pattern for offline web application.
+-->
+<html>
+<head>
+  <title>SimpleNotes Demo</title>
+  <link href="styles.css" rel="stylesheet" type="text/css" />
+  <script src="../global_functions.js" language="javascript"
+      type="text/javascript"></script>
+  <script src="../dbwrapperapi.js" language="javascript"
+      type="text/javascript"></script>
+  <script src="../dbwrapper_html5.js" language="javascript"
+      type="text/javascript"></script>
+  <script src="../databasefactory.js" language="javascript"
+      type="text/javascript"></script>
+  <script src="template.js" language="javascript"
+      type="text/javascript"></script>
+  <script src="simplenotes.js" language="javascript"
+      type="text/javascript"></script>
+</head>
+<body>
+<div id="list-note" class="screen list-note-screen" >
+  <div class="title-bar">Note List</div>
+  <div class="top command-bar">
+    <button id="view-note-new">New</button>
+  </div>
+  <div class="status-bar">status bar</div>
+  <div class="list-note-container-empty" style="display:none;"></div>
+  <div class="list-note-container" style="display:none;">
+    <div class="list-note-item">
+      <a href="javascript:showNote(%noteKey%);">%subject%</a>
+    </div>
+  </div>
+  <div class="top command-bar">
+    <button id="view-note-new">New</button>
+  </div>
+</div>
+<div id="view-note" class="screen view-note-screen" style="display:none;">
+  <div class="title-bar">View Note</div>
+  <div class="top command-bar">
+    <button id="view-note-back">Back</button>
+    <button id="view-note-edit">Edit Note</button>
+  </div>
+  <div class="status-bar">status bar</div>
+  <div class="view-note-container" style="display:none;">
+    <div class="subject">%subject%</div>
+    <div class="body">%body%</div>
+  </div>
+  <div class="bottom command-bar">
+    <button id="view-note-back">Back</button>
+    <button id="view-note-edit">Edit Note</button>
+  </div>
+</div>
+<div id="edit-note" class="screen edit-note-screen" style="display:none;">
+  <div class="title-bar">Edit Note</div>
+  <div class="top command-bar">
+    <button id="edit-back-save">Save Note</button>
+    <button id="edit-back-revert">Revert Note</button>
+  </div>
+  <div class="status-bar">status bar</div>
+  <div>Subject:</div>
+  <textarea rows="1" style="width:100%;" id="edit-note-subject"></textarea>
+  <br>
+  <div>Note:</div>
+  <textarea rows="20"  style="width:100%;" id="edit-note-body"></textarea>
+  <div class="bottom command-bar">
+    <button id="edit-back-save">Save Note</button>
+    <button id="edit-back-revert">Revert Note</button>
+  </div>
+</div>
+</body>
+<script>
+/**
+ * Tests the given DOM element for a specific CSS class.
+ * @param {Object} e A DOM element.
+ * @param {string} css A CSS class identifier to match.
+ * @return {boolean} true if the element has the CSS class.
+ */
+function hasCssClass(e, css) {
+  return e && e.className && e.className.search(css + '( |$)') > -1;
+};
+/**
+ * Finds the parent element of a given element that has
+ * the specified CSS class.
+ * @param {Object} e A DOM element.
+ * @param {string} css A CSS class identifier to match.
+ * @param {Object} opt_stop A parent DOM element to stop at.
+ * @return {Object} A DOM element parent of e or null.
+ */
+function findParentOfClass(e, css, opt_stop) {
+  var stop = opt_stop || document;
+  while (e && e != stop && !hasCssClass(e, css)) {
+    e = e.parentElement;
+  }
+  return hasCssClass(e, css) ? e : null;
+};
+/**
+ * Navigates to the note creation screen.
+ */
+function editNote(event) {
+  google.logger('editNote: <' + currentNote.subject + '>');
+  hideBlock('#edit-note .status-bar');
+  var subject = document.getElementById('edit-note-subject');
+  var body = document.getElementById('edit-note-body');
+  subject.value = currentNote.subject;
+  body.value = currentNote.body;
+  google.logger('end of editNote');
+}
+/**
+ * Saves a note.
+ */
+function saveNote(event) {
+  google.logger('saveNote: do database or other activity here');
+  // Copy contents from fields and save.
+  var subject = document.getElementById('edit-note-subject');
+  var body = document.getElementById('edit-note-body');
+  cache.applyUiChange(currentNote.noteKey, subject.value,
+      body.value, showNote);
+  google.logger('saveNote');
+}
+/**
+ * Abandons the note.
+ */
+function abandonNote(event) {
+  google.logger('abandonNote: do database or other activity here');
+  showNote(currentNote.noteKey);
+  google.logger('abandonNote');
+}
+/**
+ * Prepares to edit a new note.
+ */
+function newNote(event) {
+  google.logger('newNote: do database or other activity here');
+  alert('not implemented');
+  // grab the contents and inject into the database.
+  var subject = document.getElementById('edit-note-subject');
+  var body = document.getElementById('edit-note-body');
+  subject.value = '';
+  body.value = '';
+  google.logger('newNote');
+}
+/**
+ * Maps button names to customizer functions.
+ */
+var buttonHandlerSpecification = {
+  'view-note-new': ['edit-note', newNote],
+  'view-note-back': ['list-note', showNoteList],
+  'view-note-edit': ['edit-note', editNote],
+  'edit-back-save': ['view-note', saveNote],
+  'edit-back-revert': ['view-note', abandonNote]
+};
+/**
+ * Hides a block specified by a CSS selector and parent node.
+ * @param {string} selector A CSS selector string.
+ * @param {Object} opt_el A DOM element.
+ */
+function hideBlock(selector, opt_el) {
+  var el = opt_el || document;
+  var targetEl = el.querySelector(selector);
+  targetEl.style.display = 'none';
+}
+/**
+ * Shows a block specified by a CSS selector and parent node, inserting
+ * the specified string as the innerHTML property of the selected block.
+ * @param {string} selector A CSS selector
+ * @param {string} html String to assign to the innerHTML property.
+ * @param {Object} opt_el A DOM element.
+ */
+function showBlock(selector, html, opt_el) {
+  var el = opt_el || document;
+  var targetEl = el.querySelector(selector);
+  if (html) targetEl.innerHTML = html;
+  targetEl.style.display = 'block';
+}
+/**
+ * Handles all button events.
+ */
+function buttonHandler(event) {
+  google.logger('clicked on: ' + event.target.id);
+  var currentScreen = findParentOfClass(event.target, 'screen');
+  var nextScreen = document.getElementById(
+      buttonHandlerSpecification[event.target.id][0]);
+  var helperFunction = buttonHandlerSpecification[event.target.id][1];
+  // All button handlers have a common implementation.
+  // 1. hide current screen
+  currentScreen.style.display = 'none';
+  // 2. show new screen
+  nextScreen.style.display = 'block';
+  // 3. Activate status
+  showBlock('.status-bar', 'Working...', nextScreen);
+  // 4. Call customizer function (which will probably query the model
+  // stored in the cache.
+  helperFunction(event);
+  // 5. A (possibly asynchronous) callback from the customizer will
+  // finish the action by running the appropriate view function.
+  google.logger('end of button Handler');
+}
+/**
+ * Call back from a specific JavaScript url to show a specific
+ * note.
+ * @param {number} noteKey
+ * @return {boolean}
+ */
+function showNote(noteKey) {
+  hideBlock('#list-note');
+  showBlock('#view-note .status-bar', 'Working...');
+  showBlock('#view-note');
+  cache.getValues('fullnote', [noteKey], renderFullNote);
+  return false;
+}
+/**
+ * Generates HTML for a note and display it.
+ * @param {Object} oneNote
+ * @param {boolean} complete True if the note has been provided or
+ *     if an updated note is arriving. (Necessary for future support for
+ *     sub-note updates.)
+ */
+function renderFullNote(oneNote, complete) {
+  google.logger('renderFullNote');
+  showBlock('.view-note-container', noteViewTemplate.process(oneNote));
+  if (complete) {
+    hideBlock('#view-note .status-bar');
+  }
+  currentNote = oneNote;
+  google.logger('done renderFullNote');
+}
+/**
+ * Generates HTML for a note list and display it.
+ * @param {Array.<Object>} noteHeaders
+ * @param {boolean} complete True if all in-existence notes that lie
+ *     in the query range have been provided even if less than what was
+ *     requested.
+ */
+function renderNoteList(noteHeaders, complete) {
+  google.logger('renderNoteList: ' + noteHeaders.length);
+  if (noteHeaders.length == 0) {
+    showBlock('.list-note-container-empty', 'No notes');
+  } else {
+    var notes = noteHeaders.map(function(n) {
+      return noteListTemplate.process(n);
+    });
+    showBlock('.list-note-container', notes.join());
+  }
+  if (complete) {
+    hideBlock('#list-note .status-bar');
+  }
+  google.logger('done renderNoteList');
+}
+/**
+ * Query for an updated note list.
+ */
+function showNoteList() {
+  google.logger('showNoteList');
+  cache.getValues('list', [0,20], renderNoteList);
+  currentNote = undefined;
+  google.logger('end of showNoteList');
+}
+/**
+ * A constructor for the controller. Sets up the UI and
+ * queries the cache for initial notelist contents.
+ */
+function createController() {
+  google.logger('createController:');
+  var buttons = document.querySelectorAll('.command-bar button');
+  Array.prototype.forEach.call(buttons, function(b) {
+    b.addEventListener('click', buttonHandler);
+  });
+  google.logger('controller is live');
+  showNoteList();
+}
+google.logger('about to fetch the template');
+var currentNote = undefined;
+var noteListTemplate = new google.wspl.simplenotes.Template(
+    document.querySelector('.list-note-container').innerHTML);
+var noteViewTemplate = new google.wspl.simplenotes.Template(
+    document.querySelector('.view-note-container').innerHTML);
+// var noteEditTemplate = new google.wspl.simplenotes.Template();
+google.logger('created the template');
+// debugging code... tear out...
+// test the template construction...
+// showBlock('.list-note-container', noteListTemplate.process(
+//    {noteKey: 123, subject: 'hi rob'}));
+google.logger('loaded database');
+var cache = new google.wspl.simplenotes.Cache();
+cache.startCache(createController);
+google.logger('finished loading page');
+</script>
+</html>

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

@@ -0,0 +1,503 @@
+/*
+  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 A concrete example of the cache pattern for building an offline
+ * webapplication: a cache for SimpleNotes.
+ */
+google.wspl.simplenotes = google.wspl.simplenotes || {};
+google.logger('start simplenotes.js');
+/**
+ * Status keys for the write buffer.
+ * @enum {number}
+ */
+google.wspl.simplenotes.WriteBufferStates = {
+  /**
+   * The update is in flight to the server.
+   */
+  INFLIGHT: 1,
+  /**
+   * The update needs to be (re)sent to the server but is not in flight.
+   */
+  SEND: 2,
+  /**
+   * The update needs to be applied to the cached notes.
+   */
+  REAPPLY: 8
+};
+/**
+ * Creates a SimpleNotes cache wrapping a backing database.
+ * @constructor
+ */
+google.wspl.simplenotes.Cache = function() {
+  this.dbms_ = google.wspl.DatabaseFactory.createDatabase(
+      'simple-notes', 'http://yourdomain/dbworker.js');
+  /**
+   * Cache directory is a two-tuple over a range. (Holes
+   * must be allowed to support delection.)
+   * This is the lower (inclusive) bound of the cached range.
+   * @type {number}
+   * @private
+  */
+  this.start_ = -1;
+  /**
+   *
+   * This is the upper (inclusive) bound of the cached range.
+   * @type {number}
+   * @private
+   */
+  this.end_ = -1;
+  /**
+   * Start of range of notes known to exist on server at time of last
+   * response.
+   * @param {number}
+   */
+   this.serverStart_ = -1;
+  /**
+   * End of range of notes known to exist on server at time of last
+   * response.
+   * @param {number}
+   */
+   this.serverEnd_ = -1;
+  /**
+   * Time of last refresh.
+   * @type {number}
+   * @private
+   */
+  this.lastRefresh_ = -1;
+  /**
+   * Last missing query.
+   * @type {Object}
+   * @private
+   */
+  this.lastMiss_ = undefined;
+};
+/**
+ * Interval between refreshes in milliseconds.
+ * @type {number}
+ * @private
+ */
+google.wspl.simplenotes.Cache.TIME_BETWEEN_REFRESH_ = 2000;
+google.wspl.simplenotes.Cache.CREATE_CACHED_NOTES_ =
+      new google.wspl.Statement(
+    'CREATE TABLE IF NOT EXISTS cached_notes (' +
+        'noteKey INTEGER UNIQUE PRIMARY KEY,' +
+        'subject TEXT,' +
+        'body TEXT' +
+    ');'
+);
+google.wspl.simplenotes.Cache.CREATE_WRITE_BUFFER_ =
+      new google.wspl.Statement(
+    'CREATE TABLE IF NOT EXISTS write_buffer (' +
+        'sequence INTEGER UNIQUE PRIMARY KEY AUTOINCREMENT,' +
+        'noteKey INTEGER,' +
+        'status INTEGER,' +
+        'subject TEXT,' +
+        'body TEXT' +
+    ');'
+);
+google.wspl.simplenotes.Cache.DETERMINE_MIN_KEY_ =
+  new google.wspl.Statement(
+  'SELECT MIN(noteKey) as minNoteKey FROM cached_notes;');
+google.wspl.simplenotes.Cache.DETERMINE_MAX_KEY_ =
+  new google.wspl.Statement(
+  'SELECT MAX(noteKey) as maxNoteKey FROM cached_notes;');
+/**
+ * Builds a cache and writebuffer combination for notes and then
+ * invokes the given callback.
+ * @param {function) callback.
+ */
+google.wspl.simplenotes.Cache.prototype.startCache = function(callback) {
+  google.logger('startCache');
+  var statc  = 0;
+  var self = this;
+  var perStatCallback = function(tx, result) {
+    google.logger('perStatCallback');
+    if (statc == 4) {
+      self.start_ = (result.isValidRow()) ? result.getRow().minNoteKey : -1;
+      self.serverStart_ = self.start_; // Temporary. Remove when server exists.
+    } else if (statc == 5) {
+      self.end_ = (result.isValidRow()) ? result.getRow().maxNoteKey : -1;
+      self.serverEnd_ = self.end_; // Temporary. Remove when server exists.
+    }
+    statc++;
+  };
+  this.dbms_.executeAll([
+      google.wspl.simplenotes.Cache.CREATE_CACHED_NOTES_,
+      google.wspl.simplenotes.Cache.CREATE_WRITE_BUFFER_,
+      google.wspl.simplenotes.Cache.CREATE_UPDATE_TRIGGER_,
+      google.wspl.simplenotes.Cache.CREATE_REPLAY_TRIGGER_,
+      google.wspl.simplenotes.Cache.DETERMINE_MIN_KEY_,
+      google.wspl.simplenotes.Cache.DETERMINE_MAX_KEY_],
+      {onSuccess: perStatCallback, onFailure: this.logError_},
+      {onSuccess: callback, onFailure: this.logError_});
+  google.logger('finished startCache');
+};
+/**
+ * Stub function to be replaced with a server communication.
+ * @param {Array.<Object>} updates Payload to send to server.
+ */
+google.wspl.simplenotes.Cache.prototype.sendXhrPost = function(updates) {
+  google.logger('Should dispatch XHR to server now.');
+};
+/**
+ * @type {google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.LIST_CACHED_NOTES_ =
+      new google.wspl.Statement(
+    'SELECT noteKey, subject from cached_notes WHERE ' +
+        'noteKey >= ? AND ' +
+        'noteKey <= ? ' +
+    ';'
+);
+/**
+ * Tests if the given range is stored in the cache.
+ * Note that this mechanism requires extension to handle the
+ * creation of new notes.
+ * @param {number} start Lower bound (inclusive) on range.
+ * @param {number} end Uppder bound (inclusive) on range.
+ * @private
+ */
+google.wspl.simplenotes.Cache.prototype.isCacheHit_ = function(start, end) {
+  return start >= this.start_ && end <= this.end_
+};
+/**
+ * Logs a possibly useful error message.
+ * @param {Object} error An error descriptor.
+ * @private
+ */
+google.wspl.simplenotes.Cache.prototype.logError_ = function(error) {
+  google.logger('Simple Notes Cache is sad: ' + error);
+};
+/**
+ * Queries the cache for a list of note headers.
+ * @param {number} start The lower id in a range of notes.
+ * @param {number} end The higher id in a range of notes.
+ * @param {function(Array.<Object>)} valuesCallback A function to call
+ *     with the result set after the transaction has completed.
+ * @private
+ */
+google.wspl.simplenotes.Cache.prototype.getNoteList_ = function(start, end,
+    valuesCallback) {
+  var notes = [];
+  var accumulateResults = function(tx, result) {
+    for(; result.isValidRow(); result.next()) {
+      notes.push(result.getRow());
+      google.logger('pushed...');
+    }
+  };
+  var inTransactionGetNotes = function(tx) {
+    tx.execute(google.wspl.simplenotes.Cache.LIST_CACHED_NOTES_.
+        createStatement([start, end]), {
+        onSuccess: accumulateResults,
+        onFailure: this.logError_});
+  };
+  var hit = this.isCacheHit_(start, end);
+  this.dbms_.createTransaction(inTransactionGetNotes, {onSuccess: function() {
+    valuesCallback(notes, hit);
+  }, onFailure: this.logError_});
+  if (hit) {
+    this.fetchFromServer(this.start_, this.end_); // Refresh
+  } else {
+    this.fetchFromServer(Math.min(this.start_, start), Math.max(this.end_, end));
+    this.lastMiss_ = {callback: valuesCallback, start: start, end: end};
+  }
+};
+/**
+ * @type {google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.GET_ONE_NOTE_ =
+      new google.wspl.Statement(
+    'SELECT noteKey, subject, body from cached_notes WHERE ' +
+        'noteKey = ? ' +
+    ';'
+);
+/**
+ * Queries the cache for a list of note headers.
+ * @param {number} noteId The note to get from the cache.
+ * @param {function(Array.<Object>)} valuesCallback A function to call
+ *     with the result set after the transaction has completed.
+ * @private
+ */
+google.wspl.simplenotes.Cache.prototype.getOneNote_ = function(noteId,
+    callback) {
+  var note;
+  this.dbms_.execute(google.wspl.simplenotes.Cache.GET_ONE_NOTE_.
+      createStatement([noteId]),
+      {onSuccess: function(tx, result) { note = result.getRow(); },
+      onFailure: this.logError_},
+      {onSuccess: function() { callback(note, true); },
+      onFailure: this.logError_});
+};
+/**
+ * Queries the cache for either a list of notes or a single note including
+ * its body.
+ * @param {string} type The kind of values desired: 'list' or 'fullnote'.
+ * @param {Array.<number>} query The query for the values.
+ * @param {function(Array.<Object>)} valuesCallback A function to call
+ *     with the result set after the transaction has completed.
+ */
+google.wspl.simplenotes.Cache.prototype.getValues = function(type,
+    query, valuesCallback) {
+  // Reduce any query to what would be available from the server
+  query[0] = Math.max(this.serverStart_, query[0]);
+  query[1] = Math.min(this.serverEnd_, query[1]);
+  if (type == 'list') {
+    this.getNoteList_(query[0], query[1], valuesCallback);
+  } else if (type == 'fullnote') {
+    this.getOneNote_(query[0], valuesCallback);
+  }
+};
+/**
+ * SQL trigger to insert a new change from write buffer to
+ * cache.
+ * @private
+ */
+google.wspl.simplenotes.Cache.CREATE_UPDATE_TRIGGER_ =
+    new google.wspl.Statement(
+        'CREATE TRIGGER IF NOT EXISTS updateTrigger ' +
+        'AFTER INSERT ON write_buffer ' +
+        'BEGIN ' +
+        '  REPLACE INTO cached_notes ' +
+        '    SELECT noteKey, subject, body ' +
+        '      FROM write_buffer WHERE status & 8 = 8; ' +
+        '  UPDATE write_buffer SET status = status & ~ 8; ' +
+        'END;'
+    );
+/**
+ * SQL trigger to replay changes from the write buffer to
+ * the cache.
+ * @private
+ */
+google.wspl.simplenotes.Cache.CREATE_REPLAY_TRIGGER_ =
+    new google.wspl.Statement(
+        'CREATE TRIGGER IF NOT EXISTS replayTrigger ' +
+        'AFTER UPDATE ON write_buffer WHEN NEW.status & 8 = 8 ' +
+        'BEGIN ' +
+        '  REPLACE INTO cached_notes ' +
+        '    SELECT noteKey, subject, body ' +
+        '      FROM write_buffer ' +
+        '      WHERE noteKey = NEW.noteKey ' +
+        '      ORDER BY sequence ASC;' +
+        '  UPDATE write_buffer SET status = status & ~ 8; ' +
+        'END;'
+    );
+/**
+ * SQL statement to mark actions for replay.
+ */
+google.wspl.simplenotes.Cache.MARK_FOR_REPLAY =
+    new google.wspl.Statement(
+        'UPDATE write_buffer SET status = status | 8;');
+/**
+ * SQL statement to insert notes updates.
+ * @type {!google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.INSERT_UI_UPDATE_ =
+    new google.wspl.Statement(
+        'INSERT INTO write_buffer (' +
+          'noteKey, status, subject, body' +
+        ') ' + 'VALUES(?,?,?,?);');
+/**
+ * Updates the given entry and write a new write buffer entry.
+ * @param {number} noteKey
+ * @param {string} subject
+ * @param {string} body
+ * @param {function(number)} ackCallback
+ */
+google.wspl.simplenotes.Cache.prototype.applyUiChange = function(noteKey,
+    subject, body, ackCallback) {
+  var self = this;
+  var update = [noteKey, 2 | 8, subject, body];
+  var stat = google.wspl.simplenotes.Cache.INSERT_UI_UPDATE_.createStatement(
+      update);
+  this.dbms_.execute(stat, null, {onSuccess: function() {
+    google.logger('applyUiChange cb');
+    ackCallback(noteKey);
+  }, onFailure: function (error) {
+    self.logError_(error);
+    ackCallback(-1);
+  }});
+};
+/**
+ * SQL statement to insert notes updates.
+ * @type {!google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.INSERT_NOTE_ =
+    new google.wspl.Statement(
+        'REPLACE INTO cached_notes (noteKey, subject, body) ' +
+        'VALUES(?,?,?);' );
+/**
+ * SQL statement to force replay of pending actions by setting a bit
+ * flag on each write-buffer row indicating that it should be reapplied
+ * to the contents of the cache.
+ * @type {!google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.FORCE_REPLAY_ =
+    new google.wspl.Statement(
+        'UPDATE write_buffer SET status = status | 8;' );
+/**
+ * SQL statement to delete notes no longer to be cached.
+ * @type {!google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.EVICT_ =
+    new google.wspl.Statement(
+        'DELETE FROM cached_notes WHERE noteKey < ? OR noteKey > ?;');
+/**
+ * Applies the changes delivered from the server by first inserting
+ * them into the cache and reapplying the write-buffer to the cache.
+ * @param {!Array.<Object>} notes An array of arrays.
+ */
+google.wspl.simplenotes.Cache.prototype.insertUpdate = function(notes) {
+  var self = this; var stats = [];
+  var start = notes[0].noteKey;
+  var end = notes[0].noteKey;
+  for (var i = 0; i < notes.length; i++) {
+    stats.push(google.wspl.simplenotes.Cache.INSERT_NOTE_.
+        createStatement([notes[i].noteKey, notes[i].subject, notes[i].body]));
+    start = Math.min(start, notes[0].noteKey);
+    end = Math.max(end, notes[0].noteKey);
+  }
+  stats.push(google.wspl.simplenotes.Cache.EVICT_.createStatement([start, end]));
+  stats.push(google.wspl.simplenotes.Cache.FORCE_REPLAY_);
+  var inTrans = function(tx) {
+    self.start_ = start;
+    self.end_ = end;
+    tx.executeAll(stats);
+  };
+  var afterInsert = function(tx) {
+    if (this.lastMiss_ &&
+        this.isCacheHit_(this.lastMiss_.start, this.lastMiss_.end)) {
+      this.lastMiss_.callback(notes);
+      this.lastMiss_ = undefined;
+    }
+  };
+  this.dbms_.createTransaction(inTrans, {onSuccess: afterInsert,
+      onError: this.logError_});
+};
+/**
+ * SQL statement to force replay of pending actions by setting a bit
+ * flag on each write-buffer row indicating that it should be reapplied
+ * to the contents of the cache.
+ * @type {!google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.GET_UPDATES_TO_RESEND_ =
+    new google.wspl.Statement(
+        'SELECT noteKey, subject, body FROM write_buffer WHERE status & 2 = 2;');
+/**
+ * SQL statement to mark write buffer statements as inflight.
+ * @type {!google.wspl.Statement}
+ * @private
+ */
+google.wspl.simplenotes.Cache.MARK_AS_INFLIGHT_ =
+    new google.wspl.Statement(
+        'UPDATE write_buffer SET status = status & ~2 | 1 WHERE status & 2 = 2;');
+/**
+ * Fetches new material from the server as required.
+ * @param {number} start
+ * @param {number} end
+ * @param {function} opt_valueCallBack
+ */
+google.wspl.simplenotes.Cache.prototype.fetchFromServer = function(start,
+    end) {
+  google.logger('fetchFromServer');
+  var now = this.dbms_.getCurrentTime();
+  if (start >= this.start_ && end <= this.end_ &&
+      now - this.lastRefresh_ <
+      google.wspl.simplenotes.Cache.TIME_BETWEEN_REFRESH_) {
+    return;
+  }
+  var updates = []; var self = this; var flag = 1; var sql = []
+  sql.push(google.wspl.simplenotes.Cache.GET_UPDATES_TO_RESEND_);
+  sql.push(google.wspl.simplenotes.Cache.MARK_AS_INFLIGHT_);
+  var accumulateUpdates = function(tx, rs) {
+    if (flag == 1) {
+      for(; rs.isValidRow(); rs.next()) { updates.push(['u', rs.getRow()]); }
+      flag++;
+    }
+  };
+  var ackAndPost = function() {
+    updates.push(['q', {start: start, end: end}]);
+    self.sendXhrPost(updates);
+  };
+  this.dbms_.executeAll(sql,
+      {onSuccess: accumulateUpdates, onFailure: this.logError_},
+      {onSuccess: ackAndPost, onFailure: this.logError_});
+};