sports_db 0.2.3 → 0.2.4

data/app/assets/javascripts/core/App.js

@@ -0,0 +1,256 @@
+var Application = Class.extend({
+    initialize: function() {
+
+        this.views = {};
+        this.params = {};
+        this.cache = {};
+        this.currentView = null;
+        this.clientCallbackHandlers = [];
+        this.wrapper = $('#view_wrapper');
+        this.buffer = $('#tmp');
+        this.footer = $('#footer');
+        this.client = {};
+        this.setClientParams();
+
+        // Get hash params
+        if (window.location.hash) {
+            this.params = $.serialize(location.hash.slice(1));
+        }
+
+        this.params = $.extend(window.CONFIG, this.params);
+
+        if (!this.params.clientSupportsClose) {
+            this.app_is_initializing = true;
+        }
+
+        // Start timer for game updates
+        // TODO only run this on game views
+        this.timer = new Timer($.proxy(this._fireTimerEvent, this), this.params.defaultTimer);
+        this.timer.start();
+    },
+    setClientParams: function() {
+        var q = $.deserialize( location.search.slice(1) );
+
+        $.assert(q.client, '`client` param is required.');
+        $.assert(q.version, '`version` param is required.');
+
+        this.client[q.client] = true;
+        // this.client.version_major = q.version.split('.')[0];
+        // this.client.version_minor = q.version.split('.')[1];
+
+        $('html').addClass('client_'+q.client);
+    },
+    // Fire a timer event
+    _fireTimerEvent: function() {
+        $(document.body).trigger('timerReachInterval');
+    },
+    // Call the view if the method exists
+    _onTimerReachedInterval: function() {
+        var view = this.currentView;
+        if (view && view._onTimerReachedInterval) {
+            view._onTimerReachedInterval.call(view);
+        }
+    },
+    // Register a view constructor under a specific name. If a link in the application has
+    // a parameter named "view" that points to a registered view name, then the `Application`
+    // will load that view. Optionally, you can pass in parameters, and these will be merged
+    // with any other parameters in the link that triggers view loading (parameters in the
+    // link override parameters in the registration binding). This allows you to bind the
+    // same view under different names with different parameters in order to parameterize
+    // its behavior.
+    //
+    //      @param {Object} name
+    //      @param {Object} constructor
+    //      @param {Object} params (optional)
+    registerView: function(name, constructor, params) {
+        this.views[name] = { constructor: constructor, params: (params || {}) };
+    },
+    // Stash a view, i.e. change the url to something meaningful, but do not show the
+    // view based on this URL change. This is needed in cases where the device goes to
+    // sleep, and then reloads upon awakening.
+    stashView: function(params) {
+        $.assert(!this.params.clientSupportsClose, "App should not be using Application.stashView method");
+
+        // TODO kill this method in all apps. Need client support.
+        if (!this.params.clientSupportsClose) {
+            console.log('** Application.stashView');
+            var local = {};
+            local.view = params.view;
+            if (params.filter) { local.filter = params.filter; }
+            if (params.key) { local.key = params.key; }
+            local.stash = true;
+            var url = "#" + $.serialize(local);
+
+            document.location = url;
+        }
+    },
+    // Show a view based on the supplied parameters. The only required parameter is "view"
+    // which must reference a valid view name.
+    //
+    //      @param {Object} params
+    showView: function(params) {
+        console.log('$$ Application.showView');
+        $.assert(params.view, 'No view specified (use /' + this.params.serverPath + '/#view=<viewName>)');
+
+        var binding = this.views[params.view];
+
+        $.assert(binding, params.view + ' is not a registered view name. Did you add it to views.js?');
+
+        // Merge binding parameters (from views.js) into any parameters that were supplied in the URL
+        for (var prop in binding.params) {
+            if (typeof params[prop] === 'undefined') {
+                params[prop] = binding.params[prop];
+            }
+        }
+        var view = new binding.constructor(params, this);
+        $.assert(view.create, params.view + ' does not have a create method and is not a valid view');
+
+        view.create(params);
+    },
+    // When the view is done initializing, it must call this method.
+    appendView: function(newView, cached) {
+        console.log('$$ Application.appendView');
+
+        // Save the scroll state of the old view
+        if (this.currentView) {
+            this.currentView.params.pageYOffset = window.pageYOffset;
+        }
+
+        // Re-assign this.currentView to the new view.
+        // Add it to the Application.cache.
+        this.currentView = this.cache[History.currentHash()] = newView;
+
+        // Mark the view as cached
+        if (cached) {
+            this.currentView.params.cached = true;
+            // NBA3 TODO use the param
+            $(newView.element).addClass('cached');
+        }
+
+        this.wrapper.empty().append(newView.element);
+
+        this.currentView._evaluateDataAttribute();
+
+        // Set scroll position.
+        window.scrollTo(0, (this.currentView.params.pageYOffset || 0));
+
+        // Reset metrics flag
+        this.currentView.params.hasSentMetrics = false;
+
+        // Allow the view to add behavior.
+        this.currentView.onViewChanged(this.currentView.params, this);
+
+        // Send Metrics
+        if (!this.currentView.params.skip_metrics === true) {
+            this.sendMetrics(this.currentView);
+        }
+
+        // Let plugins know about the view being appended
+        $(document.body).trigger('Application:viewAppended', [this.currentView.params]);
+
+        // Show the footer
+        if (this.footer) {
+            this.footer.show();
+        }
+
+        // Hide the loader
+        $.hideLoader();
+    },
+    sendMetrics: function(view) {
+        Client.notify({
+            'action': view.getAction(),
+            'buttons': view.getButtons(),
+            'filter': view.getFilter(),
+            'metric': view.getMetric(),
+            'refreshAd': view.shouldRefreshAd(),
+            'section': view.getSection(),
+            'title': view.getTitle()
+        });
+        view.params.hasSentMetrics = true;
+    },
+    storage: function() {
+        // Feature detect localStorage + local reference
+        var storage, fail, uid;
+
+        try {
+            uid = new Date;
+            (storage = window.localStorage).setItem(uid, uid);
+            fail = storage.getItem(uid) != uid;
+            storage.removeItem(uid);
+            fail && (storage = false);
+        } catch(e) {}
+
+        if (storage) {
+            console.log('=> localStorage is available');
+            return storage;
+        } else {
+            console.log('=> localStorage is NOT available');
+            return null;
+        }
+    },
+    // The web application is receiving a callback from the client to set a value or execute some
+    // behavior. If the view has an `onClientCallback` method, this will be executed first. It can
+    // cancel any further event handling by returning `true`. Otherwise, the application sends the
+    // event to all of the `clientCallbackHandlers` that are registered with the application, in the
+    // order they were registered.
+    //
+    //      @param {String} name
+    //      @param {Object} value
+    onClientCallback: function(name, value) {
+        var handled = false;
+        var view = this.currentView;
+        if (view && view.onClientCallback) {
+            handled = view.onClientCallback.call(view, name, value);
+        }
+        if (!handled) {
+            this.clientCallbackHandlers.forEach(function(handler) {
+                handler.call(this, name, value);
+            }, this);
+        }
+    },
+    // load a view from cache or the server when we get a hashchange event
+    _onHashChange: function(event, memo) {
+        if (!this.params.clientSupportsClose) {
+            // If the app is not initializing, and the view is stashed, do not do anything
+            if (!this.app_is_initializing && memo.stash) {
+                console.log('=> App is not initializing & a view is stashed. RETURN');
+                return;
+            }
+        }
+
+        $.assert(memo.view, 'The requested URL could not be found. { href: ' + location.href + ' }');
+
+        var view = this.cache[History.currentHash()];
+        if (view) {
+            console.log('@@ Getting view from cache.');
+            view.params.cached = true;
+            this.appendView(view, true);
+        } else {
+            console.log('@@ Creating view from scratch.');
+            this.showView(memo);
+        }
+
+        if (!this.params.clientSupportsClose) {
+            this.app_is_initializing = false;
+        }
+    },
+    // Initializes application functionality on page ready, and kicks off loading the view.
+    //
+    //     @private
+    _onReady: function() {
+        $(document.body)
+            .on('hashchange', $.proxy(Application._onHashChange, this))
+            .on('timerReachInterval', $.proxy(Application._onTimerReachedInterval, this))
+            .list_hl('tr[href]', function(e, el) {
+                History.add( $.deserialize( el.attr('href').slice(1) ) );
+            });
+    }
+});
+
+// Singleton.
+console.log('@@@@ Starting Application');
+Application = new Application();
+
+Zepto(function($) {
+    Application._onReady();
+});

