bookends 2.8.0 → 3.0.0.beta1

data/app/assets/images/logo.svg

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="143px" height="40px" viewBox="0 0 143 40" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
+    <!-- Generator: Sketch 3.3.3 (12072) - http://www.bohemiancoding.com/sketch -->
+    <title>logo</title>
+    <desc>Created with Sketch.</desc>
+    <defs></defs>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" sketch:type="MSPage">
+        <g id="main" sketch:type="MSArtboardGroup" transform="translate(-25.000000, -23.000000)" fill="#FFFFFF">
+            <g id="nav" sketch:type="MSLayerGroup" transform="translate(25.000000, 23.000000)">
+                <path d="M32.274167,0 L3.58601855,0 C1.60573942,0 0,1.612 0,3.6 L0,36.4 C0,38.388 1.60573942,40 3.58601855,40 L32.274167,40 C34.2544461,40 35.8601855,38.388 35.8601855,36.4 L35.8601855,3.6 C35.8601855,1.612 34.2544461,0 32.274167,0 Z M33.867953,36.4 C33.867953,37.2825 33.1532396,38 32.274167,38 L3.58601855,38 C2.70744401,38 1.99223253,37.2825 1.99223253,36.4 L1.99223253,3.6 C1.99223253,2.7175 2.70744401,2 3.58601855,2 L32.274167,2 C33.1532396,2 33.867953,2.7175 33.867953,3.6 L33.867953,36.4 Z M8.96504638,34 L13.4475696,30 L8.96504638,26 L8.96504638,34 Z M25.1604027,17.7875 C24.357533,16.972 22.8832809,16 20.4203834,16 C17.7194142,16 14.9387556,16.7055 12.9495114,17.3555 L12.9495114,6 L8.96504638,6 L8.96504638,23.346 L11.7795729,22.066 C11.8248962,22.0455 16.3691786,20 20.4203834,20 C22.4429975,20 22.8912498,21.1215 22.9106741,22.055 L22.9106741,34 L26.8951392,34 L26.8951392,22 C26.8976294,21.744 26.8737227,19.5275 25.1604027,17.7875 Z M19.9223253,12.5 L23.9067904,12.5 C25.7087647,10.45 26.6261878,8.272 26.8951392,6 L22.9106741,6 C22.4713868,8.267 21.4882201,10.4375 19.9223253,12.5 Z M130.435895,21.9021404 L130.435895,13.0509941 L134.436196,13.0509941 L134.436196,21.8825993 C134.436196,23.9193901 135.096308,24.838326 136.69693,24.838326 C138.296549,24.838326 138.936597,23.9193901 138.936597,21.8825993 L138.936597,13.0509941 L142.857143,13.0509941 L142.857143,21.9021404 C142.857143,25.8188917 140.977127,28.0556037 136.656802,28.0556037 C132.335975,28.0556037 130.435895,25.8188917 130.435895,21.9021404 Z M113.581962,13.0509941 L117.581762,13.0509941 L117.581762,18.4062758 L121.662821,13.0509941 L126.30317,13.0509941 L121.322231,18.8852849 L126.742576,27.8361414 L122.222111,27.8361414 L118.722412,21.9216816 L117.581762,23.2404598 L117.581762,27.8361414 L113.581962,27.8361414 L113.581962,13.0509941 Z M94.5876806,20.4430667 C94.5876806,15.0296624 98.2875201,12.770904 101.867978,12.770904 C105.428371,12.770904 109.128712,15.0296624 109.128712,20.4430667 C109.128712,25.857473 105.428371,28.1152293 101.867978,28.1152293 C98.2875201,28.1152293 94.5876806,25.857473 94.5876806,20.4430667 Z M105.127909,20.4430667 C105.127909,17.7258424 103.948134,16.0678496 101.867978,16.0678496 C99.7677568,16.0678496 98.5879815,17.7258424 98.5879815,20.4430667 C98.5879815,23.1612931 99.7677568,24.9189959 101.867978,24.9189959 C103.948134,24.9189959 105.127909,23.1612931 105.127909,20.4430667 Z M78.5132424,13.0509941 L84.29374,13.0509941 C88.0939005,13.0509941 90.4143258,14.3101467 90.4143258,17.8661379 C90.4143258,20.1835199 89.4336878,21.5228414 87.4939807,22.1812284 L90.6340289,27.8361414 L86.3939607,27.8361414 L83.5333066,22.7018251 L82.4332865,22.7018251 L82.4332865,27.8361414 L78.5132424,27.8361414 L78.5132424,13.0509941 Z M84.1532905,19.6639253 C85.7935393,19.6639253 86.5133427,19.2044573 86.5133427,17.965848 C86.5133427,16.7277397 85.7935393,16.2873119 84.1532905,16.2873119 L82.4332865,16.2873119 L82.4332865,19.6639253 L84.1532905,19.6639253 Z M63.2182986,13.0509941 L73.7790931,13.0509941 L73.7790931,16.3679818 L67.2185995,16.3679818 L67.2185995,18.7655327 L71.899077,18.7655327 L71.899077,21.8825993 L67.2185995,21.8825993 L67.2185995,24.6193647 L74.119683,24.6193647 L74.119683,27.8361414 L63.2182986,27.8361414 L63.2182986,13.0509941 Z M45.1444623,13.0509941 L49.1447632,13.0509941 L49.1447632,18.5450682 L54.065008,18.5450682 L54.065008,13.0509941 L58.0658106,13.0509941 L58.0658106,27.8361414 L54.065008,27.8361414 L54.065008,21.862056 L49.1447632,21.862056 L49.1447632,27.8361414 L45.1444623,27.8361414 L45.1444623,13.0509941 Z" id="logo" sketch:type="MSShapeGroup"></path>
+            </g>
+        </g>
+    </g>
+</svg>

