import

Signed-off-by: Chris Granger <[email protected]>

Author: ibdknox

LICENSE.md

@@ -0,0 +1,9 @@
+##Python for Light Table
+
+The official Python language plugin for Light Table.
+
+###License
+
+Copyright (C) 2013 Kodowa Inc.
+
+Distributed under the GPLv3, see license.md for the full text.

README.md

@@ -0,0 +1,368 @@
+CodeMirror.defineMode("python",function(conf,parserConf){
+varERRORCLASS='error';
+
+functionwordRegexp(words){
+returnnewRegExp("^(("+words.join(")|(")+"))\\b");
+}
+
+varsingleOperators=parserConf.singleOperators||newRegExp("^[\\+\\-\\*/%&|\\^~<>!]");
+varsingleDelimiters=parserConf.singleDelimiters||newRegExp('^[\\(\\)\\[\\]\\{\\}@,:`=;\\.]');
+vardoubleOperators=parserConf.doubleOperators||newRegExp("^((==)|(!=)|(<=)|(>=)|(<>)|(<<)|(>>)|(//)|(\\*\\*))");
+vardoubleDelimiters=parserConf.doubleDelimiters||newRegExp("^((\\+=)|(\\-=)|(\\*=)|(%=)|(/=)|(&=)|(\\|=)|(\\^=))");
+vartripleDelimiters=parserConf.tripleDelimiters||newRegExp("^((//=)|(>>=)|(<<=)|(\\*\\*=))");
+varidentifiers=parserConf.identifiers||newRegExp("^[_A-Za-z][_A-Za-z0-9]*");
+
+varwordOperators=wordRegexp(['and','or','not','is','in']);
+varcommonkeywords=['as','assert','break','class','continue',
+'def','del','elif','else','except','finally',
+'for','from','global','if','import',
+'lambda','pass','raise','return',
+'try','while','with','yield'];
+varcommonBuiltins=['abs','all','any','bin','bool','bytearray','callable','chr',
+'classmethod','compile','complex','delattr','dict','dir','divmod',
+'enumerate','eval','filter','float','format','frozenset',
+'getattr','globals','hasattr','hash','help','hex','id',
+'input','int','isinstance','issubclass','iter','len',
+'list','locals','map','max','memoryview','min','next',
+'object','oct','open','ord','pow','property','range',
+'repr','reversed','round','set','setattr','slice',
+'sorted','staticmethod','str','sum','super','tuple',
+'type','vars','zip','__import__','NotImplemented',
+'Ellipsis','__debug__'];
+varpy2={'builtins': ['apply','basestring','buffer','cmp','coerce','execfile',
+'file','intern','long','raw_input','reduce','reload',
+'unichr','unicode','xrange','False','True','None'],
+'keywords': ['exec','print']};
+varpy3={'builtins': ['ascii','bytes','exec','print'],
+'keywords': ['nonlocal','False','True','None']};
+
+if(parserConf.extra_keywords!=undefined){
+commonkeywords=commonkeywords.concat(parserConf.extra_keywords);
+}
+if(parserConf.extra_builtins!=undefined){
+commonBuiltins=commonBuiltins.concat(parserConf.extra_builtins);
+}
+if(!!parserConf.version&&parseInt(parserConf.version,10)===3){
+commonkeywords=commonkeywords.concat(py3.keywords);
+commonBuiltins=commonBuiltins.concat(py3.builtins);
+varstringPrefixes=newRegExp("^(([rb]|(br))?('{3}|\"{3}|['\"]))","i");
+}else{
+commonkeywords=commonkeywords.concat(py2.keywords);
+commonBuiltins=commonBuiltins.concat(py2.builtins);
+varstringPrefixes=newRegExp("^(([rub]|(ur)|(br))?('{3}|\"{3}|['\"]))","i");
+}
+varkeywords=wordRegexp(commonkeywords);
+varbuiltins=wordRegexp(commonBuiltins);
+
+varindentInfo=null;
+
+// tokenizers
+functiontokenBase(stream,state){
+// Handle scope changes
+if(stream.sol()){
+varscopeOffset=state.scopes[0].offset;
+if(stream.eatSpace()){
+varlineOffset=stream.indentation();
+if(lineOffset>scopeOffset){
+indentInfo='indent';
+}elseif(lineOffset<scopeOffset){
+indentInfo='dedent';
+}
+returnnull;
+}else{
+if(scopeOffset>0){
+dedent(stream,state);
+}
+}
+}
+if(stream.eatSpace()){
+returnnull;
+}
+
+varch=stream.peek();
+
+// Handle Comments
+if(ch==='#'){
+stream.skipToEnd();
+return'comment';
+}
+
+// Handle Number Literals
+if(stream.match(/^[0-9\.]/,false)){
+varfloatLiteral=false;
+// Floats
+if(stream.match(/^\d*\.\d+(e[\+\-]?\d+)?/i)){floatLiteral=true;}
+if(stream.match(/^\d+\.\d*/)){floatLiteral=true;}
+if(stream.match(/^\.\d+/)){floatLiteral=true;}
+if(floatLiteral){
+// Float literals may be "imaginary"
+stream.eat(/J/i);
+return'number';
+}
+// Integers
+varintLiteral=false;
+// Hex
+if(stream.match(/^0x[0-9a-f]+/i)){intLiteral=true;}
+// Binary
+if(stream.match(/^0b[01]+/i)){intLiteral=true;}
+// Octal
+if(stream.match(/^0o[0-7]+/i)){intLiteral=true;}
+// Decimal
+if(stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)){
+// Decimal literals may be "imaginary"
+stream.eat(/J/i);
+// TODO - Can you have imaginary longs?
+intLiteral=true;
+}
+// Zero by itself with no other piece of number.
+if(stream.match(/^0(?![\dx])/i)){intLiteral=true;}
+if(intLiteral){
+// Integer literals may be "long"
+stream.eat(/L/i);
+return'number';
+}
+}
+
+// Handle Strings
+if(stream.match(stringPrefixes)){
+state.tokenize=tokenStringFactory(stream.current());
+returnstate.tokenize(stream,state);
+}
+
+// Handle operators and Delimiters
+if(stream.match(tripleDelimiters)||stream.match(doubleDelimiters)){
+returnnull;
+}
+if(stream.match(doubleOperators)
+||stream.match(singleOperators)
+||stream.match(wordOperators)){
+return'operator';
+}
+if(stream.match(singleDelimiters)){
+returnnull;
+}
+
+if(stream.match(keywords)){
+return'keyword';
+}
+
+if(stream.match(builtins)){
+return'builtin';
+}
+
+if(stream.match(identifiers)){
+if(state.lastToken=='def'||state.lastToken=='class'){
+return'def';
+}
+return'variable';
+}
+
+// Handle non-detected items
+stream.next();
+returnERRORCLASS;
+}
+
+functiontokenStringFactory(delimiter){
+while('rub'.indexOf(delimiter.charAt(0).toLowerCase())>=0){
+delimiter=delimiter.substr(1);
+}
+varsingleline=delimiter.length==1;
+varOUTCLASS='string';
+
+functiontokenString(stream,state){
+while(!stream.eol()){
+stream.eatWhile(/[^'"\\]/);
+if(stream.eat('\\')){
+stream.next();
+if(singleline&&stream.eol()){
+returnOUTCLASS;
+}
+}elseif(stream.match(delimiter)){
+state.tokenize=tokenBase;
+returnOUTCLASS;
+}else{
+stream.eat(/['"]/);
+}
+}
+if(singleline){
+if(parserConf.singleLineStringErrors){
+returnERRORCLASS;
+}else{
+state.tokenize=tokenBase;
+}
+}
+returnOUTCLASS;
+}
+tokenString.isString=true;
+returntokenString;
+}
+
+functionindent(stream,state,type){
+type=type||'py';
+varindentUnit=0;
+if(type==='py'){
+if(state.scopes[0].type!=='py'){
+state.scopes[0].offset=stream.indentation();
+return;
+}
+for(vari=0;i<state.scopes.length;++i){
+if(state.scopes[i].type==='py'){
+indentUnit=state.scopes[i].offset+conf.indentUnit;
+break;
+}
+}
+}else{
+indentUnit=stream.column()+stream.current().length;
+}
+state.scopes.unshift({
+offset: indentUnit,
+type: type
+});
+}
+
+functiondedent(stream,state,type){
+type=type||'py';
+if(state.scopes.length==1)return;
+if(state.scopes[0].type==='py'){
+var_indent=stream.indentation();
+var_indent_index=-1;
+for(vari=0;i<state.scopes.length;++i){
+if(_indent===state.scopes[i].offset){
+_indent_index=i;
+break;
+}
+}
+if(_indent_index===-1){
+returntrue;
+}
+while(state.scopes[0].offset!==_indent){
+state.scopes.shift();
+}
+returnfalse;
+}else{
+if(type==='py'){
+state.scopes[0].offset=stream.indentation();
+returnfalse;
+}else{
+if(state.scopes[0].type!=type){
+returntrue;
+}
+state.scopes.shift();
+returnfalse;
+}
+}
+}
+
+functiontokenLexer(stream,state){
+indentInfo=null;
+varstyle=state.tokenize(stream,state);
+varcurrent=stream.current();
+
+// Handle '.' connected identifiers
+if(current==='.'){
+style=stream.match(identifiers,false) ? null : ERRORCLASS;
+if(style===null&&state.lastStyle==='meta'){
+// Apply 'meta' style to '.' connected identifiers when
+// appropriate.
+style='meta';
+}
+returnstyle;
+}
+
+// Handle decorators
+if(current==='@'){
+returnstream.match(identifiers,false) ? 'meta' : ERRORCLASS;
+}
+
+if((style==='variable'||style==='builtin')
+&&state.lastStyle==='meta'){
+style='meta';
+}
+
+// Handle scope changes.
+if(current==='pass'||current==='return'){
+state.dedent+=1;
+}
+if(current==='lambda')state.lambda=true;
+if((current===':'&&!state.lambda&&state.scopes[0].type=='py')
+||indentInfo==='indent'){
+indent(stream,state);
+}
+vardelimiter_index='[({'.indexOf(current);
+if(delimiter_index!==-1){
+indent(stream,state,'])}'.slice(delimiter_index,delimiter_index+1));
+}
+if(indentInfo==='dedent'){
+if(dedent(stream,state)){
+returnERRORCLASS;
+}
+}
+delimiter_index='])}'.indexOf(current);
+if(delimiter_index!==-1){
+if(dedent(stream,state,current)){
+returnERRORCLASS;
+}
+}
+if(state.dedent>0&&stream.eol()&&state.scopes[0].type=='py'){
+if(state.scopes.length>1)state.scopes.shift();
+state.dedent-=1;
+}
+
+returnstyle;
+}
+
+varexternal={
+startState: function(basecolumn){
+return{
+tokenize: tokenBase,
+scopes: [{offset:basecolumn||0,type:'py'}],
+lastStyle: null,
+lastToken: null,
+lambda: false,
+dedent: 0
+};
+},
+
+token: function(stream,state){
+varstyle=tokenLexer(stream,state);
+
+state.lastStyle=style;
+
+varcurrent=stream.current();
+if(current&&style){
+state.lastToken=current;
+}
+
+if(stream.eol()&&state.lambda){
+state.lambda=false;
+}
+returnstyle;
+},
+
+indent: function(state){
+if(state.tokenize!=tokenBase){
+returnstate.tokenize.isString ? CodeMirror.Pass : 0;
+}
+
+returnstate.scopes[0].offset;
+},
+
+lineComment: "#",
+fold: "indent"
+};
+returnexternal;
+});
+
+CodeMirror.defineMIME("text/x-python","python");
+
+(function(){
+"use strict";
+varwords=function(str){returnstr.split(' ');};
+
+CodeMirror.defineMIME("text/x-cython",{
+name: "python",
+extra_keywords: words("by cdef cimport cpdef ctypedef enum except"+
+"extern gil include nogil property public"+
+"readonly struct union DEF IF ELIF ELSE")
+});
+})();

codemirror/python.js

@@ -0,0 +1,10 @@
+{
+"name": "Python",
+"author": "Kodowa",
+"version": "0.0.1",
+"source": "https://github.com/LightTable/Python",
+"desc": "Python language plugin for Light Table",
+"dependencies":{
+ },
+"behaviors": "python.behaviors"
+}

plugin.json

@@ -0,0 +1,3 @@
+(defprojectcom.lighttable/python"0.0.1"
+:description"Python language plugin for Light Table"
+:dependencies [[org.clojure/clojure "1.5.1"]])