port to es5 and add es6 shims for object prototypes instead

4 files changed, 68 insertions, 69 deletions

diff --git a/js/controller/AppController.js b/js/controller/AppController.js
index 17471e71e..184cf6fc5 100644
--- a/js/controller/AppController.js
+++ b/js/controller/AppController.js
@@ -9,12 +9,11 @@
  */
 app.controller('AppController',
 function (Loading, FeedResource, FolderResource) {
-
     'use strict';
 
     this.loading = Loading;
 
-    this.isFirstRun = () => {
+    this.isFirstRun = function () {
         return FeedResource.size() === 0 && FolderResource.size() === 0;
     };
 
diff --git a/js/controller/ContentController.js b/js/controller/ContentController.js
index 92d2fe585..ae265f2cf 100644
--- a/js/controller/ContentController.js
+++ b/js/controller/ContentController.js
@@ -21,23 +21,23 @@ function (Publisher, FeedResource, ItemResource, SettingsResource, data,
 
     this.isAutoPagingEnabled = true;
 
-    this.getItems = () => {
+    this.getItems = function () {
         return ItemResource.getAll();
     };
 
-    this.toggleStar = (itemId) => {
+    this.toggleStar = function (itemId) {
         ItemResource.toggleStar(itemId);
     };
 
-    this.toggleItem = (item) => {
+    this.toggleItem = function (item) {
         // TODO: unittest
         if (this.isCompactView()) {
             item.show = !item.show;
         }
     };
 
-    this.markRead = (itemId) => {
-        let item = ItemResource.get(itemId);
+    this.markRead = function (itemId) {
+        var item = ItemResource.get(itemId);
 
         if (!item.keepUnread) {
             ItemResource.markItemRead(itemId);
@@ -45,12 +45,12 @@ function (Publisher, FeedResource, ItemResource, SettingsResource, data,
         }
     };
 
-    this.getFeed = (feedId) => {
+    this.getFeed = function (feedId) {
         return FeedResource.getById(feedId);
     };
 
-    this.toggleKeepUnread = (itemId) => {
-        let item = ItemResource.get(itemId);
+    this.toggleKeepUnread = function (itemId) {
+        var item = ItemResource.get(itemId);
         if (!item.unread) {
             FeedResource.markItemOfFeedUnread(item.feedId);
             ItemResource.markItemRead(itemId, false);
@@ -59,7 +59,7 @@ function (Publisher, FeedResource, ItemResource, SettingsResource, data,
         item.keepUnread = !item.keepUnread;
     };
 
-    this.orderBy = () => {
+    this.orderBy = function () {
         if (SettingsResource.get('oldestFirst')) {
             return 'id';
         } else {
@@ -67,55 +67,55 @@ function (Publisher, FeedResource, ItemResource, SettingsResource, data,
         }
     };
 
-    this.isCompactView = () => {
+    this.isCompactView = function () {
         return SettingsResource.get('compact');
     };
 
-    this.autoPagingEnabled = () => {
+    this.autoPagingEnabled = function () {
         return this.isAutoPagingEnabled;
     };
 
-    this.markReadEnabled = () => {
+    this.markReadEnabled = function () {
         return !SettingsResource.get('preventReadOnScroll');
     };
 
-    this.scrollRead = (itemIds) => {
-        let ids = [];
-        let feedIds = [];
+    this.scrollRead = function (itemIds) {
+        var ids = [];
+        var feedIds = [];
 
-        for (let itemId of itemIds) {
-            let item = ItemResource.get(itemId);
+        itemIds.forEach(function (itemId) {
+            var item = ItemResource.get(itemId);
             if (!item.keepUnread) {
                 ids.push(itemId);
                 feedIds.push(item.feedId);
             }
-        }
+        });
 
         FeedResource.markItemsOfFeedsRead(feedIds);
         ItemResource.markItemsRead(ids);
     };
 
-    this.autoPage = () => {
+    this.autoPage = function () {
         this.isAutoPagingEnabled = false;
 
-        let type = $route.current.$$route.type;
-        let id = $routeParams.id;
+        var type = $route.current.$$route.type;
+        var id = $routeParams.id;
 
-        ItemResource.autoPage(type, id).success((data) => {
+        ItemResource.autoPage(type, id).success(function (data) {
             Publisher.publishAll(data);
 
             if (data.items.length > 0) {
                 this.isAutoPagingEnabled = true;
             }
-        }).error(() => {
+        }).error(function () {
             this.isAutoPagingEnabled = true;
         });
     };
 
-    this.getRelativeDate = (timestamp) => {
+    this.getRelativeDate = function (timestamp) {
         if (timestamp !== undefined && timestamp !== '') {
-            let languageCode = SettingsResource.get('language');
-            let date =
+            var languageCode = SettingsResource.get('language');
+            var date =
                 moment.unix(timestamp).locale(languageCode).fromNow() + '';
             return date;
         } else {
diff --git a/js/controller/NavigationController.js b/js/controller/NavigationController.js
index 24c740423..6a79b8970 100644
--- a/js/controller/NavigationController.js
+++ b/js/controller/NavigationController.js
@@ -15,69 +15,69 @@ function ($route, FEED_TYPE, FeedResource, FolderResource, ItemResource,
     this.feedError = '';
     this.folderError = '';
 
-    this.getFeeds = () => {
+    this.getFeeds = function () {
         return FeedResource.getAll();
     };
 
-    this.getFolders = () => {
+    this.getFolders = function () {
         return FolderResource.getAll();
     };
 
-    this.markFolderRead = (folderId) => {
+    this.markFolderRead = function (folderId) {
         FeedResource.markFolderRead(folderId);
 
-        for (let feed of FeedResource.getByFolderId(folderId)) {
+        FeedResource.getByFolderId(folderId).forEach(function (feed) {
             ItemResource.markFeedRead(feed.id);
-        }
+        });
     };
 
-    this.markFeedRead = (feedId) => {
+    this.markFeedRead = function (feedId) {
         ItemResource.markFeedRead(feedId);
         FeedResource.markFeedRead(feedId);
     };
 
-    this.markRead = () => {
+    this.markRead = function () {
         ItemResource.markRead();
         FeedResource.markRead();
     };
 
-    this.isShowAll = () => {
+    this.isShowAll = function () {
         return SettingsResource.get('showAll');
     };
 
-    this.getFeedsOfFolder = (folderId) => {
+    this.getFeedsOfFolder = function (folderId) {
         return FeedResource.getByFolderId(folderId);
     };
 
-    this.getUnreadCount = () => {
+    this.getUnreadCount = function () {
         return FeedResource.getUnreadCount();
     };
 
-    this.getFeedUnreadCount = (feedId) => {
+    this.getFeedUnreadCount = function (feedId) {
         return FeedResource.getById(feedId).unreadCount;
     };
 
-    this.getFolderUnreadCount= (folderId) => {
+    this.getFolderUnreadCount= function (folderId) {
         return FeedResource.getFolderUnreadCount(folderId);
     };
 
-    this.getStarredCount = () => {
+    this.getStarredCount = function () {
         return ItemResource.getStarredCount();
     };
 
-    this.toggleFolder = (folderName) => {
+    this.toggleFolder = function (folderName) {
         FolderResource.toggleOpen(folderName);
     };
 
-    this.hasFeeds = (folderId) => {
+    this.hasFeeds = function (folderId) {
         return FeedResource.getFolderUnreadCount(folderId) !== undefined;
     };
 
-    this.subFeedActive = (folderId) => {
-        let type = $route.current.$$route.type;
+    this.subFeedActive = function (folderId) {
+        var type = $route.current.$$route.type;
 
         if (type === FEED_TYPE.FEED) {
-            let feed = FeedResource.getById($route.current.params.id);
+            var feed = FeedResource.getById($route.current.params.id);
 
             if (feed.folderId === folderId) {
                 return true;
@@ -87,78 +87,78 @@ function ($route, FEED_TYPE, FeedResource, FolderResource, ItemResource,
         return false;
     };
 
-    this.isSubscriptionsActive = () => {
+    this.isSubscriptionsActive = function () {
         return $route.current &&
             $route.current.$$route.type === FEED_TYPE.SUBSCRIPTIONS;
     };
 
-    this.isStarredActive = () => {
+    this.isStarredActive = function () {
         return $route.current &&
             $route.current.$$route.type === FEED_TYPE.STARRED;
     };
 
-    this.isFolderActive = (folderId) => {
-        let currentId = parseInt($route.current.params.id, 10);
+    this.isFolderActive = function (folderId) {
+        var currentId = parseInt($route.current.params.id, 10);
         return $route.current &&
             $route.current.$$route.type === FEED_TYPE.FOLDER &&
             currentId === folderId;
     };
 
-    this.isFeedActive = (feedId) => {
-        let currentId = parseInt($route.current.params.id, 10);
+    this.isFeedActive = function (feedId) {
+        var currentId = parseInt($route.current.params.id, 10);
         return $route.current &&
             $route.current.$$route.type === FEED_TYPE.FEED &&
             currentId === feedId;
     };
 
-    this.folderNameExists = (folderName) => {
+    this.folderNameExists = function (folderName) {
         return FolderResource.get(folderName) !== undefined;
     };
 
     // TBD
-    this.isAddingFolder = () => {
+    this.isAddingFolder = function () {
         return true;
     };
 
-    this.createFolder = (folder) => {
+    this.createFolder = function (folder) {
         console.log(folder.name);
         folder.name = '';
     };
 
-    this.createFeed = (feed) => {
+    this.createFeed = function (feed) {
         this.newFolder = false;
         console.log(feed.url + feed.folder);
         feed.url = '';
     };
 
-    this.renameFeed = (feed) => {
+    this.renameFeed = function (feed) {
         feed.editing = false;
         // todo remote stuff
     };
 
-    this.renameFolder = () => {
+    this.renameFolder = function () {
         console.log('TBD');
     };
 
-    this.deleteFeed = (feed) => {
+    this.deleteFeed = function (feed) {
         feed.deleted = true;
         // todo remote stuff
     };
 
-    this.undeleteFeed = (feed) => {
+    this.undeleteFeed = function (feed) {
         feed.deleted = false;
         // todo remote stuff
     };
 
-    this.removeFeed = (feed) => {
+    this.removeFeed = function (feed) {
         console.log('remove ' + feed);
     };
 
-    this.deleteFolder = (folderName) => {
+    this.deleteFolder = function (folderName) {
         console.log(folderName);
     };
 
-    this.moveFeed = (feedId, folderId) => {
+    this.moveFeed = function (feedId, folderId) {
         console.log(feedId + folderId);
     };
 
diff --git a/js/controller/SettingsController.js b/js/controller/SettingsController.js
index 781790acc..4754b16d2 100644
--- a/js/controller/SettingsController.js
+++ b/js/controller/SettingsController.js
@@ -15,7 +15,7 @@ function ($route, SettingsResource, FeedResource) {
     this.opmlImportError = false;
     this.articleImportError = false;
 
-    let set = (key, value) => {
+    var set = function (key, value) {
         SettingsResource.set(key, value);
 
         if (['showAll', 'oldestFirst'].indexOf(key) >= 0) {
@@ -24,28 +24,28 @@ function ($route, SettingsResource, FeedResource) {
     };
 
 
-    this.toggleSetting = (key) => {
+    this.toggleSetting = function (key) {
         set(key, !this.getSetting(key));
     };
 
 
-    this.getSetting = (key) => {
+    this.getSetting = function (key) {
         return SettingsResource.get(key);
     };
 
 
-    this.feedSize = () => {
+    this.feedSize = function () {
         return FeedResource.size();
     };
 
 
     // TBD
-    this.importOpml = (content) => {
+    this.importOpml = function (content) {
         console.log(content);
     };
 
 
-    this.importArticles = (content) => {
+    this.importArticles = function (content) {
         console.log(content);
     };