Added VIM app

Author: PROPHESSOR

js/apps/vim/index.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const Vim = require('./js-vim');
+let vim;
+let kb;
+let io;
+let res;
+// const tui = require('terminal-ui');
+
+// const mauve = require('./mauve');
+// const scheme = require('./lib/scheme');
+// mauve.set(scheme);
+
+const kbaliases = {
+  enter: '\n',
+  tab: '\t',
+  backspace: '\b',
+  space: ' ',
+  escape: 'esc',
+  kpup: '↑',
+  kpdown: '↓',
+  kpleft: '←',
+  kpright: '→',
+};
+
+// const kbignore = ['kpdown', 'kpup', 'kpleft', 'kpright'];
+
+function keyboard(key) {
+  if (key.type === 'kppagedown') {
+    kb.onKeydown.remove(keyboard);
+    return res(0);
+  }
+
+  // if (kbignore.indexOf(key.type) !== -1) return false;
+  if (key.type === 'character') {
+    vim.exec(kbaliases[key.character] || key.character);
+  } else {
+    vim.exec(kbaliases[key.type] || key.type.slice(0, 2) === 'kp' ? '' : key.type);
+  }
+  return false;
+}
+
+function main(api, cb) {
+    // Instance
+  vim = new Vim();
+
+  kb = api.keyboard;
+  io = api.stdio;
+  res = cb;
+
+  // Apply node commands (file write, etc.)
+  require('./lib/commands')(vim);
+
+  kb.onKeydown.add(keyboard);
+
+  io.clear();
+  io.write(vim.view.getText());
+
+    // Tie tui to vim.view
+  vim.view.on('change', () => {
+    io.clear();
+    io.write(vim.view.getText());
+  });
+}
+exports.commands = ['vim'];
+exports.call = (app, args, api, res) => {
+  main(api, res);
+};

js/apps/vim/js-vim/.swo

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - 0.10.5

js/apps/vim/js-vim/.travis.yml

