rename the interface

Author: xynicole

analyze_test.go

@@ -2110,7 +2110,7 @@ func TestAnalyze_lua(t *testing.T) {
 			err := analyze("nginx.conf", tc.stmt, ";", tc.ctx, &ParseOptions{
 				MatchFuncs: []MatchFunc{MatchLua},
 				LexOptions: LexOptions{
-					ExternalLexers: []ExternalLexer{
+					ExternalLexers: []Lexer{
 						&Lua{},
 					},
 				},

build.go

@@ -10,7 +10,6 @@ package crossplane
 import (
 	"bytes"
 	"io"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -22,19 +21,21 @@ type BuildOptions struct {
 	Indent         int
 	Tabs           bool
 	Header         bool
-	ExternalBuilds []ExternalBuilder // handle specific directives
+	ExternalBuilds []Builder // handle specific directives
 }
 
-// ExternalBuilder is the interface that provides an abstraction for implementing builders that
-// can handle external and custom NGINXdirectives during the build process of NGINX configurations
-// from JSON payloads.
-type ExternalBuilder interface {
-	// RegisterExternalBuilder allows the build system to identify which NGINX directives are supported
-	// by the external builder and routes the build process of those directives to this builder.
-	RegisterExternalBuilder() []string
-	// Build is responsible for constructing the configuration block for a specific directive.
-	// It is called during the configuration building process whenever a registered directive is encountered.
-	Build(sb io.StringWriter, stmt *Directive) error
+// Builder is the interface implemented by types that can render a Directive
+// as it appears in NGINX configuration files.
+//
+// RegisterBuilder returns the names of the directives for which the builder can
+// build NGINX configuration.
+//
+// Build writes the strings that represent the Directive and it's Block to the
+// io.StringWriter returning any error encountered that caused the write to stop
+// early. Build must not modify the Directive.
+type Builder interface {
+	RegisterBuilder() []string
+	Build(stmt *Directive) string
 }
 
 const MaxIndent = 100
@@ -122,7 +123,7 @@ func Build(w io.Writer, config Config, options *BuildOptions) error {
 	return err
 }
 
-//nolint:funlen,gocognit,gocyclo
+//nolint:funlen,gocognit
 func buildBlock(sb io.StringWriter, parent *Directive, block Directives, depth int, lastLine int, options *BuildOptions) {
 	for i, stmt := range block {
 		// if the this statement is a comment on the same line as the preview, do not emit EOL for this stmt
@@ -147,18 +148,16 @@ func buildBlock(sb io.StringWriter, parent *Directive, block Directives, depth i
 			_, _ = sb.WriteString(directive)
 
 			if options.ExternalBuilds != nil {
-				extDirectivesMap := make(map[string]ExternalBuilder)
+				extDirectivesMap := make(map[string]Builder)
 				for _, ext := range options.ExternalBuilds {
-					directives := ext.RegisterExternalBuilder()
+					directives := ext.RegisterBuilder()
 					for _, d := range directives {
 						extDirectivesMap[d] = ext
 					}
 
 					if ext, ok := extDirectivesMap[directive]; ok {
 						_, _ = sb.WriteString(" ") // space between directives and arguments
-						if err := ext.Build(sb, stmt); err != nil {
-							log.Printf("Failed to write externaller block: %v", err)
-						}
+						_, _ = sb.WriteString(ext.Build(stmt))
 					}
 				}
 			} else {

build_test.go

@@ -260,7 +260,7 @@ var buildFixtures = []buildFixture{
 	},
 	{
 		name:    "lua block",
-		options: BuildOptions{ExternalBuilds: []ExternalBuilder{&Lua{}}},
+		options: BuildOptions{ExternalBuilds: []Builder{&Lua{}}},
 		parsed: Directives{
 			{
 				Directive: "content_by_lua_block",
@@ -273,7 +273,7 @@ var buildFixtures = []buildFixture{
 	},
 	{
 		name:    "set_by_lua_block",
-		options: BuildOptions{ExternalBuilds: []ExternalBuilder{&Lua{}}},
+		options: BuildOptions{ExternalBuilds: []Builder{&Lua{}}},
 		parsed: Directives{
 			{
 				Directive: "set_by_lua_block",

lex.go

@@ -44,13 +44,13 @@ func SetTokenChanCap(size int) {
 	tokChanCap = size
 }
 
-// ExternalLexer is an interface for implementing lexers that handle external NGINX tokens during the lexical analysis phase.
-type ExternalLexer interface {
-	// RegisterExternalLexer registers an external lexer with a given sub-scanner.
+// Lexer is an interface for implementing lexers that handle external NGINX tokens during the lexical analysis phase.
+type Lexer interface {
+	// RegisterLexer registers an external lexer with a given SubScanner.
 	// This method integrates the external lexer into the lexical analysis process,
 	// enabling it to handle external token scanning. It returns a slice of strings
 	// representing the tokens that the external lexer can recognize.
-	RegisterExternalLexer(scanner *SubScanner) []string
+	RegisterLexer(scanner *SubScanner) []string
 	// Lex processes a matched token and returns a channel of NgxToken objects.
 	// This method performs lexical analysis on the matched token and produces a stream of tokens for the parser to consume.
 	// The external lexer should close the channel once it has completed lexing the input to signal the end of tokens.
@@ -63,7 +63,7 @@ type ExternalLexer interface {
 // external lexers can ensure that these directives are processed separately
 // from the general lexical analysis logic.
 type LexOptions struct {
-	ExternalLexers []ExternalLexer
+	ExternalLexers []Lexer
 }
 
 func LexWithOptions(r io.Reader, options LexOptions) chan NgxToken {
@@ -119,18 +119,18 @@ func tokenize(reader io.Reader, tokenCh chan NgxToken, options LexOptions) {
 		lexState = skipSpace
 	}
 
-	var externalLexers map[string]ExternalLexer
+	var externalLexers map[string]Lexer
 	var externalScanner *SubScanner
 	for _, ext := range options.ExternalLexers {
 		if externalLexers == nil {
-			externalLexers = make(map[string]ExternalLexer)
+			externalLexers = make(map[string]Lexer)
 		}
 
 		if externalScanner == nil {
 			externalScanner = &SubScanner{scanner: scanner, tokenLine: tokenLine}
 		}
 
-		for _, d := range ext.RegisterExternalLexer(externalScanner) {
+		for _, d := range ext.RegisterLexer(externalScanner) {
 			externalLexers[d] = ext
 		}
 	}

lex_test.go

@@ -430,7 +430,7 @@ func TestLex(t *testing.T) {
 			}
 			defer file.Close()
 			options := LexOptions{
-				ExternalLexers: []ExternalLexer{
+				ExternalLexers: []Lexer{
 					&Lua{},
 				},
 			}

lua.go

@@ -2,7 +2,6 @@ package crossplane
 
 import (
 	"fmt"
-	"io"
 	"strings"
 )
 
@@ -31,7 +30,7 @@ func (l *Lua) directiveNames() []string {
 	}
 }
 
-func (l *Lua) RegisterExternalLexer(s *SubScanner) []string {
+func (l *Lua) RegisterLexer(s *SubScanner) []string {
 	l.s = s
 	return l.directiveNames()
 }
@@ -154,18 +153,14 @@ func (l *Lua) Lex(matchedToken string) <-chan NgxToken {
 	return tokenCh
 }
 
-func (l *Lua) RegisterExternalBuilder() []string {
+func (l *Lua) RegisterBuilder() []string {
 	return l.directiveNames()
 }
 
-func (l *Lua) Build(sb io.StringWriter, stmt *Directive) error {
+func (l *Lua) Build(stmt *Directive) string {
 	if stmt.Directive == "set_by_lua_block" {
-		s := fmt.Sprintf("%s {%s}", stmt.Args[0], stmt.Args[1])
-		_, err := sb.WriteString(s)
-		return err
+		return fmt.Sprintf("%s {%s}", stmt.Args[0], stmt.Args[1])
 	}
 
-	s := fmt.Sprintf("{%s}", stmt.Args[0])
-	_, err := sb.WriteString(s)
-	return err
+	return fmt.Sprintf("{%s}", stmt.Args[0])
 }

parse_test.go

@@ -1707,7 +1707,7 @@ var parseFixtures = []parseFixture{
 		ErrorOnUnknownDirectives: true,
 		MatchFuncs:               []MatchFunc{MatchLua},
 		LexOptions: LexOptions{
-			ExternalLexers: []ExternalLexer{
+			ExternalLexers: []Lexer{
 				&Lua{},
 			},
 		},
@@ -1838,7 +1838,7 @@ var parseFixtures = []parseFixture{
 		ErrorOnUnknownDirectives: true,
 		MatchFuncs:               []MatchFunc{MatchLua},
 		LexOptions: LexOptions{
-			ExternalLexers: []ExternalLexer{
+			ExternalLexers: []Lexer{
 				&Lua{},
 			},
 		},
@@ -1932,7 +1932,7 @@ var parseFixtures = []parseFixture{
 		ParseComments:            true,
 		MatchFuncs:               []MatchFunc{MatchLua},
 		LexOptions: LexOptions{
-			ExternalLexers: []ExternalLexer{
+			ExternalLexers: []Lexer{
 				&Lua{},
 			},
 		},