requirejs-rails-plugins 0.2.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= RequirejsPlugins
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,40 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RequirejsPlugins'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/requirejs_plugins/async.js

@@ -0,0 +1,42 @@
+/** @license
+ * RequireJS plugin for async dependency load like JSONP and Google Maps
+ * Author: Miller Medeiros
+ * Version: 0.1.1 (2011/11/17)
+ * Released under the MIT license
+ */
+define(function(){
+
+    var DEFAULT_PARAM_NAME = 'callback',
+        _uid = 0;
+
+    function injectScript(src){
+        var s, t;
+        s = document.createElement('script'); s.type = 'text/javascript'; s.async = true; s.src = src;
+        t = document.getElementsByTagName('script')[0]; t.parentNode.insertBefore(s,t);
+    }
+
+    function formatUrl(name, id){
+        var paramRegex = /!(.+)/,
+            url = name.replace(paramRegex, ''),
+            param = (paramRegex.test(name))? name.replace(/.+!/, '') : DEFAULT_PARAM_NAME;
+        url += (url.indexOf('?') < 0)? '?' : '&';
+        return url + param +'='+ id;
+    }
+
+    function uid() {
+        _uid += 1;
+        return '__async_req_'+ _uid +'__';
+    }
+
+    return{
+        load : function(name, req, onLoad, config){
+            if(config.isBuild){
+                onLoad(null); //avoid errors on the optimizer
+            }else{
+                var id = uid();
+                window[id] = onLoad; //create a global variable that stores onLoad so callback function can define new module after async load
+                injectScript(formatUrl(name, id));
+            }
+        }
+    };
+});

data/app/assets/javascripts/requirejs_plugins/domReady.js

@@ -0,0 +1,129 @@
+/**
+ * @license RequireJS domReady 2.0.1 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/domReady for details
+ */
+/*jslint */
+/*global require: false, define: false, requirejs: false,
+ window: false, clearInterval: false, document: false,
+ self: false, setInterval: false */
+
+
+define(function () {
+    'use strict';
+
+    var isTop, testDiv, scrollIntervalId,
+        isBrowser = typeof window !== "undefined" && window.document,
+        isPageLoaded = !isBrowser,
+        doc = isBrowser ? document : null,
+        readyCalls = [];
+
+    function runCallbacks(callbacks) {
+        var i;
+        for (i = 0; i < callbacks.length; i += 1) {
+            callbacks[i](doc);
+        }
+    }
+
+    function callReady() {
+        var callbacks = readyCalls;
+
+        if (isPageLoaded) {
+            //Call the DOM ready callbacks
+            if (callbacks.length) {
+                readyCalls = [];
+                runCallbacks(callbacks);
+            }
+        }
+    }
+
+    /**
+     * Sets the page as loaded.
+     */
+    function pageLoaded() {
+        if (!isPageLoaded) {
+            isPageLoaded = true;
+            if (scrollIntervalId) {
+                clearInterval(scrollIntervalId);
+            }
+
+            callReady();
+        }
+    }
+
+    if (isBrowser) {
+        if (document.addEventListener) {
+            //Standards. Hooray! Assumption here that if standards based,
+            //it knows about DOMContentLoaded.
+            document.addEventListener("DOMContentLoaded", pageLoaded, false);
+            window.addEventListener("load", pageLoaded, false);
+        } else if (window.attachEvent) {
+            window.attachEvent("onload", pageLoaded);
+
+            testDiv = document.createElement('div');
+            try {
+                isTop = window.frameElement === null;
+            } catch (e) {}
+
+            //DOMContentLoaded approximation that uses a doScroll, as found by
+            //Diego Perini: http://javascript.nwbox.com/IEContentLoaded/,
+            //but modified by other contributors, including jdalton
+            if (testDiv.doScroll && isTop && window.external) {
+                scrollIntervalId = setInterval(function () {
+                    try {
+                        testDiv.doScroll();
+                        pageLoaded();
+                    } catch (e) {}
+                }, 30);
+            }
+        }
+
+        //Check if document already complete, and if so, just trigger page load
+        //listeners. Latest webkit browsers also use "interactive", and
+        //will fire the onDOMContentLoaded before "interactive" but not after
+        //entering "interactive" or "complete". More details:
+        //http://dev.w3.org/html5/spec/the-end.html#the-end
+        //http://stackoverflow.com/questions/3665561/document-readystate-of-interactive-vs-ondomcontentloaded
+        //Hmm, this is more complicated on further use, see "firing too early"
+        //bug: https://github.com/requirejs/domReady/issues/1
+        //so removing the || document.readyState === "interactive" test.
+        //There is still a window.onload binding that should get fired if
+        //DOMContentLoaded is missed.
+        if (document.readyState === "complete") {
+            pageLoaded();
+        }
+    }
+
+    /** START OF PUBLIC API **/
+
+    /**
+     * Registers a callback for DOM ready. If DOM is already ready, the
+     * callback is called immediately.
+     * @param {Function} callback
+     */
+    function domReady(callback) {
+        if (isPageLoaded) {
+            callback(doc);
+        } else {
+            readyCalls.push(callback);
+        }
+        return domReady;
+    }
+
+    domReady.version = '2.0.1';
+
+    /**
+     * Loader Plugin API method
+     */
+    domReady.load = function (name, req, onLoad, config) {
+        if (config.isBuild) {
+            onLoad(null);
+        } else {
+            domReady(onLoad);
+        }
+    };
+
+    /** END OF PUBLIC API **/
+
+    return domReady;
+});

