isc_analytics 0.5 → 0.5.1

data/vendor/assets/javascripts/isc_analytics/session/index.js

@@ -0,0 +1 @@
+//= require_tree .

data/vendor/assets/javascripts/isc_analytics/session/session-0.4.js

@@ -0,0 +1,414 @@
+/**
+ * session.js 0.4.1
+ * (c) 2012 Iain, CodeJoust
+ * session.js is freely distributable under the MIT license.
+ * Portions of session.js are inspired or borrowed from Underscore.js, and quirksmode.org demo javascript.
+ * This version uses google's jsapi library for location services.
+ * For details, see: https://github.com/codejoust/session.js
+ */
+(function(win, doc, nav){
+  // Changing the API Version invalidates olde cookies with previous api version tags.
+  var API_VERSION = 0.4;
+  
+  // Settings: defaults
+  var options = {
+    // Use the HTML5 Geolocation API
+    // this ONLY returns lat & long, no city/address
+    use_html5_location: false,
+    // Attempts to use IPInfoDB if provided a valid key
+    // Get a key at http://ipinfodb.com/register.php
+    ipinfodb_key: false,
+    // Leaving true allows for fallback for both
+    // the HTML5 location and the IPInfoDB
+    gapi_location: true,
+    // Name of the location cookie (set blank to disable cookie)
+    //   - WARNING: different providers use the same cookie
+    //   - if switching providers, remember to use another cookie or provide checks for old cookies
+    location_cookie: "location",
+    // Location cookie expiration in hours
+    location_cookie_timeout: 5,
+    // Session expiration in days
+    session_timeout: 32,
+    // Session cookie name (set blank to disable cookie)
+    session_cookie: "first_session"
+  };
+  
+  // Session object
+  var SessionRunner = function(){
+    // Helper for querying.
+    // Usage: session.current_session.referrer_info.hostname.contains(['github.com','news.ycombinator.com'])
+    String.prototype.contains = function(other_str){
+      if (typeof(other_str) === 'string'){
+        return (this.indexOf(other_str) !== -1); }
+      for (var i = 0; i < other_str.length; i++){
+        if (this.indexOf(other_str[i]) !== -1){ return true; } }
+      return false; }
+    // Merge options
+    if (win.session && win.session.options) {
+      for (option in win.session.options){
+        options[option] = win.session.options[option]; }
+    }
+    // Modules to run
+    // If the module has arguments,
+    //   it _needs_ to return a callback function.
+    var unloaded_modules = {
+      api_version: API_VERSION,
+      locale: modules.locale(),
+      current_session: modules.session(),
+      original_session: modules.session(
+        options.session_cookie,
+        options.session_timeout * 24 * 60 * 60 * 1000),
+      browser: modules.browser(),
+      plugins: modules.plugins(),
+      time: modules.time(),
+      device: modules.device()
+    };
+    // Location switch
+    if (options.use_html5_location){
+      unloaded_modules.location = modules.html5_location();
+    } else if (options.ipinfodb_key){
+      unloaded_modules.location = modules.ipinfodb_location(options.ipinfodb_key);
+    } else if (options.gapi_location){
+      unloaded_modules.location = modules.gapi_location();
+    }
+    // Cache win.session.start
+    if (win.session && win.session.start){
+      var start = win.session.start;
+    }
+    // Set up checking, if all modules are ready
+    var asynchs = 0, module, result,
+    check_asynch = function(){
+      if (asynchs === 0){
+        // Run start calback
+        if (start){ start(win.session); }
+      }
+    };
+    win.session = {};
+    // Run asynchronous methods
+    for (var name in unloaded_modules){
+      module = unloaded_modules[name];
+      if (typeof module === "function"){
+        try {
+          module(function(data){
+            win.session[name] = data;
+            asynchs--;
+            check_asynch();
+          });
+          asynchs++;
+        } catch(err){
+          if (win.console && typeof(console.log) === "function"){
+            console.log(err); }
+        }
+      } else {
+        win.session[name] = module;
+      } }
+    check_asynch();
+  };
+  
+  
+  // Browser (and OS) detection
+  var browser = {
+    detect: function(){
+      return {
+        browser: this.search(this.data.browser),
+        version: this.search(nav.userAgent) || this.search(nav.appVersion),
+        os: this.search(this.data.os)
+    } },
+    search: function(data) {
+      if (typeof data === "object"){
+        // search for string match
+        for(var i = 0; i < data.length; i++) {
+          var dataString = data[i].string,
+              dataProp   = data[i].prop;
+          this.version_string = data[i].versionSearch || data[i].identity;
+          if (dataString){
+            if (dataString.indexOf(data[i].subString) != -1){
+              return data[i].identity;
+            }
+          } else if (dataProp){
+            return data[i].identity;
+          }
+        }
+      } else {
+        // search for version number
+        var index = data.indexOf(this.version_string);
+        if (index == -1) return;
+        return parseFloat(data.substr(index + this.version_string.length + 1));
+      }
+    },
+    data: {
+      browser: [
+        { string: nav.userAgent, subString: "Chrome", identity: "Chrome" },
+        { string: nav.userAgent, subString: "OmniWeb", versionSearch: "OmniWeb/", identity: "OmniWeb" },
+        { string: nav.vendor, subString: "Apple", identity: "Safari", versionSearch: "Version" },
+        { prop:   win.opera, identity: "Opera", versionSearch: "Version" },
+        { string: nav.vendor, subString: "iCab",identity: "iCab" },
+        { string: nav.vendor, subString: "KDE", identity: "Konqueror" },
+        { string: nav.userAgent, subString: "Firefox", identity: "Firefox" },
+        { string: nav.vendor, subString: "Camino", identity: "Camino" },
+        { string: nav.userAgent, subString: "Netscape", identity: "Netscape" },
+        { string: nav.userAgent, subString: "MSIE", identity: "Explorer", versionSearch: "MSIE" },
+        { string: nav.userAgent, subString: "Gecko", identity: "Mozilla", versionSearch: "rv" },
+        { string: nav.userAgent, subString: "Mozilla", identity: "Netscape", versionSearch: "Mozilla" }
+      ],
+      os: [
+        { string: nav.platform, subString: "Win", identity: "Windows" },
+        { string: nav.platform, subString: "Mac", identity: "Mac" },
+        { string: nav.userAgent, subString: "iPhone", identity: "iPhone/iPod" },
+        { string: nav.userAgent, subString: "iPad", identitiy: "iPad" },
+        { string: nav.platform, subString: "Linux", identity: "Linux" },
+        { string: nav.userAgent, subString: "Android", identity: "Android" }
+      ]}
+  };
+  
+  var modules = {
+    browser: function(){
+      return browser.detect();
+    },
+    time: function(){
+      // split date and grab timezone estimation.
+      // timezone estimation: http://www.onlineaspect.com/2007/06/08/auto-detect-a-time-zone-with-javascript/
+      var d1 = new Date(), d2 = new Date();
+      d1.setMonth(0); d1.setDate(1); d2.setMonth(6); d2.setDate(1);
+      return({tz_offset: -(new Date().getTimezoneOffset()) / 60, observes_dst: (d1.getTimezoneOffset() !== d2.getTimezoneOffset()) });
+      // Gives a browser estimation, not guaranteed to be correct.
+    },
+    locale: function() {
+      var lang = (
+        nav.language        ||
+        nav.browserLanguage ||
+        nav.systemLanguage  ||
+        nav.userLanguage
+      ).split("-");
+      if (lang.length == 2){
+        return { country: lang[1].toLowerCase(), lang: lang[0].toLowerCase() };
+      } else if (lang) {
+        return {lang: lang[0].toLowerCase(), country: null };
+      } else { return{lang: null, country: null }; }
+    },
+    device: function() {
+      var device = {
+        screen: {
+          width: screen.width,
+          height: screen.height
+        }
+      };
+      var html = doc.documentElement,
+          body = doc.getElementsByTagName("body")[0];
+      device.viewport = {
+        width:  win.innerWidth  || html.clientWidth  || body.clientWidth,
+        height: win.innerHeight || html.clientHeight || body.clientHeight
+      };
+      device.is_tablet = !!nav.userAgent.match(/(iPad|SCH-I800|xoom|kindle)/i);
+      device.is_phone = !device.isTablet && !!nav.userAgent.match(/(iPhone|iPod|blackberry|android 0.5|htc|lg|midp|mmp|mobile|nokia|opera mini|palm|pocket|psp|sgh|smartphone|symbian|treo mini|Playstation Portable|SonyEricsson|Samsung|MobileExplorer|PalmSource|Benq|Windows Phone|Windows Mobile|IEMobile|Windows CE|Nintendo Wii)/i);
+      device.is_mobile = (device.is_tablet || device.is_phone);
+      return device;
+    },
+    plugins: function(){
+      var check_plugin = function(name){
+        if (nav.plugins){
+          var plugin, i = 0, length = nav.plugins.length;
+          for (; i < length; i++ ){
+            plugin = nav.plugins[i];
+            if (plugin && plugin.name && plugin.name.toLowerCase().indexOf(name) !== -1){
+              return true;
+            } }
+          return false;
+        } return false;
+      }
+      return {
+        flash:       check_plugin("flash"),
+        silverlight: check_plugin("silverlight"),
+        java:        check_plugin("java"),
+        quicktime:   check_plugin("quicktime")
+      }; 
+    },
+    session: function (cookie, expires){
+      var session = util.get_obj(cookie);
+      if (session == null){
+        session = {
+          visits: 1,
+          start: new Date().getTime(), last_visit: new Date().getTime(),
+          url: win.location.href, path: win.location.pathname,
+          referrer: doc.referrer, referrer_info: util.parse_url(doc.referrer),
+          search: { engine: null, query: null }
+        };
+        var search_engines = [
+          { name: "Google", host: "google", query: "q" },
+          { name: "Bing", host: "bing.com", query: "q" },
+          { name: "Yahoo", host: "search.yahoo", query: "p" },
+          { name: "AOL", host: "search.aol", query: "q" },
+          { name: "Ask", host: "ask.com", query: "q" },
+          { name: "Baidu", host: "baidu.com", query: "wd" }
+        ], length = search_engines.length,
+           engine, match, i = 0,
+           fallbacks = 'q query term p wd query text'.split(' ');
+        for (i = 0; i < length; i++){
+          engine = search_engines[i];
+          if (session.referrer_info.host.indexOf(engine.host) !== -1){
+            session.search.engine = engine.name;
+            session.search.query  = session.referrer_info.query[engine.query];
+            session.search.terms  = session.search.query ? session.search.query.split(" ") : null;
+            break;
+          }
+        }
+        if (session.search.engine === null && session.referrer_info.search.length > 1){
+          for (i = 0; i < fallbacks.length; i++){
+            var terms = session.referrer_info.query[fallbacks[i]];
+            if (terms){
+              session.search.engine = "Unknown";
+              session.search.query  = terms; session.search.terms  = terms.split(" ");
+              break;
+            }
+          } 
+        }
+      } else {
+        session.last_visit = new Date().getTime();
+        session.visits++;
+      }
+      util.set_cookie(cookie, util.package_obj(session), expires);
+      return session;
+    },
+    html5_location: function(){
+      return function(callback){
+        nav.geolocation.getCurrentPosition(function(pos){
+          pos.source = 'html5';
+          callback(pos);
+        }, function(err) {
+          if (options.gapi_location){
+            modules.gapi_location()(callback);
+          } else {
+            callback({error: true, source: 'html5'}); }
+        });
+      };
+    },
+    gapi_location: function(){
+      return function(callback){
+        var location = util.get_obj(options.location_cookie);
+        if (!location || location.source !== 'google'){
+          win.gloader_ready = function() {
+            if ("google" in win){
+              if (win.google.loader.ClientLocation){
+                win.google.loader.ClientLocation.source = "google";
+                callback(win.google.loader.ClientLocation);
+              } else {
+                callback({error: true, source: "google"});
+              }
+              util.set_cookie(
+                options.location_cookie,
+                util.package_obj(win.google.loader.ClientLocation),
+                options.location_cookie_timeout * 60 * 60 * 1000);
+            }}
+          util.embed_script("https://www.google.com/jsapi?callback=gloader_ready");
+        } else {
+          callback(location);
+        }}
+    },
+    ipinfodb_location: function(api_key){
+      return function (callback){
+        var location_cookie = util.get_obj(options.location_cookie);
+        if (location_cookie && location_cookie.source === 'ipinfodb'){ callback(location_cookie); }
+        win.ipinfocb = function(data){
+          if (data.statusCode === "OK"){
+            data.source = "ipinfodb";
+            util.set_cookie(
+              options.location_cookie,
+              util.package_obj(data),
+              options.location_cookie * 60 * 60 * 1000);
+            callback(data);
+          } else {
+            if (options.gapi_location){ return modules.gapi_location()(callback); }
+            else { callback({error: true, source: "ipinfodb", message: data.statusMessage}); }
+          }}
+        util.embed_script("http://api.ipinfodb.com/v3/ip-city/?key=" + api_key + "&format=json&callback=ipinfocb");
+      }}
+  };
+  
+  // Utilities
+  var util = {
+    parse_url: function(url_str){
+      var a = doc.createElement("a"), query = {};
+      a.href = url_str; query_str = a.search.substr(1);
+      // Disassemble query string
+      if (query_str != ''){
+        var pairs = query_str.split("&"), i = 0,
+            length = pairs.length, parts;
+        for (; i < length; i++){
+          parts = pairs[i].split("=");
+          if (parts.length === 2){
+            query[parts[0]] = decodeURI(parts[1]); }
+        }
+      }
+      return {
+        host:     a.host,
+        path:     a.pathname,
+        protocol: a.protocol,
+        port:     a.port === '' ? 80 : a.port,
+        search:   a.search,
+        query:    query }
+    },
+    set_cookie: function(cname, value, expires, options){ // from jquery.cookie.js
+      if (!doc.cookie || !cname || !value){ return null; }
+      if (!options){ var options = {}; }
+      if (value === null || value === undefined){ expires = -1; }
+      if (expires){ options.expires = (new Date().getTime()) + expires; }
+      return (document.cookie = [
+          encodeURIComponent(cname), '=',
+          encodeURIComponent(String(value)),
+          options.expires ? '; expires=' + new Date(options.expires).toUTCString() : '', // use expires attribute, max-age is not supported by IE
+          options.path ? '; path=' + options.path : '',
+          options.domain ? '; domain=' + options.domain : '',
+          (win.location && win.location.protocol === 'https:') ? '; secure' : ''
+      ].join(''));
+    },
+    get_cookie: function(cookie_name, result){ // from jquery.cookie.js
+      return (result = new RegExp('(?:^|; )' + encodeURIComponent(cookie_name) + '=([^;]*)').exec(document.cookie)) ? decodeURIComponent(result[1]) : null;
+    },
+    embed_script: function(url){
+      var element  = doc.createElement("script");
+      element.type = "text/javascript";
+      element.src  = url;
+      doc.getElementsByTagName("body")[0].appendChild(element);
+    },
+    package_obj: function (obj){
+      obj.version = API_VERSION;
+      var ret = JSON.stringify(obj);
+      delete obj.version; return ret;
+    },
+    get_obj: function(cookie_name){
+      var obj;
+      try { obj = JSON.parse(util.get_cookie(cookie_name)); } catch(e){};
+      if (obj && obj.version == API_VERSION){
+        delete obj.version; return obj;
+      }
+    }
+  };
+  
+  // JSON
+  var JSON = {
+    parse: (win.JSON && win.JSON.parse) || function(data){
+        if (typeof data !== "string" || !data){ return null; }
+        return (new Function("return " + data))();
+    },
+    stringify: (win.JSON && win.JSON.stringify) || function(object){
+      var type = typeof object;
+      if (type !== "object" || object === null) {
+        if (type === "string"){ return '"' + object + '"'; }
+      } else {
+        var k, v, json = [],
+            isArray = (object && object.constructor === Array);
+        for (k in object ) {
+          v = object[k]; type = typeof v;
+          if (type === "string")
+            v = '"' + v + '"';
+          else if (type === "object" && v !== null)
+            v = this.stringify(v);
+          json.push((isArray ? "" : '"' + k + '":') + v);
+        }
+        return (isArray ? "[" : "{") + json.join(",") + (isArray ? "]" : "}");
+      } } };
+
+  // Initialize SessionRunner
+  SessionRunner();
+
+})(window, document, navigator);

