Export as interface, hide variables

Author: Mateusz Gajewski

cli/cli.go

@@ -36,6 +36,8 @@ type Config struct {
 	FormatCode           bool
 	ForcePluginRebuild   bool
 	OutputPackage        string
+	HideVariables        bool
+	AsInterface          bool
 }
 
 // Cli is responsible for generating plugin wrapper, can be initialized with New()
@@ -96,10 +98,7 @@ func (c *Cli) GenerateFile() error {
 		return fmt.Errorf("Could not create output file: %s", err)
 	}
 
-	tpl, err := template.New("generate").
-		Funcs(template.FuncMap{"isStandardImport": func(pkg string, importName string) bool {
-			return pkg[strings.LastIndex(pkg, "/")+1:] == importName
-		}}).Parse(generateFileTemplate)
+	tpl, err := template.New("generate").Parse(generateFileTemplate)
 
 	if err != nil {
 		return err
@@ -219,6 +218,14 @@ func (c *Cli) buildCommandArgs() string {
 		commandLine = append(commandLine, "-rebuild")
 	}
 
+	if c.config.AsInterface {
+		commandLine = append(commandLine, "-interface")
+	}
+
+	if c.config.HideVariables {
+		commandLine = append(commandLine, "-hide-vars")
+	}
+
 	return strings.Join(commandLine, " ")
 }
 
@@ -243,5 +250,9 @@ func validateConfig(config *Config) error {
 		config.PluginPath = "plugin.so"
 	}
 
+	if config.AsInterface {
+		config.HideVariables = true
+	}
+
 	return nil
 }

cli/cli_test.go

