Break method lines based on line length.

mojom/mojom_parser/formatter/printer.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package formatter
 
 import (
         "bytes"
         "fmt"
         "mojom/mojom_parser/lexer"
@@ skipping 21 matching lines @@
         // buffer is the buffer to which the write.* methods write the pretty-printed
         // mojom file element.
         buffer bytes.Buffer
 
         // indentSize is the current size of the indentation in number of space runes.
         indentSize int
 
         // eolComment is the comment to be printed at the end of the current line.
         eolComment *lexer.Token
 
-        // lineLength is the number of runes that have been written to the current line.
-        lineLength int
+        // linePos is the number of runes that have been written to the current line.
+        linePos int
+
+        // maxLineLength is the maximum number of runes that should be printed on a line.
+        // A negative maxLineLength indicates no maximum line length should be enforced.
+        // This is currently only used to decide when to break up a method on different lines.
+        maxLineLength int
 }
 
 // newPrinter is a constructor for printer.
 func newPrinter() (p *printer) {
         p = new(printer)
+        p.maxLineLength = 100
         return
 }
 
 // result returns the pretty-printed version of what was given to the printer.
 // Usually, this is a pretty-printed MojomFile.
 func (p *printer) result() string {
         return p.buffer.String()
 }
 
 // writeMojomFile is the entry point of the pretty printer.
@@ skipping 108 matching lines @@
         p.write("enum ")
         p.writeDeclaredObjectsContainer(mojomEnum)
 }
 
 func (p *printer) writeMojomInterface(mojomInterface *mojom.MojomInterface) {
         p.write("interface ")
         p.writeDeclaredObjectsContainer(mojomInterface)
 }
 
 func (p *printer) writeMojomMethod(mojomMethod *mojom.MojomMethod) {
+        splitResponse := false
+        if p.maxLineLength > 0 {
+                scratch := newPrinter()
+                scratch.maxLineLength = -1
+                scratch.writeMojomMethod(mojomMethod)
+                if len(scratch.result())+p.lineLength() > p.maxLineLength {
+                        splitResponse = true
+                }
+        }
+
         p.write(mojomMethod.NameToken().Text)
         if mojomMethod.DeclaredOrdinal() >= 0 {
                 p.writef("@%v", mojomMethod.DeclaredOrdinal())
         }
 
-        totalParams := len(mojomMethod.Parameters.Fields)
-        if mojomMethod.ResponseParameters != nil {
-                totalParams += len(mojomMethod.ResponseParameters.Fields)
-        }
-
         p.writeMethodParams(mojomMethod.Parameters)
         if mojomMethod.ResponseParameters != nil {
-                // TODO(azani): Actually enforce a line length limit instead.
-                if totalParams > 2 {
+                if splitResponse {
                         p.nl()
                         p.write("   ")
                 }
                 p.write(" => ")
                 p.writeMethodParams(mojomMethod.ResponseParameters)
         }
         p.write(";")
         p.writeRightComments(mojomMethod)
 }
 
 // writeMethodParams writes the pretty-printed method parameters represented by
 // a MojomStruct.
 func (p *printer) writeMethodParams(params *mojom.MojomStruct) {
+        ownLine := false
+        if p.maxLineLength > 0 {
+                scratch := newPrinter()
+                scratch.maxLineLength = -1
+                scratch.writeMethodParams(params)
+                if len(scratch.result())+p.lineLength() > p.maxLineLength {
+                        ownLine = true
+                }
+        }
         p.write("(")
         declaredObjects := params.GetDeclaredObjects()
 
-        // TODO(azani): Actually enforce a line length limit instead.
-        ownLine := len(declaredObjects) > 2
-        extraIndent := p.lineLength - p.indentSize
+        extraIndent := p.lineLength() - p.indentSize
         if ownLine {
                 p.indentSize += extraIndent
         }
 
         for i, param := range declaredObjects {
                 p.writeMethodParam(param.(*mojom.StructField))
                 if i < len(declaredObjects)-1 {
                         p.write(",")
                         if ownLine {
                                 p.nl()
@@ skipping 390 matching lines @@
 
 // write writes the provided string to the buffer.
 // If nothing has been written yet on the current line write also writes the
 // current indentation level.
 func (p *printer) write(s string) {
         if strings.ContainsRune(s, '\n') {
                 panic(fmt.Sprintf("Only the nl method can write a new line: %q", s))
         }
 
         // We only print the indentation if the line is not empty.
-        if p.lineLength == 0 {
+        if p.linePos == 0 {
                 p.buffer.WriteString(strings.Repeat(" ", p.indentSize))
-                p.lineLength += p.indentSize
+                p.linePos += p.indentSize
         }
-        p.lineLength += len(s)
+        p.linePos += len(s)
         p.buffer.WriteString(s)
 }
 
 // nl writes a new line. Before writing the new line, nl writes the last
 // comment on the line.
 func (p *printer) nl() {
         // Before going to the next line, print the last comment on the line.
         if p.eolComment != nil {
                 p.writef("  %s", p.eolComment.Text)
                 p.eolComment = nil
         }
 
         p.buffer.WriteString("\n")
-        p.lineLength = 0
+        p.linePos = 0
 }
 
 func (p *printer) incIndent() {
         p.indentSize += 2
 }
 
 func (p *printer) decIndent() {
         p.indentSize -= 2
         if p.indentSize < 0 {
                 panic("The printer is attempting to use negative indentation!")
         }
 }
 
 // setEolComment sets the comment that is to be printed at the end of the current line.
 // The last comment on the line is not necessarily associated with the last
 // element on the line. So when the last comment is found, we record that
 // comment so we may print it right before going to the next line.
 func (p *printer) setEolComment(comment lexer.Token) {
         if p.eolComment != nil {
                 panic("There is space for only one comment at the end of the line!")
         }
 
         if comment.Kind != lexer.SingleLineComment {
                 panic("Only SingleLineComments need to be handled specially at the end of line.")
         }
 
         p.eolComment = &comment
 }
 
+// lineLength returns the length of the line so far. If nothing has been written
+// to the line yet, it returns the indent size.
+// The purpose of lineLenght is to answer the question: If I write something now
+// how far on the current line will it be written?
+func (p *printer) lineLength() int {
+        if p.linePos == 0 {
+                return p.indentSize
+        }
+        return p.linePos
+}
+
 // Standalone utilities that do not operate on the buffer.
 
 // isNewBlock determines if an empty line should be printed above the element
 // under consideration. The purpose is to respect user-intention to separate
 // elements in a mojom file.
 //
 // If the element has attributes, and the first "comment" attached above the
 // attributes is an empty line, the element is a new block.
 // If the element has no attributes and the first "comment" attached above the
 // element itself is an empty line, the element is a new block.
@@ skipping 62 matching lines @@
 
 // See sort.Interface.
 func (ifs *importedFilesSorter) Less(i, j int) bool {
         return ifs.imports[i].SpecifiedName < ifs.imports[j].SpecifiedName
 }
 
 // See sort.Interface.
 func (ifs *importedFilesSorter) Swap(i, j int) {
         ifs.imports[i], ifs.imports[j] = ifs.imports[j], ifs.imports[i]
 }