@@ -0,0 +1,86 @@
+#js-vim
+
+![Build status](https://api.travis-ci.org/itsjoesullivan/js-vim.png)
+
+A javascript implementation of the popular vi clone.
+
+##Why bother?
+
+We already edit a lot of code online. Bringing our editor of choice to the web makes that a more enjoyable process!
+
+##Implementations
+
+This repo contains the vim "model", which is currently implemented in [web-embeddable](https://github.com/itsjoesullivan/js-vim-embed/) and [terminal](https://github.com/itsjoesullivan/js-vim-node/) versions.
+
+##Usage
+
+What makes this project palatable is an extensible API:
+
+```javascript
+vim.addCommand({
+	mode: 'command',
+	match: 'o',
+	fn: function() {
+		//The lowercase 'o' command can be represented using these commands
+		this.exec(['$','a','\n']);
+	}
+});
+```
+
+Aside from simplifying the process of defining current vim commands, it makes extending vim a cinch:
+
+```javascript
+//Open a file from dropbox
+vim.addCommand({
+	mode: 'command',
+	match: /:o (.*)\n/,
+	fn: function(path) {
+		dropboxClient.readFile(path, function(err,data) {
+			if(err) return this.notify("Error reading file");
+			var doc = new this.Doc({
+				text: data,
+				path: path
+			});
+			this.add(doc);
+		});
+	}
+});
+
+//Save a file to dropbox
+vim.addCommand({
+	mode: 'command',
+	match: /:w(?: (.*))?\n/,
+	fn: function(path) {
+		var doc = this.curDoc,
+			path = path || doc.path;
+		dropboxClient.writeFile(path, doc.text(), function(err) {
+			if(err) return this.notify(err);
+			this.notify('"' + path + '" written.');		
+		});
+	}
+});
+```
+
+##License
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Joe Sullivan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

js/apps/vim/js-vim/README.md

@@ -0,0 +1,4 @@
+#Why do this?
+
+##vim-as-language
+One way to think of Vim is as a language: the language of navigating and editing a document.

js/apps/vim/js-vim/args.md

@@ -0,0 +1,19 @@
+echo "Prepping js-vim-embed"
+cd ../js-vim-embed-page
+git checkout master
+echo "	Building js-vim-embed"
+./build
+git add vim*
+git commit -m "js-vim update"
+echo "	Committing new js-vim-embed"
+echo "Prepping js-vim-embed/gh-pages"
+git checkout gh-pages
+echo "	Checking out new build"
+git checkout master vim.js
+git checkout master vim.min.js
+git add vim*
+echo "	Committing changes"
+git commit -m "js-vim update"
+echo "Pushing to gh-pages"
+git push origin gh-pages
+echo "Deploy complete"

js/apps/vim/js-vim/deploy

@@ -0,0 +1,134 @@
+##Explanation for the overall design
+
+This is a slight elaboration of README for the sake of communicating the core of the design.
+
+This project views vim's extensibility as arising from the interchangeability of various key commands:
+
+```
+	'2dd' -->		'dd', 'dd'
+
+	'dd' -->		'0','v','$','x','del'
+```
+
+So, if we define a few core commands:
+
+```
+  v: begin selection
+  0: move to beginning of line
+  $: move to end of line
+  x: delete selection
+```
+
+Then define a few other commands:
+
+```
+	'dd': ['0','v','$','x','del']
+	'2dd': ['dd','dd']
+```
+
+We start to get some of that extensibility.
+
+###In code
+
+If we implement commands as key/value pairs, where keys are regular expressions and values are functions:
+
+```javascript
+	/([0-9]+)dd/: function(result) { //result is /([0-9]+)dd/.exec(keyBuffer)
+		vim.exec(['0','v']);
+		var ct = parseInt(result[1]); //the captured number
+		while(ct--) {
+			vim.exec('j');
+		}
+		vim.exec(['$','x','backspace']);
+	}
+```
+
+We can be clever:
+
+```javascript
+	/dd/: function(result) {
+		vim.exec('1dd');
+	};
+```
+
+###Command definition API
+
+Commands depend on mode, so they are declared like:
+
+```javascript
+	vim.addMode({
+		'insert': {
+			'(.*)': function(res) {
+				vim.insert(res[0]);
+			}
+		}
+	});
+
+	vim.addMode({
+		'command': {
+			'i': function() {
+				vim.mode = 'insert';
+			},
+			'j': function(res) {
+				vim.cursor.line--;
+			},
+	    ...
+	  }
+	});
+```
+
+###Useful functionality
+
+Any key combination can take advantage of the others, but they can do whatever they want. Looking down the road a bit:
+
+```javascript
+	// /src/modes/github.js
+
+	//imagine this exists, which it kind of does.
+	var git = new Github({username: cred.username, password: cred.password});
+	var repo = git.getRepo('itsjoesullivan/vim');
+
+	vim.fileSystem.addDirectory('itsjoesullivan/vim',repo.ls()); //maybe we could add a filesystem here
+
+	/*
+		now:
+			vim.exec(':cd itsjoesullivan/vim'); //imagine this exists
+			vim.exec(':e index.html'); //opens file at https://github.com/itsjoesullivan/vim/index.html
+	*/
+
+	vim.addMode({
+		'github': {
+			/gh push/: function(res) {
+				repo.push(); //imagining we've connected to github, the document came from there, whatever.
+			},
+			/gh add (.*)/: function(res) {
+				repo.add(res[1]); //let git handle "index.*" vs "index.html"
+			},
+			/gh commit (.*)/: function(res) {
+				repo.commit(res[1]); //similar.
+			}
+		}
+	});
+```
+
+###Testing
+
+Testing of key operations is very straightforward:
+
+```javascript
+describe('command::x', function() {
+	it('erases current character', function() {
+		vim.doc.set('hello\nworld');
+		vim.exec(['gg','x']);
+		expect(vim.doc.get()).equal('ello\nworld');
+	});
+});
+```
+
+###Rendering
+
+One reason that vim as a web app is cool is because, from a rendering perspective, it's very simple (it runs on old computers!), so it's a good way begin to create an "app" feel in the browser. However, for that reason, it deviates a lot from the DOM paradigm. For example, semantic html would put the entire application into a \<textarea>. Needless to say, that's not helpful. A Backbone-oriented MV system puts each character in its own view (\<span class='char'>h\</span>), which again is not terrifically helpful. A rendering framework that takes some of the manual rendering work out of, say, changing the 'function' keyword a certain color for the sake of syntax highlighting, would be welcome in this project.
+
+###Other stuff
+
+There are other dimensions to vim than text editing: syntax highlighting; formatting; plugins; ... . Those dimensions can largely be implemented alongside the above syntax. The above architecture says nothing about document structure, and it's possible to define such structure in a custom mode, though likely that's better defined at a lower level along with rendering logic. The main point is that the above design allows most development to occur at a relatively high level that's roughly the equivalent of key commands. Only a handful of operations (search, delete, insert, select, move, copy) need to operate on the application internals / document structure. 

js/apps/vim/js-vim/design.md

@@ -0,0 +1,72 @@
+#Cursor
+
+Each doc has at least one cursor. It represents... well, you know.
+
+##API
+
+###Cursor.line(lineNumber)
+
+Get / set the cursor's line number.
+
+__N.B.__ As everywhere else, line number is zero-indexed.
+
+####Get
+```javascript
+var line = cursor.line();
+console.log("The current line number is: " + line);
+```
+####Set
+```javascript
+cursor.line(10);
+```
+###Cursor.char(charNumber)
+
+Get / set the cursor's character.
+
+__N.B.__ This should be changed to "col"
+
+__N.B.__ As everywhere else, line number is zero-indexed.
+
+####Get
+
+```javascript
+var col = cursor.char();
+console.log("The current column is: " + col);
+```
+
+####Set
+
+```javascript
+cursor.char(10);
+```
+
+###Cursor.col(colNumber)
+
+Alias for cursor.char
+
+###Cursor.position(pos)
+
+Get / set the overall cursor position... syntactic sugar for setting line and char/col individually
+
+####Returns:
+```javascript
+{
+    line: {Number},
+    char: {Number}
+}
+```
+
+####Get
+
+```javascript
+var pos = cursor.position();
+```
+
+####Set
+```javascript
+var pos = {
+    line: 2,
+    char: 4
+}
+cursor.position(pos);
+```