Default containers

.gitignore

@@ -11,3 +11,6 @@ containerise.iml
 # build
 build
 web-ext-artifacts
+
+# Other
+/profile

package.json

@@ -12,6 +12,7 @@
     "build": "npm audit && npm run lint && npm run test && webpack --config ./webpack.prod",
     "postbuild": "cp -a static/ build/ && web-ext build -s build/",
     "web-ext": "web-ext run -s build/ --start-url=about:debugging#addons",
+    "web-ext-perm": "mkdirp ./profile && web-ext run -s build/ --start-url=about:debugging#addons -p ./profile --keep-profile-changes",
     "lint": "eslint --ignore-path .gitignore ./",
     "test": "jest",
     "test:watch": "jest --watchAll"
@@ -28,6 +29,7 @@
     "jest": "^24.8.0",
     "mini-css-extract-plugin": "^0.8.0",
     "node-sass": "^4.12.0",
+    "raw-loader": "^3.1.0",
     "rimraf": "^3.0.0",
     "sass-loader": "^8.0.0",
     "style-loader": "^1.0.0",

src/ContextualIdentity/__tests__/ContextualIdentity.spec.js

@@ -35,6 +35,9 @@ describe('ContextualIdentities', () => {
           addListener: jest.fn(() => {}),
         },
       },
+      storage: {
+        local: {},
+      },
     };
 
     ContextualIdentities = require('../index').default;
@@ -55,7 +58,7 @@ describe('ContextualIdentities', () => {
         iconUrl: 'resource://usercontext-content/circle.svg',
         color: 'grey',
         colorCode: '#999',
-        cookieStoreId: 'no-container',
+        cookieStoreId: 'firefox-default',
       }]);
     });
   });

src/ContextualIdentity/index.js

@@ -1,16 +1,65 @@
+import HostStorage from '../Storage/HostStorage';
+import PreferenceStorage from '../Storage/PreferenceStorage';
+
 export const NO_CONTAINER = {
   name: 'No Container',
   icon: 'circle',
   iconUrl: 'resource://usercontext-content/circle.svg',
   color: 'grey',
   colorCode: '#999',
-  cookieStoreId: 'no-container',
+  cookieStoreId: 'firefox-default',
 };
