ample_assets 0.0.1 → 0.0.2

data/vendor/assets/javascripts/moustache.js

@@ -0,0 +1,436 @@
+/*
+  mustache.js — Logic-less templates in JavaScript
+
+  See http://mustache.github.com/ for more info.
+*/
+
+var Mustache = function () {
+  var _toString = Object.prototype.toString;
+
+  Array.isArray = Array.isArray || function (obj) {
+    return _toString.call(obj) == "[object Array]";
+  }
+
+  var _trim = String.prototype.trim, trim;
+
+  if (_trim) {
+    trim = function (text) {
+      return text == null ? "" : _trim.call(text);
+    }
+  } else {
+    var trimLeft, trimRight;
+
+    // IE doesn't match non-breaking spaces with \s.
+    if ((/\S/).test("\xA0")) {
+      trimLeft = /^[\s\xA0]+/;
+      trimRight = /[\s\xA0]+$/;
+    } else {
+      trimLeft = /^\s+/;
+      trimRight = /\s+$/;
+    }
+
+    trim = function (text) {
+      return text == null ? "" :
+        text.toString().replace(trimLeft, "").replace(trimRight, "");
+    }
+  }
+
+  var escapeMap = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': '&quot;',
+    "'": '&#39;'
+  };
+
+  function escapeHTML(string) {
+    return String(string).replace(/&(?!\w+;)|[<>"']/g, function (s) {
+      return escapeMap[s] || s;
+    });
+  }
+
+  var regexCache = {};
+  var Renderer = function () {};
+
+  Renderer.prototype = {
+    otag: "{{",
+    ctag: "}}",
+    pragmas: {},
+    buffer: [],
+    pragmas_implemented: {
+      "IMPLICIT-ITERATOR": true
+    },
+    context: {},
+
+    render: function (template, context, partials, in_recursion) {
+      // reset buffer & set context
+      if (!in_recursion) {
+        this.context = context;
+        this.buffer = []; // TODO: make this non-lazy
+      }
+
+      // fail fast
+      if (!this.includes("", template)) {
+        if (in_recursion) {
+          return template;
+        } else {
+          this.send(template);
+          return;
+        }
+      }
+
+      // get the pragmas together
+      template = this.render_pragmas(template);
+
+      // render the template
+      var html = this.render_section(template, context, partials);
+
+      // render_section did not find any sections, we still need to render the tags
+      if (html === false) {
+        html = this.render_tags(template, context, partials, in_recursion);
+      }
+
+      if (in_recursion) {
+        return html;
+      } else {
+        this.sendLines(html);
+      }
+    },
+
+    /*
+      Sends parsed lines
+    */
+    send: function (line) {
+      if (line !== "") {
+        this.buffer.push(line);
+      }
+    },
+
+    sendLines: function (text) {
+      if (text) {
+        var lines = text.split("\n");
+        for (var i = 0; i < lines.length; i++) {
+          this.send(lines[i]);
+        }
+      }
+    },
+
+    /*
+      Looks for %PRAGMAS
+    */
+    render_pragmas: function (template) {
+      // no pragmas
+      if (!this.includes("%", template)) {
+        return template;
+      }
+
+      var that = this;
+      var regex = this.getCachedRegex("render_pragmas", function (otag, ctag) {
+        return new RegExp(otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" + ctag, "g");
+      });
+
+      return template.replace(regex, function (match, pragma, options) {
+        if (!that.pragmas_implemented[pragma]) {
+          throw({message:
+            "This implementation of mustache doesn't understand the '" +
+            pragma + "' pragma"});
+        }
+        that.pragmas[pragma] = {};
+        if (options) {
+          var opts = options.split("=");
+          that.pragmas[pragma][opts[0]] = opts[1];
+        }
+        return "";
+        // ignore unknown pragmas silently
+      });
+    },
+
+    /*
+      Tries to find a partial in the curent scope and render it
+    */
+    render_partial: function (name, context, partials) {
+      name = trim(name);
+      if (!partials || partials[name] === undefined) {
+        throw({message: "unknown_partial '" + name + "'"});
+      }
+      if (!context || typeof context[name] != "object") {
+        return this.render(partials[name], context, partials, true);
+      }
+      return this.render(partials[name], context[name], partials, true);
+    },
+
+    /*
+      Renders inverted (^) and normal (#) sections
+    */
+    render_section: function (template, context, partials) {
+      if (!this.includes("#", template) && !this.includes("^", template)) {
+        // did not render anything, there were no sections
+        return false;
+      }
+
+      var that = this;
+
+      var regex = this.getCachedRegex("render_section", function (otag, ctag) {
+        // This regex matches _the first_ section ({{#foo}}{{/foo}}), and captures the remainder
+        return new RegExp(
+          "^([\\s\\S]*?)" +         // all the crap at the beginning that is not {{*}} ($1)
+
+          otag +                    // {{
+          "(\\^|\\#)\\s*(.+)\\s*" + //  #foo (# == $2, foo == $3)
+          ctag +                    // }}
+
+          "\n*([\\s\\S]*?)" +       // between the tag ($2). leading newlines are dropped
+
+          otag +                    // {{
+          "\\/\\s*\\3\\s*" +        //  /foo (backreference to the opening tag).
+          ctag +                    // }}
+
+          "\\s*([\\s\\S]*)$",       // everything else in the string ($4). leading whitespace is dropped.
+
+        "g");
+      });
+
+
+      // for each {{#foo}}{{/foo}} section do...
+      return template.replace(regex, function (match, before, type, name, content, after) {
+        // before contains only tags, no sections
+        var renderedBefore = before ? that.render_tags(before, context, partials, true) : "",
+
+        // after may contain both sections and tags, so use full rendering function
+            renderedAfter = after ? that.render(after, context, partials, true) : "",
+
+        // will be computed below
+            renderedContent,
+
+            value = that.find(name, context);
+
+        if (type === "^") { // inverted section
+          if (!value || Array.isArray(value) && value.length === 0) {
+            // false or empty list, render it
+            renderedContent = that.render(content, context, partials, true);
+          } else {
+            renderedContent = "";
+          }
+        } else if (type === "#") { // normal section
+          if (Array.isArray(value)) { // Enumerable, Let's loop!
+            renderedContent = that.map(value, function (row) {
+              return that.render(content, that.create_context(row), partials, true);
+            }).join("");
+          } else if (that.is_object(value)) { // Object, Use it as subcontext!
+            renderedContent = that.render(content, that.create_context(value),
+              partials, true);
+          } else if (typeof value == "function") {
+            // higher order section
+            renderedContent = value.call(context, content, function (text) {
+              return that.render(text, context, partials, true);
+            });
+          } else if (value) { // boolean section
+            renderedContent = that.render(content, context, partials, true);
+          } else {
+            renderedContent = "";
+          }
+        }
+
+        return renderedBefore + renderedContent + renderedAfter;
+      });
+    },
+
+    /*
+      Replace {{foo}} and friends with values from our view
+    */
+    render_tags: function (template, context, partials, in_recursion) {
+      // tit for tat
+      var that = this;
+
+      var new_regex = function () {
+        return that.getCachedRegex("render_tags", function (otag, ctag) {
+          return new RegExp(otag + "(=|!|>|&|\\{|%)?([^#\\^]+?)\\1?" + ctag + "+", "g");
+        });
+      };
+
+      var regex = new_regex();
+      var tag_replace_callback = function (match, operator, name) {
+        switch(operator) {
+        case "!": // ignore comments
+          return "";
+        case "=": // set new delimiters, rebuild the replace regexp
+          that.set_delimiters(name);
+          regex = new_regex();
+          return "";
+        case ">": // render partial
+          return that.render_partial(name, context, partials);
+        case "{": // the triple mustache is unescaped
+        case "&": // & operator is an alternative unescape method
+          return that.find(name, context);
+        default: // escape the value
+          return escapeHTML(that.find(name, context));
+        }
+      };
+      var lines = template.split("\n");
+      for(var i = 0; i < lines.length; i++) {
+        lines[i] = lines[i].replace(regex, tag_replace_callback, this);
+        if (!in_recursion) {
+          this.send(lines[i]);
+        }
+      }
+
+      if (in_recursion) {
+        return lines.join("\n");
+      }
+    },
+
+    set_delimiters: function (delimiters) {
+      var dels = delimiters.split(" ");
+      this.otag = this.escape_regex(dels[0]);
+      this.ctag = this.escape_regex(dels[1]);
+    },
+
+    escape_regex: function (text) {
+      // thank you Simon Willison
+      if (!arguments.callee.sRE) {
+        var specials = [
+          '/', '.', '*', '+', '?', '|',
+          '(', ')', '[', ']', '{', '}', '\\'
+        ];
+        arguments.callee.sRE = new RegExp(
+          '(\\' + specials.join('|\\') + ')', 'g'
+        );
+      }
+      return text.replace(arguments.callee.sRE, '\\$1');
+    },
+
+    /*
+      find `name` in current `context`. That is find me a value
+      from the view object
+    */
+    find: function (name, context) {
+      name = trim(name);
+
+      // Checks whether a value is thruthy or false or 0
+      function is_kinda_truthy(bool) {
+        return bool === false || bool === 0 || bool;
+      }
+
+      var value;
+
+      // check for dot notation eg. foo.bar
+      if (name.match(/([a-z_]+)\./ig)) {
+        var childValue = this.walk_context(name, context);
+        if (is_kinda_truthy(childValue)) {
+          value = childValue;
+        }
+      } else {
+        if (is_kinda_truthy(context[name])) {
+          value = context[name];
+        } else if (is_kinda_truthy(this.context[name])) {
+          value = this.context[name];
+        }
+      }
+
+      if (typeof value == "function") {
+        return value.apply(context);
+      }
+      if (value !== undefined) {
+        return value;
+      }
+      // silently ignore unkown variables
+      return "";
+    },
+
+    walk_context: function (name, context) {
+      var path = name.split('.');
+      // if the var doesn't exist in current context, check the top level context
+      var value_context = (context[path[0]] != undefined) ? context : this.context;
+      var value = value_context[path.shift()];
+      while (value != undefined && path.length > 0) {
+        value_context = value;
+        value = value[path.shift()];
+      }
+      // if the value is a function, call it, binding the correct context
+      if (typeof value == "function") {
+        return value.apply(value_context);
+      }
+      return value;
+    },
+
+    // Utility methods
+
+    /* includes tag */
+    includes: function (needle, haystack) {
+      return haystack.indexOf(this.otag + needle) != -1;
+    },
+
+    // by @langalex, support for arrays of strings
+    create_context: function (_context) {
+      if (this.is_object(_context)) {
+        return _context;
+      } else {
+        var iterator = ".";
+        if (this.pragmas["IMPLICIT-ITERATOR"]) {
+          iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+        }
+        var ctx = {};
+        ctx[iterator] = _context;
+        return ctx;
+      }
+    },
+
+    is_object: function (a) {
+      return a && typeof a == "object";
+    },
+
+    /*
+      Why, why, why? Because IE. Cry, cry cry.
+    */
+    map: function (array, fn) {
+      if (typeof array.map == "function") {
+        return array.map(fn);
+      } else {
+        var r = [];
+        var l = array.length;
+        for(var i = 0; i < l; i++) {
+          r.push(fn(array[i]));
+        }
+        return r;
+      }
+    },
+
+    getCachedRegex: function (name, generator) {
+      var byOtag = regexCache[this.otag];
+      if (!byOtag) {
+        byOtag = regexCache[this.otag] = {};
+      }
+
+      var byCtag = byOtag[this.ctag];
+      if (!byCtag) {
+        byCtag = byOtag[this.ctag] = {};
+      }
+
+      var regex = byCtag[name];
+      if (!regex) {
+        regex = byCtag[name] = generator(this.otag, this.ctag);
+      }
+
+      return regex;
+    }
+  };
+
+  return({
+    name: "mustache.js",
+    version: "0.4.0-dev",
+
+    /*
+      Turns a template and view into HTML
+    */
+    to_html: function (template, view, partials, send_fun) {
+      var renderer = new Renderer();
+      if (send_fun) {
+        renderer.send = send_fun;
+      }
+      renderer.render(template, view || {}, partials);
+      if (!send_fun) {
+        return renderer.buffer.join("\n");
+      }
+    }
+  });
+}();

