logster 2.11.4 → 2.12.2

data/client-app/app/components/patterns-list.js

@@ -1,125 +1,142 @@
+import classic from "ember-classic-decorator";
+import { equal, not } from "@ember/object/computed";
 import Component from "@ember/component";
-import { not, equal } from "@ember/object/computed";
-import { computed } from "@ember/object";
+import { action, computed } from "@ember/object";
 import Pattern from "client-app/models/pattern-item";
 import { ajax } from "client-app/lib/utilities";
 
-export default Component.extend({
-  immutable: not("mutable"),
-  showCounter: equal("key", "suppression"),
+@classic
+export default class PatternsList extends Component {
+  @not("mutable") immutable;
+  @equal("key", "suppression") showCounter;
 
   init() {
-    this._super(...arguments);
-    if (this.get("patterns.length") < 1 && this.get("mutable")) {
-      this.send("create");
+    super.init(...arguments);
+
+    if (this.patterns.length < 1 && this.mutable) {
+      this.create();
     }
-  },
+  }
 
-  allPatterns: computed("patterns.[]", "newPatterns.[]", function() {
-    const patterns = this.get("patterns");
-    const newPatterns = this.get("newPatterns") || [];
+  @computed("patterns.[]", "newPatterns.[]")
+  get allPatterns() {
+    const patterns = this.patterns;
+    const newPatterns = this.newPatterns || [];
     return [...newPatterns.reverse(), ...patterns.reverse()];
-  }),
+  }
 
   makeAPICall(data = {}) {
     const { method } = data;
     delete data.method;
 
-    return ajax(`/patterns/${this.get("key")}.json`, { method, data });
-  },
+    return ajax(`/patterns/${this.key}.json`, { method, data });
+  }
 
   finallyBlock(pattern) {
     pattern.set("saving", false);
-  },
+  }
 
   catchBlock(pattern, response) {
     if (response.responseText) {
       pattern.set("error", response.responseText);
     } else {
-      pattern.set("error", "Unkown error occured. Please see dev console.");
+      pattern.set("error", "Unknown error occurred. Please see dev console.");
     }
-  },
+  }
 
   requestInit(pattern) {
     pattern.setProperties({
       saving: true,
-      error: null
+      error: null,
     });
-  },
+  }
 