data/app/assets/images/nav-dropdown-caret.svg

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="9px" height="6px" viewBox="0 0 9 6" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
+    <!-- Generator: Sketch 3.3.3 (12072) - http://www.bohemiancoding.com/sketch -->
+    <title>nav-dropdown-caret</title>
+    <desc>Created with Sketch.</desc>
+    <defs></defs>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" sketch:type="MSPage">
+        <g id="main" sketch:type="MSArtboardGroup" transform="translate(-267.000000, -42.000000)" stroke="#F2EFFF" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+            <g id="nav" sketch:type="MSLayerGroup" transform="translate(25.000000, 23.000000)">
+                <g id="main" transform="translate(174.000000, 15.000000)" sketch:type="MSShapeGroup">
+                    <path d="M75.6666667,5 L72.3333333,9 L69,5" id="nav-dropdown-caret"></path>
+                </g>
+            </g>
+        </g>
+    </g>
+</svg>

data/app/assets/javascripts/blog-fetcher.js

@@ -0,0 +1,131 @@
+//= require lscache
+//= require moment
+
+var bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+Heroku.BlogFetcher = (function() {
+  function BlogFetcher(container) {
+    this.handleError = bind(this.handleError, this);
+    this.appendData  = bind(this.appendData, this);
+    this.$container  = $(container);
+    this.init();
+  }
+
+  BlogFetcher.prototype.init = function() {
+    this.$container
+      .on('dataLoaded', this.appendData)
+      .on('dataError', this.handleError);
+    return this.getPosts();
+  };
+
+  BlogFetcher.prototype.getPosts = function() {
+    $.support.cors = true;
+    if (lscache.get('blogEntry')) {
+      return this.$container.trigger('dataLoaded');
+    } else {
+      var self = this;
+      return $.ajax({
+        url: 'https://blog.heroku.com/rss_feedburner',
+        type: 'GET',
+        dataType: 'xml',
+        crossDomain: true
+      })
+      .done(function(result) {
+        var obj = self.xmlToJson($(result).find('item')[0]);
+        var textBlock = obj.description['#text'];
+        var content = typeof textBlock === 'object' ? textBlock[0] : textBlock; // FF treats the textBlock as an object for some reason
+        var blog = {
+          'title': obj.title['#text'],
+          'contentSnippet': self.trimToLength(content, 200),
+          'link': obj.link['#text'],
+          'publishedDate': obj.pubDate['#text'],
+          'author': obj.author['#text']
+        };
+        lscache.set('blogEntry', blog, 60);
+        return self.$container.trigger('dataLoaded');
+      })
+      .fail(function(e) {
+        return self.$container.trigger('dataError');
+      });
+    }
+  };
+
+  BlogFetcher.prototype.appendData = function() {
+    var blogContent = this.$container.find('.js-blog-content');
+    this.storedEntry = lscache.get('blogEntry');
+    this.$container.find('.js-blog-link').text(this.storedEntry.title);
+    this.$container.find('.js-blog-link').attr('href', this.storedEntry.link);
+    this.$container.find('.js-blog-date').html(this.buildDateAndAuthor());
+    blogContent.html(this.storedEntry.contentSnippet);
+    blogContent.find('p').append(' <a href="' + this.storedEntry.link + '">Read More</a>');
+  };
+
+  BlogFetcher.prototype.handleError = function() {
+    if (this.storedEntry) {
+      return this.$container.trigger('dataloaded');
+    } else {
+      this.$container.find('.js-blog-link').text('Visit the Heroku Blog');
+      this.$container.find('.js-blog-date').empty();
+      this.$container.find('.js-blog-content').text('Find news and updates from Heroku in the blog.');
+    }
+  };
+
+  BlogFetcher.prototype.buildDateAndAuthor = function() {
+    var ago = moment.utc(this.storedEntry.publishedDate, 'ddd, D MMM YYYY hh:mm:ss ZZ').fromNow();
+    return ago + " by " + this.storedEntry.author;
+  };
+
+  //http://davidwalsh.name/convert-xml-json
+  BlogFetcher.prototype.xmlToJson = function(xml) {
+    // Create the return object
+    var obj = {};
+
+    if (xml.nodeType == 1) { // element
+      // do attributes
+      if (xml.attributes.length > 0) {
+        obj["@attributes"] = {};
+        for (var j = 0; j < xml.attributes.length; j++) {
+          var attribute = xml.attributes.item(j);
+          obj["@attributes"][attribute.nodeName] = attribute.nodeValue;
+        }
+      }
+    } else if (xml.nodeType == 3) { // text
+      obj = xml.nodeValue;
+    }
+
+    // do children
+    if (xml.hasChildNodes()) {
+      for(var i = 0; i < xml.childNodes.length; i++) {
+        var item = xml.childNodes.item(i);
+        var nodeName = item.nodeName;
+        if (typeof(obj[nodeName]) == "undefined") {
+          obj[nodeName] = this.xmlToJson(item);
+        } else {
+          if (typeof(obj[nodeName].push) == "undefined") {
+            var old = obj[nodeName];
+            obj[nodeName] = [];
+            obj[nodeName].push(old);
+          }
+          obj[nodeName].push(this.xmlToJson(item));
+        }
+      }
+    }
+    return obj;
+  };
+
+  BlogFetcher.prototype.trimToLength = function(str, max) {
+    if (str.length > max) {
+      return jQuery.trim(str).substring(0, max).split(' ').slice(0, -1).join(' ') + '...';
+    }
+    else {
+      return str;
+    }
+  };
+
+  return BlogFetcher;
+
+})();
+
+$(function() {
+  return window.Heroku.latestBlog = new Heroku.BlogFetcher('#more-blog');
+});

