feat: new buffer implementation

Author: fcoury

src/buffer.js

@@ -1,98 +1,70 @@
-const BUFFER_SIZE = 10000; // lines
+const BUFFER_SIZE = 100; // lines
 
-const { readChunk } = require('./file');
+const { readChunk, countLines } = require('./file');
 
 class FileBuffer {
-  constructor(file, { firstLine=0, bufferSize=BUFFER_SIZE, _readChunk=readChunk }) {
+  constructor(file, { firstLine=0, bufferSize=BUFFER_SIZE, _readChunk=readChunk, log=console.log }={}) {
     this.file = file;
-    this.firstLine = firstLine;
-    this.readChunk = _readChunk;
+    this.firstBufferLine = firstLine;
     this.bufferSize = bufferSize;
+    this.readChunk = _readChunk;
+    this.log = log;
   }
 
-  get lastLine() {
-    return this.firstLine + this.bufferSize;
+  get lastBufferLine() {
+    return this.firstBufferLine + this.lines.length || 0;
   }
 
-  read(callback) {
-    this.readChunk({
-      file: this.file,
-      start: this.firstLine,
-      length: this.bufferSize,
-    }, lines => {
-      this.lines = lines;
-      callback(lines);
-    });
-  }
+  get(line, count, callback) {
+    if (!this.lines) {
+      this.log('initial load');
+      return this.countLines(total => {
+        this.lastFileLine = total;
+        this.loadBuffer(line, count, callback);
+      });
+    }
 
-  get bufferRange() {
-    return [this.firstLine, this.lastLine];
-  }
+    if (line + count > this.lastFileLine) {
+      this.log('after end of file');
+      count = this.lastFileLine - line;
+    }
 
-  isInCache(n, length) {
-    return FileBuffer.withinRange(this.bufferRange, [n, n + length]);
-  }
+    // this.log('line', line);
+    // this.log('this.firstBufferLine', this.firstBufferLine);
+    // this.log('this.lastBufferLine', this.lastBufferLine);
 
-  readLines(n, length, callback) {
-    this.firstLine = n;
-    this.readChunk({
-      file: this.file,
-      start: this.firstLine,
-      length: this.bufferSize,
-    }, lines => {
-      this.lines = lines;
-      callback(lines.slice(0, length));
-    });
-  }
+    if (line < this.firstBufferLine) {
+      this.log('before buffer');
+      return this.loadBuffer(line, count, callback);
+    }
 
-  redoLines(n, length, callback) {
-    this.readChunk({
-      file: this.file,
-      start: n,
-      length: this.bufferSize / 2,
-    }, lines => {
-      const newLines = this.lines.concat(lines);
-      const pos = newLines.length - this.bufferSize;
-      this.lines = newLines.slice(pos);
-      callback(lines.slice(0, length));
-    });
-  }
+    // this.log('(line + count)', (line + count));
 
-  getLines(n, length, callback) {
-    if (this.isInCache(n, length)) {
-      return this.lines.slice(n, n+length);
+    if ((line + count) > this.lastBufferLine) {
+      this.log('after buffer');
+      return this.loadBuffer(line, count, callback);
     }
 
-    const missingLines = FileBuffer.missingLines(this.bufferRange, [n, n + length]);
-    if (missingLines) {
-      this.redoLines(n, length, callback);
-    } else {
-      this.readLines(n, length, callback);
-    }
+    const start = line - this.firstBufferLine;
+    callback(this.lines.slice(start, start + count));
   }
-}
-
-FileBuffer.withinRange = (range, compare) => {
-  return compare[0] >= range[0] && compare[1] <= range[1];
-};
 
-FileBuffer.rangePosition = (r1, r2) => {
-  if (r2[1] > r1[1] && r2[0] <= r1[1]) {
-    return 1;
-  }
-  if (r2[0] < r1[0] && r2[1] >= r1[0]) {
-    return -1;
+  countLines(callback) {
+    countLines(this.file, callback);
   }
-};
 
-FileBuffer.missingLines = (range, required) => {
-  const position = FileBuffer.rangePosition(range, required);
-  if (position === -1) {
-    return [required[0], range[0]-1];
-  }
-  if (position === 1) {
-    return [range[1]+1, required[1]];
+  loadBuffer(line, count, callback) {
+    const start = Math.max(0, line - this.bufferSize / 2);
+    const length = this.bufferSize;
+
+    this.log('start', start);
+
+    return this.readChunk({ file: this.file, start, length }, lines => {
+      this.firstBufferLine = start;
+      this.lines = lines;
+      this.get(line, count, callback);
+    });
   }
-};
+}
 
 module.exports = FileBuffer;

src/widgets/MainPanel.js

@@ -3,6 +3,7 @@ const _ = require('lodash');
 
 const { formatRows, levelColors } = require('../utils');
 const { readChunk, countLines } = require('../file');
+const FileBuffer = require('../buffer');
 
 const BaseWidget = require('./BaseWidget');
 const LogDetails = require('./LogDetails');
@@ -29,6 +30,7 @@ class MainPanel extends BaseWidget {
     this.updated = true;
     this.loading = false;
     this.lastRow = null;
+    this.fileBuffer = new FileBuffer(this.file, { log: this.log.bind(this) });
 
     this.log('pageWidth', this.pageWidth);
     this.on('resize', () => {
@@ -87,11 +89,16 @@ class MainPanel extends BaseWidget {
 
     this.log('readLines', filters);
 
-    readChunk({ file, start, length, filter, log: (...s) => this.log(...s) }, lines => {
+    this.fileBuffer.get(start, length, lines => {
       this.lines = lines;
       this.renderLines();
       this.clearLoading();
     });
+    // readChunk({ file, start, length, filter, log: (...s) => this.log(...s) }, lines => {
+    //   this.lines = lines;
+    //   this.renderLines();
+    //   this.clearLoading();
+    // });
   }
 
   calcLines() {