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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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_});
+};