data/app/assets/javascripts/requirejs_plugins/font.js

@@ -0,0 +1,45 @@
+/** @license
+ * RequireJS plugin for loading web fonts using the WebFont Loader
+ * Author: Miller Medeiros
+ * Version: 0.2.0 (2011/12/06)
+ * Released under the MIT license
+ */
+define(['propertyParser'], function (propertyParser) {
+
+    var rParts = /^([^,]+),([^\|]+)\|?/;
+
+    function parseName(name) {
+        var data = {},
+            vendors = name.split('|'),
+            n = vendors.length,
+            match;
+
+        while (n--) {
+            match = rParts.exec(vendors[n]);
+            data[ match[1] ] = propertyParser.parseProperties(match[2]);
+        }
+        return data;
+    }
+
+    // API
+    return {
+
+        //example: font!google,families:[Tangerine,Cantarell,Yanone Kaffeesatz:700]
+        load : function(name, req, onLoad, config){
+            if (config.isBuild) {
+                onLoad(null); //avoid errors on the optimizer
+            } else {
+                var data = parseName(name);
+                data.active = onLoad;
+                data.inactive = function(){
+                    onLoad(false);
+                };
+                req([(document.location.protocol === 'https:'? 'https' : 'http') +'://ajax.googleapis.com/ajax/libs/webfont/1/webfont.js'], function(){
+                    WebFont.load(data);
+                });
+            }
+        }
+
+    };
+
+});

data/app/assets/javascripts/requirejs_plugins/goog.js

@@ -0,0 +1,38 @@
+/** @license
+ * RequireJS plugin for loading Google Ajax API modules thru `google.load`
+ * Author: Miller Medeiros
+ * Version: 0.2.0 (2011/12/06)
+ * Released under the MIT license
+ */
+define(['async', 'propertyParser'], function (async, propertyParser) {
+
+    var rParts = /^([^,]+)(?:,([^,]+))?(?:,(.+))?/;
+
+    function parseName(name){
+        var match = rParts.exec(name),
+            data = {
+                moduleName : match[1],
+                version : match[2] || '1'
+            };
+        data.settings = propertyParser.parseProperties(match[3]);
+        return data;
+    }
+
+    return {
+        load : function(name, req, onLoad, config){
+            if (config.isBuild) {
+                onLoad(null); //avoid errors on the optimizer
+            } else {
+                var data = parseName(name),
+                    settings = data.settings;
+
+                settings.callback = onLoad;
+
+                req(['async!'+ (document.location.protocol === 'https:'? 'https' : 'http') +'://www.google.com/jsapi'], function(){
+                    google.load(data.moduleName, data.version, settings);
+                });
+            }
+        }
+    };
+
+});

data/app/assets/javascripts/requirejs_plugins/image.js

@@ -0,0 +1,53 @@
+/** @license
+ * RequireJS Image Plugin
+ * Author: Miller Medeiros
+ * Version: 0.2.2 (2013/02/08)
+ * Released under the MIT license
+ */
+define(function(){
+
+    var CACHE_BUST_QUERY_PARAM = 'bust',
+        CACHE_BUST_FLAG = '!bust',
+        RELATIVE_FLAG = '!rel';
+
+    function noop(){}
+
+    function cacheBust(url){
+        url = url.replace(CACHE_BUST_FLAG, '');
+        url += (url.indexOf('?') < 0)? '?' : '&';
+        return url + CACHE_BUST_QUERY_PARAM +'='+ Math.round(2147483647 * Math.random());
+    }
+
+    return {
+        load : function(name, req, onLoad, config){
+            var img;
+            if(config.isBuild){
+                onLoad(null); //avoid errors on the optimizer since it can't inline image files
+            }else{
+                img = new Image();
+                img.onerror = function (err) {
+                    onLoad.error(err);
+                };
+                img.onload = function(evt){
+                    onLoad(img);
+                    try {
+                        delete img.onload; //release memory - suggested by John Hann
+                    } catch(err) {
+                        img.onload = noop; // IE7 :(
+                    }
+                };
+                if (name.indexOf(RELATIVE_FLAG) !== -1) {
+                    //load image relative to module path / baseUrl
+                    img.src = req.toUrl( name.replace(RELATIVE_FLAG, '') );
+                } else {
+                    img.src = name;
+                }
+            }
+        },
+        normalize : function (name, normalize) {
+            //used normalize to avoid caching references to a "cache busted" request
+            return (name.indexOf(CACHE_BUST_FLAG) === -1)? name : cacheBust(name);
+        }
+    };
+
+});

