Code coverage report for lib/constructor.js

Statements: 94.06% (95 / 101)      Branches: 87.23% (41 / 47)      Functions: 100% (12 / 12)      Lines: 94.06% (95 / 101)      Ignored: none     

All files » lib/ » constructor.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160      1   1 1 1 1   1 6322         1 1   6365     6365 6365 5220 5220     6365 7 7   6365 6322   6365 6365   6365 6365 6365 6365 6365 6365 6365 6365 6365 6356 13   6343 6343     6365 6365 6365 6365 6365   6365 8 8 8     6357   6357 6357 6357   6   6357 6357 6357   6357 6357 1 1 1     6356           9     6365 9   6356     6356   6356 290     6356 374     6356 114     6356   6356 6353 13 13 13   13   1 3735   3735 3735   6340 6340 6340 6340 6340     6356 3 3 3       6356         6365 6343   6365 6365     1   1  
/*globals cordova */
"use strict";
 
var debug = require('debug');
 
var Adapter = require('./adapter');
var utils = require('./utils');
var TaskQueue = require('./taskqueue');
var Promise = utils.Promise;
 
function defaultCallback(err) {
  Iif (err && global.debug) {
    console.error(err);
  }
}
 
utils.inherits(PouchDB, Adapter);
function PouchDB(name, opts, callback) {
 
  Iif (!(this instanceof PouchDB)) {
    return new PouchDB(name, opts, callback);
  }
  var self = this;
  if (typeof opts === 'function' || typeof opts === 'undefined') {
    callback = opts;
    opts = {};
  }
 
  if (name && typeof name === 'object') {
    opts = name;
    name = undefined;
  }
  if (typeof callback === 'undefined') {
    callback = defaultCallback;
  }
  name = name || opts.name;
  opts = opts ? utils.clone(opts) : {};
  // if name was specified via opts, ignore for the sake of dependentDbs
  delete opts.name;
  this.__opts = opts;
  var oldCB = callback;
  self.auto_compaction = opts.auto_compaction;
  self.prefix = PouchDB.prefix;
  Adapter.call(self);
  self.taskqueue = new TaskQueue();
  var promise = new Promise(function (fulfill, reject) {
    callback = function (err, resp) {
      if (err) {
        return reject(err);
      }
      delete resp.then;
      fulfill(resp);
    };
  
    opts = utils.clone(opts);
    var originalName = opts.name || name;
    var backend, error;
    (function () {
      try {
 
        if (typeof originalName !== 'string') {
          error = new Error('Missing/invalid DB name');
          error.code = 400;
          throw error;
        }
 
        backend = PouchDB.parseAdapter(originalName, opts);
        
        opts.originalName = originalName;
        opts.name = backend.name;
        if (opts.prefix && backend.adapter !== 'http' &&
            backend.adapter !== 'https') {
          opts.name = opts.prefix + opts.name;
        }
        opts.adapter = opts.adapter || backend.adapter;
        self._adapter = opts.adapter;
        debug('pouchdb:adapter')('Picked adapter: ' + opts.adapter);
 
        self._db_name = originalName;
        if (!PouchDB.adapters[opts.adapter]) {
          error = new Error('Adapter is missing');
          error.code = 404;
          throw error;
        }
 
        Iif (!PouchDB.adapters[opts.adapter].valid()) {
          error = new Error('Invalid Adapter');
          error.code = 404;
          throw error;
        }
      } catch (err) {
        self.taskqueue.fail(err);
      }
    }());
    if (error) {
      return reject(error); // constructor error, see above
    }
    self.adapter = opts.adapter;
 
    // needs access to PouchDB;
    self.replicate = {};
 
    self.replicate.from = function (url, opts, callback) {
      return self.constructor.replicate(url, self, opts, callback);
    };
 
    self.replicate.to = function (url, opts, callback) {
      return self.constructor.replicate(self, url, opts, callback);
    };
 
    self.sync = function (dbName, opts, callback) {
      return self.constructor.sync(self, dbName, opts, callback);
    };
 
    self.replicate.sync = self.sync;
 
    PouchDB.adapters[opts.adapter].call(self, opts, function (err) {
      if (err) {
        Eif (callback) {
          self.taskqueue.fail(err);
          callback(err);
        }
        return;
      }
      function destructionListener() {
        PouchDB.emit('destroyed', opts.originalName);
        //so we don't have to sift through all dbnames
        PouchDB.emit(opts.originalName, 'destroyed');
        self.removeListener('destroyed', destructionListener);
      }
      self.on('destroyed', destructionListener);
      self.emit('created', self);
      PouchDB.emit('created', opts.originalName);
      self.taskqueue.ready(self);
      callback(null, self);
    });
 
    if (opts.skipSetup) {
      self.taskqueue.ready(self);
      process.nextTick(function () {
        callback(null, self);
      });
    }
 
    Iif (utils.isCordova()) {
      //to inform websql adapter that we can use api
      cordova.fireWindowEvent(opts.name + "_pouch", {});
    }
  });
  promise.then(function (resp) {
    oldCB(null, resp);
  }, oldCB);
  self.then = promise.then.bind(promise);
  self.catch = promise.catch.bind(promise);
}
 
PouchDB.debug = debug;
 
module.exports = PouchDB;