From b9ec43451b9feb0c743196e2b4c3419e5ff611f8 Mon Sep 17 00:00:00 2001
From: Gubolin <gubolin@fantasymail.de>
Date: Wed, 30 Jul 2014 18:23:33 +0200
Subject: replace the Snap!Cloud with GitHub

---
 snap.html | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'snap.html')

diff --git a/snap.html b/snap.html
index 904aba8..26c5124 100755
--- a/snap.html
+++ b/snap.html
@@ -16,6 +16,8 @@
 		<script type="text/javascript" src="xml.js"></script>
 		<script type="text/javascript" src="store.js"></script>
 		<script type="text/javascript" src="locale.js"></script>
+        <script type="text/javascript" src="octokit/promise-1.0.0.js"></script>
+        <script type="text/javascript" src="octokit/octokit.js"></script>
 		<script type="text/javascript" src="cloud.js"></script>
 		<script type="text/javascript" src="sha512.js"></script>
 		<script type="text/javascript">
-- 
cgit v1.3.1


From 8362eac883a067e04633190ff98d060d7b627ca2 Mon Sep 17 00:00:00 2001
From: Gubolin <gubolin@fantasymail.de>
Date: Thu, 31 Jul 2014 11:34:37 +0200
Subject: merge Snap!Cloud and GitHub; fix some bugs

---
 cloud.js  | 620 +++++++++++++++++++++++++++++++++++++++++------------
 github.js | 273 ++++++++++++++++++++++++
 gui.js    | 721 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 snap.html |   3 +-
 4 files changed, 1464 insertions(+), 153 deletions(-)
 create mode 100644 github.js

(limited to 'snap.html')

diff --git a/cloud.js b/cloud.js
index 02cc14f..54189d8 100644
--- a/cloud.js
+++ b/cloud.js
@@ -1,11 +1,12 @@
 /*
-cloud.js
 
-    a GitHub backend API for SNAP!
+    cloud.js
 
-    written by Gubolin, based on cloud.js by Jens Mönig
+    a backend API for SNAP!
 
-    Copyright (C) 2014 by Jens Mönig, Gubolin
+    written by Jens Mönig
+
+    Copyright (C) 2014 by Jens Mönig
 
     This file is part of Snap!.
 
@@ -29,73 +30,253 @@ cloud.js
 /*global modules, IDE_Morph, SnapSerializer, hex_sha512, alert, nop,
 localize*/
 
-modules.cloud = '2014-July-29';
+modules.cloud = '2014-May-26';
 
 // Global stuff
 
 var Cloud;
 
-var SnapCloud = new Cloud();
+var SnapCloud = new Cloud(
+    'https://snapcloud.miosoft.com/miocon/app/login?_app=SnapCloud'
+);
 
 // Cloud /////////////////////////////////////////////////////////////
 
 function Cloud(url) {
-    this.gh = null;
     this.username = null;
-    this.password = null; // TODO saved as plain text
+    this.password = null; // hex_sha512 hashed
+    this.url = url;
     this.session = null;
     this.api = {};
 }
 
 Cloud.prototype.clear = function () {
-    this.gh = null;
     this.username = null;
     this.password = null;
     this.session = null;
     this.api = {};
 };
 
+Cloud.prototype.hasProtocol = function () {
+    return this.url.toLowerCase().indexOf('http') === 0;
+};
+
 // Cloud: Snap! API
 
-Cloud.prototype.getProject = function (
-    dict,
+Cloud.prototype.signup = function (
+    username,
+    email,
     callBack,
     errorCall
 ) {
-    var myself = this;
-    var projectName = dict.projectname;
-    var userName = dict.username;
-
-    if (myself.gh !== null) {
-        var repo = myself.gh.getRepo(userName, projectName);
-        var branch = repo.getBranch(); // master (default)
-        var media, pdata;
-        var br;
-
-        branch.read('snap.xml', false).then(
-            function (sourceContent) {
-                branch.read('media.xml', false).then( // true for binary
-                    function (mediaContent) {
+    // both callBack and errorCall are two-argument functions
+    var request = new XMLHttpRequest(),
+        myself = this;
+    try {
+        request.open(
+            "GET",
+            (this.hasProtocol() ? '' : 'http://')
+                + this.url + 'SignUp'
+                + '&Username='
+                + encodeURIComponent(username)
+                + '&Email='
+                + encodeURIComponent(email),
+            true
+        );
+        request.setRequestHeader(
+            "Content-Type",
+            "application/x-www-form-urlencoded"
+        );
+        request.withCredentials = true;
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.responseText) {
+                    if (request.responseText.indexOf('ERROR') === 0) {
+                        errorCall.call(
+                            this,
+                            request.responseText,
+                            'Signup'
+                        );
+                    } else {
                         callBack.call(
                             null,
-                            sourceContent.content,
-                            mediaContent.content
+                            request.responseText,
+                            'Signup'
                         );
-                    },
-                    function (error) {
-                        errorCall.call(this, error, 'Github');
                     }
-                );
-            },
-            function (error) {
-                errorCall.call(this, error, 'Github');
+                } else {
+                    errorCall.call(
+                        null,
+                        myself.url + 'SignUp',
+                        localize('could not connect to:')
+                    );
+                }
+            }
+        };
+        request.send(null);
+    } catch (err) {
+        errorCall.call(this, err.toString(), 'Snap!Cloud');
+    }
+};
+
+Cloud.prototype.getPublicProject = function (
+    id,
+    callBack,
+    errorCall
+) {
+    // id is Username=username&projectName=projectname,
+    // where the values are url-component encoded
+    // callBack is a single argument function, errorCall take two args
+    var request = new XMLHttpRequest(),
+        responseList,
+        myself = this;
+    try {
+        request.open(
+            "GET",
+            (this.hasProtocol() ? '' : 'http://')
+                + this.url + 'Public'
+                + '&'
+                + id,
+            true
+        );
+        request.setRequestHeader(
+            "Content-Type",
+            "application/x-www-form-urlencoded"
+        );
+        request.withCredentials = true;
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.responseText) {
+                    if (request.responseText.indexOf('ERROR') === 0) {
+                        errorCall.call(
+                            this,
+                            request.responseText
+                        );
+                    } else {
+                        responseList = myself.parseResponse(
+                            request.responseText
+                        );
+                        callBack.call(
+                            null,
+                            responseList[0].SourceCode
+                        );
+                    }
+                } else {
+                    errorCall.call(
+                        null,
+                        myself.url + 'Public',
+                        localize('could not connect to:')
+                    );
+                }
+            }
+        };
+        request.send(null);
+    } catch (err) {
+        errorCall.call(this, err.toString(), 'Snap!Cloud');
+    }
+};
+
+Cloud.prototype.resetPassword = function (
+    username,
+    callBack,
+    errorCall
+) {
+    // both callBack and errorCall are two-argument functions
+    var request = new XMLHttpRequest(),
+        myself = this;
+    try {
+        request.open(
+            "GET",
+            (this.hasProtocol() ? '' : 'http://')
+                + this.url + 'ResetPW'
+                + '&Username='
+                + encodeURIComponent(username),
+            true
+        );
+        request.setRequestHeader(
+            "Content-Type",
+            "application/x-www-form-urlencoded"
+        );
+        request.withCredentials = true;
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.responseText) {
+                    if (request.responseText.indexOf('ERROR') === 0) {
+                        errorCall.call(
+                            this,
+                            request.responseText,
+                            'Reset Password'
+                        );
+                    } else {
+                        callBack.call(
+                            null,
+                            request.responseText,
+                            'Reset Password'
+                        );
+                    }
+                } else {
+                    errorCall.call(
+                        null,
+                        myself.url + 'ResetPW',
+                        localize('could not connect to:')
+                    );
+                }
             }
+        };
+        request.send(null);
+    } catch (err) {
+        errorCall.call(this, err.toString(), 'Snap!Cloud');
+    }
+};
+
+Cloud.prototype.connect = function (
+    callBack,
+    errorCall
+) {
+    // both callBack and errorCall are two-argument functions
+    var request = new XMLHttpRequest(),
+        myself = this;
+    try {
+        request.open(
+            "GET",
+            (this.hasProtocol() ? '' : 'http://') + this.url,
+            true
+        );
+        request.setRequestHeader(
+            "Content-Type",
+            "application/x-www-form-urlencoded"
         );
-    } else {
-        errorCall.call(null, 'Please login', 'Github');
+        request.withCredentials = true;
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.responseText) {
+                    myself.api = myself.parseAPI(request.responseText);
+                    myself.session = request.getResponseHeader('MioCracker')
+                        .split(';')[0];
+                    if (myself.api.login) {
+                        callBack.call(null, myself.api, 'Snap!Cloud');
+                    } else {
+                        errorCall.call(
+                            null,
+                            'connection failed'
+                        );
+                    }
+                } else {
+                    errorCall.call(
+                        null,
+                        myself.url,
+                        localize('could not connect to:')
+                    );
+                }
+            }
+        };
+        request.send(null);
+    } catch (err) {
+        errorCall.call(this, err.toString(), 'Snap!Cloud');
     }
 };
 
