Merge branch 'promises' of github.com:tgriesser/Ghost into tgriesser-promises

Conflicts:
	core/shared/models/dataProvider.bookshelf.users.js

.gitignore

@@ -24,6 +24,7 @@ projectFilesBackup
 *.db
 
 /core/admin/assets/css
+/core/admin/assets/sass/modules/bourbon
 .sass-cache/
 /core/admin/assets/sass/config.rb
 /core/admin/assets/sass/layouts/config.rb

core/admin/controllers/index.js

@@ -60,16 +60,14 @@
             });
         },
         'auth': function (req, res) {
-            console.log(req.body);
+            api.users.check({email: req.body.email, pw: req.body.password}).then(function (user) {
-            api.users.find({email: req.body.email, pw: req.body.password}).then(function (user) {
+                console.log('user found: ', user);
-                if (user) {
+                req.session.user = "ghostadmin";
-                    console.log('user found: ', user);
+                res.redirect(req.query.redirect || '/ghost/');
-                    req.session.user = "ghostadmin";
+            }, function(err) {
-                    res.redirect(req.query.redirect || '/ghost/');
+                // Do something here to signal the reason for an error
-                } else {
+                console.log(err.stack);
-                    res.redirect('/ghost/login/');
+                res.redirect('/ghost/login/');
-                }
-
             });
         },
         'register': function (req, res) {
@@ -82,8 +80,10 @@
         'doRegister': function (req, res) {
              // console.log(req.body);
             if (req.body.email_address !== '' && req.body.password.length > 5) {
-                // console.log('okay, this is happening');
+                api.users.add({
-                api.users.add({email_address: req.body.email_address, password: req.body.password}).then(function (user) {
+                    email_address: req.body.email_address,
+                    password: req.body.password
+                }).then(function (user) {
                     console.log('user added', user);
                     res.redirect('/ghost/login/');
                 }, function (error) {

core/ghost.js

@@ -15,8 +15,6 @@
 
         JsonDataProvider = require('./shared/models/dataProvider.json'),
         jsonDataProvider = new JsonDataProvider(),
-//        JugglingDataProvider = require('./shared/models/dataProvider.juggling'),
-//        jugglingDataProvider = new JugglingDataProvider(),
         BookshelfDataProvider = require('./shared/models/dataProvider.bookshelf'),
         bookshelfDataProvider = new BookshelfDataProvider(),
         Ghost,

core/shared/api.js

@@ -10,7 +10,6 @@
     "use strict";
 
     var Ghost = require('../ghost'),
-        when = require('when/node/function'),
         _ = require('underscore'),
 
         ghost = new Ghost(),
@@ -24,50 +23,50 @@
         // takes filter / pagination parameters
         // returns a list of posts in a json response
         browse: function (options) {
-            return when.call(ghost.dataProvider().posts.findAll, options);
+            return ghost.dataProvider().posts.findAll(options);
         },
         // takes an identifier (id or slug?)
         // returns a single post in a json response
         read: function (args) {
-            return when.call(ghost.dataProvider().posts.findOne, args);
+            return ghost.dataProvider().posts.findOne(args);
         },
         // takes a json object with all the properties which should be updated
         // returns the resulting post in a json response
         edit: function (postData) {
-            return when.call(ghost.dataProvider().posts.edit, postData);
+            return ghost.dataProvider().posts.edit(postData);
         },
         // takes a json object representing a post,
         // returns the resulting post in a json response
         add: function (postData) {
-            return when.call(ghost.dataProvider().posts.add, postData);
+            return ghost.dataProvider().posts.add(postData);
         },
         // takes an identifier (id or slug?)
         // returns a json response with the id of the deleted post
         destroy: function (args) {
-            return when.call(ghost.dataProvider().posts.destroy, args.id);
+            return ghost.dataProvider().posts.destroy(args.id);
         }
     };
 
     // # Users
     users = {
         add: function (postData) {
-            return when.call(ghost.dataProvider().users.add, postData);
+            return ghost.dataProvider().users.add(postData);
         },
-        find: function (postData) {
+        check: function (postData) {
-            return when.call(ghost.dataProvider().users.check, postData);
+            return ghost.dataProvider().users.check(postData);
         }
     };
 
     // # Settings
     settings = {
         browse: function (options) {
-            return when.call(ghost.dataProvider().settings.browse, options);
+            return ghost.dataProvider().settings.browse(options);
         },
         read: function (options) {
-            return when.call(ghost.dataProvider().settings.read, options.key);
+            return ghost.dataProvider().settings.read(options.key);
         },
         edit: function (options) {
-            return when.call(ghost.dataProvider().settings.edit, options);
+            return ghost.dataProvider().settings.edit(options);
         }
     };
 

core/shared/models/dataProvider.bookshelf.base.js

@@ -20,64 +20,44 @@
     /**
      * Naive find all
      * @param args (optional)
-     * @param callback
      */
-    BookshelfBase.prototype.findAll = BookshelfBase.prototype.browse = function (args, callback) {
+    BookshelfBase.prototype.findAll = BookshelfBase.prototype.browse = function (args) {
-        if (_.isFunction(args)) {
+        args || (args = {});
-            // Curry the optional args parameter
+        return this.collection.forge(args).fetch();
-            callback = args;
-            args = {};
-        }
-
-        this.collection.forge(args).fetch().then(function (results) {
-            callback(null, results);
-        }, callback);
     };
 
     /**
      * Naive find one where args match
      * @param args
-     * @param callback
      */
-    BookshelfBase.prototype.findOne = BookshelfBase.prototype.read = function (args, callback) {
+    BookshelfBase.prototype.findOne = BookshelfBase.prototype.read = function (args) {
-        this.model.forge(args).fetch().then(function (result) {
+        return this.model.forge(args).fetch();
-            callback(null, result);
-        }, callback);
     };
 
     /**
      * Naive edit
      * @param editedObj
-     * @param callback
      */
-    BookshelfBase.prototype.edit = BookshelfBase.prototype.update = function (editedObj, callback) {
+    BookshelfBase.prototype.edit = BookshelfBase.prototype.update = function (editedObj) {
-        this.model.forge({id: editedObj.id}).fetch().then(function (foundObj) {
+        return this.model.forge({id: editedObj.id}).fetch().then(function (foundObj) {
-            foundObj.set(editedObj).save().then(function (updatedObj) {
+            return foundObj.set(editedObj).save();
-                callback(null, updatedObj);
-            }, callback);
         });
     };
 
     /**
      * Naive add
      * @param newObj
-     * @param callback
      */
-    BookshelfBase.prototype.add = BookshelfBase.prototype.create = function (newObj, callback) {
+    BookshelfBase.prototype.add = BookshelfBase.prototype.create = function (newObj) {
-        this.model.forge(newObj).save().then(function (createdObj) {
+        return this.model.forge(newObj).save();
-            callback(null, createdObj);
-        }, callback);
     };
 
     /**
      * Naive destroy
      * @param _identifier
-     * @param callback
      */
-    BookshelfBase.prototype.destroy = BookshelfBase.prototype['delete'] = function (_identifier, callback) {
+    BookshelfBase.prototype.destroy = BookshelfBase.prototype['delete'] = function (_identifier) {
-        this.model.forge({id: _identifier}).destroy().then(function () {
+        return this.model.forge({id: _identifier}).destroy();
-            callback(null);
-        });
     };
 
     module.exports = BookshelfBase;

core/shared/models/dataProvider.bookshelf.settings.js

@@ -17,25 +17,20 @@
 
     util.inherits(SettingsProvider, BaseProvider);
 
-    SettingsProvider.prototype.read = function(_key, callback) {
+    SettingsProvider.prototype.read = function(_key) {
         // Allow for just passing the key instead of attributes
         if (_.isString(_key)) {
             _key = { key: _key };
         }
-
+        return BaseProvider.prototype.read.call(this, _key);
-        BaseProvider.prototype.read.call(this, _key, callback);
     };
 
-    SettingsProvider.prototype.edit = function(_data, callback) {
+    SettingsProvider.prototype.edit = function(_data) {
-        var self = this;
+        return when.all(_.map(_data, function (value, key) {
-
+            return this.model.forge({ key: key }).fetch().then(function (setting) {
-        when.all(_.map(_data, function (value, key) {
-            return self.model.forge({ key: key }).fetch().then(function (setting) {
                 return setting.set('value', value).save();
             });
-        })).then(function (settings) {
+        }, this));
-            callback(null, settings);
-        }, callback);
     };
 
     module.exports = SettingsProvider;

core/shared/models/dataProvider.bookshelf.users.js

@@ -5,6 +5,8 @@
         _ = require('underscore'),
         bcrypt = require('bcrypt'),
         models = require('./models.js'),
+        when = require('when'),
+        nodefn = require('when/node/function'),
         BaseProvider = require('./dataProvider.bookshelf.base.js'),
         UsersProvider;
 
@@ -20,65 +22,34 @@
     /**
      * Naive user add
      * @param  _user
-     * @param  callback
      *
      * Hashes the password provided before saving to the database.
      */
-    UsersProvider.prototype.add = function (_user, callback) {
+    UsersProvider.prototype.add = function (_user) {
         var self = this,
             // Clone the _user so we don't expose the hashed password unnecessarily
             userData = _.extend({}, _user);
 
-        this._hashPassword(userData.password, function (err, hash) {
+        return nodefn.call(bcrypt.hash, _user.password, 10).then(function(hash) {
-            if (err) {
-                return callback(err);
-            }
-
             userData.password = hash;
-
+            return BaseProvider.prototype.add.call(self, userData);
-            BaseProvider.prototype.add.call(self, userData, function (err, createdUser) {
-                if (err) {
-                    return callback(err);
-                }
-
-                callback(null, createdUser);
-            });
         });
     };
 
-    UsersProvider.prototype._hashPassword = function (password, callback) {
+    /**
-        bcrypt.genSalt(10, function (err, salt) {
+     * User check
-            if (err) {
+     * @param  _userdata
-                return callback(err);
+     *
-            }
+     * Finds the user by email, and check's the password
-
+     */
-            bcrypt.hash(password, salt, function (err, hash) {
+    UsersProvider.prototype.check = function (_userdata) {
-                if (err) {
+        console.log('just checking', _userdata);
-                    return callback(err);
+        return this.model.forge({
-                }
-
-                callback(null, hash);
-            });
-        });
-    };
-
-    UsersProvider.prototype.check = function (_userdata, callback) {
-        var test = {
             email_address: _userdata.email
-        };
+        }).fetch().then(function (user) {
-
+            return nodefn.call(bcrypt.compare, _userdata.pw, user.get('password')).then(function(matched) {
-        this.model.forge(test).fetch().then(function (user) {
+                if (!matched) return when.reject(new Error('Password does not match'));
-            var _user;
+                return user;
-            bcrypt.compare(_userdata.pw, user.attributes.password, function (err, res) {
-                if (err) {
-                    return callback(err);
-                }
-                if (res) {
-                    _user = user;
-                } else {
-                    _user = false;
-                }
-                callback(null, _user);
             });
         });
     };

core/shared/models/dataProvider.json.js

@@ -7,7 +7,7 @@
     "use strict";
 
     var _ = require('underscore'),
-
+        when = require('when'),
         DataProvider,
         blogData,
         instance,
@@ -23,25 +23,22 @@
         if (!instance) {
             instance = this;
         }
-
         return instance;
     };
     DataProvider.prototype.globals = {};
     DataProvider.prototype.globals.data = [];
 
 
-    DataProvider.prototype.globals.findAll = function (callback) {
+    DataProvider.prototype.globals.findAll = function() {
-        callback(null, this.data);
+        return when(this.data);
     };
 
-    DataProvider.prototype.globals.save = function (globals, callback) {
+    DataProvider.prototype.globals.save = function (globals) {
-        var self = this;
-
         _.each(globals, function (global, key) {
-            self.data[key] = global;
+            this.data[key] = global;
-        });
+        }, this);
 
-        callback(null, globals);
+        return when(globals);
     };
 
     /* Lets bootstrap with dummy data */