@@ -18,6 +18,7 @@ type testCase struct {
 	Plugin         string
 	ExpectedOutput string
 	ExecutedCode   string
+	AsInterface    bool
 }
 
 func TestWillGenerateComplexPluginWithoutErrors(t *testing.T) {
@@ -33,6 +34,12 @@ func TestWillGenerateComplexPluginWithoutErrors(t *testing.T) {
 			ExecutedCode:   "fmt.Println(pl.ReturningIntArray())",
 			ExpectedOutput: "[1 0 1]",
 		},
+		{
+			Plugin:         "plugin_as_interface",
+			ExecutedCode:   "fmt.Println(pl.ReturningStringSlice())",
+			ExpectedOutput: "hello world",
+			AsInterface:    true,
+		},
 	}
 
 	for i, testCase := range testCases {
@@ -47,14 +54,15 @@ func TestWillGenerateComplexPluginWithoutErrors(t *testing.T) {
 			ForcePluginRebuild: true,
 			OutputPackage:      "main",
 			OutputName:         "TestWrapper",
+			AsInterface:        testCase.AsInterface,
 		}
 
 		client, err := New(config, log.New(ioutil.Discard, "", 0))
 		if err != nil {
 			t.Fatalf("[Test %d] Expected err to be nil, actual: %s", i, err)
 		}
 
-		if generateErr := client.GenerateFile(); err != nil {
+		if generateErr := client.GenerateFile(); generateErr != nil {
 			t.Fatalf("[Test %d] Expected err to be nil, actual: %s", i, generateErr)
 		}
 

cli/plugin.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"plugin"
+	"strings"
 	"unsafe"
 )
 
@@ -23,7 +24,10 @@ type pluginStructure struct {
 
 	Functions    []*function
 	Variables    []*variable
-	ImportsNames map[string]string
+	Imports      []string
+	NamedImports map[string]string
+
+	importsNames map[string]string
 }
 
 func loadPlugin(path string, imports []string) (*pluginStructure, error) {
@@ -47,9 +51,9 @@ func loadPlugin(path string, imports []string) (*pluginStructure, error) {
 	ps := &pluginStructure{
 		Symbols:      plug.symbols,
 		Package:      plug.path,
-		ImportsNames: make(map[string]string),
 		Size:         stat.Size(),
 		Sha256:       shaSum,
+		importsNames: make(map[string]string),
 	}
 
 	for _, pkg := range imports {
@@ -62,6 +66,9 @@ func loadPlugin(path string, imports []string) (*pluginStructure, error) {
 		return nil, err2
 	}
 
+	ps.Imports = ps.imports()
+	ps.NamedImports = ps.namedImports()
+
 	return ps, nil
 }
 
@@ -80,3 +87,33 @@ func (p *pluginStructure) analyze() error {
 
 	return nil
 }
+
+func (p *pluginStructure) namedImports() map[string]string {
+	var ret = make(map[string]string)
+
+	for name, imp := range p.importsNames {
+		if p.isNamedImport(imp, name) {
+			ret[name] = imp
+		}
+	}
+
+	return ret
+}
+
+func (p *pluginStructure) imports() []string {
+	var ret []string
+
+	for name, imp := range p.importsNames {
+		if p.isNamedImport(imp, name) {
+			ret = append(ret, fmt.Sprintf("%s %q", name, imp))
+		} else {
+			ret = append(ret, fmt.Sprintf("%q", imp))
+		}
+	}
+
+	return ret
+}
+
+func (p *pluginStructure) isNamedImport(pkg string, importName string) bool {
+	return pkg[strings.LastIndex(pkg, "/")+1:] != importName
+}

cli/reflect.go

@@ -57,7 +57,7 @@ func (p *pluginStructure) getNamedPkgImport(pkg string) string {
 			nextImportName = fmt.Sprintf("%s_%d", importName, nextIndex)
 		}
 
-		if current, ok := p.ImportsNames[nextImportName]; ok {
+		if current, ok := p.importsNames[nextImportName]; ok {
 			// We already have this package
 			if current == pkg {
 				return nextImportName + "."
@@ -66,7 +66,7 @@ func (p *pluginStructure) getNamedPkgImport(pkg string) string {
 			nextIndex++
 			continue
 		} else {
-			p.ImportsNames[nextImportName] = pkg
+			p.importsNames[nextImportName] = pkg
 			return nextImportName + "."
 		}
 	}

cli/template.go

@@ -9,35 +9,51 @@ var generateFileTemplate = `package {{.OutputPackage}}
 // - size: {{.Plugin.Size}} bytes
 // - sha256: {{.Plugin.Sha256}}
 
-import ({{ range $key, $val := .Plugin.ImportsNames }}
-  {{if isStandardImport $val $key }}"{{ $val }}"{{else}}{{ $key }} "{{ $val }}"{{end }}{{end}}
+{{ $imports := .Plugin.Imports }}
+import ({{ range $imports }}
+  {{.}}
+{{end}}
 )
-{{$useVarReference := .Config.DereferenceVariables|not}}{{$pluginPackage := .Plugin.Package}}{{$receiver := .Config.OutputName}}
+{{$useVarReference := .Config.DereferenceVariables|not}}{{$pluginPackage := .Plugin.Package}}{{$receiver := .Config.OutputName}}{{$interface := .Config.AsInterface}}
 // {{.Config.OutputName}} wraps symbols (functions and variables) exported by plugin {{.Plugin.Package}}
 //
 // See docs at https://godoc.org/{{$pluginPackage}}
-type {{.Config.OutputName}} struct {
+type {{if $interface}}_{{end}}{{.Config.OutputName}} struct {
   // Exported functions
   {{range .Plugin.Functions}}_{{ .Name }} {{ .Signature }}
   {{end}}
+  {{if .Config.HideVariables | not }}
   // Exported variables (public references)
   {{range .Plugin.Variables}}
   // See docs at https://godoc.org/{{$pluginPackage}}#{{ .Name }}
   {{ .Name }} {{if $useVarReference}}*{{end}}{{ .Signature }}{{end}}
+  {{end}}
 }
+
+{{if $interface}}
+// {{.Config.OutputName}} wraps functions exported by plugin {{.Plugin.Package}}
+//
+// See docs at https://godoc.org/{{$pluginPackage}}
+type {{.Config.OutputName}} interface {
+  // Exported functions
+  {{range .Plugin.Functions}}{{ .Name }} {{ .TrimmedSignature }}
+  {{end}}
+}
+{{end}}
+
 {{range .Plugin.Functions}}
 // {{.Name}} function was exported from plugin {{$pluginPackage}} symbol '{{.Name}}'
 //
 // See docs at https://godoc.org/{{$pluginPackage}}#{{.Name}}
-func (p *{{$receiver}}) {{.Name}}{{.TrimmedSignature}} {
+func (p *{{if $interface}}_{{end}}{{$receiver}}) {{.Name}}{{.TrimmedSignature}} {
   {{ if .ReturnsVoid | not }}return {{ end }}p._{{ .Name }}({{ .ArgumentsCall }})
 }
 {{end}}
 
 // String returnes textual representation of the wrapper. It provides info on exported symbols and variables.
-func (p *{{$receiver}}) String() string {
+func (p *{{if $interface}}_{{end}}{{$receiver}}) String() string {
   var lines []string
-  lines = append(lines, "Wrapper info:")
+  lines = append(lines, "{{if $interface}}Interface{{else}}Struct{{end}} {{.Config.OutputName}}:")
   lines = append(lines, "\t- Generated on: {{.Build.Date}}")
   lines = append(lines, "\t- Command: {{.Build.Command}}")
   lines = append(lines, "\nPlugin info:")
@@ -47,19 +63,26 @@ func (p *{{$receiver}}) String() string {
   lines = append(lines, "\nExported functions ({{.Plugin.Functions|len}}):")
   {{ range .Plugin.Functions }}lines = append(lines, "\t- {{.Name}} {{ .Signature }}")
   {{ end }}
+  {{ if .Config.HideVariables | not }}
+  {{ if .Plugin.Variables }}
   lines = append(lines, "\nExported variables ({{.Plugin.Variables|len}}):")
   {{ range .Plugin.Variables }}lines = append(lines, "\t- {{.Name}} {{ .Signature }}")
   {{ end }}
-  lines = append(lines, "\nPlugin imports:"){{ range $key, $val := .Plugin.ImportsNames }}{{if isStandardImport $val $key | not }}
+  {{end}}
+  {{end}}
+  {{$imports := .Plugin.NamedImports}}
+  {{if $imports}}
+  lines = append(lines, "\nPlugin imports:"){{ range $key, $val := $imports }}
   lines = append(lines, "\t- {{ $val }} as {{ $key }}")
-  {{end}}{{ end }}
+  {{end}}
+  {{end}}
   return strings.Join(lines, "\n")
 }
 
-// Load{{.Config.OutputName}} loads plugin from the given path and binds symbols (variables and functions)
-// to the {{.Config.OutputName}} struct. {{if .Config.DereferenceVariables}}All variables are derefenences. {{end}}
-{{ if .Config.CheckSha256 }}// When plugin is loaded sha256 checksum is computed and checked against precomputed once. On mismatch error is returned. {{end}}
-func Bind{{.Config.OutputName}}(path string) (*{{.Config.OutputName}}, error) {
+// Bind{{.Config.OutputName}} loads plugin from the given path and binds {{if .Config.AsInterface}}functions{{else}}symbols (variables and functions){{end}}
+// to the {{if .Config.AsInterface}}struct implementing {{.Config.OutputName}} interface{{else}}{{.Config.OutputName}} struct{{end}}. {{if .Config.HideVariables | not}}{{if .Config.DereferenceVariables}}All variables are derefenences. {{end}}{{end}}
+{{ if .Config.CheckSha256 }}// When plugin is loaded sha256 checksum is computed and checked against precomputed once. On mismatch error is returned.
+{{end}}func Bind{{.Config.OutputName}}(path string) ({{if.Config.AsInterface|not}}*{{end}}{{.Config.OutputName}}, error) {
     p, err := plugin.Open(path)
 
     if err != nil {
@@ -92,7 +115,7 @@ func Bind{{.Config.OutputName}}(path string) (*{{.Config.OutputName}}, error) {
       return nil, fmt.Errorf("Sha256 checksum mismatch (expected: {{.Plugin.Sha256}}, actual: %s)", checksum)
     }{{ end }}
 
-    ret := new({{.Config.OutputName}})
+    ret := new({{if .Config.AsInterface}}_{{end}}{{.Config.OutputName}})
     {{range .Plugin.Functions}}
     func{{ .Name }}, err := p.Lookup("{{ .Name }}")
     if err != nil {
@@ -104,7 +127,9 @@ func Bind{{.Config.OutputName}}(path string) (*{{.Config.OutputName}}, error) {
     } else {
       return nil, fmt.Errorf("Could not import function '{{ .Name }}', incompatible types '{{ .Signature }}' and '%s'", reflect.TypeOf(func{{ .Name }}))
     }
-    {{end}}{{range .Plugin.Variables}}
+    {{end}}
+    {{if .Config.HideVariables|not}}
+    {{range .Plugin.Variables}}
     var{{ .Name }}, err := p.Lookup("{{ .Name }}")
     if err != nil {
       return nil, fmt.Errorf("Could not import variable '{{ .Name }}', symbol not found: %s", err)
@@ -116,6 +141,8 @@ func Bind{{.Config.OutputName}}(path string) (*{{.Config.OutputName}}, error) {
       return nil, fmt.Errorf("Could not import variable '{{ .Name }}', incompatible types '{{ .Signature }}' and '%s'", reflect.TypeOf(var{{ .Name }}))
     }
     {{end}}
+    {{end}}
+
     return ret, nil
 }
 `

internal/test_fixtures/basic_plugin/plugin.go

@@ -2,18 +2,22 @@ package main
 
 import "fmt"
 
+// ReturningInt32 is only exported for testing purposes
 func ReturningInt32() int32 {
 	return 32
 }
 
+// ReturningStringSlice is only exported for testing purposes
 func ReturningStringSlice() []string {
 	return make([]string, 0)
 }
 
+// ReturningIntArray is only exported for testing purposes
 func ReturningIntArray() [3]int32 {
 	return [...]int32{1, 0, 1}
 }
 
+// NonReturningFunction is only exported for testing purposes
 func NonReturningFunction() {
 	fmt.Println("I'm not returning anything")
 }

internal/test_fixtures/complex_plugin/http/http.go

@@ -1,9 +1,11 @@
 package http
 
+// Work is only exported for testing purposes
 type Work struct {
 	Work string
 }
 
+// DoWork2 is only exported for testing purposes
 func DoWork2(w Work) string {
 	return "I'm doing my work: " + w.Work
 }