Implement formatting exclusion.

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 28 matching lines @@
         // eolComment is the comment to be printed at the end of the current line.
         eolComment *lexer.Token
 
         // 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
+
+        // mojomFile is the file being printed.
+        mojomFile *mojom.MojomFile
+
+        // noFormat indicates we are in a block where formatting has been disabled.
+        noFormat bool
+
+        // token that begins a block where formatting has been disabled.
+        noFormatStart lexer.Token
+
+        // indentSize at the time noFormat is set.
+        noFormatStartIndent 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.
 // It takes a mojom file with attached comments and creates a pretty-printed
 // representation.
 func (p *printer) writeMojomFile(mojomFile *mojom.MojomFile) {
         if p.used {
                 panic("A printer can only be used once!")
         }
         p.used = true
+        p.mojomFile = mojomFile
 
         p.writeAttributes(mojomFile.Attributes)
         p.writeModuleNamespace(mojomFile.ModuleNamespace)
 
         if len(mojomFile.Imports) > 0 {
                 p.writeImportedFiles(mojomFile.Imports)
         }
 
         for _, declaredObject := range mojomFile.DeclaredObjects {
                 p.writeDeclaredObject(declaredObject)
                 p.nl()
         }
 
         if mojomFile.FinalComments != nil {
                 finalComments := trimEmptyLines(mojomFile.FinalComments)
                 if len(finalComments) > 0 {
                         p.nl()
                         p.writeCommentBlocks(finalComments, true)
                 }
         }
+
+        p.eofNoFormat()
 }
 
 // writeModuleNamespace writes a mojom file's module statement and associated
 // comments.
 func (p *printer) writeModuleNamespace(module *mojom.ModuleNamespace) {
         if module == nil || module.Identifier == "" {
                 return
         }
         p.writeBeforeComments(module)
         p.writef("module %s;", module.Identifier)
@@ skipping 462 matching lines @@
                 p.writef(" %s", comment.Text)
         }
 }
 
 // writeCommentBlocks writes a slice of comments. If finalEol is true, a new
 // line is written after all the comments are written.
 func (p *printer) writeCommentBlocks(comments []lexer.Token, finalEol bool) {
         for i, comment := range comments {
                 switch comment.Kind {
                 case lexer.SingleLineComment:
+                        if comment.Text == "// no-format" {
+                                p.startNoFormat(comment)
+                        } else if comment.Text == "// end-no-format" {
+                                p.endNoFormat(comment)
+                        }
                         p.write(comment.Text)
                         if finalEol || i < len(comments)-1 {
                                 p.nl()
                         }
                 case lexer.MultiLineComment:
                         p.writeMultiLineComment(comment)
                         if finalEol || i < len(comments)-1 {
                                 p.nl()
                         }
                 case lexer.EmptyLine:
@@ skipping 44 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.linePos == 0 {
-                p.buffer.WriteString(strings.Repeat(" ", p.indentSize))
+                if !p.noFormat {
+                        p.buffer.WriteString(strings.Repeat(" ", p.indentSize))
+                }
                 p.linePos += p.indentSize
         }
         p.linePos += len(s)
-        p.buffer.WriteString(s)
+        if !p.noFormat {
+                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)
+                if !p.noFormat {
+                        p.writef("  %s", p.eolComment.Text)
+                }
                 p.eolComment = nil
         }
 
-        p.buffer.WriteString("\n")
+        if !p.noFormat {
+                p.buffer.WriteString("\n")
+        }
         p.linePos = 0
 }
 
 func (p *printer) incIndent() {
         p.indentSize += 2
 }
 
 func (p *printer) decIndent() {
         p.indentSize -= 2
         if p.indentSize < 0 {
@@ skipping 21 matching lines @@
 // 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
 }
 
+// startNoFormat disables writes to the buffer (future writes are discarded).
+func (p *printer) startNoFormat(startToken lexer.Token) {
+        if p.noFormat {
+                return
+        }
+
+        p.noFormat = true
+        p.noFormatStart = startToken
+        p.noFormatStartIndent = p.indentSize
+}
+
+// endNoFormat re-enables writes to the buffer and writes the source starting
+// at the beginning of p.startToken and ending right before endToken.
+func (p *printer) endNoFormat(endToken lexer.Token) {
+        if !p.noFormat {
+                return
+        }
+
+        fileContents := p.mojomFile.FileContents()
+        notFormatted := fileContents[p.noFormatStart.SourcePosBytes:endToken.SourcePosBytes]
+
+        // Remove any unformatted indentation right before the end of the unformatted block.
+        notFormatted = strings.TrimRight(notFormatted, " \t")
+        p.buffer.WriteString(strings.Repeat(" ", p.noFormatStartIndent))
+        p.buffer.WriteString(notFormatted)
+        p.noFormat = false
+}
+
+// eofNoFormat handles the case where formatting had been disabled but not
+// re-enabled. It writes everything after the formatting was ended.
+func (p *printer) eofNoFormat() {
+        if !p.noFormat {
+                return
+        }
+
+        fileContents := p.mojomFile.FileContents()
+        p.endNoFormat(lexer.Token{SourcePosBytes: len(fileContents)})
+}
+
 // 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]
 }