Merge branch 'develop'

Author: fdecampredon

src/commons/formattingService.ts

@@ -0,0 +1,43 @@
+//   Copyright 2013-2014 François de Campredon
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+
+import Promise = require('bluebird');
+
+/**
+ * A service allowing to retrieve formating information for a given file
+ */
+interface IFormattingService {
+    /**
+     * Retrieve formating information for a givent file
+     * @param fileName the absolute path of the file 
+     * @param options formation options
+     * @param startPos an option start position for the formating range
+     * @param endPos an optional end position for the formating range
+     * 
+     * @return a promise resolving to a formating range info
+     */
+    getFormatingForFile(fileName: string, options: TypeScript.Services.FormatCodeOptions,
+            startPos?: CodeMirror.Position, endPos?: CodeMirror.Position): Promise<IFormattingService.TextEdit[]>;
+}
+
+module IFormattingService {
+    export interface TextEdit {
+        text: string;
+        endPos: CodeMirror.Position;
+        startPos: CodeMirror.Position;
+    }
+}
+
+export = IFormattingService;

src/declarations/brackets.d.ts

@@ -971,6 +971,7 @@ declare module brackets {
     //--------------------------------------------------------------------------
     interface CommandManager {
         execute(id: string, args: any): JQueryPromise<any>;
+        register(name: string, id: string, callback: () => void): void;
     }
 
 

src/main/formattingManager.ts

@@ -0,0 +1,74 @@
+//   Copyright 2013-2014 François de Campredon
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+
+'use strict';
+
+import ServiceConsumer = require('./serviceConsumer');
+import IFormatingService = require('../commons/formattingService');
+
+var EditorManager = brackets.getModule('editor/EditorManager'),
+    Editor = brackets.getModule('editor/Editor').Editor;
+
+
+class FormattingManager extends ServiceConsumer<IFormatingService> {
+    format = () => {
+        var editor = EditorManager.getCurrentFullEditor();
+        if (!editor) {
+            return;
+        }
+        var useTabs = Editor.getUseTabChar();
+        
+        var options: TypeScript.Services.FormatCodeOptions = {
+            IndentSize: Editor.getSpaceUnits(),
+            TabSize: Editor.getTabSize(),
+            NewLineCharacter: '\n',
+            ConvertTabsToSpaces: !useTabs,
+            InsertSpaceAfterSemicolonInForStatements: true,
+            InsertSpaceAfterCommaDelimiter: true,
+            InsertSpaceBeforeAndAfterBinaryOperators: true,
+            InsertSpaceAfterKeywordsInControlFlowStatements: true,
+            InsertSpaceAfterFunctionKeywordForAnonymousFunctions: true,
+            InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+            PlaceOpenBraceOnNewLineForFunctions: false,
+            PlaceOpenBraceOnNewLineForControlBlocks: false
+        };
+        var currentRange = editor.getSelection(true),
+            startPos = currentRange ? currentRange.start : undefined,
+            endPos = currentRange ? currentRange.end : undefined;
+        
+        if (startPos && endPos && startPos.line === endPos.line && startPos.ch === endPos.ch) {
+            startPos = endPos = undefined;    
+        }
+        
+        
+        this.getService().then(service => {
+            service.getFormatingForFile(editor.document.file.fullPath, options, startPos, endPos).then(textEdits => {
+                if (EditorManager.getCurrentFullEditor() !== editor) {
+                    return;
+                }
+                textEdits.forEach(edit => {
+                    editor.document.replaceRange(edit.text, edit.startPos, edit.endPos);
+                });
+            });
+        });
+    };
+    
+    static FORMAT_COMMAND_ID = 'fdecampred.brackets-typescript.format';
+    
+    static FORMAT_LABEL = 'Format';
+}
+
+export = FormattingManager;
+

src/main/index.ts

@@ -25,6 +25,7 @@ import TypeScriptQuickEditProvider = require('./quickEdit');
 import TypeScriptQuickJumpProvider = require('./quickJump');
 import TypeScriptQuickFindDefitionProvider = require('./quickFindDefinition');
 import CodeHintProvider = require('./codeHintProvider');
+import FormattingManager = require('./formattingManager');
 import typeScriptModeFactory = require('./mode');
 
 
@@ -45,13 +46,16 @@ var LanguageManager = brackets.getModule('language/LanguageManager'),
     EditorManager = brackets.getModule('editor/EditorManager'),
     QuickOpen = brackets.getModule('search/QuickOpen'),
     PreferencesManager = brackets.getModule('preferences/PreferencesManager'),
-    CodeMirror: typeof CodeMirror = brackets.getModule('thirdparty/CodeMirror2/lib/codemirror');
+    CommandManager = brackets.getModule('command/CommandManager'),
+    CodeMirror: typeof CodeMirror = brackets.getModule('thirdparty/CodeMirror2/lib/codemirror'),
+    Menus = brackets.getModule('command/Menus');
 
 var tsErrorReporter: TypeScriptErrorReporter,
     quickEditProvider: TypeScriptQuickEditProvider,
     codeHintProvider: CodeHintProvider,
     quickJumpProvider: TypeScriptQuickJumpProvider,
-    quickFindDefinitionProvider: TypeScriptQuickFindDefitionProvider;
+    quickFindDefinitionProvider: TypeScriptQuickFindDefitionProvider,
+    formattingManager: FormattingManager;
 
 
 
@@ -95,7 +99,12 @@ function init(config: { logLevel: string; typeScriptLocation: string; workerLoca
     //Register quickFindDefinitionProvider
     quickFindDefinitionProvider = new TypeScriptQuickFindDefitionProvider();
     QuickOpen.addQuickOpenPlugin(quickFindDefinitionProvider);
-
+    
+    //Register formatting command
+    formattingManager = new FormattingManager();
+    CommandManager.register(FormattingManager.FORMAT_LABEL, FormattingManager.FORMAT_COMMAND_ID, formattingManager.format);
+    var contextMenu = Menus.getContextMenu(Menus.ContextMenuIds.EDITOR_MENU);
+    contextMenu.addMenuItem(FormattingManager.FORMAT_COMMAND_ID);
 
     initServices(config.workerLocation, config.typeScriptLocation, config.logLevel);
 
@@ -111,6 +120,7 @@ function disposeServices() {
     workingSet.dispose();
     preferencesManager.dispose();
 
+    formattingManager.reset();
     tsErrorReporter.reset();
     codeHintProvider.reset();
     quickEditProvider.reset();
@@ -143,6 +153,7 @@ function initServices(workerLocation: string, typeScriptLocation: string, logLev
         quickEditProvider.setService(proxy.definitionService);
         quickJumpProvider.setService(proxy.definitionService);
         quickFindDefinitionProvider.setService(proxy.lexicalStructureService);
+        formattingManager.setService(proxy.formattingService);
     });
 }
 

src/ts-worker/formattingService.ts

@@ -0,0 +1,69 @@
+//   Copyright 2013-2014 François de Campredon
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+'use strict';
+
+import IFormattingService = require('../commons/formattingService');
+import TypeScriptProjectManager = require('./projectManager');
+import Promise = require('bluebird');
+
+
+
+class FormattingService implements IFormattingService {
+    
+    /**
+     * @param projectManager the Project manager used by the service to retrieve project
+     */
+    constructor(
+        private projectManager: TypeScriptProjectManager
+    ) {}
+    
+        
+    /**
+     * Retrieve formating information for a givent file
+     * @param fileName the absolute path of the file 
+     * @param options formation options
+     * @param startPos an option start position for the formating range
+     * @param endPos an optional end position for the formating range
+     * 
+     * @return a promise resolving to a formating range info
+     */
+    getFormatingForFile(fileName: string, options: TypeScript.Services.FormatCodeOptions,
+            startPos?: CodeMirror.Position, endPos?: CodeMirror.Position): Promise<IFormattingService.TextEdit[]> {
+        return this.projectManager.getProjectForFile(fileName).then(project => {
+            
+            var languageServiceHost = project.getLanguageServiceHost(),
+                languageService = project.getLanguageService(),
+                minChar: number, limChar: number;
+            
+            if (!startPos || ! endPos) {
+                minChar = 0;
+                limChar = project.getLanguageServiceHost().getScriptContent(fileName).length - 1;
+            } else {
+                minChar = languageServiceHost.getIndexFromPos(fileName, startPos);
+                limChar = languageServiceHost.getIndexFromPos(fileName, endPos);
+            }
+            
+            var result = languageService.getFormattingEditsForRange(fileName, minChar, limChar, options);
+            
+            return result && result.reverse().map(editRange => ({
+                text: editRange.text,
+                startPos: languageServiceHost.indexToPosition(fileName, editRange.minChar),
+                endPos: languageServiceHost.indexToPosition(fileName, editRange.limChar)
+            }));
+        });
+    }
+}
+
+export = FormattingService;

src/ts-worker/index.ts

@@ -24,6 +24,7 @@ import TypeScriptProject = require('./project');
 import ErrorService = require('./errorService');
 import DefinitionService = require('./definitionService');
 import CompletionService = require('./completionService');
+import FormattingService= require('./formattingService');
 import LexicalStructureService = require('./lexicalStructureService');
 import WorkerBridge = require('../commons/workerBridge');
 import logger = require('../commons/logger');
@@ -34,14 +35,16 @@ var projectManager = new TypeScriptProjectManager(),
     completionService = new CompletionService(projectManager),
     definitionService = new DefinitionService(projectManager),
     lexicalStructureService = new LexicalStructureService(projectManager),
+    formattingService = new FormattingService(projectManager),
     bridge = new WorkerBridge(<any>self);
 
 //expose the worker services
 bridge.init({
     errorService: errorService,
     completionService: completionService,
     definitionService: definitionService,
-    lexicalStructureService: lexicalStructureService
+    lexicalStructureService: lexicalStructureService,
+    formattingService: formattingService
 }).then(proxy => {
     //inject main services into worker components
     proxy.getTypeScriptLocation().then( (location: string) => {