data/vendor/assets/javascripts/pdfobject.js

@@ -0,0 +1,244 @@
+/*
+    PDFObject v1.2.20111123
+    https://github.com/pipwerks/PDFObject
+    Copyright (c) Philip Hutchison
+    MIT-style license: http://pipwerks.mit-license.org/
+*/
+
+/*jslint browser: true, sloppy: true, white: true, plusplus: true */
+/*global ActiveXObject, window */
+
+var PDFObject = function (obj){
+
+    if(!obj || !obj.url){ return false; }
+
+    var pdfobjectversion = "1.2",
+        //Set reasonable defaults
+        id = obj.id || false,
+        width = obj.width || "100%",
+        height = obj.height || "100%",
+        pdfOpenParams = obj.pdfOpenParams,
+        url,
+        pluginTypeFound,
+
+        //declare functions
+        createAXO,
+        hasReaderActiveX,
+        hasReader,
+        hasGeneric,
+        pluginFound,
+        setCssForFullWindowPdf,
+        buildQueryString,
+        get,
+        embed;
+
+
+    /* ----------------------------------------------------
+       Supporting functions
+       ---------------------------------------------------- */
+
+    createAXO = function (type){
+        var ax;
+        try {
+            ax = new ActiveXObject(type);
+        } catch (e) {
+            //ensure ax remains null
+            ax = null;
+        }
+        return ax;
+    };
+
+    //Tests specifically for Adobe Reader (aka Acrobat) in Internet Explorer
+    hasReaderActiveX = function (){
+
+        var axObj = null;
+
+        if (window.ActiveXObject) {
+
+            axObj = createAXO("AcroPDF.PDF");
+
+            //If "AcroPDF.PDF" didn't work, try "PDF.PdfCtrl"
+            if(!axObj){ axObj = createAXO("PDF.PdfCtrl"); }
+
+            //If either "AcroPDF.PDF" or "PDF.PdfCtrl" are found, return true
+            if (axObj !== null) { return true; }
+
+        }
+
+        //If you got to this point, there's no ActiveXObject for PDFs
+        return false;
+
+    };
+
+
+
+    //Tests specifically for Adobe Reader (aka Adobe Acrobat) in non-IE browsers
+    hasReader = function (){
+
+        var i,
+            n = navigator.plugins,
+            count = n.length,
+            regx = /Adobe Reader|Adobe PDF|Acrobat/gi;
+
+        for(i=0; i<count; i++){
+            if(regx.test(n[i].name)){
+                return true;
+            }
+        }
+
+        return false;
+
+    };
+
+
+    //Detects unbranded PDF support
+    hasGeneric = function (){
+        var plugin = navigator.mimeTypes["application/pdf"];
+        return (plugin && plugin.enabledPlugin);
+    };
+
+
+    //Determines what kind of PDF support is available: Adobe or generic
+    pluginFound = function (){
+
+        var type = null;
+
+        if(hasReader() || hasReaderActiveX()){
+
+            type = "Adobe";
+
+        } else if(hasGeneric()) {
+
+            type = "generic";
+
+        }
+
+        return type;
+
+    };
+
+
+    //If setting PDF to fill page, need to handle some CSS first
+    setCssForFullWindowPdf = function (){
+
+        var html = document.getElementsByTagName("html"),
+            html_style,
+            body_style;
+
+        if(!html){ return false; }
+
+        html_style = html[0].style;
+        body_style = document.body.style;
+
+        html_style.height = "100%";
+        html_style.overflow = "hidden";
+        body_style.margin = "0";
+        body_style.padding = "0";
+        body_style.height = "100%";
+        body_style.overflow = "hidden";
+
+    };
+
+
+    //Creating a querystring for using PDF Open parameters when embedding PDF
+    buildQueryString = function(pdfParams){
+
+        var string = "",
+            prop;
+
+        if(!pdfParams){ return string; }
+
+        for (prop in pdfParams) {
+
+            if (pdfParams.hasOwnProperty(prop)) {
+
+                string += prop + "=";
+
+                if(prop === "search") {
+
+                    string += encodeURI(pdfParams[prop]);
+
+                } else {
+
+                    string += pdfParams[prop];
+
+                }
+
+                string += "&";
+
+            }
+
+        }
+
+        //Remove last ampersand
+        return string.slice(0, string.length - 1);
+
+    };
+
+
+    //Simple function for returning values from PDFObject
+    get = function(prop){
+
+        var value = null;
+
+        switch(prop){
+            case "url" : value = url; break;
+            case "id" : value = id; break;
+            case "width" : value = width; break;
+            case "height" : value = height; break;
+            case "pdfOpenParams" : value = pdfOpenParams; break;
+            case "pluginTypeFound" : value = pluginTypeFound; break;
+            case "pdfobjectversion" : value = pdfobjectversion; break;
+        }
+
+        return value;
+
+    };
+
+
+    /* ----------------------------------------------------
+       PDF Embedding functions
+       ---------------------------------------------------- */
+
+
+    embed = function(targetID){
+
+        if(!pluginTypeFound){ return false; }
+
+        var targetNode = null;
+
+        if(targetID){
+
+            //Allow users to pass an element OR an element's ID
+            targetNode = (targetID.nodeType && targetID.nodeType === 1) ? targetID : document.getElementById(targetID);
+
+            //Ensure target element is found in document before continuing
+            if(!targetNode){ return false; }
+
+        } else {
+
+            targetNode = document.body;
+            setCssForFullWindowPdf();
+            width = "100%";
+            height = "100%";
+
+        }
+
+        targetNode.innerHTML = '<object    data="' +url +'" type="application/pdf" width="' +width +'" height="' +height +'"></object>';
+
+        return targetNode.getElementsByTagName("object")[0];
+
+    };
+
+    //The hash (#) prevents odd behavior in Windows
+    //Append optional Adobe params for opening document
+    url = encodeURI(obj.url) + "#" + buildQueryString(pdfOpenParams);
+    pluginTypeFound = pluginFound();
+
+    this.get = function(prop){ return get(prop); };
+    this.embed = function(id){ return embed(id); };
+    this.pdfobjectversion = pdfobjectversion;
+
+    return this;
+
+};