data/{fixtures/dummy-rails/app/assets/javascripts/application.js → app/assets/javascripts/bookends.js}

@@ -10,6 +10,5 @@
 // Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
 // about supported directives.
 //
-//= require jquery
+//= require heroku-namespace
 //= require_tree .
-//= require newsletter

data/app/assets/javascripts/heroku-namespace.js

@@ -0,0 +1 @@
+var Heroku = Heroku || {};

data/app/assets/javascripts/lscache.js

@@ -0,0 +1,359 @@
+/**
+ * lscache library
+ * Copyright (c) 2011, Pamela Fox
+ *
+ * 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.
+ */
+
+/* jshint undef:true, browser:true, node:true */
+/* global define */
+
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define([], factory);
+    } else if (typeof module !== "undefined" && module.exports) {
+        // CommonJS/Node module
+        module.exports = factory();
+    } else {
+        // Browser globals
+        root.lscache = factory();
+    }
+}(this, function () {
+
+  // Prefix for all lscache keys
+  var CACHE_PREFIX = 'lscache-';
+
+  // Suffix for the key name on the expiration items in localStorage
+  var CACHE_SUFFIX = '-cacheexpiration';
+
+  // expiration date radix (set to Base-36 for most space savings)
+  var EXPIRY_RADIX = 10;
+
+  // time resolution in minutes
+  var EXPIRY_UNITS = 60 * 1000;
+
+  // ECMAScript max Date (epoch + 1e8 days)
+  var MAX_DATE = Math.floor(8.64e15/EXPIRY_UNITS);
+
+  var cachedStorage;
+  var cachedJSON;
+  var cacheBucket = '';
+  var warnings = false;
+
+  // Determines if localStorage is supported in the browser;
+  // result is cached for better performance instead of being run each time.
+  // Feature detection is based on how Modernizr does it;
+  // it's not straightforward due to FF4 issues.
+  // It's not run at parse-time as it takes 200ms in Android.
+  function supportsStorage() {
+    var key = '__lscachetest__';
+    var value = key;
+
+    if (cachedStorage !== undefined) {
+      return cachedStorage;
+    }
+
+    try {
+      setItem(key, value);
+      removeItem(key);
+      cachedStorage = true;
+    } catch (e) {
+        if (isOutOfSpace(e)) {    // If we hit the limit, then it means we have support, 
+            cachedStorage = true; // just maxed it out and even the set test failed.
+        } else {
+            cachedStorage = false;
+        }
+    }
+    return cachedStorage;
+  }
+
+  // Check to set if the error is us dealing with being out of space
+  function isOutOfSpace(e) {
+    if (e && e.name === 'QUOTA_EXCEEDED_ERR' || 
+            e.name === 'NS_ERROR_DOM_QUOTA_REACHED' || 
+            e.name === 'QuotaExceededError') {
+        return true;
+    }
+    return false;
+  }
+
+  // Determines if native JSON (de-)serialization is supported in the browser.
+  function supportsJSON() {
+    /*jshint eqnull:true */
+    if (cachedJSON === undefined) {
+      cachedJSON = (window.JSON != null);
+    }
+    return cachedJSON;
+  }
+  
+  /**
+   * Returns a string where all RegExp special characters are escaped with a \.
+   * @param {String} text
+   * @return {string}
+   */
+  function escapeRegExpSpecialCharacters(text) {
+    return text.replace(/[[\]{}()*+?.\\^$|]/g, '\\$&');
+  }
+
+  /**
+   * Returns the full string for the localStorage expiration item.
+   * @param {String} key
+   * @return {string}
+   */
+  function expirationKey(key) {
+    return key + CACHE_SUFFIX;
+  }
+
+  /**
+   * Returns the number of minutes since the epoch.
+   * @return {number}
+   */
+  function currentTime() {
+    return Math.floor((new Date().getTime())/EXPIRY_UNITS);
+  }
+
+  /**
+   * Wrapper functions for localStorage methods
+   */
+
+  function getItem(key) {
+    return localStorage.getItem(CACHE_PREFIX + cacheBucket + key);
+  }
+
+  function setItem(key, value) {
+    // Fix for iPad issue - sometimes throws QUOTA_EXCEEDED_ERR on setItem.
+    localStorage.removeItem(CACHE_PREFIX + cacheBucket + key);
+    localStorage.setItem(CACHE_PREFIX + cacheBucket + key, value);
+  }
+
+  function removeItem(key) {
+    localStorage.removeItem(CACHE_PREFIX + cacheBucket + key);
+  }
+
+  function eachKey(fn) {
+    var prefixRegExp = new RegExp('^' + CACHE_PREFIX + escapeRegExpSpecialCharacters(cacheBucket) + '(.*)');
+    // Loop in reverse as removing items will change indices of tail
+    for (var i = localStorage.length-1; i >= 0 ; --i) {
+      var key = localStorage.key(i);
+      key = key && key.match(prefixRegExp);
+      key = key && key[1];
+      if (key && key.indexOf(CACHE_SUFFIX) < 0) {
+        fn(key, expirationKey(key));
+      }
+    }
+  }
+
+  function flushItem(key) {
+    var exprKey = expirationKey(key);
+
+    removeItem(key);
+    removeItem(exprKey);
+  }
+
+  function flushExpiredItem(key) {
+    var exprKey = expirationKey(key);
+    var expr = getItem(exprKey);
+
+    if (expr) {
+      var expirationTime = parseInt(expr, EXPIRY_RADIX);
+
+      // Check if we should actually kick item out of storage
+      if (currentTime() >= expirationTime) {
+        removeItem(key);
+        removeItem(exprKey);
+        return true;
+      }
+    }
+  }
+
+  function warn(message, err) {
+    if (!warnings) return;
+    if (!('console' in window) || typeof window.console.warn !== 'function') return;
+    window.console.warn("lscache - " + message);
+    if (err) window.console.warn("lscache - The error was: " + err.message);
+  }
+
+  var lscache = {
+    /**
+     * Stores the value in localStorage. Expires after specified number of minutes.
+     * @param {string} key
+     * @param {Object|string} value
+     * @param {number} time
+     */
+    set: function(key, value, time) {
+      if (!supportsStorage()) return;
+
+      // If we don't get a string value, try to stringify
+      // In future, localStorage may properly support storing non-strings
+      // and this can be removed.
+      if (typeof value !== 'string') {
+        if (!supportsJSON()) return;
+        try {
+          value = JSON.stringify(value);
+        } catch (e) {
+          // Sometimes we can't stringify due to circular refs
+          // in complex objects, so we won't bother storing then.
+          return;
+        }
+      }
+
+      try {
+        setItem(key, value);
+      } catch (e) {
+        if (isOutOfSpace(e)) {
+          // If we exceeded the quota, then we will sort
+          // by the expire time, and then remove the N oldest
+          var storedKeys = [];
+          var storedKey;
+          eachKey(function(key, exprKey) {
+            var expiration = getItem(exprKey);
+            if (expiration) {
+              expiration = parseInt(expiration, EXPIRY_RADIX);
+            } else {
+              // TODO: Store date added for non-expiring items for smarter removal
+              expiration = MAX_DATE;
+            }
+            storedKeys.push({
+              key: key,
+              size: (getItem(key) || '').length,
+              expiration: expiration
+            });
+          });
+          // Sorts the keys with oldest expiration time last
+          storedKeys.sort(function(a, b) { return (b.expiration-a.expiration); });
+
+          var targetSize = (value||'').length;
+          while (storedKeys.length && targetSize > 0) {
+            storedKey = storedKeys.pop();
+            warn("Cache is full, removing item with key '" + key + "'");
+            flushItem(storedKey.key);
+            targetSize -= storedKey.size;
+          }
+          try {
+            setItem(key, value);
+          } catch (e) {
+            // value may be larger than total quota
+            warn("Could not add item with key '" + key + "', perhaps it's too big?", e);
+            return;
+          }
+        } else {
+          // If it was some other error, just give up.
+          warn("Could not add item with key '" + key + "'", e);
+          return;
+        }
+      }
+
+      // If a time is specified, store expiration info in localStorage
+      if (time) {
+        setItem(expirationKey(key), (currentTime() + time).toString(EXPIRY_RADIX));
+      } else {
+        // In case they previously set a time, remove that info from localStorage.
+        removeItem(expirationKey(key));
+      }
+    },
+
+    /**
+     * Retrieves specified value from localStorage, if not expired.
+     * @param {string} key
+     * @return {string|Object}
+     */
+    get: function(key) {
+      if (!supportsStorage()) return null;
+
+      // Return the de-serialized item if not expired
+      if (flushExpiredItem(key)) { return null; }
+
+      // Tries to de-serialize stored value if its an object, and returns the normal value otherwise.
+      var value = getItem(key);
+      if (!value || !supportsJSON()) {
+        return value;
+      }
+
+      try {
+        // We can't tell if its JSON or a string, so we try to parse
+        return JSON.parse(value);
+      } catch (e) {
+        // If we can't parse, it's probably because it isn't an object
+        return value;
+      }
+    },
+
+    /**
+     * Removes a value from localStorage.
+     * Equivalent to 'delete' in memcache, but that's a keyword in JS.
+     * @param {string} key
+     */
+    remove: function(key) {
+      if (!supportsStorage()) return;
+
+      flushItem(key);
+    },
+
+    /**
+     * Returns whether local storage is supported.
+     * Currently exposed for testing purposes.
+     * @return {boolean}
+     */
+    supported: function() {
+      return supportsStorage();
+    },
+
+    /**
+     * Flushes all lscache items and expiry markers without affecting rest of localStorage
+     */
+    flush: function() {
+      if (!supportsStorage()) return;
+
+      eachKey(function(key) {
+        flushItem(key);
+      });
+    },
+
+    /**
+     * Flushes expired lscache items and expiry markers without affecting rest of localStorage
+     */
+    flushExpired: function() {
+      if (!supportsStorage()) return;
+
+      eachKey(function(key) {
+        flushExpiredItem(key);
+      });
+    },
+
+    /**
+     * Appends CACHE_PREFIX so lscache will partition data in to different buckets.
+     * @param {string} bucket
+     */
+    setBucket: function(bucket) {
+      cacheBucket = bucket;
+    },
+
+    /**
+     * Resets the string being appended to CACHE_PREFIX so lscache will use the default storage behavior.
+     */
+    resetBucket: function() {
+      cacheBucket = '';
+    },
+
+    /**
+     * Sets whether to display warnings when an item is removed from the cache or not.
+     */
+    enableWarnings: function(enabled) {
+      warnings = enabled;
+    }
+  };
+
+  // Return the module
+  return lscache;
+}));