integration wip: take-away-node command
[fnpeditor.git] / libs / vkbeautify.js
1 /**
2 * vkBeautify - javascript plugin to pretty-print or minify text in XML, JSON, CSS and SQL formats.
3 *  
4 * Version - 0.99.00.beta 
5 * Copyright (c) 2012 Vadim Kiryukhin
6 * vkiryukhin @ gmail.com
7 * http://www.eslinstructor.net/vkbeautify/
8
9 * Dual licensed under the MIT and GPL licenses:
10 *   http://www.opensource.org/licenses/mit-license.php
11 *   http://www.gnu.org/licenses/gpl.html
12 *
13 *   Pretty print
14 *
15 *        vkbeautify.xml(text [,indent_pattern]);
16 *        vkbeautify.json(text [,indent_pattern]);
17 *        vkbeautify.css(text [,indent_pattern]);
18 *        vkbeautify.sql(text [,indent_pattern]);
19 *
20 *        @text - String; text to beatufy;
21 *        @indent_pattern - Integer | String;
22 *                Integer:  number of white spaces;
23 *                String:   character string to visualize indentation ( can also be a set of white spaces )
24 *   Minify
25 *
26 *        vkbeautify.xmlmin(text [,preserve_comments]);
27 *        vkbeautify.jsonmin(text);
28 *        vkbeautify.cssmin(text [,preserve_comments]);
29 *        vkbeautify.sqlmin(text);
30 *
31 *        @text - String; text to minify;
32 *        @preserve_comments - Bool; [optional];
33 *                Set this flag to true to prevent removing comments from @text ( minxml and mincss functions only. )
34 *
35 *   Examples:
36 *        vkbeautify.xml(text); // pretty print XML
37 *        vkbeautify.json(text, 4 ); // pretty print JSON
38 *        vkbeautify.css(text, '. . . .'); // pretty print CSS
39 *        vkbeautify.sql(text, '----'); // pretty print SQL
40 *
41 *        vkbeautify.xmlmin(text, true);// minify XML, preserve comments
42 *        vkbeautify.jsonmin(text);// minify JSON
43 *        vkbeautify.cssmin(text);// minify CSS, remove comments ( default )
44 *        vkbeautify.sqlmin(text);// minify SQL
45 *
46 */
47
48 (function() {
49
50 function createShiftArr(step) {
51
52         var space = '    ';
53         
54         if ( isNaN(parseInt(step)) ) {  // argument is string
55                 space = step;
56         } else { // argument is integer
57                 switch(step) {
58                         case 1: space = ' '; break;
59                         case 2: space = '  '; break;
60                         case 3: space = '   '; break;
61                         case 4: space = '    '; break;
62                         case 5: space = '     '; break;
63                         case 6: space = '      '; break;
64                         case 7: space = '       '; break;
65                         case 8: space = '        '; break;
66                         case 9: space = '         '; break;
67                         case 10: space = '          '; break;
68                         case 11: space = '           '; break;
69                         case 12: space = '            '; break;
70                 }
71         }
72
73         var shift = ['\n']; // array of shifts
74         for(ix=0;ix<100;ix++){
75                 shift.push(shift[ix]+space); 
76         }
77         return shift;
78 }
79
80 function vkbeautify(){
81         this.step = '    '; // 4 spaces
82         this.shift = createShiftArr(this.step);
83 };
84
85 vkbeautify.prototype.xml = function(text,step) {
86
87         var ar = text.replace(/>\s{0,}</g,"><")
88                                  .replace(/</g,"~::~<")
89                                  .replace(/\s*xmlns\:/g,"~::~xmlns:")
90                                  .replace(/\s*xmlns\=/g,"~::~xmlns=")
91                                  .split('~::~'),
92                 len = ar.length,
93                 inComment = false,
94                 deep = 0,
95                 str = '',
96                 ix = 0,
97                 shift = step ? createShiftArr(step) : this.shift;
98
99                 for(ix=0;ix<len;ix++) {
100                         // start comment or <![CDATA[...]]> or <!DOCTYPE //
101                         if(ar[ix].search(/<!/) > -1) { 
102                                 str += shift[deep]+ar[ix];
103                                 inComment = true; 
104                                 // end comment  or <![CDATA[...]]> //
105                                 if(ar[ix].search(/-->/) > -1 || ar[ix].search(/\]>/) > -1 || ar[ix].search(/!DOCTYPE/) > -1 ) { 
106                                         inComment = false; 
107                                 }
108                         } else 
109                         // end comment  or <![CDATA[...]]> //
110                         if(ar[ix].search(/-->/) > -1 || ar[ix].search(/\]>/) > -1) { 
111                                 str += ar[ix];
112                                 inComment = false; 
113                         } else 
114                         // <elm></elm> //
115                         if( /^<\w/.exec(ar[ix-1]) && /^<\/\w/.exec(ar[ix]) &&
116                                 /^<[\w:\-\.\,]+/.exec(ar[ix-1]) == /^<\/[\w:\-\.\,]+/.exec(ar[ix])[0].replace('/','')) { 
117                                 str += ar[ix];
118                                 if(!inComment) deep--;
119                         } else
120                          // <elm> //
121                         if(ar[ix].search(/<\w/) > -1 && ar[ix].search(/<\//) == -1 && ar[ix].search(/\/>/) == -1 ) {
122                                 str = !inComment ? str += shift[deep++]+ar[ix] : str += ar[ix];
123                         } else 
124                          // <elm>...</elm> //
125                         if(ar[ix].search(/<\w/) > -1 && ar[ix].search(/<\//) > -1) {
126                                 str = !inComment ? str += shift[deep]+ar[ix] : str += ar[ix];
127                         } else 
128                         // </elm> //
129                         if(ar[ix].search(/<\//) > -1) { 
130                                 str = !inComment ? str += shift[--deep]+ar[ix] : str += ar[ix];
131                         } else 
132                         // <elm/> //
133                         if(ar[ix].search(/\/>/) > -1 ) { 
134                                 str = !inComment ? str += shift[deep]+ar[ix] : str += ar[ix];
135                         } else 
136                         // <? xml ... ?> //
137                         if(ar[ix].search(/<\?/) > -1) { 
138                                 str += shift[deep]+ar[ix];
139                         } else 
140                         // xmlns //
141                         if( ar[ix].search(/xmlns\:/) > -1  || ar[ix].search(/xmlns\=/) > -1) { 
142                                 str += shift[deep]+ar[ix];
143                         } 
144                         
145                         else {
146                                 str += ar[ix];
147                         }
148                 }
149                 
150         return  (str[0] == '\n') ? str.slice(1) : str;
151 }
152
153 vkbeautify.prototype.json = function(text,step) {
154
155         var step = step ? step : this.step;
156         
157         if (typeof JSON === 'undefined' ) return text; 
158         
159         if ( typeof text === "string" ) return JSON.stringify(JSON.parse(text), null, step);
160         if ( typeof text === "object" ) return JSON.stringify(text, null, step);
161                 
162         return text; // text is not string nor object
163 }
164
165 vkbeautify.prototype.css = function(text, step) {
166
167         var ar = text.replace(/\s{1,}/g,' ')
168                                 .replace(/\{/g,"{~::~")
169                                 .replace(/\}/g,"~::~}~::~")
170                                 .replace(/\;/g,";~::~")
171                                 .replace(/\/\*/g,"~::~/*")
172                                 .replace(/\*\//g,"*/~::~")
173                                 .replace(/~::~\s{0,}~::~/g,"~::~")
174                                 .split('~::~'),
175                 len = ar.length,
176                 deep = 0,
177                 str = '',
178                 ix = 0,
179                 shift = step ? createShiftArr(step) : this.shift;
180                 
181                 for(ix=0;ix<len;ix++) {
182
183                         if( /\{/.exec(ar[ix]))  { 
184                                 str += shift[deep++]+ar[ix];
185                         } else 
186                         if( /\}/.exec(ar[ix]))  { 
187                                 str += shift[--deep]+ar[ix];
188                         } else
189                         if( /\*\\/.exec(ar[ix]))  { 
190                                 str += shift[deep]+ar[ix];
191                         }
192                         else {
193                                 str += shift[deep]+ar[ix];
194                         }
195                 }
196                 return str.replace(/^\n{1,}/,'');
197 }
198
199 //----------------------------------------------------------------------------
200
201 function isSubquery(str, parenthesisLevel) {
202         return  parenthesisLevel - (str.replace(/\(/g,'').length - str.replace(/\)/g,'').length )
203 }
204
205 function split_sql(str, tab) {
206
207         return str.replace(/\s{1,}/g," ")
208
209                                 .replace(/ AND /ig,"~::~"+tab+tab+"AND ")
210                                 .replace(/ BETWEEN /ig,"~::~"+tab+"BETWEEN ")
211                                 .replace(/ CASE /ig,"~::~"+tab+"CASE ")
212                                 .replace(/ ELSE /ig,"~::~"+tab+"ELSE ")
213                                 .replace(/ END /ig,"~::~"+tab+"END ")
214                                 .replace(/ FROM /ig,"~::~FROM ")
215                                 .replace(/ GROUP\s{1,}BY/ig,"~::~GROUP BY ")
216                                 .replace(/ HAVING /ig,"~::~HAVING ")
217                                 //.replace(/ SET /ig," SET~::~")
218                                 .replace(/ IN /ig," IN ")
219                                 
220                                 .replace(/ JOIN /ig,"~::~JOIN ")
221                                 .replace(/ CROSS~::~{1,}JOIN /ig,"~::~CROSS JOIN ")
222                                 .replace(/ INNER~::~{1,}JOIN /ig,"~::~INNER JOIN ")
223                                 .replace(/ LEFT~::~{1,}JOIN /ig,"~::~LEFT JOIN ")
224                                 .replace(/ RIGHT~::~{1,}JOIN /ig,"~::~RIGHT JOIN ")
225                                 
226                                 .replace(/ ON /ig,"~::~"+tab+"ON ")
227                                 .replace(/ OR /ig,"~::~"+tab+tab+"OR ")
228                                 .replace(/ ORDER\s{1,}BY/ig,"~::~ORDER BY ")
229                                 .replace(/ OVER /ig,"~::~"+tab+"OVER ")
230
231                                 .replace(/\(\s{0,}SELECT /ig,"~::~(SELECT ")
232                                 .replace(/\)\s{0,}SELECT /ig,")~::~SELECT ")
233                                 
234                                 .replace(/ THEN /ig," THEN~::~"+tab+"")
235                                 .replace(/ UNION /ig,"~::~UNION~::~")
236                                 .replace(/ USING /ig,"~::~USING ")
237                                 .replace(/ WHEN /ig,"~::~"+tab+"WHEN ")
238                                 .replace(/ WHERE /ig,"~::~WHERE ")
239                                 .replace(/ WITH /ig,"~::~WITH ")
240                                 
241                                 //.replace(/\,\s{0,}\(/ig,",~::~( ")
242                                 //.replace(/\,/ig,",~::~"+tab+tab+"")
243
244                                 .replace(/ ALL /ig," ALL ")
245                                 .replace(/ AS /ig," AS ")
246                                 .replace(/ ASC /ig," ASC ")     
247                                 .replace(/ DESC /ig," DESC ")   
248                                 .replace(/ DISTINCT /ig," DISTINCT ")
249                                 .replace(/ EXISTS /ig," EXISTS ")
250                                 .replace(/ NOT /ig," NOT ")
251                                 .replace(/ NULL /ig," NULL ")
252                                 .replace(/ LIKE /ig," LIKE ")
253                                 .replace(/\s{0,}SELECT /ig,"SELECT ")
254                                 .replace(/\s{0,}UPDATE /ig,"UPDATE ")
255                                 .replace(/ SET /ig," SET ")
256                                                         
257                                 .replace(/~::~{1,}/g,"~::~")
258                                 .split('~::~');
259 }
260
261 vkbeautify.prototype.sql = function(text,step) {
262
263         var ar_by_quote = text.replace(/\s{1,}/g," ")
264                                                         .replace(/\'/ig,"~::~\'")
265                                                         .split('~::~'),
266                 len = ar_by_quote.length,
267                 ar = [],
268                 deep = 0,
269                 tab = this.step,//+this.step,
270                 inComment = true,
271                 inQuote = false,
272                 parenthesisLevel = 0,
273                 str = '',
274                 ix = 0,
275                 shift = step ? createShiftArr(step) : this.shift;;
276
277                 for(ix=0;ix<len;ix++) {
278                         if(ix%2) {
279                                 ar = ar.concat(ar_by_quote[ix]);
280                         } else {
281                                 ar = ar.concat(split_sql(ar_by_quote[ix], tab) );
282                         }
283                 }
284                 
285                 len = ar.length;
286                 for(ix=0;ix<len;ix++) {
287                         
288                         parenthesisLevel = isSubquery(ar[ix], parenthesisLevel);
289                         
290                         if( /\s{0,}\s{0,}SELECT\s{0,}/.exec(ar[ix]))  { 
291                                 ar[ix] = ar[ix].replace(/\,/g,",\n"+tab+tab+"")
292                         } 
293                         
294                         if( /\s{0,}\s{0,}SET\s{0,}/.exec(ar[ix]))  { 
295                                 ar[ix] = ar[ix].replace(/\,/g,",\n"+tab+tab+"")
296                         } 
297                         
298                         if( /\s{0,}\(\s{0,}SELECT\s{0,}/.exec(ar[ix]))  { 
299                                 deep++;
300                                 str += shift[deep]+ar[ix];
301                         } else 
302                         if( /\'/.exec(ar[ix]) )  { 
303                                 if(parenthesisLevel<1 && deep) {
304                                         deep--;
305                                 }
306                                 str += ar[ix];
307                         }
308                         else  { 
309                                 str += shift[deep]+ar[ix];
310                                 if(parenthesisLevel<1 && deep) {
311                                         deep--;
312                                 }
313                         } 
314                         var junk = 0;
315                 }
316
317                 str = str.replace(/^\n{1,}/,'').replace(/\n{1,}/g,"\n");
318                 return str;
319 }
320
321
322 vkbeautify.prototype.xmlmin = function(text, preserveComments) {
323
324         var str = preserveComments ? text
325                                                            : text.replace(/\<![ \r\n\t]*(--([^\-]|[\r\n]|-[^\-])*--[ \r\n\t]*)\>/g,"")
326                                                                          .replace(/[ \r\n\t]{1,}xmlns/g, ' xmlns');
327         return  str.replace(/>\s{0,}</g,"><"); 
328 }
329
330 vkbeautify.prototype.jsonmin = function(text) {
331
332         if (typeof JSON === 'undefined' ) return text; 
333         
334         return JSON.stringify(JSON.parse(text), null, 0); 
335                                 
336 }
337
338 vkbeautify.prototype.cssmin = function(text, preserveComments) {
339         
340         var str = preserveComments ? text
341                                                            : text.replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\//g,"") ;
342
343         return str.replace(/\s{1,}/g,' ')
344                           .replace(/\{\s{1,}/g,"{")
345                           .replace(/\}\s{1,}/g,"}")
346                           .replace(/\;\s{1,}/g,";")
347                           .replace(/\/\*\s{1,}/g,"/*")
348                           .replace(/\*\/\s{1,}/g,"*/");
349 }
350
351 vkbeautify.prototype.sqlmin = function(text) {
352         return text.replace(/\s{1,}/g," ").replace(/\s{1,}\(/,"(").replace(/\s{1,}\)/,")");
353 }
354
355 window.vkbeautify = new vkbeautify();
356
357 })();
358