data/app/assets/javascripts/requirejs_plugins/json.js

@@ -0,0 +1,61 @@
+/** @license
+ * RequireJS plugin for loading JSON files
+ * - depends on Text plugin and it was HEAVILY "inspired" by it as well.
+ * Author: Miller Medeiros
+ * Version: 0.3.1 (2013/02/04)
+ * Released under the MIT license
+ */
+define(['text'], function(text){
+
+    var CACHE_BUST_QUERY_PARAM = 'bust',
+        CACHE_BUST_FLAG = '!bust',
+        jsonParse = (typeof JSON !== 'undefined' && typeof JSON.parse === 'function')? JSON.parse : function(val){
+            return eval('('+ val +')'); //quick and dirty
+        },
+        buildMap = {};
+
+    function cacheBust(url){
+        url = url.replace(CACHE_BUST_FLAG, '');
+        url += (url.indexOf('?') < 0)? '?' : '&';
+        return url + CACHE_BUST_QUERY_PARAM +'='+ Math.round(2147483647 * Math.random());
+    }
+
+    //API
+    return {
+
+        load : function(name, req, onLoad, config) {
+            if ( config.isBuild && (config.inlineJSON === false || name.indexOf(CACHE_BUST_QUERY_PARAM +'=') !== -1) ) {
+                //avoid inlining cache busted JSON or if inlineJSON:false
+                onLoad(null);
+            } else {
+                text.get(req.toUrl(name), function(data){
+                        if (config.isBuild) {
+                            buildMap[name] = data;
+                            onLoad(data);
+                        } else {
+                            onLoad(jsonParse(data));
+                        }
+                    },
+                    onLoad.error, {
+                        accept: 'application/json'
+                    }
+                );
+            }
+        },
+
+        normalize : function (name, normalize) {
+            //used normalize to avoid caching references to a "cache busted" request
+            return (name.indexOf(CACHE_BUST_FLAG) === -1)? name : cacheBust(name);
+        },
+
+        //write method based on RequireJS official text plugin by James Burke
+        //https://github.com/jrburke/requirejs/blob/master/text.js
+        write : function(pluginName, moduleName, write){
+            if(moduleName in buildMap){
+                var content = buildMap[moduleName];
+                write('define("'+ pluginName +'!'+ moduleName +'", function(){ return '+ content +';});\n');
+            }
+        }
+
+    };
+});

data/app/assets/javascripts/requirejs_plugins/nokia.js

@@ -0,0 +1,65 @@
+/**
+ * RequireJS plugin for loading Nokia Maps API features thru `nokia.Features.load`
+ * @author Bogumil Wrona
+ * @license Released under the MIT license
+ */
+
+
+/**
+ * RequireJS Plugin
+ * @param {Array} nokiaLoader module which has defined path and shim
+ * @example
+
+ require.config({
+    waitSeconds: 15,
+    paths: {
+        nokiaLoader: 'http://api.maps.nokia.com/2.2.4/jsl.js?blank=true',
+        domReady: 'requirejs_plugins/domReady',
+        nokia: 'requirejs_plugins/nokia'
+    },
+    shim: {
+        nokiaLoader: {
+            exports: 'nokia'
+        }
+    }
+});
+ require(['nokia!', 'domReady!'], function() {
+    var map = new nokia.maps.map.Display(document.getElementById('map'), {
+        center: [52.521542, 13.382178],
+        zoomLevel: 6,
+        components: [
+            new nokia.maps.map.component.Behavior(),
+            new nokia.maps.map.component.TypeSelector(),
+            new nokia.maps.map.component.DistanceMeasurement(),
+            new nokia.maps.map.component.Overview()
+        ]
+    });
+});
+ */
+define(['nokiaLoader'], function(nokia) {
+    var _uid = 0,
+        DEFAULT_MODULES = ['all'],
+        uid = function() {
+            _uid +=1;
+            return '__async_nokia_features_' + _uid + '__';
+        },
+        load = function(name, req, onLoad, config) {
+            if(config.isBuild) {
+                onLoad(null);
+            } else {
+                var id = uid(),
+                    features = ('' !== name) ? name.split(',') : DEFAULT_MODULES;
+                window[id] = onLoad;
+                nokia.Features.load(nokia.Features.getFeaturesFromMatrix(features), function() {
+                    window[id]();
+                }, function() {
+                    console && console.log && console.log('ERROR while loading nokia map api module(s)');
+                }, document, false);
+            }
+        } ;
+
+    return {
+        load: load
+    }
+
+});