Removing ugly looking jsdoc comment

lib/buffer.js

@@ -1,12 +1,6 @@
 var Types = require("types.js");
 
-
-/**
- * Represents a buffer
- * @class
- * @param {InternalClient} client The vim client linked to the buffer
- * @param {number} buffId Id of the buffer
- */
+//A controler owned buffer representation
 function Buffer (client, buffId) {
     "use strict";
 
@@ -15,240 +9,169 @@ function Buffer (client, buffId) {
 
     /* COMMANDS */
 
-    /**
-     * Place an annotation
-     * @function
-     * @param {number} annoType Returned annoType by defineAnnoType
-     * @param {number|number[]} offset Position of the annotation
-     * @return {number} Serial number of the anno
-     */
+    //Add an annotation into buffer. annoType is obtained through defineAnnoType. off is the position
+    //The anno id is returned by the call
     this.addAnno = function (annoType, off) {
         serNum += 1;
         client.sendCommand("addAnno", buffId, serNum, annoType,Types.position(off), 0 );
         return serNum;
     };
 
-    /**
-     * Close the buffer.
-     * @function
-     */
+    //Close the buffer
     this.close = function(){
         client.sendCommand("close", buffId);
     };
 
-    /**
-     * Define a type of annotation for this buffer
-     * @function
-     * @param {string} typeName Name that identifies this annotation type
-     * @param {string} glyphFile Name of icon file
-     * @param {string|number} fg Foreground color
-     * @param {string|number} bg Background color
-     * @return {number} Identifier of the annotation type
-     */
+    //Define an annotation type. typename : friendly name, glyphFile : icon, fg and bg are the colors
+    //The anno type id is returned by the call
     this.defineAnnoType = function (typeName, glyphFile, fg, bg) {
         typeNum += 1;
         client.sendCommand("defineAnnoType", buffId, typeNum, Types.string(typeName), Types.string(""), Types.string(glyphFile), Types.color(fg), Types.color(bg));
         return typeNum;
     };
 
-    /**
-     * Mark the buffer to report changes with "insert" and "remove" events
-     * @function
-     */
+    //Start listening for insert and remove events on buffer
     this.startDocumentListen = function () {
         client.sendCommand("startDocumentListen", buffId);
     };
 
-
-    /**
-     * Mark the buffer to stop reporting changes
-     * @function
-     */
+    //Stop listening for insert and remove events on buffer
     this.stopDocumentListen = function () {
         client.sendCommand("stopDocumentListen", buffId);
     };
 
-    /**
-     * Mark an area in the buffer as guarded
-     * @function
-     * @param {number|number[]} off Starting position
-     * @param {number} len Length of the area
-     */
+    //Guard an area of the buffer. off is the position, len the length of text
     this.guard = function (off, len) {
         client.sendCommand("guard",buffId, Types.position(off), len); 
     };
 
-    /**
-     * Tell Vim that the buffer is ready to be used and make it the current buffer
-     * Fire the BufReadPost autocommand event
-     * @function 
-     */
+    //Tell Vim that the buffer is ready to be used
     this.initDone = function () { 
         client.sendCommand("initdone", buffId);
     };
 
-    
-    /**
-     * Tell Vim an initial insert is done
-     * Trigger a read message being printed
-     * @function
-     */
+    //Tell Vim that inserts are done
     this.insertDone = function () {
         client.sendCommand("insertDone", buffId);
     };
 
-    
-    /**
-     * Tell Vim that the buffer is owned by the controller
-     * @function
-     * @param isNetBeansBuffer
-     */
+    //Tell Vim that the buffer is owned by the controler
     this.netbeansBuffer = function (isNetBeansBuffer) {
         client.sendCommand("netbeansBuffer", buffId, Types.bool(isNetBeansBuffer));   
     };
 
-
-    /**
-     * Removes a previously added annotation
-     * @function
-     * @param {number} serNum Identifier of the annotation to remove
-     */
+    //Remove and anno 
     this.removeAnno = function (serNum) {
         client.sendCommand("removeAnno",buffId,serNum); 
     };
 
-    /**
-     * Tell Vim to save the buffer
-     * Vim fire a setModified event when done
-     * @function
-     **/
+    //Tell Vim to save the buffer
     this.save = function () {
         client.sendCommand("save", buffId);    
     };
 
-    /**
-     * Tell Vim the buffer has been saved
-     * @function
-     */
+    //Tell Vim that the controler have saved the buffer
     this.saveDone = function () {
         client.sendCommand("saveDone", buffId); 
     };
 
-    
-    /**
-     * Set Vim cursor position and set the buffer as current buffer
-     * @function
-     * @param {number|number[]} off Position of the cursor
-     */
+    //Set the cursor position (and make the buffer the current buffer)
     this.setDot = function (off) {
         client.sendCommand("setDot", buffId, Types.position(off)); 
     };
 
-    /**
-     * Set the name of the buffer.
-     * It does not read the file content
-     * @function
-     * @param {string} pathName Name of the buffer
-     */
+    //Set the filename of a buffer. It does not actually feed the buffer with file content, use insert for that
     this.setFullName = function (pathName) {
         client.sendCommand("setFullName", buffId, Types.string(pathName)); 
     };
 
-    /**
-     * Toggle the buffer modified mark
-     * @function
-     * @param {bool} modified Value of the modified flag
-     */
+    //Set the modified flag
     this.setModified = function (modified) {
         client.sendCommand("setModified", buffId, Types.bool(modified)); 
     };
 
-    /**
-     * Update a buffer modification time 
-     * @function
-     * @param {number} time Modification time to set
-     */
+    //Set the modtime
     this.setModtime = function (time) {
         client.sendCommand("setModtime", buffId, time); 
     };
 
-    /**
-     * Mark the buffer as readonly
-     * @function
-     */
+    //Set the file as read-only
     this.setReadOnly = function () {
         client.sendCommand("setReadOnly", buffId); 
     };
 
-    /**
-     * Set the title of the function (used by controller only)
-     * @function
-     * @param {string} name Name of the buffer
-     */
+    //Set the title of the buffer. The title is just an internal name, it's not visible by the user
     this.setTitle = function (name) {
         client.sendCommand("setTitle", buffId, Types.string(name)); 
     };
 
-    /**
-     * Goto the buffer
-     * @function
-     */
+    //Show the buffer
     this.setVisible = function () {
         client.sendCommand("setVisible", buffId, Types.bool(true)); 
     };
 
-    /**
-     * Display a balloon containing the text (GVim only)
-     * @function
-     * @param {string} text Text to show
-     */
+    //Show a balloon containing the text around the cursor (GVim only)
     this.showBalloon = function (text) {
         client.sendCommand("showBalloon", buffId,Types.string(text));   
     };
 
-    /**
-     * Ungard the text
-     * @function
-     * @param {number|number[]} off Start position of the text to unguard
-     * @param {number} len Length of the text to unguard
-     */
+    //Ungard the text. off is the starting position, len the length of the text
     this.unguard = function (off, len) {
         client.sendCommand("unguard", buffId, Types.position(off), len); 
     };
 
+    //Edit the file in the current buffer
     this.editFile = function (pathName){
         client.sendCommand("editFile", buffId, Types.string(pathName));    
     };
 
+    //Start an atomic opperation. Vim screen is not updated untill endAtomic is called
+    this.startAtomic = function () {
+        client.sendCommand("startAtomic", buffId); 
+    };
+
+    //End an atomic opperation.
+    this.endAtomic = function() {
+        client.sendCommand("endAtmoic", buffId);
+    };
+
 
     /* FUNCTIONS */
 
+    //Get cursor position. Callback function get the line, column and offset 
     this.getCursor = function (callback) {
        client.callFunction("getCursor", buffId, callback);  
     };
 
+    //Get the length of current buffer.
     this.getLength = function (callback) {
         client.callFunction("getLength", buffId, callback);
     };
 
+    //Get the line position of an anno
     this.getAnno = function (serNum, callback) {
         client.callFunction("getAnno", buffId, serNum, callback);
     };
 
+    //Get the status of modified flag
     this.getModified = function (callback) {
         client.callFunction("getModified", buffId, callback);
     };
 
+    //Return the content of the buffer as string
     this.getText = function (callback) {
         client.callFunction("getText", buffId, callback); 
     };
 
+    //Insert text at the position. Callback get nothing if everything went good, the error otherwise
     this.insert = function (off, text, callback){
         client.callFunction("insert", buffId, Types.position(off), Types.string(text), callback); 
     };
 
+    //Remove text at the position. Callback get nothing if everything went good, the error otherwise
     this.remove = function (off, length, callback) {
         client.callFunction("remove", buffId, Types.position(off), length, callback);
     };
 }
 
+module.exports = Buffer;