modernize lib/file.js and calculate downloaded correctly

lib/file.js

@@ -1,127 +1,135 @@
-module.exports = File
-
-var eos = require('end-of-stream')
-var EventEmitter = require('events').EventEmitter
-var FileStream = require('./file-stream')
-var inherits = require('inherits')
-var path = require('path')
-var render = require('render-media')
-var stream = require('readable-stream')
-var streamToBlob = require('stream-to-blob')
-var streamToBlobURL = require('stream-to-blob-url')
-var streamToBuffer = require('stream-with-known-length-to-buffer')
-
-inherits(File, EventEmitter)
-
-function File (torrent, file) {
-  EventEmitter.call(this)
-
-  this._torrent = torrent
-  this._destroyed = false
-
-  this.name = file.name
-  this.path = file.path
-  this.length = file.length
-  this.offset = file.offset
-
-  this.done = false
+const {EventEmitter} = require('events')
+const {PassThrough} = require('readable-stream')
+const eos = require('end-of-stream')
+const path = require('path')
+const render = require('render-media')
+const streamToBlob = require('stream-to-blob')
+const streamToBlobURL = require('stream-to-blob-url')
+const streamToBuffer = require('stream-with-known-length-to-buffer')
+const FileStream = require('./file-stream')
+
+class File extends EventEmitter {
+  constructor (torrent, file) {
+    super()
+
+    this._torrent = torrent
+    this._destroyed = false
+
+    this.name = file.name
+    this.path = file.path
+    this.length = file.length
+    this.offset = file.offset
+
+    this.done = false
+
+    const start = file.offset
+    const end = start + file.length - 1
+
+    this._startPiece = start / this._torrent.pieceLength | 0
+    this._endPiece = end / this._torrent.pieceLength | 0
+
+    if (this.length === 0) {
+      this.done = true
+      this.emit('done')
+    }
+  }
 
-  var start = file.offset
-  var end = start + file.length - 1
+  get downloaded () {
+    if (!this._torrent.bitfield) return 0
 
-  this._startPiece = start / this._torrent.pieceLength | 0
-  this._endPiece = end / this._torrent.pieceLength | 0
+    const { pieces, bitfield, pieceLength } = this._torrent
+    const { _startPiece: start, _endPiece: end } = this
+    const piece = pieces[start]
 
-  if (this.length === 0) {
-    this.done = true
-    this.emit('done')
-  }
-}
+    // Calculate first piece diffrently, it sometimes have a offset
+    let downloaded = bitfield.get(start)
+      ? pieceLength - this.offset
+      : Math.max(piece.length - piece.missing - this.offset, 0)
 
-Object.defineProperty(File.prototype, 'downloaded', {
-  get: function () {
-    if (!this._torrent.bitfield) return 0
-    var downloaded = 0
-    for (var index = this._startPiece; index <= this._endPiece; ++index) {
-      if (this._torrent.bitfield.get(index)) {
+    for (let index = start + 1; index <= end; ++index) {
+      if (bitfield.get(index)) {
         // verified data
-        downloaded += (index === this._endPiece) ? this._torrent.lastPieceLength : this._torrent.pieceLength
+        downloaded += pieceLength
       } else {
         // "in progress" data
-        var piece = this._torrent.pieces[index]
-        downloaded += (piece.length - piece.missing)
+        const piece = pieces[index]
+        downloaded += piece.length - piece.missing
       }
     }
-    return downloaded
+
+    // We don't have a end-offset and one small file can fith in the middle
+    // of one chunk, so return this.length if it's oversized
+    return Math.min(downloaded, this.length)
   }
-})
 
-Object.defineProperty(File.prototype, 'progress', {
-  get: function () { return this.length ? this.downloaded / this.length : 0 }
-})
+  get progress () {
+    return this.length ? this.downloaded / this.length : 0
+  }
 
-File.prototype.select = function (priority) {
-  if (this.length === 0) return
-  this._torrent.select(this._startPiece, this._endPiece, priority)
-}
+  select (priority) {
+    if (this.length === 0) return
+    this._torrent.select(this._startPiece, this._endPiece, priority)
+  }
 
-File.prototype.deselect = function () {
-  if (this.length === 0) return
-  this._torrent.deselect(this._startPiece, this._endPiece, false)
-}
+  deselect () {
+    if (this.length === 0) return
+    this._torrent.deselect(this._startPiece, this._endPiece, false)
+  }
 
-File.prototype.createReadStream = function (opts) {
-  var self = this
-  if (this.length === 0) {
-    var empty = new stream.PassThrough()
-    process.nextTick(function () {
-      empty.end()
+  createReadStream (opts) {
+    if (this.length === 0) {
+      const empty = new PassThrough()
+      process.nextTick(() => {
+        empty.end()
+      })
+      return empty
+    }
+
+    const fileStream = new FileStream(this, opts)
+    this._torrent.select(fileStream._startPiece, fileStream._endPiece, true, () => {
+      fileStream._notify()
+    })
+    eos(fileStream, () => {
+      if (this._destroyed) return
+      if (!this._torrent.destroyed) {
+        this._torrent.deselect(fileStream._startPiece, fileStream._endPiece, true)
+      }
     })
-    return empty
+    return fileStream
   }
 
-  var fileStream = new FileStream(self, opts)
-  self._torrent.select(fileStream._startPiece, fileStream._endPiece, true, function () {
-    fileStream._notify()
-  })
-  eos(fileStream, function () {
-    if (self._destroyed) return
-    if (!self._torrent.destroyed) {
-      self._torrent.deselect(fileStream._startPiece, fileStream._endPiece, true)
-    }
-  })
-  return fileStream
-}
+  getBuffer (cb) {
+    streamToBuffer(this.createReadStream(), this.length, cb)
+  }
 
-File.prototype.getBuffer = function (cb) {
-  streamToBuffer(this.createReadStream(), this.length, cb)
-}
+  getBlob (cb) {
+    if (typeof window === 'undefined') throw new Error('browser-only method')
+    streamToBlob(this.createReadStream(), this._getMimeType(), cb)
+  }
 
-File.prototype.getBlob = function (cb) {
-  if (typeof window === 'undefined') throw new Error('browser-only method')
-  streamToBlob(this.createReadStream(), this._getMimeType(), cb)
-}
+  getBlobURL (cb) {
+    if (typeof window === 'undefined') throw new Error('browser-only method')
+    streamToBlobURL(this.createReadStream(), this._getMimeType(), cb)
+  }
 
-File.prototype.getBlobURL = function (cb) {
-  if (typeof window === 'undefined') throw new Error('browser-only method')
-  streamToBlobURL(this.createReadStream(), this._getMimeType(), cb)
-}
+  appendTo (elem, opts, cb) {
+    if (typeof window === 'undefined') throw new Error('browser-only method')
+    render.append(this, elem, opts, cb)
+  }
 
-File.prototype.appendTo = function (elem, opts, cb) {
-  if (typeof window === 'undefined') throw new Error('browser-only method')
-  render.append(this, elem, opts, cb)
-}
+  renderTo (elem, opts, cb) {
+    if (typeof window === 'undefined') throw new Error('browser-only method')
+    render.render(this, elem, opts, cb)
+  }
 
-File.prototype.renderTo = function (elem, opts, cb) {
-  if (typeof window === 'undefined') throw new Error('browser-only method')
-  render.render(this, elem, opts, cb)
-}
+  _getMimeType () {
+    return render.mime[path.extname(this.name).toLowerCase()]
+  }
 
-File.prototype._getMimeType = function () {
-  return render.mime[path.extname(this.name).toLowerCase()]
+  _destroy () {
+    this._destroyed = true
+    this._torrent = null
+  }
 }
 
-File.prototype._destroy = function () {
-  this._destroyed = true
-  this._torrent = null
-}
+module.exports = File