data/app/assets/javascripts/core/BaseView.js

@@ -1,9 +1,10 @@
+/*global View Application unescape */
 // A basic view implementation that expects an `URL` to be passed as one of the parameters
 // to the view; it will format that `URL` using any other parameters, and use it to retrieve
 // an `HTML` fragment from the server. This is only one of many strategies that could be
 // followed to create views, of course. It also assumes that the parameters object will
 // get a title property.
-var BaseView = View.extend({
+window.BaseView = View.extend({
     // Subclasses must ensure there is an url property to the parameter object passed
     // into this superconstructor, i.e.:
     //
@@ -71,21 +72,21 @@ var BaseView = View.extend({
                     console.log('$$ BaseView.create(): Not appending autoupdate view. We are no longer on that view!');
                 } else {
                     // NBA3 only
-                    if ($.highResifyLogosForRetinaAndAndroid) {
-                        response = $.highResifyLogosForRetinaAndAndroid(response);
-                    }
+                    // if ($.highResifyLogosForRetinaAndAndroid) {
+                    //     response = $.highResifyLogosForRetinaAndAndroid(response);
+                    // }
 
                     // Get a node rather than plain HTML
                     this.element = Application.buffer.html(response).find('div').get(0);
                     Application.appendView(this);
 
                     // NBA3 only
-                    if ($.delayedLoad) {
-                        $.delayedLoad();
-                    }
+                    // if ($.delayedLoad) {
+                    //     $.delayedLoad();
+                    // }
                 }
             }, this),
-            error: function(e) {
+            error: function() {
                 $.hideLoader();
                 $.flash("A network error occurred.", Application.currentView.params, true);
                 throw new Error('An error occurred.');
@@ -112,8 +113,10 @@ var BaseView = View.extend({
             var data = JSON.parse(params);
 
             for (var key in data) {
-                // If you escape a non-string value, it is first converted to a string, which we don't want
-                this.params[key] = (typeof data[key] == "string") ? unescape(data[key]) : data[key];
+                if (data.hasOwnProperty(key)) {
+                    // If you escape a non-string value, it is first converted to a string, which we don't want
+                    this.params[key] = (typeof data[key] === "string") ? unescape(data[key]) : data[key];
+                }
             }
         }
     }

data/app/assets/javascripts/core/History.js

@@ -1,7 +1,7 @@
 // A very simple history implementation. Generates events on the `document.body` element when the
 // hash changes, and includes a parsed object of parameters or a string from the hash.
 
-var History = (function() {
+window.History = (function() {
 
     var currentHash = null;
 
@@ -40,6 +40,6 @@ var History = (function() {
         currentHash: function() {
             return getHash();
         }
-    }
+    };
 
 })();

data/app/assets/javascripts/core/Mock.js

@@ -1,7 +1,8 @@
+/*global Class Application Client MOCK_FAVES_CONFIG */
 //= require core/mock_config.js
 
 // Mock client interface
-var Mock = Class.extend({
+window.Mock = Class.extend({
     initialize: function(client) {
         this.client = client;
         window.addEventListener("load", $.proxy(this._makeToolbar, this), true);
@@ -10,12 +11,7 @@ var Mock = Class.extend({
         var toolbar = document.createElement("div");
         toolbar.id = "mock-toolbar-container";
         // CSS is set in `mock.css`
-        toolbar.innerHTML = "<div id='mock-toolbar'>\
-                                <div id='mock-left'></div>\
-                                <div id='mock-center'></div>\
-                                <div id='mock-right'></div>\
-                            </div>";
-
+        toolbar.innerHTML = "<div id=mock-toolbar><div id=mock-left></div><div id=mock-center></div><div id=mock-right></div></div>";
         document.body.insertBefore(toolbar, document.body.firstChild);
         this.toolbar = toolbar;
     }
@@ -26,7 +22,7 @@ var Mock = new Mock(Client);
 Client.makeButtons = function(str) {
     if (!str) return;
     var specs = str.split(":");
-    if (specs.length != 2) {
+    if (specs.length !== 2) {
         alert("There should be 2 segments to a buttons specification");
     } else {
         makeButtonsForSection(specs[0], "mock-left");
@@ -76,7 +72,9 @@ Client.notify = function(obj) {
     if (window.console && window.console.log) {
         var arr = [];
         for (var prop in obj) {
-            arr.push(prop + ": " + obj[prop]);
+            if (obj.hasOwnProperty(prop)) {
+                arr.push(prop + ": " + obj[prop]);
+            }
         }
         console.log("))) Client.notify({ " + arr.join(", ") + " })");
     }

data/app/assets/javascripts/core/Timer.js

@@ -1,5 +1,7 @@
+/*global Class */
+
 // Timer class for use with auto-updating of game status'.
-var Timer = Class.extend({
+window.Timer = Class.extend({
     initialize: function(func, period) {
         this.func = func;
         this.period = period;

data/app/assets/javascripts/core/View.js

@@ -1,3 +1,4 @@
+/*global Class */
 // If your view implements an initialization function, that function will be passed a parameter
 // object containing all the query parameters in the URL that triggered the view's creation, plus
 // all of those values that were assigned to the view when it was registered and bound to a name.
@@ -5,7 +6,7 @@
 // `this.params`). At the end of a view's create method, it should have inserted a dom element into
 // the body of the page. This will be assigned as the "element" property to the view by the application,
 // as it needs to be referenced outside your view class.
-var View = Class.extend({
+window.View = Class.extend({
     // This method should create (by any means desirable) a DOM element and insert it into the page.
     // Our base implementation queries for an HTML fragment from the server, but this is up to
     // your view implementation.

data/app/assets/javascripts/core/utilities.js

@@ -21,27 +21,29 @@ String.prototype.format = function(hash, translate_key) {
     translate_key = translate_key || false;
     var s = this;
     for (var key in hash) {
-        var re = new RegExp('\\{' + (key) + '\\}','gm');
-        s = s.replace(re, hash[key]);
+        if (hash.hasOwnProperty(key)) {
+            var re = new RegExp('\\{' + (key) + '\\}','gm');
+            s = s.replace(re, hash[key]);
+        }
     }
     return s;
-}
+};
 
 window.$id = function(id) {
     return document.getElementById(id);
-}
+};
 
 // Capitalize the first character of a string.
 String.prototype.capitalize = function() {
     return this.charAt(0).toUpperCase() + this.substr(1).toLowerCase();
-}
+};
 
 // zepto/querySelector, understandably, can't deal with periods in the id attr.
 String.prototype.dotToBar = function() {
     return this.replace(/\./g,"_");
 };
 
-var macrojungle = function(tmpl) {
+window.macrojungle = function(tmpl) {
     // This is kind of stupid.
     // But at least it's only written once.
     var html = $('#tmp').empty().microjungle(tmpl).html();

data/app/assets/javascripts/plugins/articles.js

@@ -0,0 +1,195 @@
+;(function($){
+
+    var getMetricPrefix = function(view) {
+        var metric = view.getMetric();
+        if (view.params.view === 'team') {
+            metric += '/News';
+        }
+        return metric;
+    };
+
+    $.articles = function(opts) {
+        var view = Application.currentView;
+        var defaults = {
+            'params': {},
+            'id': null
+        };
+        opts = $.extend(defaults, opts);
+
+        var show_article = function(params) {
+            if (params.id.substring(0) !== "#") {
+                params.id = "#"+params.id;
+            }
+
+            view.params.activeArticle = params.id;
+
+            $('.summaries,#filter,.article_wrapper,#footer,#team_heading,#team_tabs').hide();
+            $(params.id).show();
+
+            window.scrollTo(0,1);
+
+            if (Application.params.clientSupportsClose) {
+                Client.notify({
+                    'buttons': ($('.summary_link').size() < 2) ? 'Close:' : 'Close:NudgeNav',
+                    'metric': getMetricPrefix(view) + '/Detail',
+                    'refreshAd': true
+                });
+            } else {
+                // Makes the back button to work
+                Application.stashView(view.params);
+                Client.notify({
+                    "buttons": view.params.should_have_buttons,
+                    "metric": getMetricPrefix(view) + "/Detail",
+                    "title": view.getTitle(),
+                    'refreshAd': true
+                });
+            }
+
+        };
+
+        var handlers = function() {
+            $('.resizeable').resizeable();
+
+            $('.summaries').list_hl('.summary_link', function(e, el) {
+                view.params.pageYOffset = window.pageYOffset;
+                show_article({ 'id': el.attr('for') });
+            });
+
+            $('.share_btn')
+                .off('click')
+                .on('click', function(e) {
+                    var $this = $(this);
+                    var c = {
+                        'title': $this.data('title'),
+                        'summary': $this.data('summary'),
+                        'url': $this.data('url'),
+                        'platform': Application.client.ios ? 'iOS' : 'Android',
+                        'img': $this.data('fbimg'),
+                        'shortName': Application.params.shortName,
+                        'longName': Application.params.longName,
+                        'sharingUrl': Application.params.sharingUrl
+                    };
+                    var email_message_tmpl = [
+                        ['p',
+                            'I found "{title}" and thought you might be interested: '.format(c),
+                            ['a', {'href': '@SHORTENED_URL@'}, '@SHORTENED_URL@']
+                        ],
+                        ['p', '--'],
+                        ['p', 'Get more from {longName} while on the go. '.format(c),
+                            ['a', {'href': '{sharingUrl}'.format(c)}, 'Download'],
+                            ' it now.'
+                        ]
+                    ];
+                    var twitter_message = '"{title}" @SHORTENED_URL@ via {shortName}'.format(c);
+                    var email_subject = '"{title}" via {longName} for {platform}'.format(c);
+
+                    var share_params = {
+                        'action': 'share',
+                        'twitter_message': twitter_message,
+                        'facebook_name': c.title,
+                        'facebook_message': c.summary,
+                        'facebook_image': c.img,
+                        'email_subject': email_subject,
+                        'email_message': macrojungle(email_message_tmpl),
+                        'url': c.url
+                    };
+                    // Don't send these to iOS. See bug 24061.
+                    if (Application.client.android) {
+                        share_params.title = c.title;
+                        share_params.excerpt = c.summary;
+                        if (c.img) {
+                            share_params.img_url = c.img;
+                        }
+                    }
+                    Client.notify(share_params);
+                });
+        };
+        var handle_notifications = function(params) {
+            params.notifs = params.notifs || [];
+
+            // Check if this notif has been viewed before.
+            if (params.notifs[params.digest]) return;
+
+            if ($('#'+params.digest).size() > 0) {
+                Client.notify({
+                    'metric': getMetricPrefix(view) + '/Notification'
+                });
+                show_article({ 'id': params.digest });
+            } else {
+                if (Application.params.clientSupportsAlert) {
+                    Client.notify({
+                        'action': 'alert',
+                        'heading': 'An error occurred',
+                        'text': 'The requested article could not be found.'
+                    });
+                } else {
+                    alert('The requested article could not be found.');
+                }
+            }
+            // Mark that this notif has been viewed, or even though
+            // the digest was bogus, mark that it was read so
+            // the user isn't told the article doesn't exist over and over.
+            params.notifs[params.digest] = true;
+        };
+
+        // This is used with the Nudge Nav.
+        if (opts.id) {
+            show_article({ 'id': opts.id });
+        // This is the standard initialization.
+        } else {
+            $('.article_wrapper').hide();
+            $('.summaries,#filter,#footer,#team_heading,#team_tabs').show();
+
+            handlers();
+
+            if (opts.params.digest) {
+                handle_notifications(opts.params);
+            }
+            if (!Application.params.clientSupportsClose) {
+                Application.currentView.params.should_have_buttons = ($('.summary_link').size() < 2) ? "Back:" : "Back:NudgeNav";
+            }
+        }
+
+    };
+
+    // Supports nudge navigation via client application.
+    // Navigation loops.
+    $.articlesClientCallback = function(name, value) {
+        var view = Application.currentView;
+        var params = view.params;
+        var $article = $(params.activeArticle);
+
+        if (name === 'close') {
+            $('.article_wrapper').hide();
+            $('.summaries,#filter,#footer,#team_heading,#team_tabs').show();
+
+            window.scrollTo(0, view.params.pageYOffset);
+
+            Client.notify({
+                'buttons': "Back:",
+                'metric': getMetricPrefix(view),
+                'refreshAd': true
+            });
+        }
+
+        if (name === 'nudge') {
+            if (value === 'next' && $article.data('next')) {
+                $.articles({
+                    'params': params,
+                    'id': $article.data('next')
+                });
+            } else if (value === 'prev' && $article.data('prev')) {
+                $.articles({
+                    'params': params,
+                    'id': $article.data('prev')
+                });
+            } else {
+                $.articles({
+                    'params': params,
+                    'id': $('.article_wrapper').first().attr('id')
+                });
+            }
+        }
+    };
+
+})(Zepto);

data/app/assets/javascripts/plugins/assert.js

@@ -7,5 +7,5 @@
             }
             throw new Error(error);
         }
-    }
+    };
 })(Zepto);

data/app/assets/javascripts/plugins/calnav.js

@@ -1,9 +1,10 @@
+/*global Application $id */
 // Behavior for calendar (schedule) navigation.
 ;(function($){
     $.calnav = function(){
         $('.calnav .item[href]')
             .off('click')
-            .on('click', function(e) {
+            .on('click', function() {
                 Application.showView(
                     $.deserialize(this.getAttribute('href'))
                 );

data/app/assets/javascripts/plugins/collapsible.js

@@ -1,3 +1,4 @@
+/*global Application */
 ;(function($){
     $.fn.collapsible = function() {