-  actions: {
-    create() {
-      if (!this.get("newPatterns")) {
-        this.set("newPatterns", []);
-      }
-      this.get("newPatterns").pushObject(Pattern.create({ isNew: true }));
-    },
+  @action
+  create() {
+    if (!this.newPatterns) {
+      this.set("newPatterns", []);
+    }
+    this.newPatterns.pushObject(Pattern.create({ isNew: true }));
+  }
 
-    trash(pattern) {
-      if (pattern.get("isNew")) {
-        this.get("newPatterns").removeObject(pattern);
-        pattern.destroy();
-      } else {
-        this.requestInit(pattern);
-        this.makeAPICall({
-          method: "DELETE",
-          pattern: pattern.get("value")
-        })
-          .then(() => {
-            this.get("patterns").removeObject(pattern);
-            pattern.destroy();
-          })
-          .catch(response => this.catchBlock(pattern, response))
-          .finally(() => this.finallyBlock(pattern));
-      }
-    },
+  @action
+  async trash(pattern) {
+    if (pattern.isNew) {
+      this.newPatterns.removeObject(pattern);
+      pattern.destroy();
+      return;
+    }
+
+    this.requestInit(pattern);
 
-    save(pattern) {
-      this.requestInit(pattern);
-      let promise;
-      if (pattern.get("isNew")) {
-        promise = this.makeAPICall({
+    try {
+      await this.makeAPICall({
+        method: "DELETE",
+        pattern: pattern.value,
+      });
+
+      this.patterns.removeObject(pattern);
+      pattern.destroy();
+    } catch (response) {
+      this.catchBlock(pattern, response);
+    } finally {
+      this.finallyBlock(pattern);
+    }
+  }
+
+  @action
+  async save(pattern) {
+    this.requestInit(pattern);
+
+    try {
+      if (pattern.isNew) {
+        const response = await this.makeAPICall({
           method: "POST",
           pattern: pattern.valueBuffer,
-          retroactive: !!pattern.retroactive
-        }).then(response => {
-          pattern.updateValue(response.pattern);
-          pattern.set("isNew", false);
-          this.get("patterns").pushObject(pattern);
-          this.get("newPatterns").removeObject(pattern);
+          retroactive: !!pattern.retroactive,
         });
+
+        pattern.updateValue(response.pattern);
+        pattern.set("isNew", false);
+        this.patterns.pushObject(pattern);
+        this.newPatterns.removeObject(pattern);
       } else {
-        promise = this.makeAPICall({
+        const response = await this.makeAPICall({
           method: "PUT",
-          pattern: pattern.get("value"),
-          new_pattern: pattern.get("valueBuffer")
-        }).then(response => {
-          pattern.updateValue(response.pattern);
-          pattern.set("count", 0);
+          pattern: pattern.value,
+          new_pattern: pattern.valueBuffer,
         });
+
+        pattern.updateValue(response.pattern);
+        pattern.set("count", 0);
       }
-      promise
-        .catch(response => {
-          this.catchBlock(pattern, response);
-        })
-        .finally(() => this.finallyBlock(pattern));
-    },
-
-    resetCount(pattern) {
-      pattern.set("saving", true);
-      ajax("/reset-count.json", {
+    } catch (response) {
+      this.catchBlock(pattern, response);
+    } finally {
+      this.finallyBlock(pattern);
+    }
+  }
+
+  @action
+  async resetCount(pattern) {
+    pattern.set("saving", true);
+
+    try {
+      await ajax("/reset-count.json", {
         method: "PUT",
-        data: { pattern: pattern.get("value"), hard: !!pattern.get("hard") }
-      })
-        .then(() => {
-          pattern.set("count", 0);
-        })
-        .catch(response => this.catchBlock(pattern, response))
-        .finally(() => this.finallyBlock(pattern));
-    },
-
-    checkboxChanged(pattern) {
-      pattern.toggleProperty("retroactive");
+        data: { pattern: pattern.value, hard: !!pattern.hard },
+      });
+
+      pattern.set("count", 0);
+    } catch (response) {
+      this.catchBlock(pattern, response);
+    } finally {
+      this.finallyBlock(pattern);
     }
   }
-});
+
+  @action
+  checkboxChanged(pattern) {
+    pattern.toggleProperty("retroactive");
+  }
+}

data/client-app/app/components/tab-contents.js

@@ -1,27 +1,23 @@
+import classic from "ember-classic-decorator";
+import { classNameBindings } from "@ember-decorators/component";
 import Component from "@ember/component";
 
-export default Component.extend({
-  classNameBindings: ["active", ":content", "name"],
-  isLink: false,
-
-  invokeParent(name) {
-    let current = this.get("parentView");
-    while (current && !current[name]) {
-      current = current.get("parentView");
-    }
-    if (current) {
-      current[name](this);
-    }
-  },
+@classic
+@classNameBindings("active", ":content", "name")
+export default class TabContents extends Component {
+  isLink = false;
 
   didInsertElement() {
-    this.invokeParent("addTab");
-    if (this.get("defaultTab")) {
-      this.invokeParent("selectTab");
+    super.didInsertElement(...arguments);
+    this.tabActions.addTab(this);
+
+    if (this.defaultTab) {
+      this.tabActions.selectTab(this);
     }
-  },
+  }
 
   willDestroyElement() {
-    this.invokeParent("removeTab");
+    super.willDestroyElement(...arguments);
+    this.tabActions.removeTab(this);
   }
-});
+}

data/client-app/app/components/tabbed-section.js

@@ -1,33 +1,45 @@
+import classic from "ember-classic-decorator";
 import Component from "@ember/component";
+import { A } from "@ember/array";
+import { action } from "@ember/object";
 
-export default Component.extend({
-  tabs: Em.A(),
-  selectTab(view) {
-    if (view.get("isLink")) {
-      this.triggerAction(view.get("action"));
+@classic
+export default class TabbedSection extends Component {
+  tabs = A();
+  selected = null;
+
+  @action
+  selectTab(tab) {
+    if (tab.isLink) {
+      this.triggerAction(tab.action);
       return;
     }
 
-    const selected = this.get("selected");
-    if (selected) {
-      selected.set("active", false);
+    if (this.selected) {
+      this.selected.set("active", false);
     }
-    this.set("selected", view);
-    view.set("active", true);
-    this.onTabChange(view.name);
-  },
 
+    this.set("selected", tab);
+    tab.set("active", true);
+
+    this.onTabChange(tab.name);
+  }
+
+  @action
   addTab(tab) {
-    this.get("tabs").addObject(tab);
-    if (!this.get("selected") && !tab.get("isLink")) {
+    this.tabs.addObject(tab);
+
+    if (!this.selected && !tab.isLink) {
       this.selectTab(tab);
     }
-  },
+  }
 
+  @action
   removeTab(tab) {
-    if (this.get("selected") === tab) {
+    if (this.selected === tab) {
       this.set("selected", null);
     }
-    this.get("tabs").removeObject(tab);
+
+    this.tabs.removeObject(tab);
   }
-});
+}

data/client-app/app/components/time-formatter.js

@@ -1,25 +1,36 @@
+import classic from "ember-classic-decorator";
+import { tagName } from "@ember-decorators/component";
+import { computed } from "@ember/object";
 import Component from "@ember/component";
 import { formatTime } from "client-app/lib/utilities";
-import { computed } from "@ember/object";
+import { later } from "@ember/runloop";
+
+const UPDATE_INTERVAL = 60_000;
 
-export default Component.extend({
-  tagName: "span",
-  classNames: "auto-update-time",
-  attributeBindings: ["dataTimestamp:data-timestamp", "title"],
+@classic
+@tagName("")
+export default class TimeFormatter extends Component {
+  didInsertElement() {
+    super.didInsertElement(...arguments);
+    later(this, this.updateTime, UPDATE_INTERVAL);
+  }
 
-  title: computed(function() {
-    return this.get("moment").format();
-  }),
+  @computed("timestamp")
+  get title() {
+    return moment(this.timestamp).format();
+  }
 
-  dataTimestamp: computed(function() {
-    return this.get("timestamp");
-  }),
+  @computed("timestamp")
+  get time() {
+    return formatTime(this.timestamp);
+  }
 
-  moment: computed(function() {
-    return moment(this.get("timestamp"));
-  }),
+  updateTime() {
+    if (this.isDestroying || this.isDestroyed) {
+      return;
+    }
 
-  time: computed("timestamp", function() {
-    return formatTime(this.get("timestamp"));
-  })
-});
+    this.notifyPropertyChange("timestamp");
+    later(this, this.updateTime, UPDATE_INTERVAL);
+  }
+}

data/client-app/app/controllers/index.js

@@ -1,141 +1,165 @@
+import classic from "ember-classic-decorator";
 import { debounce } from "@ember/runloop";
-import { computed } from "@ember/object";
+import { action, computed } from "@ember/object";
 import Controller from "@ember/controller";
-import { ajax, getLocalStorage, setLocalStorage } from "client-app/lib/utilities";
+import {
+  ajax,
+  getLocalStorage,
+  setLocalStorage,
+} from "client-app/lib/utilities";
 import Preload from "client-app/lib/preload";
 
-export default Controller.extend({
-  showDebug: getLocalStorage("showDebug", false),
-  showInfo: getLocalStorage("showInfo", false),
-  showWarn: getLocalStorage("showWarn", true),
-  showErr: getLocalStorage("showErr", true),
-  showFatal: getLocalStorage("showFatal", true),
-  search: null,
-  queryParams: ["search"],
-
-  showSettings: computed(function() {
+@classic
+export default class IndexController extends Controller {
+  showDebug = getLocalStorage("showDebug", false);
+  showInfo = getLocalStorage("showInfo", false);
+  showWarn = getLocalStorage("showWarn", true);
+  showErr = getLocalStorage("showErr", true);
+  showFatal = getLocalStorage("showFatal", true);
+  search = null;
+  queryParams = ["search"];
+
+  @computed
+  get showSettings() {
     return Preload.get("patterns_enabled");
-  }),
+  }
+
+  get actionsInMenu() {
+    return (
+      /mobile/i.test(navigator.userAgent) && !/iPad/.test(navigator.userAgent)
+    );
+  }
+
+  @computed("search")
+  get searchTerm() {
+    if (this.search) {
+      this.doSearch(this.search);
+      return this.search;
+    }
+    return null;
+  }
+
+  async doSearch(term) {
+    this.model.set("search", term);
+    await this.model.reload();
+    this.model.updateSelectedRow();
+  }
 
   resizePanels(amount) {
     const bottomPanel = document.getElementById("bottom-panel");
     const topPanel = document.getElementById("top-panel");
     bottomPanel.style.height = `${amount - 13}px`;
     topPanel.style.bottom = `${amount + 12}px`;
-  },
-
-  actionsInMenu: computed(function() {
-    return this.site.isMobile;
-  }),
-
-  actions: {
-    expandMessage(message) {
-      message.expand();
-    },
-
-    selectRowAction(row, opts = {}) {
-      this.model.selectRow(row, opts);
-    },
-
-    tabChangedAction(newTab) {
-      this.model.tabChanged(newTab);
-    },
-
-    showMoreBefore() {
-      this.model.showMoreBefore();
-    },
-
-    loadMore() {
-      return this.model.loadMore();
-    },
-
-    clear() {
-      if (confirm("Clear the logs?\n\nCancel = No, OK = Clear")) {
-        ajax("/clear", { type: "POST" }).then(() => {
-          this.model.reload();
-        });
-      }
-    },
-
-    removeMessage(msg) {
-      const group = this.model.currentRow.group ? this.model.currentRow : null;
-      const rows = this.model.rows;
-      const idx = group ? rows.indexOf(group) : rows.indexOf(msg);
-
-      msg.destroy();
-      msg.set("selected", false);
-      this.model.set("total", this.model.total - 1);
-      let removedRow = false;
-      let messageIndex = 0;
-
-      if (group) {
-        messageIndex = group.messages.indexOf(msg);
-        group.messages.removeObject(msg);
-        messageIndex = Math.min(messageIndex, group.messages.length - 1);
-        if (group.messages.length === 0) {
-          rows.removeObject(group);
-          removedRow = true;
-        }
-      } else {
-        rows.removeObject(msg);
+  }
+
+  @action
+  expandMessage(message) {
+    message.expand();
+  }
+
+  @action
+  selectRowAction(row, opts = {}) {
+    this.model.selectRow(row, opts);
+  }
+
+  @action
+  tabChangedAction(newTab) {
+    this.model.tabChanged(newTab);
+  }
+
+  @action
+  showMoreBefore() {
+    this.model.showMoreBefore();
+  }
+
+  @action
+  loadMore() {
+    return this.model.loadMore();
+  }
+
+  @action
+  async clear() {
+    // eslint-disable-next-line no-alert
+    if (confirm("Clear the logs?\n\nCancel = No, OK = Clear")) {
+      await ajax("/clear", { type: "POST" });
+      this.model.reload();
+    }
+  }
+
+  @action
+  removeMessage(msg) {
+    const group = this.model.currentRow.group ? this.model.currentRow : null;
+    const rows = this.model.rows;
+    const idx = group ? rows.indexOf(group) : rows.indexOf(msg);
+
+    msg.destroy();
+    msg.set("selected", false);
+    this.model.set("total", this.model.total - 1);
+    let removedRow = false;
+    let messageIndex = 0;
+
+    if (group) {
+      messageIndex = group.messages.indexOf(msg);
+      group.messages.removeObject(msg);
+      messageIndex = Math.min(messageIndex, group.messages.length - 1);
+      if (group.messages.length === 0) {
+        rows.removeObject(group);
         removedRow = true;
       }
+    } else {
+      rows.removeObject(msg);
+      removedRow = true;
+    }
 
-      if (removedRow) {
-        if (idx > 0) {
-          this.model.selectRow(rows[idx - 1]);
-        } else if (this.model.total > 0) {
-          this.model.selectRow(rows[0]);
-        } else {
-          this.model.reload();
-        }
-      } else if (group) {
-        this.model.selectRow(rows[idx], { messageIndex });
-      }
-    },
-
-    solveMessage(msg) {
-      this.model.solve(msg);
-    },
-
-    groupedMessageChangedAction(newPosition) {
-      this.model.groupedMessageChanged(newPosition);
-    },
-
-    envChangedAction(newPosition) {
-      this.model.envChanged(newPosition);
-    },
-
-    updateFilter(name) {
-      this.toggleProperty(name);
-      this.model.set(name, this[name]);
-      setLocalStorage(name, this[name]);
-      this.model.reload().then(() => this.model.updateSelectedRow());
-    },
-
-    updateSearch(term) {
-      if (term === this.search) {
-        return;
+    if (removedRow) {
+      if (idx > 0) {
+        this.model.selectRow(rows[idx - 1]);
+      } else if (this.model.total > 0) {
+        this.model.selectRow(rows[0]);
+      } else {
+        this.model.reload();
       }
+    } else if (group) {
+      this.model.selectRow(rows[idx], { messageIndex });
+    }
+  }
 
-      if (term && term.length === 1) {
-        return;
-      }
+  @action
+  solveMessage(msg) {
+    this.model.solve(msg);
+  }
+
+  @action
+  groupedMessageChangedAction(newPosition) {
+    this.model.groupedMessageChanged(newPosition);
+  }
+
+  @action
+  envChangedAction(newPosition) {
+    this.model.envChanged(newPosition);
+  }
+
+  @action
+  async updateFilter(name) {
+    this.toggleProperty(name);
+    this.model.set(name, this[name]);
+    setLocalStorage(name, this[name]);
+    await this.model.reload();
+    this.model.updateSelectedRow();
+  }
+
+  @action
+  updateSearch(event) {
+    const term = event.target.value;
 
-      debounce(this, this.doSearch, term, 250);
+    if (term === this.search) {
+      return;
     }
-  },
 
-  searchTerm: computed("search", function () {
-    if (this.search) {
-      this.doSearch(this.search)
-      return this.search;
+    if (term && term.length === 1) {
+      return;
     }
-    return null;
-  }),
 
-  doSearch(term) {
-    this.model.set("search", term);
-    this.model.reload().then(() => this.model.updateSelectedRow());
+    debounce(this, this.doSearch, term, 250);
   }
-});
+}