Merge pull request #191 from WillAbides/directive

Directives without leading whitespace

Author: jmattheis

comments/parse_docs.go

@@ -93,7 +93,7 @@ func parseFunctions(fset *token.FileSet, pkg *types.Package, decl *ast.GenDecl,
 		name := value.Names[0].Name
 
 		location := fileWithLine(fset.Position(value.Pos()))
-		result[name] = parseRawLines(location, value.Doc.Text())
+		result[name] = parseRawLines(location, parse.CommentToString(value.Doc))
 	}
 
 	converter := config.RawConverter{
@@ -107,7 +107,7 @@ func parseFunctions(fset *token.FileSet, pkg *types.Package, decl *ast.GenDecl,
 }
 
 func parseGenDecl(fset *token.FileSet, pkg *types.Package, decl *ast.GenDecl) ([]config.RawConverter, error) {
-	declDocs := decl.Doc.Text()
+	declDocs := parse.CommentToString(decl.Doc)
 
 	if strings.Contains(declDocs, variablesMarker) {
 		return parseFunctions(fset, pkg, decl, declDocs)
@@ -135,8 +135,8 @@ func parseGenDecl(fset *token.FileSet, pkg *types.Package, decl *ast.GenDecl) ([
 	var converters []config.RawConverter
 
 	for _, spec := range decl.Specs {
-		if typeSpec, ok := spec.(*ast.TypeSpec); ok && strings.Contains(typeSpec.Doc.Text(), converterMarker) {
-			c, err := parseInterface(fset, pkg, typeSpec, typeSpec.Doc.Text())
+		if typeSpec, ok := spec.(*ast.TypeSpec); ok && strings.Contains(parse.CommentToString(typeSpec.Doc), converterMarker) {
+			c, err := parseInterface(fset, pkg, typeSpec, parse.CommentToString(typeSpec.Doc))
 			if err != nil {
 				return nil, err
 			}
@@ -180,7 +180,7 @@ func parseInterfaceMethods(location *token.FileSet, inter *ast.InterfaceType) (m
 		name := method.Names[0].String()
 
 		location := location.Position(method.Pos())
-		result[name] = parseRawLines(fileWithLine(location), method.Doc.Text())
+		result[name] = parseRawLines(fileWithLine(location), parse.CommentToString(method.Doc))
 	}
 	return result, nil
 }

config/parse/comment.go

@@ -0,0 +1,109 @@
+// CommentToString is a modified version of ast.CommentGroup.Text() that doesn't skip directives.
+// https://github.com/golang/go/blob/b70244ff7a043786c211775b68259de6104ff91c/src/go/ast/ast.go#L97
+//
+// Copyright 2009 The Go Authors.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google LLC nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package parse
+
+import (
+	"go/ast"
+	"strings"
+)
+
+func CommentToString(g *ast.CommentGroup) string {
+	if g == nil {
+		return ""
+	}
+	comments := make([]string, len(g.List))
+	for i, c := range g.List {
+		comments[i] = c.Text
+	}
+
+	lines := make([]string, 0, 10) // most comments are less than 10 lines
+	for _, c := range comments {
+		// Remove comment markers.
+		// The parser has given us exactly the comment text.
+		switch c[1] {
+		case '/':
+			//-style comment (no newline at the end)
+			c = c[2:]
+			if len(c) == 0 {
+				// empty line
+				break
+			}
+			if c[0] == ' ' {
+				// strip first space - required for Example tests
+				c = c[1:]
+				break
+			}
+
+			// This is where [*ast.CommentGroup.Text] detects and skips directives.
+
+		case '*':
+			/*-style comment */
+			c = c[2 : len(c)-2]
+		}
+
+		// Split on newlines.
+		cl := strings.Split(c, "\n")
+
+		// Walk lines, stripping trailing white space and adding to list.
+		for _, l := range cl {
+			lines = append(lines, stripTrailingWhitespace(l))
+		}
+	}
+
+	// Remove leading blank lines; convert runs of
+	// interior blank lines to a single blank line.
+	n := 0
+	for _, line := range lines {
+		if line != "" || n > 0 && lines[n-1] != "" {
+			lines[n] = line
+			n++
+		}
+	}
+	lines = lines[0:n]
+
+	// Add final "" entry to get trailing newline from Join.
+	if n > 0 && lines[n-1] != "" {
+		lines = append(lines, "")
+	}
+
+	return strings.Join(lines, "\n")
+}
+
+func isWhitespace(ch byte) bool { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' }
+
+func stripTrailingWhitespace(s string) string {
+	i := len(s)
+	for i > 0 && isWhitespace(s[i-1]) {
+		i--
+	}
+	return s[0:i]
+}

docs/changelog.md

@@ -6,6 +6,9 @@ import GH from './GH.vue';
 
 ## unreleased
 
+- Allow specifying `goverter:` settings without leading space e.g.
+  `//goverter:converter` <GH issue="190" pr="191"/>
+
 ## v1.8.0
 
 - Fix go1.24 support. <GH issue="186" pr="187"/>

pkgload/pkgload.go

@@ -108,7 +108,7 @@ func (g *PackageLoader) localConfig(pkg *packages.Package, name string) method.L
 		for _, file := range pkg.Syntax {
 			for _, decl := range file.Decls {
 				if fn, ok := decl.(*ast.FuncDecl); ok {
-					lines := parse.SettingLines(fn.Doc.Text())
+					lines := parse.SettingLines(parse.CommentToString(fn.Doc))
 					if len(lines) == 0 {
 						continue
 					}

scenario/directive.yml

@@ -0,0 +1,57 @@
+input:
+    input.go: |
+        package directive
+
+        //goverter:converter
+        type Simple interface {
+            //goverter:context c
+            //goverter:map Value | FromContext
+            Convert(source struct{ Value int }, c string) struct{ Value string }
+        }
+
+        type (
+            //goverter:converter
+            One interface{}
+            Two interface{}
+        )
+
+        //goverter:variables
+        var (
+            Convert func(string) string
+        )
+
+        //goverter:context c
+        func FromContext(c string) string { return c }
+success:
+    - generated/generated.go: |
+        // Code generated by github.com/jmattheis/goverter, DO NOT EDIT.
+
+        package generated
+
+        import execution "github.com/jmattheis/goverter/execution"
+
+        type OneImpl struct{}
+        type SimpleImpl struct{}
+
+        func (c *SimpleImpl) Convert(source struct {
+        	Value int
+        }, context string) struct {
+        	Value string
+        } {
+        	var unnamed struct {
+        		Value string
+        	}
+        	unnamed.Value = execution.FromContext(context)
+        	_ = source
+        	return unnamed
+        }
+    - input.gen.go: |
+        // Code generated by github.com/jmattheis/goverter, DO NOT EDIT.
+
+        package directive
+
+        func init() {
+        	Convert = func(source string) string {
+        		return source
+        	}
+        }