+export const COLORS = [
+  'blue',
+  'green',
+  'orange',
+  'pink',
+  'purple',
+  'red',
+  'turquoise',
+  'yellow',
+];
 
 class ContextualIdentities {
 
   constructor() {
     this.contextualIdentities = browser.contextualIdentities;
+    this.addOnRemoveListener((changeInfo) => {
+      const cookieStoreId = changeInfo.contextualIdentity.cookieStoreId;
+      this.cleanPreferences(cookieStoreId);
+      this.cleanMaps(cookieStoreId);
+    });
+  }
+
+  create(name) {
+    return this.contextualIdentities.create({
+      name: name,
+      color: COLORS[Math.floor(Math.random() * COLORS.length)],
+      icon: 'circle',
+    });
+  }
+
+  /**
+   * Gets rid of a container and all corresponding rules
+   */
+  async remove(cookieStoreId) {
+    if (cookieStoreId === NO_CONTAINER.cookieStoreId) {
+      return;
+    }
+    return this.contextualIdentities.remove(cookieStoreId);
+  }
+
+  async cleanMaps(cookieStoreId) {
+    const hostMaps = await HostStorage.getAll();
+    return HostStorage.remove(Object.keys(hostMaps)
+        .filter(host => hostMaps[host].cookieStoreId === cookieStoreId)
+    );
+  }
+  async cleanPreferences(cookieStoreId) {
+    const preferences = await PreferenceStorage.getAll();
+    return PreferenceStorage.remove(Object.keys(preferences)
+        .filter(prefName => prefName.startsWith(`containers.${cookieStoreId}`))
+    );
   }
 
   getAll(details = {}) {
@@ -19,7 +68,7 @@ class ContextualIdentities {
 
   get(name) {
     if (name === NO_CONTAINER.name) {
-      return Promise.resolve(NO_CONTAINER);
+      return Promise.resolve([NO_CONTAINER]);
     }
     return this.contextualIdentities.query({name});
   }

src/ExtendedURL/__tests__/ExtendURL.spec.js

@@ -0,0 +1,12 @@
+describe('utils', () => {
+
+  const ExtendedURL = require('../index').default;
+
+  it('should have domain', function () {
+    const eUrl = new ExtendedURL('https://gist.github.com');
+    expect(eUrl.domain).toEqual('github');
+    expect(eUrl.tld).toEqual('com');
+  });
+
+
+});

src/ExtendedURL/index.js

@@ -0,0 +1,12 @@
+export default class ExtendedURL extends URL {
+  constructor(url) {
+    super(url);
+    const split = this.hostname.split('.');
+    this.tld = split[split.length - 1];
+    if (split.length > 1) {
+      this.domain = split[split.length - 2];
+    } else {
+      this.domain = this.tld;
+    }
+  }
+}

src/Storage/PreferenceStorage.js

@@ -6,6 +6,23 @@ class PreferenceStorage extends PrefixStorage {
     this.PREFIX = 'pref=';
   }
 
+  async getAll(valuesOnly = false) {
+    let preferences = await super.getAll();
+    if (valuesOnly) {
+      for (let preferenceKey in preferences) {
+        preferences[preferenceKey] = preferences[preferenceKey].value;
+      }
+    }
+    return preferences;
+  }
+
+  async get(key, valueOnly = false) {
+    let preference = await super.get(key);
+    if (valueOnly && preference !== undefined) {
+      preference = preference.value;
+    }
+    return preference;
+  }
 }
 
 export default new PreferenceStorage();

src/__tests__/utils.spec.js

@@ -0,0 +1,66 @@
+describe('utils', () => {
+
+  const utils = require('../utils');
+
+  describe('formatString', () => {
+    it('should return same string without variables', function () {
+      const string = 'Farouq Nadeeb';
+      expect(utils.formatString(string, {}))
+          .toEqual(string);
+    });
+
+    it('should replace alphanumeric variables', function () {
+      const name = 'Farouq';
+      const lastName = 'Nadeeb';
+      expect(utils.formatString('{name} {lastName}', {
+        name, lastName,
+      })).toEqual(`${name} ${lastName}`);
+    });
+
+    it('should replace kebab-case variables', function () {
+      const name = 'Farouq';
+      const lastName = 'Nadeeb';
+      expect(utils.formatString('{name} {last-name}', {
+        name, ['last-name']: lastName,
+      })).toEqual(`${name} ${lastName}`);
+    });
+
+    it('should throw on non-existent variables', function () {
+      const name = 'Farouq';
+      const lastName = 'Nadeeb';
+      expect(() => {
+        utils.formatString('{name} {lastName} - born {dob}', {
+          name, lastName,
+        });
+      }).toThrow('Cannot find variable \'dob\' in context');
+    });
+
+  });
+
+  describe('filterByKey', () => {
+    it('should create object with keys that don\'t start with a string', function () {
+      expect(utils.filterByKey({
+        removeThis: 'lol',
+        removeThat: 'rofl',
+        removeAnother: 'do eet!',
+        keepMe: 'kept',
+        keepThem: 'kept',
+      }, (key) => !key.startsWith('remove')))
+          .toEqual({
+            keepMe: 'kept',
+            keepThem: 'kept',
+          });
+    });
+
+    it('should fail without a filter function', function () {
+      expect(() => {
+        utils.filterByKey({
+          a: true,
+          b: true,
+        });
+      }).toThrow('undefined is not a function');
+    });
+
+  });
+
+});

src/containers.js

@@ -2,6 +2,16 @@ import Storage from './Storage/HostStorage';
 import ContextualIdentity, {NO_CONTAINER} from './ContextualIdentity';
 import Tabs from './Tabs';
 import PreferenceStorage from './Storage/PreferenceStorage';
+import {filterByKey} from './utils';
+import {buildDefaultContainer} from './defaultContainer';
+
+const IGNORED_URLS_REGEX = /^(about|moz-extension):/;
+
+/**
+ * Keep track of the tabs we're creating
+ * tabId: url
+ */
+const creatingTabs = {};
 
 const createTab = (url, newTabIndex, currentTabId, openerTabId, cookieStoreId) => {
   Tabs.get(currentTabId).then((currentTab) => {
@@ -17,6 +27,7 @@ const createTab = (url, newTabIndex, currentTabId, openerTabId, cookieStoreId) =
       createOptions.openerTabId = openerTabId;
     }
     Tabs.create(createOptions).then((createdTab) => {
+      creatingTabs[createdTab.id] = url;
       if (!cookieStoreId && openerTabId) {
         Tabs.update(createdTab.id, {
           openerTabId: openerTabId,
@@ -38,35 +49,65 @@ const createTab = (url, newTabIndex, currentTabId, openerTabId, cookieStoreId) =
   };
 };
 
-function handle(url, tabId) {
-  return Promise.all([
+
+async function handle(url, tabId) {
+  const creatingUrl = creatingTabs[tabId];
+  if (IGNORED_URLS_REGEX.test(url) || creatingUrl === url) {
+    return;
+  } else if (creatingUrl) {
+    delete creatingTabs[tabId];
+  }
+
+  let [hostMap, preferences, identities, currentTab] = await Promise.all([
     Storage.get(url),
+    PreferenceStorage.getAll(true),
     ContextualIdentity.getAll(),
     Tabs.get(tabId),
-  ]).then(([hostMap, identities, currentTab]) => {
+  ]);
 
-    if (currentTab.incognito || !hostMap) {
-      return {};
-    }
+  if (currentTab.incognito || !hostMap) {
+    return {};
+  }
 
-    const hostIdentity = identities.find((identity) => identity.cookieStoreId === hostMap.cookieStoreId);
-    const tabIdentity = identities.find((identity) => identity.cookieStoreId === currentTab.cookieStoreId);
+  const hostIdentity = identities.find((identity) => identity.cookieStoreId === hostMap.cookieStoreId);
+  const tabIdentity = identities.find((identity) => identity.cookieStoreId === currentTab.cookieStoreId);
 
-    if (!hostIdentity) {
-      return {};
+  if (!hostIdentity) {
+    if (preferences.defaultContainer) {
+      const defaultContainer = await buildDefaultContainer(
+          filterByKey(preferences, prefKey => prefKey.startsWith('defaultContainer')),
+          url
+      );
+      const defaultCookieStoreId = defaultContainer.cookieStoreId;
+      const defaultIsNoContainer = defaultCookieStoreId === NO_CONTAINER.cookieStoreId;
+      const tabHasContainer = currentTab.cookieStoreId !== NO_CONTAINER.cookieStoreId;
+      const tabInDifferentContainer = currentTab.cookieStoreId !== defaultCookieStoreId;
+      const openInNoContainer = defaultIsNoContainer && tabHasContainer;
+      if ((tabInDifferentContainer && !openInNoContainer) || openInNoContainer) {
+        console.debug('Opening', url, 'in default container', defaultCookieStoreId, defaultContainer.name);
+        return createTab(
+            url,
+            currentTab.index + 1, currentTab.id,
+            currentTab.openerTabId,
+            defaultCookieStoreId);
+      }
     }
+    return {};
 
-    const openerTabId = currentTab.openerTabId;
-    if (hostIdentity.cookieStoreId === NO_CONTAINER.cookieStoreId && tabIdentity) {
-      return createTab(url, currentTab.index + 1, currentTab.id, openerTabId);
-    }
+  }
 
-    if (hostIdentity.cookieStoreId !== currentTab.cookieStoreId && hostIdentity.cookieStoreId !== NO_CONTAINER.cookieStoreId) {
-      return createTab(url, currentTab.index + 1, currentTab.id, openerTabId, hostIdentity.cookieStoreId);
-    }
+  const openerTabId = currentTab.openerTabId;
+  if (hostIdentity.cookieStoreId === NO_CONTAINER.cookieStoreId && tabIdentity) {
+    return createTab(url, currentTab.index + 1, currentTab.id, openerTabId);
+  }
+
+  if (hostIdentity.cookieStoreId !== currentTab.cookieStoreId && hostIdentity.cookieStoreId !== NO_CONTAINER.cookieStoreId) {
+    return createTab(url, currentTab.index + 1, currentTab.id, openerTabId, hostIdentity.cookieStoreId);
+  }
+
+
+  return {};
 
-    return {};
-  });
 }
 
 export const webRequestListener = (requestDetails) => {
@@ -81,6 +122,5 @@ export const tabUpdatedListener = (tabId, changeInfo) => {
   if (!changeInfo.url) {
     return;
   }
-  console.log(tabId, 'url changed', changeInfo.url);
   return handle(changeInfo.url, tabId);
 };