data/vendor/assets/javascripts/isc_analytics/yepnope/css_prefix.js

@@ -0,0 +1,21 @@
+/**
+ * Yepnope CSS Force prefix
+ *
+ * Use a combination of any prefix, and they should work
+ * Usage: ['css!genStyles.php?234', 'normal-styles.css' ]
+ *
+ * Official Yepnope Plugin
+ *
+ * WTFPL License
+ *
+ * by Alex Sexton | AlexSexton@gmail.com
+ */
+( function ( yepnope ) {
+  // add each prefix
+  yepnope.addPrefix( 'css', function ( resource ) {
+    // Set the force flag
+    resource.forceCSS = true;
+    //carry on
+    return resource;
+  } );
+} )( this.yepnope );

data/vendor/assets/javascripts/isc_analytics/yepnope/index.js

@@ -0,0 +1,2 @@
+//= require ./yepnope
+//= require ./css_prefix

data/vendor/assets/javascripts/isc_analytics/yepnope/yepnope.js

@@ -0,0 +1,546 @@
+/*yepnope1.0.2|WTFPL*/
+// yepnope.js
+// Version - 1.0.2
+//
+// by
+// Alex Sexton - @SlexAxton - AlexSexton[at]gmail.com
+// Ralph Holzmann - @ralphholzmann - ralphholzmann[at]gmail.com
+//
+// http://yepnopejs.com/
+// https://github.com/SlexAxton/yepnope.js/
+//
+// Tri-license - WTFPL | MIT | BSD
+//
+// Please minify before use.
+// Also available as Modernizr.load via the Modernizr Project
+//
+( function ( window, doc, undef ) {
+
+var docElement            = doc.documentElement,
+    sTimeout              = window.setTimeout,
+    firstScript           = doc.getElementsByTagName( 'script' )[ 0 ],
+    toString              = {}.toString,
+    execStack             = [],
+    started               = 0,
+    // Before you get mad about browser sniffs, please read:
+    // https://github.com/Modernizr/Modernizr/wiki/Undetectables
+    // If you have a better solution, we are actively looking to solve the problem
+    isGecko               = ( 'MozAppearance' in docElement.style ),
+    isGeckoLTE18          = isGecko && !! doc.createRange().compareNode,
+    isGeckoGT18           = isGecko && ! isGeckoLTE18,
+    insBeforeObj          = isGeckoLTE18 ? docElement : firstScript.parentNode,
+    // Thanks to @jdalton for showing us this opera detection (by way of @kangax) (and probably @miketaylr too, or whatever...)
+    isOpera               = window.opera && toString.call( window.opera ) == '[object Opera]',
+    isWebkit              = ( 'webkitAppearance' in docElement.style ),
+    isNewerWebkit         = isWebkit && 'async' in doc.createElement('script'),
+    strJsElem             = isGecko ? 'object' : ( isOpera || isNewerWebkit ) ? 'img' : 'script',
+    strCssElem            = isWebkit ? 'img' : strJsElem,
+    isArray               = Array.isArray || function ( obj ) {
+      return toString.call( obj ) == '[object Array]';
+    },
+    isObject              = function ( obj ) {
+      return Object(obj) === obj;
+    },
+    isString              = function ( s ) {
+      return typeof s == 'string';
+    },
+    isFunction            = function ( fn ) {
+      return toString.call( fn ) == '[object Function]';
+    },
+    globalFilters         = [],
+    prefixes              = {},
+    handler,
+    yepnope;
+
+  /* Loader helper functions */
+  function isFileReady ( readyState ) {
+    // Check to see if any of the ways a file can be ready are available as properties on the file's element
+    return ( ! readyState || readyState == 'loaded' || readyState == 'complete' );
+  }
+
+  function execWhenReady () {
+    var execStackReady = 1,
+        i              = -1;
+
+    // Loop through the stack of scripts in the cue and execute them when all scripts in a group are ready
+    while ( execStack.length - ++i ) {
+      if ( execStack[ i ].s && ! ( execStackReady = execStack[ i ].r ) ) {
+        // As soon as we encounter a script that isn't ready, stop looking for more
+        break;
+      }
+    }
+
+    // If we've set the stack as ready in the loop, make it happen here
+    execStackReady && executeStack();
+
+  }
+
+  // Takes a preloaded js obj (changes in different browsers) and injects it into the head
+  // in the appropriate order
+  function injectJs ( oldObj ) {
+    var script = doc.createElement( 'script' ),
+        done;
+
+    script.src = oldObj.s;
+
+    // Bind to load events
+    script.onreadystatechange = script.onload = function () {
+
+      if ( ! done && isFileReady( script.readyState ) ) {
+
+        // Set done to prevent this function from being called twice.
+        done = 1;
+        execWhenReady();
+
+        // Handle memory leak in IE
+        script.onload = script.onreadystatechange = null;
+      }
+    };
+
+    // 404 Fallback
+    sTimeout( function () {
+      if ( ! done ) {
+        done = 1;
+        execWhenReady();
+      }
+    }, yepnope.errorTimeout );
+
+    // Inject script into to document
+    // or immediately callback if we know there
+    // was previously a timeout error
+    oldObj.e ? script.onload() : firstScript.parentNode.insertBefore( script, firstScript );
+  }
+
+  // Takes a preloaded css obj (changes in different browsers) and injects it into the head
+  // in the appropriate order
+  // Many credits to John Hann (@unscriptable) for a lot of the ideas here - found in the css! plugin for RequireJS
+  function injectCss ( oldObj ) {
+
+    // Create stylesheet link
+    var link = doc.createElement( 'link' ),
+        done;
+
+    // Add attributes
+    link.href = oldObj.s;
+    link.rel  = 'stylesheet';
+    link.type = 'text/css';
+
+    // Poll for changes in webkit and gecko
+    if ( ! oldObj.e && ( isWebkit || isGecko ) ) {
+      // A self executing function with a sTimeout poll to call itself
+      // again until the css file is added successfully
+      var poll = function ( link ) {
+        sTimeout( function () {
+          // Don't run again if we're already done
+          if ( ! done ) {
+            try {
+              // In supporting browsers, we can see the length of the cssRules of the file go up
+              if ( link.sheet.cssRules.length ) {
+                // Then turn off the poll
+                done = 1;
+                // And execute a function to execute callbacks when all dependencies are met
+                execWhenReady();
+              }
+              // otherwise, wait another interval and try again
+              else {
+                poll( link );
+              }
+            }
+            catch ( ex ) {
+              // In the case that the browser does not support the cssRules array (cross domain)
+              // just check the error message to see if it's a security error
+              if ( ( ex.code == 1e3 ) || ( ex.message == 'security' || ex.message == 'denied' ) ) {
+                // if it's a security error, that means it loaded a cross domain file, so stop the timeout loop
+                done = 1;
+                // and execute a check to see if we can run the callback(s) immediately after this function ends
+                sTimeout( function () {
+                  execWhenReady();
+                }, 0 );
+              }
+              // otherwise, continue to poll
+              else {
+                poll( link );
+              }
+            }
+          }
+        }, 0 );
+      };
+      poll( link );
+
+    }
+    // Onload handler for IE and Opera
+    else {
+      // In browsers that allow the onload event on link tags, just use it
+      link.onload = function () {
+        if ( ! done ) {
+          // Set our flag to complete
+          done = 1;
+          // Check to see if we can call the callback
+          sTimeout( function () {
+            execWhenReady();
+          }, 0 );
+        }
+      };
+
+      // if we shouldn't inject due to error or settings, just call this right away
+      oldObj.e && link.onload();
+    }
+
+    // 404 Fallback
+    sTimeout( function () {
+      if ( ! done ) {
+        done = 1;
+        execWhenReady();
+      }
+    }, yepnope.errorTimeout );
+
+    // Inject CSS
+    // only inject if there are no errors, and we didn't set the no inject flag ( oldObj.e )
+    ! oldObj.e && firstScript.parentNode.insertBefore( link, firstScript );
+  }
+
+  function executeStack ( ) {
+    // shift an element off of the stack
+    var i   = execStack.shift();
+    started = 1;
+
+    // if a is truthy and the first item in the stack has an src
+    if ( i ) {
+      // if it's a script, inject it into the head with no type attribute
+      if ( i.t ) {
+        // Inject after a timeout so FF has time to be a jerk about it and
+        // not double load (ignore the cache)
+        sTimeout( function () {
+          i.t == 'c' ?  injectCss( i ) : injectJs( i );
+        }, 0 );
+      }
+      // Otherwise, just call the function and potentially run the stack
+      else {
+        i();
+        execWhenReady();
+      }
+    }
+    else {
+      // just reset out of recursive mode
+      started = 0;
+    }
+  }
+
+  function preloadFile ( elem, url, type, splicePoint, docElement, dontExec ) {
+
+    // Create appropriate element for browser and type
+    var preloadElem = doc.createElement( elem ),
+        done        = 0,
+        stackObject = {
+          t: type,     // type
+          s: url,      // src
+        //r: 0,        // ready
+          e : dontExec // set to true if we don't want to reinject
+        };
+
+    function onload () {
+
+      // If the script/css file is loaded
+      if ( ! done && isFileReady( preloadElem.readyState ) ) {
+
+        // Set done to prevent this function from being called twice.
+        stackObject.r = done = 1;
+
+        ! started && execWhenReady();
+
+        // Handle memory leak in IE
+        preloadElem.onload = preloadElem.onreadystatechange = null;
+        sTimeout(function(){ insBeforeObj.removeChild( preloadElem ) }, 0);
+      }
+    }
+
+    // Just set the src and the data attributes so we don't have differentiate between elem types
+    preloadElem.src = preloadElem.data = url;
+
+    // Don't let it show up visually
+    ! isGeckoLTE18 && ( preloadElem.style.display = 'none' );
+    preloadElem.width = preloadElem.height = '0';
+
+
+    // Only if we have a type to add should we set the type attribute (a real script has no type)
+    if ( elem != 'object' ) {
+      preloadElem.type = type;
+    }
+
+    // Attach handlers for all browsers
+    preloadElem.onload = preloadElem.onreadystatechange = onload;
+
+    // If it's an image
+    if ( elem == 'img' ) {
+      // Use the onerror callback as the 'completed' indicator
+      preloadElem.onerror = onload;
+    }
+    // Otherwise, if it's a script element
+    else if ( elem == 'script' ) {
+      // handle errors on script elements when we can
+      preloadElem.onerror = function () {
+        stackObject.e = stackObject.r = 1;
+        executeStack();
+      };
+    }
+
+    // inject the element into the stack depending on if it's
+    // in the middle of other scripts or not
+    execStack.splice( splicePoint, 0, stackObject );
+
+    // The only place these can't go is in the <head> element, since objects won't load in there
+    // so we have two options - insert before the head element (which is hard to assume) - or
+    // insertBefore technically takes null/undefined as a second param and it will insert the element into
+    // the parent last. We try the head, and it automatically falls back to undefined.
+    insBeforeObj.insertBefore( preloadElem, isGeckoLTE18 ? null : firstScript );
+
+    // If something fails, and onerror doesn't fire,
+    // continue after a timeout.
+    sTimeout( function () {
+      if ( ! done ) {
+        // Remove the node from the dom
+        insBeforeObj.removeChild( preloadElem );
+        // Set it to ready to move on
+        // indicate that this had a timeout error on our stack object
+        stackObject.r = stackObject.e = done = 1;
+        // Continue on
+        execWhenReady();
+      }
+    }, yepnope.errorTimeout );
+  }
+
+  function load ( resource, type, dontExec ) {
+
+    var elem  = ( type == 'c' ? strCssElem : strJsElem );
+
+    // If this method gets hit multiple times, we should flag
+    // that the execution of other threads should halt.
+    started = 0;
+
+    // We'll do 'j' for js and 'c' for css, yay for unreadable minification tactics
+    type = type || 'j';
+    if ( isString( resource ) ) {
+      // if the resource passed in here is a string, preload the file
+      preloadFile( elem, resource, type, this.i++, docElement, dontExec );
+    } else {
+      // Otherwise it's a resource object and we can splice it into the app at the current location
+      execStack.splice( this.i++, 0, resource );
+      execStack.length == 1 && executeStack();
+    }
+
+    // OMG is this jQueries? For chaining...
+    return this;
+  }
+
+  // return the yepnope object with a fresh loader attached
+  function getYepnope () {
+    var y = yepnope;
+    y.loader = {
+      load: load,
+      i : 0
+    };
+    return y;
+  }
+
+  /* End loader helper functions */
+    // Yepnope Function
+  yepnope = function ( needs ) {
+
+    var i,
+        need,
+        // start the chain as a plain instance
+        chain = this.yepnope.loader;
+
+    function satisfyPrefixes ( url ) {
+      // split all prefixes out
+      var parts   = url.split( '!' ),
+      gLen    = globalFilters.length,
+      origUrl = parts.pop(),
+      pLen    = parts.length,
+      res     = {
+        url      : origUrl,
+        // keep this one static for callback variable consistency
+        origUrl  : origUrl,
+        prefixes : parts
+      },
+      mFunc,
+      j;
+
+      // loop through prefixes
+      // if there are none, this automatically gets skipped
+      for ( j = 0; j < pLen; j++ ) {
+        mFunc = prefixes[ parts[ j ] ];
+        if ( mFunc ) {
+          res = mFunc( res );
+        }
+      }
+
+      // Go through our global filters
+      for ( j = 0; j < gLen; j++ ) {
+        res = globalFilters[ j ]( res );
+      }
+
+      // return the final url
+      return res;
+    }
+
+    function loadScriptOrStyle ( input, callback, chain, index, testResult ) {
+      // run through our set of prefixes
+      var resource     = satisfyPrefixes( input ),
+          autoCallback = resource.autoCallback;
+
+      // if no object is returned or the url is empty/0 just exit the load
+      if ( resource.bypass ) {
+        return;
+      }
+
+      // Determine callback, if any
+      if ( callback ) {
+        callback = isFunction( callback ) ? callback : callback[ input ] || callback[ index ] || callback[ ( input.split( '/' ).pop().split( '?' )[ 0 ] ) ];
+      }
+
+      // if someone is overriding all normal functionality
+      if ( resource.instead ) {
+        return resource.instead( input, callback, chain, index, testResult );
+      }
+      else {
+
+        chain.load( resource.url, ( ( resource.forceCSS || ( ! resource.forceJS && /css$/.test( resource.url ) ) ) ) ? 'c' : undef, resource.noexec );
+
+        // If we have a callback, we'll start the chain over
+        if ( isFunction( callback ) || isFunction( autoCallback ) ) {
+          // Call getJS with our current stack of things
+          chain.load( function () {
+            // Hijack yepnope and restart index counter
+            getYepnope();
+            // Call our callbacks with this set of data
+            callback && callback( resource.origUrl, testResult, index );
+            autoCallback && autoCallback( resource.origUrl, testResult, index );
+          } );
+        }
+      }
+    }
+
+    function loadFromTestObject ( testObject, chain ) {
+        var testResult = !! testObject.test,
+            group      = testResult ? testObject.yep : testObject.nope,
+            always     = testObject.load || testObject.both,
+            callback   = testObject.callback,
+            callbackKey;
+
+        // Reusable function for dealing with the different input types
+        // NOTE:: relies on closures to keep 'chain' up to date, a bit confusing, but
+        // much smaller than the functional equivalent in this case.
+        function handleGroup ( needGroup ) {
+          // If it's a string
+          if ( isString( needGroup ) ) {
+            // Just load the script of style
+            loadScriptOrStyle( needGroup, callback, chain, 0, testResult );
+          }
+          // See if we have an object. Doesn't matter if it's an array or a key/val hash
+          // Note:: order cannot be guaranteed on an key value object with multiple elements
+          // since the for-in does not preserve order. Arrays _should_ go in order though.
+          else if ( isObject( needGroup ) ) {
+            for ( callbackKey in needGroup ) {
+              // Safari 2 does not have hasOwnProperty, but not worth the bytes for a shim
+              // patch if needed. Kangax has a nice shim for it. Or just remove the check
+              // and promise not to extend the object prototype.
+              if ( needGroup.hasOwnProperty( callbackKey ) ) {
+                loadScriptOrStyle( needGroup[ callbackKey ], callback, chain, callbackKey, testResult );
+              }
+            }
+          }
+        }
+
+        // figure out what this group should do
+        handleGroup( group );
+
+        // Run our loader on the load/both group too
+        handleGroup( always );
+
+        // Fire complete callback
+        if ( testObject.complete ) {
+          chain.load( testObject.complete );
+        }
+
+    }
+
+    // Someone just decides to load a single script or css file as a string
+    if ( isString( needs ) ) {
+      loadScriptOrStyle( needs, 0, chain, 0 );
+    }
+    // Normal case is likely an array of different types of loading options
+    else if ( isArray( needs ) ) {
+      // go through the list of needs
+      for( i = 0; i < needs.length; i++ ) {
+        need = needs[ i ];
+
+        // if it's a string, just load it
+        if ( isString( need ) ) {
+          loadScriptOrStyle( need, 0, chain, 0 );
+        }
+        // if it's an array, call our function recursively
+        else if ( isArray( need ) ) {
+          yepnope( need );
+        }
+        // if it's an object, use our modernizr logic to win
+        else if ( isObject( need ) ) {
+          loadFromTestObject( need, chain );
+        }
+      }
+    }
+    // Allow a single object to be passed in
+    else if ( isObject( needs ) ) {
+      loadFromTestObject( needs, chain );
+    }
+  };
+
+  // This publicly exposed function is for allowing
+  // you to add functionality based on prefixes on the
+  // string files you add. 'css!' is a builtin prefix
+  //
+  // The arguments are the prefix (not including the !) as a string
+  // and
+  // A callback function. This function is passed a resource object
+  // that can be manipulated and then returned. (like middleware. har.)
+  //
+  // Examples of this can be seen in the officially supported ie prefix
+  yepnope.addPrefix = function ( prefix, callback ) {
+    prefixes[ prefix ] = callback;
+  };
+
+  // A filter is a global function that every resource
+  // object that passes through yepnope will see. You can
+  // of course conditionally choose to modify the resource objects
+  // or just pass them along. The filter function takes the resource
+  // object and is expected to return one.
+  //
+  // The best example of a filter is the 'autoprotocol' officially
+  // supported filter
+  yepnope.addFilter = function ( filter ) {
+    globalFilters.push( filter );
+  };
+
+  // Default error timeout to 10sec - modify to alter
+  yepnope.errorTimeout = 1e4;
+
+  // Webreflection readystate hack
+  // safe for jQuery 1.4+ ( i.e. don't use yepnope with jQuery 1.3.2 )
+  // if the readyState is null and we have a listener
+  if ( doc.readyState == null && doc.addEventListener ) {
+    // set the ready state to loading
+    doc.readyState = 'loading';
+    // call the listener
+    doc.addEventListener( 'DOMContentLoaded', handler = function () {
+      // Remove the listener
+      doc.removeEventListener( 'DOMContentLoaded', handler, 0 );
+      // Set it to ready
+      doc.readyState = 'complete';
+    }, 0 );
+  }
+
+  // Attach loader &
+  // Leak it
+  window.yepnope = getYepnope();
+
+} )( this, this.document );

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: isc_analytics
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -81,6 +81,11 @@ files:
 - lib/isc_analytics/services.rb
 - lib/isc_analytics/tags.rb
 - lib/isc_analytics.rb
+- vendor/assets/javascripts/isc_analytics/session/index.js
+- vendor/assets/javascripts/isc_analytics/session/session-0.4.js
+- vendor/assets/javascripts/isc_analytics/yepnope/css_prefix.js
+- vendor/assets/javascripts/isc_analytics/yepnope/index.js
+- vendor/assets/javascripts/isc_analytics/yepnope/yepnope.js
 - Rakefile
 - Gemfile
 - README.md