+
 Cloud.prototype.login = function (
     username,
     password,
@@ -103,22 +284,61 @@ Cloud.prototype.login = function (
     errorCall
 ) {
     var myself = this;
+    this.connect(
+        function () {
+            myself.rawLogin(username, password, callBack, errorCall);
+            myself.disconnect();
+        },
+        errorCall
+    );
+};
 
-    myself.gh = new Octokit({
-        username: username,
-        password: password
-    });
-
-    myself.gh.getUser().getInfo().then(
-        function(info) {
-            myself.username = username;
-            myself.password = password;
-
-            callBack.call(myself);
+Cloud.prototype.rawLogin = function (
+    username,
+    password,
+    callBack,
+    errorCall
+) {
+    // both callBack and errorCall are two-argument functions
+    var myself = this,
+        pwHash = hex_sha512("miosoft%20miocon,"
+            + this.session.split('=')[1] + ","
+            + encodeURIComponent(username.toLowerCase()) + ","
+            + password // alreadey hex_sha512 hashed
+            );
+    this.callService(
+        'login',
+        function (response, url) {
+            if (myself.api.logout) {
+                myself.username = username;
+                myself.password = password;
+                callBack.call(null, response, url);
+            } else {
+                errorCall.call(
+                    null,
+                    'Service catalog is not available,\nplease retry',
+                    'Connection Error:'
+                );
+            }
         },
-        function (error) {
-            errorCall.call(this, error, 'Github');
-        }
+        errorCall,
+        [username, pwHash]
+    );
+};
+
+Cloud.prototype.reconnect = function (
+    callBack,
+    errorCall
+) {
+    if (!(this.username && this.password)) {
+        this.message('You are not logged in');
+        return;
+    }
+    this.login(
+        this.username,
+        this.password,
+        callBack,
+        errorCall
     );
 };
 
@@ -126,7 +346,6 @@ Cloud.prototype.saveProject = function (ide, callBack, errorCall) {
     var myself = this,
         pdata,
         media;
-    var repoName = ide.projectName.replace(/[^\w-]/g, ''); // FIXME validation of project name
 
     ide.serializer.isCollectingMedia = true;
     pdata = ide.serializer.serialize(ide.stage);
@@ -153,94 +372,215 @@ Cloud.prototype.saveProject = function (ide, callBack, errorCall) {
     ide.serializer.isCollectingMedia = false;
     ide.serializer.flushMedia();
 
-    myself.getProjectList(
-            function (projects) {
-                var exists = false;
-
-                projects.forEach(function (project) {
-                    if (project.ProjectName.indexOf(repoName) > -1) {
-                        exists = true;
-                        return;
-                    }
-                });
-
-                if (exists === false){
-                    myself.gh.getUser().createRepo(repoName, { // these should be discussed
-                        'description': 'Snap! Project',
-                        'has_wiki': 'false',
-                        'has_downloads': 'false',
-                        'auto_init': true,
-                        'license_template': 'mit' // discuss
-                    }).then(
-                        function () {},
-                        function (error) {
-                            errorCall.call(this, error, 'Github');
-                        }
-                    );
-                }
-
-                if (myself.gh !== null) {
-                    var repo = myself.gh.getRepo(myself.username, ide.projectName);
-                    var branch = repo.getBranch(); // master (default)
-                    var message = ''; // FIXME optional: specify message
-
-                    var contents = {
-                        'snap.xml': pdata,
-                        'media.xml': media // may be binary
-                    };
-
-                    branch.writeMany(contents, message).then(
-                        function () {
-                            callBack.call()
-                        },
-                        function (error) {
-                            errorCall.call(this, error, 'Github');
-                        }
-                    );
-                }
-            },
-            function (error) {
-                errorCall.call(null, error, 'Github');
-            }
+    myself.reconnect(
+        function () {
+            myself.callService(
+                'saveProject',
+                function (response, url) {
+                    callBack.call(null, response, url);
+                    myself.disconnect();
+                    ide.hasChangedMedia = false;
+                },
+                errorCall,
+                [
+                    ide.projectName,
+                    pdata,
+                    media,
+                    pdata.length,
+                    media ? media.length : 0
+                ]
+            );
+        },
+        errorCall
     );
 };
 
 Cloud.prototype.getProjectList = function (callBack, errorCall) {
     var myself = this;
+    this.reconnect(
+        function () {
+            myself.callService(
+                'getProjectList',
+                function (response, url) {
+                    callBack.call(null, response, url);
+                    myself.disconnect();
+                },
+                errorCall
+            );
+        },
+        errorCall
+    );
+};
 
-    if (myself.gh !== null) {
-        myself.gh.getUser().getRepos().then(
-                function (repos) {
-                    var snapProjects = [];
+Cloud.prototype.changePassword = function (
+    oldPW,
+    newPW,
+    callBack,
+    errorCall
+) {
+    var myself = this;
+    this.reconnect(
+        function () {
+            myself.callService(
+                'changePassword',
+                function (response, url) {
+                    callBack.call(null, response, url);
+                    myself.disconnect();
+                },
+                errorCall,
+                [oldPW, newPW]
+            );
+        },
+        errorCall
+    );
+};
 
-                    repos.forEach(function (repo) {
-                        if (repo.description === 'Snap! Project') { // FIXME nicer detection
-                            var project;
+Cloud.prototype.logout = function (callBack, errorCall) {
+    this.clear();
+    this.callService(
+        'logout',
+        callBack,
+        errorCall
+    );
+};
 
-                            project = {
-                                'ProjectName': repo.name
-                            };
+Cloud.prototype.disconnect = function () {
+    this.callService(
+        'logout',
+        nop,
+        nop
+    );
+};
 
-                            snapProjects.push(project);
-                        }
-                    });
+// Cloud: backend communication
 
-                    callBack.call(myself, snapProjects);
-                },
-                function (error) {
-                    errorCall.call(this, error, 'Github');
-                }
+Cloud.prototype.callURL = function (url, callBack, errorCall) {
+    // both callBack and errorCall are optional two-argument functions
+    var request = new XMLHttpRequest(),
+        myself = this;
+    try {
+        request.open('GET', url, true);
+        request.withCredentials = true;
+        request.setRequestHeader(
+            "Content-Type",
+            "application/x-www-form-urlencoded"
         );
-    } else {
-        errorCall.call(myself, 'Please login', 'Github');
+        request.setRequestHeader('MioCracker', this.session);
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                if (request.responseText) {
+                    var responseList = myself.parseResponse(
+                        request.responseText
+                    );
+                    callBack.call(null, responseList, url);
+                } else {
+                    errorCall.call(
+                        null,
+                        url,
+                        'no response from:'
+                    );
+                }
+            }
+        };
+        request.send(null);
+    } catch (err) {
+        errorCall.call(this, err.toString(), url);
     }
 };
 
-Cloud.prototype.logout = function (callBack) {
-    this.clear();
+Cloud.prototype.callService = function (
+    serviceName,
+    callBack,
+    errorCall,
+    args
+) {
+    // both callBack and errorCall are optional two-argument functions
+    var request = new XMLHttpRequest(),
+        service = this.api[serviceName],
+        myself = this,
+        postDict;
+
+    if (!this.session) {
+        errorCall.call(null, 'You are not connected', 'Cloud');
+        return;
+    }
+    if (!service) {
+        errorCall.call(
+            null,
+            'service ' + serviceName + ' is not available',
+            'API'
+        );
+        return;
+    }
+    if (args && args.length > 0) {
+        postDict = {};
+        service.parameters.forEach(function (parm, idx) {
+            postDict[parm] = args[idx];
+        });
+    }
+    try {
+        request.open(service.method, service.url, true);
+        request.withCredentials = true;
+        request.setRequestHeader(
+            "Content-Type",
+            "application/x-www-form-urlencoded"
+        );
+        request.setRequestHeader('MioCracker', this.session);
+        request.onreadystatechange = function () {
+            if (request.readyState === 4) {
+                var responseList = [];
+                if (request.responseText &&
+                        request.responseText.indexOf('ERROR') === 0) {
+                    errorCall.call(
+                        this,
+                        request.responseText,
+                        localize('Service:') + ' ' + localize(serviceName)
+                    );
+                    return;
+                }
+                if (serviceName === 'login') {
+                    myself.api = myself.parseAPI(request.responseText);
+                }
+                responseList = myself.parseResponse(
+                    request.responseText
+                );
+                callBack.call(null, responseList, service.url);
+            }
+        };
+        request.send(this.encodeDict(postDict));
+    } catch (err) {
+        errorCall.call(this, err.toString(), service.url);
+    }
 };
 
-// Cloud: backend communication
+// Cloud: payload transformation
+
+Cloud.prototype.parseAPI = function (src) {
+    var api = {},
+        services;
+    services = src.split(" ");
+    services.forEach(function (service) {
+        var entries = service.split("&"),
+            serviceDescription = {},
+            parms;
+        entries.forEach(function (entry) {
+            var pair = entry.split("="),
+                key = decodeURIComponent(pair[0]).toLowerCase(),
+                val = decodeURIComponent(pair[1]);
+            if (key === "service") {
+                api[val] = serviceDescription;
+            } else if (key === "parameters") {
+                parms = val.split(",");
+                if (!(parms.length === 1 && !parms[0])) {
+                    serviceDescription.parameters = parms;
+                }
+            } else {
+                serviceDescription[key] = val;
+            }
+        });
+    });
+    return api;
+};
 
 Cloud.prototype.parseResponse = function (src) {
     var ans = [],
@@ -248,16 +588,16 @@ Cloud.prototype.parseResponse = function (src) {
     if (!src) {return ans; }
     lines = src.split(" ");
     lines.forEach(function (service) {
-            var entries = service.split("&"),
-                dict = {};
-            entries.forEach(function (entry) {
-                    var pair = entry.split("="),
-                        key = decodeURIComponent(pair[0]),
-                        val = decodeURIComponent(pair[1]);
-                    dict[key] = val;
-                });
-            ans.push(dict);
+        var entries = service.split("&"),
+            dict = {};
+        entries.forEach(function (entry) {
+            var pair = entry.split("="),
+                key = decodeURIComponent(pair[0]),
+                val = decodeURIComponent(pair[1]);
+            dict[key] = val;
         });
+        ans.push(dict);
+    });
     return ans;
 };
 
@@ -266,8 +606,8 @@ Cloud.prototype.parseDict = function (src) {
     if (!src) {return dict; }
     src.split("&").forEach(function (entry) {
         var pair = entry.split("="),
-        key = decodeURIComponent(pair[0]),
-        val = decodeURIComponent(pair[1]);
+            key = decodeURIComponent(pair[0]),
+            val = decodeURIComponent(pair[1]);
         dict[key] = val;
     });
     return dict;
@@ -279,8 +619,10 @@ Cloud.prototype.encodeDict = function (dict) {
         key;
     if (!dict) {return null; }
     for (key in dict) {
-            if (dict.hasOwnProperty(key)) {
-                pair = encodeURIComponent(key) + '=' + encodeURIComponent(dict[key]);
+        if (dict.hasOwnProperty(key)) {
+            pair = encodeURIComponent(key)
+                + '='
+                + encodeURIComponent(dict[key]);
             if (str.length > 0) {
                 str += '&';
             }
@@ -289,3 +631,9 @@ Cloud.prototype.encodeDict = function (dict) {
     }
     return str;
 };
+
+// Cloud: user messages (to be overridden)
+
+Cloud.prototype.message = function (string) {
+    alert(string);
+};
diff --git a/github.js b/github.js
new file mode 100644
index 0000000..a3b3223
--- /dev/null
+++ b/github.js
@@ -0,0 +1,273 @@
+/*
+ 
+    github.js
+
+    a GitHubBackend backend API for SNAP!
+
+    written by Gubolin, based on cloud.js by Jens Mönig
+
+    Copyright (C) 2014 by Jens Mönig, Gubolin
+
+    This file is part of Snap!.
+
+    Snap! is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of
+    the License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+// Global settings /////////////////////////////////////////////////////
+
+/*global modules, IDE_Morph, SnapSerializer, nop,
+localize*/
+
+modules.github = '2014-July-31';
+
+// Global stuff
+
+var GitHubBackend;
+
+var GitHub = new GitHubBackend();
+
+// GitHubBackend /////////////////////////////////////////////////////////////
+
+function GitHubBackend(url) {
+    this.gh = null;
+    this.username = null;
+    this.password = null; // TODO saved as plain text
+}
+
+GitHubBackend.prototype.clear = function () {
+    this.gh = null;
+    this.username = null;
+    this.password = null;
+};
+
+// GitHubBackend: Snap! API
+
+GitHubBackend.prototype.getProject = function (
+    userName,
+    projectName,
+    callBack,
+    errorCall
+) {
+    var myself = this;
+
+    if (myself.gh === null) {
+        myself.gh = new Octokit();
+    }
+
+    var repo = myself.gh.getRepo(userName, projectName);
+    var branch = repo.getBranch(); // master (default)
+    var media, pdata;
+
+    branch.read('snap.xml', false).then(
+        function (sourceContent) {
+            branch.read('media.xml', false).then( // true for binary
+                function (mediaContent) {
+                    callBack.call(
+                        null,
+                        sourceContent.content,
+                        mediaContent.content
+                    );
+                },
+                function (error) {
+                    errorCall.call(this, error, 'GitHub');
+                }
+            );
+        },
+        function (error) {
+            errorCall.call(this, error, 'GitHub');
+        }
+    );
+};
+
+GitHubBackend.prototype.login = function (
+    username,
+    password,
+    validateData,
+    callBack,
+    errorCall
+) {
+    var myself = this;
+    var me;
+
+    myself.gh = new Octokit({
+        username: username,
+        password: password
+    });
+
+    if (validateData === true) {
+        me = myself.gh.getUser();
+        if (me !== null) {
+            me.getInfo().then(
+                function(info) {
+                    myself.username = username;
+                    myself.password = password;
+
+                    callBack.call(myself);
+                },
+                function (error) {
+                    errorCall.call(this, error, 'GitHub');
+                }
+            );
+        } else {
+            errorCall.call(myself, localize('Something went wrong :('), 'GitHub');
+        }
+    } else {
+        myself.username = username;
+        myself.password = password;
+
+        callBack.call(myself);
+    }
+};
+
+GitHubBackend.prototype.saveProject = function (ide, callBack, errorCall) {
+    var myself = this,
+        pdata,
+        media;
+    var repoName = ide.projectName.replace(/[^\w-]/g, ''); // TODO validation of project name
+
+    ide.serializer.isCollectingMedia = true;
+    pdata = ide.serializer.serialize(ide.stage);
+    media = ide.hasChangedMedia ?
+            ide.serializer.mediaXML(ide.projectName) : null;
+    ide.serializer.isCollectingMedia = false;
+    ide.serializer.flushMedia();
+
+    // check if serialized data can be parsed back again
+    try {
+        ide.serializer.parse(pdata);
+    } catch (err) {
+        ide.showMessage('Serialization of program data failed:\n' + err);
+        throw new Error('Serialization of program data failed:\n' + err);
+    }
+    if (media !== null) {
+        try {
+            ide.serializer.parse(media);
+        } catch (err) {
+            ide.showMessage('Serialization of media failed:\n' + err);
+            throw new Error('Serialization of media failed:\n' + err);
+        }
+    }
+    ide.serializer.isCollectingMedia = false;
+    ide.serializer.flushMedia();
+
+    myself.getProjectList(
+            function (projects) {
+                var exists = false;
+
+                projects.forEach(function (project) {
+                    if (project.ProjectName.indexOf(repoName) > -1) {
+                        exists = true;
+                        return;
+                    }
+                });
+
+                if (exists === false){
+                    myself.gh.getUser().createRepo(repoName, { // these should be discussed
+                        'description': 'Snap! Project - http://snap.berkeley.edu/snapsource/snap.html#github:Username=' + myself.username + '&projectName=' + repoName,
+                        'has_wiki': 'false',
+                        'has_downloads': 'false',
+                        'auto_init': true,
+                        'license_template': 'mit' // discuss
+                    }).then(
+                        function () {},
+                        function (error) {
+                            errorCall.call(this, error, 'GitHub');
+                        }
+                    );
+                }
+
+                if (myself.gh !== null) {
+                    var repo = myself.gh.getRepo(myself.username, ide.projectName);
+                    var branch = repo.getBranch(); // master (default)
+                    var message = ''; // TODO optional: specify message
+
+                    var contents = {
+                        'snap.xml': pdata,
+                        'media.xml': media, // may be binary
+                        'README.md': ide.projectNotes
+                    };
+
+                    branch.writeMany(contents, message).then(
+                        function () {
+                            callBack.call();
+                        },
+                        function (error) {
+                            errorCall.call(this, error, 'GitHub');
+                        }
+                    );
+                }
+            },
+            function (error) {
+                errorCall.call(null, error, 'GitHub');
+            }
+    );
+};
+
+GitHubBackend.prototype.getProjectList = function (callBack, errorCall) {
+    var myself = this;
+
+    if (myself.gh !== null) {
+        myself.gh.getUser().getRepos().then(
+                function (repos) {
+                    var snapProjects = [];
+
+                    var modCallBack = (function () {
+                        var called = 0;
+                        return function () {
+                            if (++called == repos.length) {
+                                callBack.call(myself, snapProjects);
+                            }
+                        };
+                    })();
+
+                    repos.forEach(function (repo) {
+                        if (repo.description.indexOf('Snap! Project') > -1) { // TODO nicer detection
+                            var project, ghrepo, branch;
+                            
+                            ghrepo = myself.gh.getRepo(repo.owner.login, repo.name);
+                            branch = ghrepo.getBranch(); // master (default)
+
+                            branch.read('README.md', false).then(
+                                function (notesContent) {
+                                    project = {
+                                        'ProjectName': repo.name,
+                                        'Notes': notesContent.content,
+                                        'Updated': repo.updated_at.replace(/T/, ' ').replace(/Z/, '') // TODO this could be better
+                                    };
+
+                                    snapProjects.push(project);
+                                    modCallBack();
+                                },
+                                function (error) {
+                                    errorCall.call(this, error, 'GitHub');
+                                }
+                            );
+                        } else {
+                            modCallBack();
+                        }
+                    });
+                },
+                function (error) {
+                    errorCall.call(this, error, 'GitHub');
+                }
+        );
+    } else {
+        errorCall.call(myself, localize('Please login'), 'GitHub');
+    }
+};
+
+GitHubBackend.prototype.logout = function (callBack) {
+    this.clear();
+};
diff --git a/gui.js b/gui.js
index a4e1dd5..cbc3353 100644
--- a/gui.js
+++ b/gui.js
@@ -63,13 +63,13 @@ Costume, CostumeEditorMorph, MorphicPreferences, touchScreenSettings,
 standardSettings, Sound, BlockMorph, ToggleMorph, InputSlotDialogMorph,
 ScriptsMorph, isNil, SymbolMorph, BlockExportDialogMorph,
 BlockImportDialogMorph, SnapTranslator, localize, List, InputSlotMorph,
-SnapCloud, Uint8Array, HandleMorph, SVG_Costume, fontHeight, hex_sha512,
+SnapCloud, GitHub, Uint8Array, HandleMorph, SVG_Costume, fontHeight, hex_sha512,
 sb, CommentMorph, CommandBlockMorph, BlockLabelPlaceHolderMorph, Audio,
 SpeechBubbleMorph*/
 
 // Global stuff ////////////////////////////////////////////////////////
 
-modules.gui = '2014-July-30';
+modules.gui = '2014-July-31';
 
 // Declarations
 
@@ -240,6 +240,7 @@ IDE_Morph.prototype.openIn = function (world) {
     // get persistent user data, if any
     if (localStorage) {
         usr = localStorage['-snap-user'];
+        ghusr = localStorage['-snap-ghuser'];
         if (usr) {
             usr = SnapCloud.parseResponse(usr)[0];
             if (usr) {
@@ -247,6 +248,13 @@ IDE_Morph.prototype.openIn = function (world) {
                         function() {}, myself.cloudError());
             }
         }
+        if (ghusr) {
+            ghusr = SnapCloud.parseResponse(ghusr)[0];
+            if (ghusr) {
+                GitHub.login(ghusr.username, ghusr.password, false,
+                        function() {}, myself.githubError());
+            }
+        }
     }
 
     // override SnapCloud's user message with Morphic
@@ -338,11 +346,12 @@ IDE_Morph.prototype.openIn = function (world) {
             this.parent.add(this.shield);
             myself.showMessage('Fetching project\nfrom the cloud...');
 
+            // make sure to lowercase the username
             dict = SnapCloud.parseDict(location.hash.substr(9));
-            dict.Username = dict.Username;
+            dict.Username = dict.Username.toLowerCase();
 
             SnapCloud.getPublicProject(
-                dict,
+                SnapCloud.encodeDict(dict),
                 function (projectData) {
                     var msg;
                     myself.nextSteps([
@@ -370,10 +379,51 @@ IDE_Morph.prototype.openIn = function (world) {
                 },
                 this.cloudError()
             );
+        } else if (location.hash.substr(0, 8) === '#github:') {
+            this.shield = new Morph();
+            this.shield.color = this.color;
+            this.shield.setExtent(this.parent.extent());
+            this.parent.add(this.shield);
+            myself.showMessage('Fetching project\nfrom GitHub...');
+
+            dict = SnapCloud.parseDict(location.hash.substr(8));
+
+            GitHub.getProject(
+                dict.Username,
+                dict.projectName,
+                function (projectData) {
+                    var msg;
+                    myself.nextSteps([
+                        function () {
+                            msg = myself.showMessage('Opening GitHub project...');
+                        },
+                        function () {
+                            if (projectData.indexOf('<snapdata') === 0) {
+                                myself.rawOpenCloudDataString(projectData);
+                            } else if (
+                                projectData.indexOf('<project') === 0
+                            ) {
+                                myself.rawOpenProjectString(projectData);
+                            }
+                            myself.hasChangedMedia = true;
+                        },
+                        function () {
+                            myself.shield.destroy();
+                            myself.shield = null;
+                            msg.destroy();
+                            myself.toggleAppMode(true);
+                            myself.runScripts();
+                        }
+                    ]);
+                },
+                this.githubError()
+            );
         } else if (location.hash.substr(0, 6) === '#lang:') {
             urlLanguage = location.hash.substr(6);
             this.setLanguage(urlLanguage);
             this.loadNewProject = true;
+        } else if (location.hash.substr(0, 7) === '#signup') {
+            this.createCloudAccount();
         }
     }
 
@@ -1934,16 +1984,49 @@ IDE_Morph.prototype.cloudMenu = function () {
         shiftClicked = (world.currentKey === 16);
 
     menu = new MenuMorph(this);
+    if (shiftClicked) {
+         menu.addItem(
+           'url...',
+           'setCloudURL',
+            null,
+            new Color(100, 0, 0)
+        );
+        menu.addLine();
+    }
     if (!SnapCloud.username) {
         menu.addItem(
             'Login...',
             'initializeCloud'
         );
+        menu.addItem(
+            'Signup...',
+            'createCloudAccount'
+        );
+        menu.addItem(
+            'Reset Password...',
+            'resetCloudPassword'
+        );
     } else {
         menu.addItem(
             localize('Logout') + ' ' + SnapCloud.username,
             'logout'
         );
+        menu.addItem(
+            'Change Password...',
+            'changeCloudPassword'
+        );
+    }
+
+    if (!GitHub.username) {
+        menu.addItem(
+            'Login via GitHub...',
+            'initializeGitHub'
+        );
+    } else {
+        menu.addItem(
+            localize('Logout') + ' ' + GitHub.username + ' ' + localize('from GitHub'),
+            'logoutGitHub'
+        );
     }
     if (shiftClicked) {
         menu.addLine();
@@ -1989,6 +2072,53 @@ IDE_Morph.prototype.cloudMenu = function () {
             null,
             new Color(100, 0, 0)
         );
+    menu.addLine();
+    menu.addItem(
+            'open shared project from cloud...',
+            function () {
+                myself.prompt('Author name…', function (usr) {
+                    myself.prompt('Project name...', function (prj) {
+                        var id = 'Username=' +
+                            encodeURIComponent(usr.toLowerCase()) +
+                            '&ProjectName=' +
+                            encodeURIComponent(prj);
+                        myself.showMessage(
+                            'Fetching project\nfrom the cloud...'
+                        );
+                        SnapCloud.getPublicProject(
+                            id,
+                            function (projectData) {
+                                var msg;
+                                if (!Process.prototype.isCatchingErrors) {
+                                    window.open(
+                                        'data:text/xml,' + projectData
+                                    );
+                                }
+                                myself.nextSteps([
+                                    function () {
+                                        msg = myself.showMessage(
+                                            'Opening project...'
+                                        );
+                                    },
+                                    function () {
+                                        myself.rawOpenCloudDataString(
+                                            projectData
+                                        );
+                                    },
+                                    function () {
+                                        msg.destroy();
+                                    }
+                                ]);
+                            },
+                            myself.cloudError()
+                        );
+
+                    }, null, 'project');
+                }, null, 'project');
+            },
+            null,
+            new Color(100, 0, 0)
+        );
     }
     menu.popup(world, pos);
 };
@@ -2633,7 +2763,14 @@ IDE_Morph.prototype.editProjectNotes = function () {
 };
 
 IDE_Morph.prototype.newProject = function () {
-    this.source = SnapCloud.username ? 'cloud' : 'local';
+    if (SnapCloud.username) {
+        this.source = 'cloud';
+    } else if (GitHub.username) {
+        this.source = 'github';
+    } else {
+        this.source = 'local';
+    }
+
     if (this.stage) {
         this.stage.destroy();
     }
@@ -2665,8 +2802,10 @@ IDE_Morph.prototype.save = function () {
     if (this.projectName) {
         if (this.source === 'local') { // as well as 'examples'
             this.saveProject(this.projectName);
-        } else { // 'cloud'
+        } else if (this.source === 'cloud') { // 'cloud'
             this.saveProjectToCloud(this.projectName);
+        } else { // 'github'
+            this.saveProjectToGitHub(this.projectName);
         }
     } else {
         this.saveProjectsBrowser();
@@ -3554,17 +3693,17 @@ IDE_Morph.prototype.initializeCloud = function () {
     new DialogBoxMorph(
         null,
         function (user) {
-            var pw = user.password,
+            var pwh = hex_sha512(user.password),
                 str;
             SnapCloud.login(
                 user.username,
-                pw,
+                pwh,
                 function () {
                     if (user.choice) {
                         str = SnapCloud.encodeDict(
                             {
                                 username: user.username,
-                                password: pw
+                                password: pwh
                             }
                         );
                         localStorage['-snap-user'] = str;
@@ -3589,6 +3728,160 @@ IDE_Morph.prototype.initializeCloud = function () {
     );
 };
 
+IDE_Morph.prototype.initializeGitHub = function () {
+    var myself = this,
+        world = this.world();
+    new DialogBoxMorph(
+        null,
+        function (user) {
+            var pw = user.password,
+                str;
+            GitHub.login(
+                user.username,
+                pw,
+                true,
+                function () {
+                    if (user.choice) {
+                        str = SnapCloud.encodeDict(
+                            {
+                                username: user.username,
+                                password: pw
+                            }
+                        );
+                        localStorage['-snap-ghuser'] = str;
+                    }
+                    myself.source = 'github';
+                    myself.showMessage('now connected.', 2);
+                },
+                myself.githubError()
+            );
+        }
+    ).withKey('cloudlogin').promptCredentials(
+        'Sign in with your GitHub account',
+        'login',
+        null,
+        null,
+        null,
+        null,
+        'stay signed in on this computer\nuntil logging out',
+        world,
+        myself.cloudIcon(),
+        myself.cloudMsg
+    );
+};
+
+IDE_Morph.prototype.createCloudAccount = function () {
+    var myself = this,
+        world = this.world();
+/*
+    // force-logout, commented out for now:
+    delete localStorage['-snap-user'];
+    SnapCloud.clear();
+*/
+    new DialogBoxMorph(
+        null,
+        function (user) {
+            SnapCloud.signup(
+                user.username,
+                user.email,
+                function (txt, title) {
+                    new DialogBoxMorph().inform(
+                        title,
+                        txt +
+                            '.\n\nAn e-mail with your password\n' +
+                            'has been sent to the address provided',
+                        world,
+                        myself.cloudIcon(null, new Color(0, 180, 0))
+                    );
+                },
+                myself.cloudError()
+            );
+        }
+    ).withKey('cloudsignup').promptCredentials(
+        'Sign up',
+        'signup',
+        'http://snap.berkeley.edu/tos.html',
+        'Terms of Service...',
+        'http://snap.berkeley.edu/privacy.html',
+        'Privacy...',
+        'I have read and agree\nto the Terms of Service',
+        world,
+        myself.cloudIcon(),
+        myself.cloudMsg
+    );
+};
+
+IDE_Morph.prototype.resetCloudPassword = function () {
+    var myself = this,
+        world = this.world();
+/*
+    // force-logout, commented out for now:
+    delete localStorage['-snap-user'];
+    SnapCloud.clear();
+*/
+    new DialogBoxMorph(
+        null,
+        function (user) {
+            SnapCloud.resetPassword(
+                user.username,
+                function (txt, title) {
+                    new DialogBoxMorph().inform(
+                        title,
+                        txt +
+                            '.\n\nAn e-mail with a link to\n' +
+                            'reset your password\n' +
+                            'has been sent to the address provided',
+                        world,
+                        myself.cloudIcon(null, new Color(0, 180, 0))
+                    );
+                },
+                myself.cloudError()
+            );
+        }
+    ).withKey('cloudresetpassword').promptCredentials(
+        'Reset password',
+        'resetPassword',
+        null,
+        null,
+        null,
+        null,
+        null,
+        world,
+        myself.cloudIcon(),
+        myself.cloudMsg
+    );
+};
+
+IDE_Morph.prototype.changeCloudPassword = function () {
+    var myself = this,
+        world = this.world();
+    new DialogBoxMorph(
+        null,
+        function (user) {
+            SnapCloud.changePassword(
+                user.oldpassword,
+                user.password,
+                function () {
+                    myself.logout();
+                    myself.showMessage('password has been changed.', 2);
+                },
+                myself.cloudError()
+            );
+        }
+    ).withKey('cloudpassword').promptCredentials(
+        'Change Password',
+        'changePassword',
+        null,
+        null,
+        null,
+        null,
+        null,
+        world,
+        myself.cloudIcon(),
+        myself.cloudMsg
+    );
+};
+
 IDE_Morph.prototype.logout = function () {
     var myself = this;
     delete localStorage['-snap-user'];
@@ -3602,6 +3895,19 @@ IDE_Morph.prototype.logout = function () {
     );
 };
 
+IDE_Morph.prototype.logoutGitHub = function () {
+    var myself = this;
+    delete localStorage['-snap-ghuser'];
+    GitHub.logout(
+        function () {
+            myself.showMessage('disconnected.', 2);
+        },
+        function () {
+            myself.showMessage('disconnected.', 2);
+        }
+    );
+};
+
 IDE_Morph.prototype.saveProjectToCloud = function (name) {
     var myself = this;
     if (name) {
@@ -3615,6 +3921,19 @@ IDE_Morph.prototype.saveProjectToCloud = function (name) {
     }
 };
 
+IDE_Morph.prototype.saveProjectToGitHub = function (name) {
+    var myself = this;
+    if (name) {
+        this.showMessage('Saving project\nto GitHub...');
+        this.setProjectName(name);
+        GitHub.saveProject(
+            this,
+            function () {myself.showMessage('saved.', 2); },
+            this.githubError()
+        );
+    }
+};
+
 IDE_Morph.prototype.exportProjectMedia = function (name) {
     var menu, media;
     this.serializer.isCollectingMedia = true;
@@ -3811,6 +4130,42 @@ IDE_Morph.prototype.cloudError = function () {
     };
 };
 
+IDE_Morph.prototype.githubError = function () {
+    var myself = this;
+
+    function getURL(url) {
+        try {
+            var request = new XMLHttpRequest();
+            request.open('GET', url, false);
+            request.send();
+            if (request.status === 200) {
+                return request.responseText;
+            }
+            return null;
+        } catch (err) {
+            return null;
+        }
+    }
+
+    return function (responseText, url) {
+        var response = responseText;
+        if (myself.shield) {
+            myself.shield.destroy();
+            myself.shield = null;
+        }
+        if (response.length > 50) {
+            response = response.substring(0, 50) + '...';
+        }
+        new DialogBoxMorph().inform(
+            'GitHub',
+            (url ? url + '\n' : '')
+                + response,
+            myself.world(),
+            myself.cloudIcon(null, new Color(180, 0, 0))
+        );
+    };
+};
+
 IDE_Morph.prototype.cloudIcon = function (height, color) {
     var clr = color || DialogBoxMorph.prototype.titleBarColor,
         isFlat = MorphicPreferences.isFlat,
@@ -3827,6 +4182,31 @@ IDE_Morph.prototype.cloudIcon = function (height, color) {
     return icon;
 };
 
+IDE_Morph.prototype.setCloudURL = function () {
+    new DialogBoxMorph(
+        null,
+        function (url) {
+            SnapCloud.url = url;
+        }
+    ).withKey('cloudURL').prompt(
+        'Cloud URL',
+        SnapCloud.url,
+        this.world(),
+        null,
+        {
+            'Snap!Cloud' :
+                'https://snapcloud.miosoft.com/miocon/app/' +
+                    'login?_app=SnapCloud',
+            'local network lab' :
+                '192.168.2.107:8087/miocon/app/login?_app=SnapCloud',
+            'local network office' :
+                '192.168.186.146:8087/miocon/app/login?_app=SnapCloud',
+            'localhost dev' :
+                'localhost/miocon/app/login?_app=SnapCloud'
+        }
+    );
+};
+
 // IDE_Morph synchronous Http data fetching
 
 IDE_Morph.prototype.getURL = function (url) {
@@ -3923,7 +4303,7 @@ ProjectDialogMorph.prototype.init = function (ide, task) {
     // additional properties:
     this.ide = ide;
     this.task = task || 'open'; // String describing what do do (open, save)
-    this.source = ide.source || 'local'; // or 'cloud' or 'examples'
+    this.source = ide.source || 'local'; // 'or 'cloud' or 'github' or 'examples'
     this.projectList = []; // [{name: , thumb: , notes:}]
 
     this.handle = null;
@@ -3934,6 +4314,8 @@ ProjectDialogMorph.prototype.init = function (ide, task) {
     this.notesText = null;
     this.notesField = null;
     this.deleteButton = null;
+    this.shareButton = null;
+    this.unshareButton = null;
 
     // initialize inherited properties:
     ProjectDialogMorph.uber.init.call(
@@ -3981,6 +4363,7 @@ ProjectDialogMorph.prototype.buildContents = function () {
     }
 
     this.addSourceButton('cloud', localize('Cloud'), 'cloud');
+    this.addSourceButton('github', localize('GitHub'), 'github');
     this.addSourceButton('local', localize('Browser'), 'storage');
     if (this.task === 'open') {
         this.addSourceButton('examples', localize('Examples'), 'poster');
@@ -4073,6 +4456,10 @@ ProjectDialogMorph.prototype.buildContents = function () {
         this.addButton('saveProject', 'Save');
         this.action = 'saveProject';
     }
+    this.shareButton = this.addButton('shareProject', 'Share');
+    this.unshareButton = this.addButton('unshareProject', 'Unshare');
+    this.shareButton.hide();
+    this.unshareButton.hide();
     this.deleteButton = this.addButton('deleteProject', 'Delete');
     this.addButton('cancel', 'Cancel');
 
@@ -4225,6 +4612,20 @@ ProjectDialogMorph.prototype.setSource = function (source) {
             }
         );
         return;
+    case 'github':
+        msg = myself.ide.showMessage('Updating\nproject list...');
+        this.projectList = [];
+        GitHub.getProjectList(
+            function (projectList) {
+                myself.installGitHubProjectList(projectList);
+                msg.destroy();
+            },
+            function (err, lbl) {
+                msg.destroy();
+                myself.ide.githubError().call(null, err, lbl);
+            }
+        );
+        return;
     case 'examples':
         this.projectList = this.getExamplesProjectList();
         break;
@@ -4277,7 +4678,7 @@ ProjectDialogMorph.prototype.setSource = function (source) {
             }
             myself.edit();
         };
-    } else { // 'examples', 'cloud' is initialized elsewhere
+    } else { // 'examples', 'cloud' and 'github' is initialized elsewhere
         this.listField.action = function (item) {
             var src, xml;
             if (item === undefined) {return; }
@@ -4302,6 +4703,8 @@ ProjectDialogMorph.prototype.setSource = function (source) {
         };
     }
     this.body.add(this.listField);
+    this.shareButton.hide();
+    this.unshareButton.hide();
     if (this.source === 'local') {
         this.deleteButton.show();
     } else { // examples
@@ -4371,6 +4774,83 @@ ProjectDialogMorph.prototype.installCloudProjectList = function (pl) {
         return x.ProjectName < y.ProjectName ? -1 : 1;
     });
 
+    this.listField.destroy();
+    this.listField = new ListMorph(
+        this.projectList,
+        this.projectList.length > 0 ?
+                function (element) {
+                    return element.ProjectName;
+                } : null,
+        [ // format: display shared project names bold
+            [
+                'bold',
+                function (proj) {return proj.Public === 'true'; }
+            ]
+        ],
+        function () {myself.ok(); }
+    );
+    this.fixListFieldItemColors();
+    this.listField.fixLayout = nop;
+    this.listField.edge = InputFieldMorph.prototype.edge;
+    this.listField.fontSize = InputFieldMorph.prototype.fontSize;
+    this.listField.typeInPadding = InputFieldMorph.prototype.typeInPadding;
+    this.listField.contrast = InputFieldMorph.prototype.contrast;
+    this.listField.drawNew = InputFieldMorph.prototype.drawNew;
+    this.listField.drawRectBorder = InputFieldMorph.prototype.drawRectBorder;
+
+    this.listField.action = function (item) {
+        if (item === undefined) {return; }
+        if (myself.nameField) {
+            myself.nameField.setContents(item.ProjectName || '');
+        }
+        if (myself.task === 'open') {
+            myself.notesText.text = item.Notes || '';
+            myself.notesText.drawNew();
+            myself.notesField.contents.adjustBounds();
+            myself.preview.texture = item.Thumbnail || null;
+            myself.preview.cachedTexture = null;
+            myself.preview.drawNew();
+            (new SpeechBubbleMorph(new TextMorph(
+                localize('last changed') + '\n' + item.Updated,
+                null,
+                null,
+                null,
+                null,
+                'center'
+            ))).popUp(
+                myself.world(),
+                myself.preview.rightCenter().add(new Point(2, 0))
+            );
+        }
+        if (item.Public === 'true') {
+            myself.shareButton.hide();
+            myself.unshareButton.show();
+        } else {
+            myself.unshareButton.hide();
+            myself.shareButton.show();
+        }
+        myself.buttons.fixLayout();
+        myself.fixLayout();
+        myself.edit();
+    };
+    this.body.add(this.listField);
+    this.shareButton.show();
+    this.unshareButton.hide();
+    this.deleteButton.show();
+    this.buttons.fixLayout();
+    this.fixLayout();
+    if (this.task === 'open') {
+        this.clearDetails();
+    }
+};
+
+ProjectDialogMorph.prototype.installGitHubProjectList = function (pl) {
+    var myself = this;
+    this.projectList = pl || [];
+    this.projectList.sort(function (x, y) {
+        return x.ProjectName < y.ProjectName ? -1 : 1;
+    });
+
     this.listField.destroy();
     this.listField = new ListMorph(
         this.projectList,
@@ -4443,6 +4923,8 @@ ProjectDialogMorph.prototype.openProject = function () {
     this.ide.source = this.source;
     if (this.source === 'cloud') {
         this.openCloudProject(proj);
+    } else if (this.source === 'github') {
+        this.openGitHubProject(proj);
     } else if (this.source === 'examples') {
         src = this.ide.getURL(
             'http://snap.berkeley.edu/snapsource/Examples/' +
@@ -4468,20 +4950,58 @@ ProjectDialogMorph.prototype.openCloudProject = function (project) {
     ]);
 };
 
+ProjectDialogMorph.prototype.openGitHubProject = function (project) {
+    var myself = this;
+    myself.ide.nextSteps([
+        function () {
+            myself.ide.showMessage('Fetching project\nfrom GitHub...');
+        },
+        function () {
+            myself.rawOpenGitHubProject(project);
+        }
+    ]);
+};
+
 ProjectDialogMorph.prototype.rawOpenCloudProject = function (proj) {
     var myself = this;
-    SnapCloud.getProject(
-        {'projectname': proj.ProjectName, 'username': SnapCloud.username},
+    SnapCloud.reconnect(
+        function () {
+            SnapCloud.callService(
+                'getProject',
+                function (response) {
+                    SnapCloud.disconnect();
+                    myself.ide.source = 'cloud';
+                    myself.ide.droppedText(response[0].SourceCode);
+                    if (proj.Public === 'true') {
+                        location.hash = '#present:Username=' +
+                            encodeURIComponent(SnapCloud.username) +
+                            '&ProjectName=' +
+                            encodeURIComponent(proj.ProjectName);
+                    }
+                },
+                myself.ide.cloudError(),
+                [proj.ProjectName]
+            );
+        },
+        myself.ide.cloudError()
+    );
+    this.destroy();
+};
+
+ProjectDialogMorph.prototype.rawOpenGitHubProject = function (proj) {
+    var myself = this;
+    GitHub.getProject(
+        GitHub.username,
+        proj.ProjectName, 
         function (code, media) {
-            myself.ide.source = 'cloud';
+            myself.ide.source = 'github';
             myself.ide.droppedText(media);
             myself.ide.droppedText(code);
         },
-        myself.ide.cloudError()
+        myself.ide.githubError()
     );
     this.destroy();
 };
-
 ProjectDialogMorph.prototype.saveProject = function () {
     var name = this.nameField.contents().text.text,
         notes = this.notesText.text,
@@ -4508,6 +5028,25 @@ ProjectDialogMorph.prototype.saveProject = function () {
                 this.ide.setProjectName(name);
                 myself.saveCloudProject();
             }
+        } else if (this.source === 'github') {
+            if (detect(
+                    this.projectList,
+                    function (item) {return item.ProjectName === name; }
+                )) {
+                this.ide.confirm(
+                    localize(
+                        'Are you sure you want to replace'
+                    ) + '\n"' + name + '"?',
+                    'Replace Project',
+                    function () {
+                        myself.ide.setProjectName(name);
+                        myself.saveGitHubProject();
+                    }
+                );
+            } else {
+                this.ide.setProjectName(name);
+                myself.saveGitHubProject();
+            }
         } else { // 'local'
             if (detect(
                     this.projectList,
@@ -4549,6 +5088,156 @@ ProjectDialogMorph.prototype.saveCloudProject = function () {
     this.destroy();
 };
 
+ProjectDialogMorph.prototype.saveGitHubProject = function () {
+    var myself = this;
+    this.ide.showMessage('Committing project\nto GitHub...');
+    GitHub.saveProject(
+        this.ide,
+        function () {
+            myself.ide.source = 'github';
+            myself.ide.showMessage('saved.', 2);
+        },
+        this.ide.githubError()
+    );
+    this.destroy();
+};
+
+ProjectDialogMorph.prototype.deleteProject = function () {
+    var myself = this,
+        proj,
+        idx,
+        name;
+
+    if (this.source === 'github') {
+        // TODO: not implemented
+    } else if (this.source === 'cloud') {
+        proj = this.listField.selected;
+        if (proj) {
+            this.ide.confirm(
+                localize( 'Are you sure you want to delete'
+                ) + '\n"' + proj.ProjectName + '"?',
+                'Delete Project',
+                function () {
+                    SnapCloud.reconnect(
+                        function () {
+                            SnapCloud.callService(
+                                'deleteProject',
+                                function () {
+                                    SnapCloud.disconnect();
+                                    myself.ide.hasChangedMedia = true;
+                                    idx = myself.projectList.indexOf(proj);
+                                    myself.projectList.splice(idx, 1);
+                                    myself.installCloudProjectList(
+                                        myself.projectList
+                                    ); // refresh list
+                                },
+                                myself.ide.cloudError(),
+                                [proj.ProjectName]
+                            );
+                        },
+                        myself.ide.cloudError()
+                    );
+                }
+            );
+        }
+    } else { // 'local, examples'
+        if (this.listField.selected) {
+            name = this.listField.selected.name;
+            this.ide.confirm(
+                localize(
+                    'Are you sure you want to delete'
+                ) + '\n"' + name + '"?',
+                'Delete Project',
+                function () {
+                    delete localStorage['-snap-project-' + name];
+                    myself.setSource(myself.source); // refresh list
+                }
+            );
+        }
+    }
+};
+
+ProjectDialogMorph.prototype.shareProject = function () {
+    var myself = this,
+        proj = this.listField.selected,
+        entry = this.listField.active;
+
+    if (proj) {
+        this.ide.confirm(
+            localize(
+                'Are you sure you want to publish'
+            ) + '\n"' + proj.ProjectName + '"?',
+            'Share Project',
+            function () {
+                myself.ide.showMessage('sharing\nproject...');
+                SnapCloud.reconnect(
+                    function () {
+                        SnapCloud.callService(
+                            'publishProject',
+                            function () {
+                                SnapCloud.disconnect();
+                                proj.Public = 'true';
+                                myself.unshareButton.show();
+                                myself.shareButton.hide();
+                                entry.label.isBold = true;
+                                entry.label.drawNew();
+                                entry.label.changed();
+                                myself.buttons.fixLayout();
+                                myself.drawNew();
+                                myself.ide.showMessage('shared.', 2);
+                            },
+                            myself.ide.cloudError(),
+                            [proj.ProjectName]
+                        );
+                    },
+                    myself.ide.cloudError()
+                );
+            }
+        );
+    }
+};
+
+ProjectDialogMorph.prototype.unshareProject = function () {
+    var myself = this,
+        proj = this.listField.selected,
+        entry = this.listField.active;
+
+
+    if (proj) {
+        this.ide.confirm(
+            localize(
+                'Are you sure you want to unpublish'
+            ) + '\n"' + proj.ProjectName + '"?',
+            'Unshare Project',
+            function () {
+                myself.ide.showMessage('unsharing\nproject...');
+                SnapCloud.reconnect(
+                    function () {
+                        SnapCloud.callService(
+                            'unpublishProject',
+                            function () {
+                                SnapCloud.disconnect();
+                                proj.Public = 'false';
+                                myself.shareButton.show();
+                                myself.unshareButton.hide();
+                                entry.label.isBold = false;
+                                entry.label.drawNew();
+                                entry.label.changed();
+                                myself.buttons.fixLayout();
+                                myself.drawNew();
+                                myself.ide.showMessage('unshared.', 2);
+                            },
+                            myself.ide.cloudError(),
+                            [proj.ProjectName]
+                        );
+                    },
+                    myself.ide.cloudError()
+                );
+            }
+        );
+    }
+};
+
 ProjectDialogMorph.prototype.edit = function () {
     if (this.nameField) {
         this.nameField.edit();
diff --git a/snap.html b/snap.html
index 26c5124..11e0095 100755
--- a/snap.html
+++ b/snap.html
@@ -16,9 +16,10 @@
 		<script type="text/javascript" src="xml.js"></script>
 		<script type="text/javascript" src="store.js"></script>
 		<script type="text/javascript" src="locale.js"></script>
+		<script type="text/javascript" src="cloud.js"></script>
         <script type="text/javascript" src="octokit/promise-1.0.0.js"></script>
         <script type="text/javascript" src="octokit/octokit.js"></script>
-		<script type="text/javascript" src="cloud.js"></script>
+        <script type="text/javascript" src="github.js"></script>
 		<script type="text/javascript" src="sha512.js"></script>
 		<script type="text/javascript">
 			var world;
-- 
cgit v1.3.1


From d54340a6571ebe140046e9f56c3450ac2b2178b5 Mon Sep 17 00:00:00 2001
From: Gubolin <gubolin@fantasymail.de>
Date: Sun, 3 Aug 2014 17:39:34 +0200
Subject: add octokit.js as submodule

---
 .gitmodules      |   3 +
 octokit.js       |   1 +
 promise-1.0.0.js | 684 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 snap.html        |   6 +-
 4 files changed, 691 insertions(+), 3 deletions(-)
 create mode 100644 .gitmodules
 create mode 160000 octokit.js
 create mode 100644 promise-1.0.0.js

(limited to 'snap.html')

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..24bc92d
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "octokit.js"]
+	path = octokit.js
+	url = https://github.com/philschatz/octokit.js
diff --git a/octokit.js b/octokit.js
new file mode 160000
index 0000000..d7d66ce
--- /dev/null
+++ b/octokit.js
@@ -0,0 +1 @@
+Subproject commit d7d66ce448edc4eb58664721c5b73655ebe172a5
diff --git a/promise-1.0.0.js b/promise-1.0.0.js
new file mode 100644
index 0000000..5619cfa
--- /dev/null
+++ b/promise-1.0.0.js
@@ -0,0 +1,684 @@
+(function() {
+var define, requireModule, require, requirejs;
+
+(function() {
+  var registry = {}, seen = {};
+
+  define = function(name, deps, callback) {
+    registry[name] = { deps: deps, callback: callback };
+  };
+
+  requirejs = require = requireModule = function(name) {
+  requirejs._eak_seen = registry;
+
+    if (seen[name]) { return seen[name]; }
+    seen[name] = {};
+
+    if (!registry[name]) {
+      throw new Error("Could not find module " + name);
+    }
+
+    var mod = registry[name],
+        deps = mod.deps,
+        callback = mod.callback,
+        reified = [],
+        exports;
+
+    for (var i=0, l=deps.length; i<l; i++) {
+      if (deps[i] === 'exports') {
+        reified.push(exports = {});
+      } else {
+        reified.push(requireModule(resolve(deps[i])));
+      }
+    }
+
+    var value = callback.apply(this, reified);
+    return seen[name] = exports || value;
+
+    function resolve(child) {
+      if (child.charAt(0) !== '.') { return child; }
+      var parts = child.split("/");
+      var parentBase = name.split("/").slice(0, -1);
+
+      for (var i=0, l=parts.length; i<l; i++) {
+        var part = parts[i];
+
+        if (part === '..') { parentBase.pop(); }
+        else if (part === '.') { continue; }
+        else { parentBase.push(part); }
+      }
+
+      return parentBase.join("/");
+    }
+  };
+})();
+
+define("promise/all", 
+  ["./utils","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /* global toString */
+
+    var isArray = __dependency1__.isArray;
+    var isFunction = __dependency1__.isFunction;
+
+    /**
+      Returns a promise that is fulfilled when all the given promises have been
+      fulfilled, or rejected if any of them become rejected. The return promise
+      is fulfilled with an array that gives all the values in the order they were
+      passed in the `promises` array argument.
+
+      Example:
+
+      ```javascript
+      var promise1 = RSVP.resolve(1);
+      var promise2 = RSVP.resolve(2);
+      var promise3 = RSVP.resolve(3);
+      var promises = [ promise1, promise2, promise3 ];
+
+      RSVP.all(promises).then(function(array){
+        // The array here would be [ 1, 2, 3 ];
+      });
+      ```
+
+      If any of the `promises` given to `RSVP.all` are rejected, the first promise
+      that is rejected will be given as an argument to the returned promises's
+      rejection handler. For example:
+
+      Example:
+
+      ```javascript
+      var promise1 = RSVP.resolve(1);
+      var promise2 = RSVP.reject(new Error("2"));
+      var promise3 = RSVP.reject(new Error("3"));
+      var promises = [ promise1, promise2, promise3 ];
+
+      RSVP.all(promises).then(function(array){
+        // Code here never runs because there are rejected promises!
+      }, function(error) {
+        // error.message === "2"
+      });
+      ```
+
+      @method all
+      @for RSVP
+      @param {Array} promises
+      @param {String} label
+      @return {Promise} promise that is fulfilled when all `promises` have been
+      fulfilled, or rejected if any of them become rejected.
+    */
+    function all(promises) {
+      /*jshint validthis:true */
+      var Promise = this;
+
+      if (!isArray(promises)) {
+        throw new TypeError('You must pass an array to all.');
+      }
+
+      return new Promise(function(resolve, reject) {
+        var results = [], remaining = promises.length,
+        promise;
+
+        if (remaining === 0) {
+          resolve([]);
+        }
+
+        function resolver(index) {
+          return function(value) {
+            resolveAll(index, value);
+          };
+        }
+
+        function resolveAll(index, value) {
+          results[index] = value;
+          if (--remaining === 0) {
+            resolve(results);
+          }
+        }
+
+        for (var i = 0; i < promises.length; i++) {
+          promise = promises[i];
+
+          if (promise && isFunction(promise.then)) {
+            promise.then(resolver(i), reject);
+          } else {
+            resolveAll(i, promise);
+          }
+        }
+      });
+    }
+
+    __exports__.all = all;
+  });
+define("promise/asap", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var browserGlobal = (typeof window !== 'undefined') ? window : {};
+    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var local = (typeof global !== 'undefined') ? global : (this === undefined? window:this);
+
+    // node
+    function useNextTick() {
+      return function() {
+        process.nextTick(flush);
+      };
+    }
+
+    function useMutationObserver() {
+      var iterations = 0;
+      var observer = new BrowserMutationObserver(flush);
+      var node = document.createTextNode('');
+      observer.observe(node, { characterData: true });
+
+      return function() {
+        node.data = (iterations = ++iterations % 2);
+      };
+    }
+
+    function useSetTimeout() {
+      return function() {
+        local.setTimeout(flush, 1);
+      };
+    }
+
+    var queue = [];
+    function flush() {
+      for (var i = 0; i < queue.length; i++) {
+        var tuple = queue[i];
+        var callback = tuple[0], arg = tuple[1];
+        callback(arg);
+      }
+      queue = [];
+    }
+
+    var scheduleFlush;
+
+    // Decide what async method to use to triggering processing of queued callbacks:
+    if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+      scheduleFlush = useNextTick();
+    } else if (BrowserMutationObserver) {
+      scheduleFlush = useMutationObserver();
+    } else {
+      scheduleFlush = useSetTimeout();
+    }
+
+    function asap(callback, arg) {
+      var length = queue.push([callback, arg]);
+      if (length === 1) {
+        // If length is 1, that means that we need to schedule an async flush.
+        // If additional callbacks are queued before the queue is flushed, they
+        // will be processed by this flush that we are scheduling.
+        scheduleFlush();
+      }
+    }
+
+    __exports__.asap = asap;
+  });
+define("promise/config", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var config = {
+      instrument: false
+    };
+
+    function configure(name, value) {
+      if (arguments.length === 2) {
+        config[name] = value;
+      } else {
+        return config[name];
+      }
+    }
+
+    __exports__.config = config;
+    __exports__.configure = configure;
+  });
+define("promise/polyfill", 
+  ["./promise","./utils","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    /*global self*/
+    var RSVPPromise = __dependency1__.Promise;
+    var isFunction = __dependency2__.isFunction;
+
+    function polyfill() {
+      var local;
+
+      if (typeof global !== 'undefined') {
+        local = global;
+      } else if (typeof window !== 'undefined' && window.document) {
+        local = window;
+      } else {
+        local = self;
+      }
+
+      var es6PromiseSupport = 
+        "Promise" in local &&
+        // Some of these methods are missing from
+        // Firefox/Chrome experimental implementations
+        "resolve" in local.Promise &&
+        "reject" in local.Promise &&
+        "all" in local.Promise &&
+        "race" in local.Promise &&
+        // Older version of the spec had a resolver object
+        // as the arg rather than a function
+        (function() {
+          var resolve;
+          new local.Promise(function(r) { resolve = r; });
+          return isFunction(resolve);
+        }());
+
+      if (!es6PromiseSupport) {
+        local.Promise = RSVPPromise;
+      }
+    }
+
+    __exports__.polyfill = polyfill;
+  });
+define("promise/promise", 
+  ["./config","./utils","./all","./race","./resolve","./reject","./asap","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __exports__) {
+    "use strict";
+    var config = __dependency1__.config;
+    var configure = __dependency1__.configure;
+    var objectOrFunction = __dependency2__.objectOrFunction;
+    var isFunction = __dependency2__.isFunction;
+    var now = __dependency2__.now;
+    var all = __dependency3__.all;
+    var race = __dependency4__.race;
+    var staticResolve = __dependency5__.resolve;
+    var staticReject = __dependency6__.reject;
+    var asap = __dependency7__.asap;
+
+    var counter = 0;
+
+    config.async = asap; // default async is asap;
+
+    function Promise(resolver) {
+      if (!isFunction(resolver)) {
+        throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+      }
+
+      if (!(this instanceof Promise)) {
+        throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+      }
+
+      this._subscribers = [];
+
+      invokeResolver(resolver, this);
+    }
+
+    function invokeResolver(resolver, promise) {
+      function resolvePromise(value) {
+        resolve(promise, value);
+      }
+
+      function rejectPromise(reason) {
+        reject(promise, reason);
+      }
+
+      try {
+        resolver(resolvePromise, rejectPromise);
+      } catch(e) {
+        rejectPromise(e);
+      }
+    }
+
+    function invokeCallback(settled, promise, callback, detail) {
+      var hasCallback = isFunction(callback),
+          value, error, succeeded, failed;
+
+      if (hasCallback) {
+        try {
+          value = callback(detail);
+          succeeded = true;
+        } catch(e) {
+          failed = true;
+          error = e;
+        }
+      } else {
+        value = detail;
+        succeeded = true;
+      }
+
+      if (handleThenable(promise, value)) {
+        return;
+      } else if (hasCallback && succeeded) {
+        resolve(promise, value);
+      } else if (failed) {
+        reject(promise, error);
+      } else if (settled === FULFILLED) {
+        resolve(promise, value);
+      } else if (settled === REJECTED) {
+        reject(promise, value);
+      }
+    }
+
+    var PENDING   = void 0;
+    var SEALED    = 0;
+    var FULFILLED = 1;
+    var REJECTED  = 2;
+
+    function subscribe(parent, child, onFulfillment, onRejection) {
+      var subscribers = parent._subscribers;
+      var length = subscribers.length;
+
+      subscribers[length] = child;
+      subscribers[length + FULFILLED] = onFulfillment;
+      subscribers[length + REJECTED]  = onRejection;
+    }
+
+    function publish(promise, settled) {
+      var child, callback, subscribers = promise._subscribers, detail = promise._detail;
+
+      for (var i = 0; i < subscribers.length; i += 3) {
+        child = subscribers[i];
+        callback = subscribers[i + settled];
+
+        invokeCallback(settled, child, callback, detail);
+      }
+
+      promise._subscribers = null;
+    }
+
+    Promise.prototype = {
+      constructor: Promise,
+
+      _state: undefined,
+      _detail: undefined,
+      _subscribers: undefined,
+
+      then: function(onFulfillment, onRejection) {
+        var promise = this;
+
+        var thenPromise = new this.constructor(function() {});
+
+        if (this._state) {
+          var callbacks = arguments;
+          config.async(function invokePromiseCallback() {
+            invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
+          });
+        } else {
+          subscribe(this, thenPromise, onFulfillment, onRejection);
+        }
+
+        return thenPromise;
+      },
+
+      'catch': function(onRejection) {
+        return this.then(null, onRejection);
+      }
+    };
+
+    Promise.all = all;
+    Promise.race = race;
+    Promise.resolve = staticResolve;
+    Promise.reject = staticReject;
+
+    function handleThenable(promise, value) {
+      var then = null,
+      resolved;
+
+      try {
+        if (promise === value) {
+          throw new TypeError("A promises callback cannot return that same promise.");
+        }
+
+        if (objectOrFunction(value)) {
+          then = value.then;
+
+          if (isFunction(then)) {
+            then.call(value, function(val) {
+              if (resolved) { return true; }
+              resolved = true;
+
+              if (value !== val) {
+                resolve(promise, val);
+              } else {
+                fulfill(promise, val);
+              }
+            }, function(val) {
+              if (resolved) { return true; }
+              resolved = true;
+
+              reject(promise, val);
+            });
+
+            return true;
+          }
+        }
+      } catch (error) {
+        if (resolved) { return true; }
+        reject(promise, error);
+        return true;
+      }
+
+      return false;
+    }
+
+    function resolve(promise, value) {
+      if (promise === value) {
+        fulfill(promise, value);
+      } else if (!handleThenable(promise, value)) {
+        fulfill(promise, value);
+      }
+    }
+
+    function fulfill(promise, value) {
+      if (promise._state !== PENDING) { return; }
+      promise._state = SEALED;
+      promise._detail = value;
+
+      config.async(publishFulfillment, promise);
+    }
+
+    function reject(promise, reason) {
+      if (promise._state !== PENDING) { return; }
+      promise._state = SEALED;
+      promise._detail = reason;
+
+      config.async(publishRejection, promise);
+    }
+
+    function publishFulfillment(promise) {
+      publish(promise, promise._state = FULFILLED);
+    }
+
+    function publishRejection(promise) {
+      publish(promise, promise._state = REJECTED);
+    }
+
+    __exports__.Promise = Promise;
+  });
+define("promise/race", 
+  ["./utils","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /* global toString */
+    var isArray = __dependency1__.isArray;
+
+    /**
+      `RSVP.race` allows you to watch a series of promises and act as soon as the
+      first promise given to the `promises` argument fulfills or rejects.
+
+      Example:
+
+      ```javascript
+      var promise1 = new RSVP.Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve("promise 1");
+        }, 200);
+      });
+
+      var promise2 = new RSVP.Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve("promise 2");
+        }, 100);
+      });
+
+      RSVP.race([promise1, promise2]).then(function(result){
+        // result === "promise 2" because it was resolved before promise1
+        // was resolved.
+      });
+      ```
+
+      `RSVP.race` is deterministic in that only the state of the first completed
+      promise matters. For example, even if other promises given to the `promises`
+      array argument are resolved, but the first completed promise has become
+      rejected before the other promises became fulfilled, the returned promise
+      will become rejected:
+
+      ```javascript
+      var promise1 = new RSVP.Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve("promise 1");
+        }, 200);
+      });
+
+      var promise2 = new RSVP.Promise(function(resolve, reject){
+        setTimeout(function(){
+          reject(new Error("promise 2"));
+        }, 100);
+      });
+
+      RSVP.race([promise1, promise2]).then(function(result){
+        // Code here never runs because there are rejected promises!
+      }, function(reason){
+        // reason.message === "promise2" because promise 2 became rejected before
+        // promise 1 became fulfilled
+      });
+      ```
+
+      @method race
+      @for RSVP
+      @param {Array} promises array of promises to observe
+      @param {String} label optional string for describing the promise returned.
+      Useful for tooling.
+      @return {Promise} a promise that becomes fulfilled with the value the first
+      completed promises is resolved with if the first completed promise was
+      fulfilled, or rejected with the reason that the first completed promise
+      was rejected with.
+    */
+    function race(promises) {
+      /*jshint validthis:true */
+      var Promise = this;
+
+      if (!isArray(promises)) {
+        throw new TypeError('You must pass an array to race.');
+      }
+      return new Promise(function(resolve, reject) {
+        var results = [], promise;
+
+        for (var i = 0; i < promises.length; i++) {
+          promise = promises[i];
+
+          if (promise && typeof promise.then === 'function') {
+            promise.then(resolve, reject);
+          } else {
+            resolve(promise);
+          }
+        }
+      });
+    }
+
+    __exports__.race = race;
+  });
+define("promise/reject", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      `RSVP.reject` returns a promise that will become rejected with the passed
+      `reason`. `RSVP.reject` is essentially shorthand for the following:
+
+      ```javascript
+      var promise = new RSVP.Promise(function(resolve, reject){
+        reject(new Error('WHOOPS'));
+      });
+
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
+
+      Instead of writing the above, your code now simply becomes the following:
+
+      ```javascript
+      var promise = RSVP.reject(new Error('WHOOPS'));
+
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
+
+      @method reject
+      @for RSVP
+      @param {Any} reason value that the returned promise will be rejected with.
+      @param {String} label optional string for identifying the returned promise.
+      Useful for tooling.
+      @return {Promise} a promise that will become rejected with the given
+      `reason`.
+    */
+    function reject(reason) {
+      /*jshint validthis:true */
+      var Promise = this;
+
+      return new Promise(function (resolve, reject) {
+        reject(reason);
+      });
+    }
+
+    __exports__.reject = reject;
+  });
+define("promise/resolve", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function resolve(value) {
+      /*jshint validthis:true */
+      if (value && typeof value === 'object' && value.constructor === this) {
+        return value;
+      }
+
+      var Promise = this;
+
+      return new Promise(function(resolve) {
+        resolve(value);
+      });
+    }
+
+    __exports__.resolve = resolve;
+  });
+define("promise/utils", 
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    function objectOrFunction(x) {
+      return isFunction(x) || (typeof x === "object" && x !== null);
+    }
+
+    function isFunction(x) {
+      return typeof x === "function";
+    }
+
+    function isArray(x) {
+      return Object.prototype.toString.call(x) === "[object Array]";
+    }
+
+    // Date.now is not available in browsers < IE9
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
+    var now = Date.now || function() { return new Date().getTime(); };
+
+
+    __exports__.objectOrFunction = objectOrFunction;
+    __exports__.isFunction = isFunction;
+    __exports__.isArray = isArray;
+    __exports__.now = now;
+  });
+requireModule('promise/polyfill').polyfill();
+}());
\ No newline at end of file
diff --git a/snap.html b/snap.html
index 11e0095..c716efa 100755
--- a/snap.html
+++ b/snap.html
@@ -17,9 +17,9 @@
 		<script type="text/javascript" src="store.js"></script>
 		<script type="text/javascript" src="locale.js"></script>
 		<script type="text/javascript" src="cloud.js"></script>
-        <script type="text/javascript" src="octokit/promise-1.0.0.js"></script>
-        <script type="text/javascript" src="octokit/octokit.js"></script>
-        <script type="text/javascript" src="github.js"></script>
+                <script type="text/javascript" src="promise-1.0.0.js"></script>
+                <script type="text/javascript" src="octokit.js/octokit.js"></script>
+                <script type="text/javascript" src="github.js"></script>
 		<script type="text/javascript" src="sha512.js"></script>
 		<script type="text/javascript">
 			var world;
-- 
cgit v1.3.1


From f70276f603a346f51bacb946fb6e615bb2a09f66 Mon Sep 17 00:00:00 2001
From: Gubolin <gubolin@fantasymail.de>
Date: Fri, 12 Sep 2014 15:42:12 +0200
Subject: beautify xml

---
 .gitmodules | 3 +++
 snap.html   | 1 +
 store.js    | 4 ++--
 vkBeautify  | 1 +
 4 files changed, 7 insertions(+), 2 deletions(-)
 create mode 100644 .gitmodules
 create mode 160000 vkBeautify

(limited to 'snap.html')

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..c2d8927
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "vkBeautify"]
+	path = vkBeautify
+	url = https://github.com/vkiryukhin/vkBeautify
diff --git a/snap.html b/snap.html
index 904aba8..867f552 100755
--- a/snap.html
+++ b/snap.html
@@ -18,6 +18,7 @@
 		<script type="text/javascript" src="locale.js"></script>
 		<script type="text/javascript" src="cloud.js"></script>
 		<script type="text/javascript" src="sha512.js"></script>
+                <script type="text/javascript" src="vkBeautify/vkbeautify.js"></script>
 		<script type="text/javascript">
 			var world;
 			window.onload = function () {
diff --git a/store.js b/store.js
index f8d46bf..56ead6c 100644
--- a/store.js
+++ b/store.js
@@ -97,7 +97,7 @@ XML_Serializer.prototype.serialize = function (object) {
     this.flushMedia();
     xml = this.store(object);
     this.flush();
-    return xml;
+    return vkbeautify.xml(xml);
 };
 
 XML_Serializer.prototype.store = function (object, mediaID) {
@@ -135,7 +135,7 @@ XML_Serializer.prototype.mediaXML = function () {
         );
         xml = xml + str;
     });
-    return xml + '</media>';
+    return vkbeautify.xml(xml + '</media>');
 };
 
 XML_Serializer.prototype.add = function (object) {
diff --git a/vkBeautify b/vkBeautify
new file mode 160000
index 0000000..ecfc3b9
--- /dev/null
+++ b/vkBeautify
@@ -0,0 +1 @@
+Subproject commit ecfc3b9e2b911ad8ebd49600c4089aca30619f29
-- 
cgit v1.3.1


From 0772e7d750532a91fc89c9bb131229a7fb989b91 Mon Sep 17 00:00:00 2001
From: Gubolin <gubolin@fantasymail.de>
Date: Fri, 12 Sep 2014 19:54:58 +0200
Subject: support merging [WIP]

---
 .gitmodules |  3 +++
 github.js   | 71 ++++++++++++++++++++++++++++++++++++++++++-------------------
 gui.js      | 18 +++++++++++++---
 snap.html   |  1 +
 4 files changed, 68 insertions(+), 25 deletions(-)

(limited to 'snap.html')

diff --git a/.gitmodules b/.gitmodules
index 417778f..510117d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,6 @@
 [submodule "vkBeautify"]
 	path = vkBeautify
 	url = https://github.com/vkiryukhin/vkBeautify
+[submodule "diff-merge"]
+	path = diff-merge
+	url = https://github.com/nighca/diff-merge
diff --git a/github.js b/github.js
index c261cbb..f231e6d 100644
--- a/github.js
+++ b/github.js
@@ -57,7 +57,8 @@ GitHubBackend.prototype.getProject = function (
     userName,
     projectName,
     callBack,
-    errorCall
+    errorCall,
+    commitSha
 ) {
     var myself = this;
 
@@ -67,12 +68,19 @@ GitHubBackend.prototype.getProject = function (
 
     var repo = myself.gh.getRepo(userName, projectName);
     var branch = repo.getBranch(); // master (default)
-
-    branch.read('snap.xml', false).then(
-        function (sourceContent) {
-            callBack.call(
-                null,
-                sourceContent.content
+    branch.getCommits({}).then(
+        function (commits) {
+            branch.read('snap.xml', false).then(
+                function (sourceContent) {
+                    callBack.call(
+                        null,
+                        sourceContent.content,
+                        commits[0].sha
+                    );
+                },
+                function (error) {
+                    errorCall.call(this, error, 'GitHub');
+                }
             );
         },
         function (error) {
@@ -100,7 +108,7 @@ GitHubBackend.prototype.login = function (
         me = myself.gh.getUser();
         if (me !== null) {
             me.getInfo().then(
-                function(info) {
+                function() {
                     myself.username = username;
                     myself.password = password;
 
@@ -121,7 +129,7 @@ GitHubBackend.prototype.login = function (
     }
 };
 
-GitHubBackend.prototype.saveProject = function (commitMessage, ide, callBack, errorCall) {
+GitHubBackend.prototype.saveProject = function (commitMessage, parentCommitSha, lastCommit, ide, callBack, errorCall) {
     var myself = this,
         data;
     var pdata, media;
@@ -162,27 +170,46 @@ GitHubBackend.prototype.saveProject = function (commitMessage, ide, callBack, er
                     }
                 });
 
-                function pushChanges () {
+                pushChanges = function () {
                     if (myself.gh !== null) {
                         var repo = myself.gh.getRepo(myself.username, ide.projectName);
                         var branch = repo.getBranch(); // master (default)
                         var message = commitMessage;
 
-                        var contents = {
-                            'snap.xml': data,
-                            'README.md': ide.projectNotes
+                        writeChanges = function (code, pcSha) {
+                            if (pcSha !== parentCommitSha && data !== code) {
+                                var compareResult = window.diff.compare(lastCommit, data, '\n'); // get diff from last push
+                                data = window.diff.merge(code, compareResult); // apply it to the latest code
+                                console.log(data);
+                            }
+
+                            var contents = {
+                                'snap.xml': data,
+                                'README.md': ide.projectNotes
+                            };
+
+                            branch.writeMany(contents, message, pcSha).then(
+                                function () {
+                                    callBack.call();
+                                },
+                                function (error) {
+                                    errorCall.call(this, error, 'GitHub');
+                                }
+                            );
                         };
 
-                        branch.writeMany(contents, message).then(
-                            function () {
-                                callBack.call();
-                            },
-                            function (error) {
-                                errorCall.call(this, error, 'GitHub');
-                            }
-                        );
+                        if (parentCommitSha !== null) { // repo was just created
+                            myself.getProject(myself.username, ide.projectName,
+                                writeChanges,
+                                function (error) {
+                                    errorCall.call(this, error, 'GitHub');
+                                }
+                            );
+                        } else {
+                            writeChanges(data, parentCommitSha);
+                        }
                     }
-                }
+                };
 
                 if (exists === false){
                     myself.gh.getUser().createRepo(repoName, { // these should be discussed
diff --git a/gui.js b/gui.js
index 6ae7222..1cc8468 100644
--- a/gui.js
+++ b/gui.js
@@ -221,6 +221,8 @@ IDE_Morph.prototype.init = function (isAutoFill) {
     this.stageRatio = 1; // for IDE animations, e.g. when zooming
 
     this.loadNewProject = false; // flag when starting up translated
+    this.parentCommitSha = null; // for GitHub
+    this.lastCommit = null; // for GitHub
     this.shield = null;
 
     // initialize inherited properties:
@@ -401,13 +403,15 @@ IDE_Morph.prototype.openIn = function (world) {
             GitHub.getProject(
                 dict.Username,
                 dict.projectName,
-                function (code) {
+                function (code, pcSha) {
                     var msg;
                     myself.nextSteps([
                         function () {
                             msg = myself.showMessage('Opening GitHub project...');
                         },
                         function () {
+                            myself.parentCommitSha = pcSha;
+                            myself.lastCommit = code;
                             myself.rawOpenCloudDataString(code);
                             myself.hasChangedMedia = true;
                         },
@@ -3935,13 +3939,17 @@ IDE_Morph.prototype.saveProjectToGitHub = function (name, commitMessage) {
         this.setProjectName(name);
         GitHub.saveProject(
             commitMessage,
+            this.parentCommitSha,
+            this.lastCommit,
             this,
             function () {
                 GitHub.getProject(
                     GitHub.username,
                     name, 
-                    function (code) {
+                    function (code, pcSha) {
                         myself.source = 'github';
+                        myself.parentCommitSha = pcSha;
+                        myself.lastCommit = code;
                         myself.droppedText(code);
                     },
                     myself.githubError()
@@ -5072,8 +5080,10 @@ ProjectDialogMorph.prototype.rawOpenGitHubProject = function (proj, user) {
     GitHub.getProject(
         user,
         proj.ProjectName, 
-        function (code) {
+        function (code, pcSha) {
             myself.ide.source = 'github';
+            myself.ide.parentCommitSha = pcSha;
+            myself.ide.lastCommit = code;
             myself.ide.droppedText(code);
         },
         myself.ide.githubError()
@@ -5171,6 +5181,8 @@ ProjectDialogMorph.prototype.saveGitHubProject = function () {
     this.ide.showMessage('Committing project\nto GitHub...');
     GitHub.saveProject(
         null,
+        this.ide.parentCommitSha,
+        this.ide.lastCommit,
         this.ide,
         function () {
             myself.ide.source = 'github';
diff --git a/snap.html b/snap.html
index 733b571..63bdebd 100755
--- a/snap.html
+++ b/snap.html
@@ -22,6 +22,7 @@
                 <script type="text/javascript" src="github.js"></script>
 		<script type="text/javascript" src="sha512.js"></script>
                 <script type="text/javascript" src="vkBeautify/vkbeautify.js"></script>
+                <script type="text/javascript" src="diff-merge/dist/diff.js"></script>
 		<script type="text/javascript">
 			var world;
 			window.onload = function () {
-- 
cgit v1.3.1