refactor plugin architecture

Signed-off-by: Bryce Palmer <bpalmer@redhat.com>

Author: everettraven

examples/simple.star

@@ -0,0 +1 @@
+github("everettraven", "synkr")

pkg/builtins/github.go

@@ -0,0 +1,17 @@
+package builtins
+
+import "go.starlark.net/starlark"
+
+func TypeFromStarlarkList[T any](list *starlark.List) []T{
+	types := []T{}
+
+	if list != nil {
+		for v := range list.Elements() {
+			if typeInstance, ok := v.(T); ok {
+				types = append(types, typeInstance)
+			}
+		}
+	}
+
+	return types
+}

pkg/builtins/utils.go

@@ -6,17 +6,18 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/everettraven/synkr/pkg/builtins"
 	"github.com/everettraven/synkr/pkg/engine"
+	"github.com/everettraven/synkr/pkg/plugins"
 	"github.com/everettraven/synkr/pkg/printers"
 	"github.com/spf13/cobra"
 	"go.starlark.net/lib/time"
 	"go.starlark.net/starlark"
 	"go.starlark.net/syntax"
+
+	_ "github.com/everettraven/synkr/pkg/plugins/registration"
 )
 
 func NewSynkrCommand() *cobra.Command {
-	eng := &engine.Engine{}
 	var configFile string
 	var outputFormat string
 
@@ -25,7 +26,7 @@ func NewSynkrCommand() *cobra.Command {
 		Short: "synkr is an engine for syncing work items based on a Starlark configuration",
 		Args:  cobra.ExactArgs(0),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return run(cmd.Context(), eng, configFile, outputFormat)
+			return run(cmd.Context(), configFile, outputFormat)
 		},
 	}
 
@@ -35,31 +36,46 @@ func NewSynkrCommand() *cobra.Command {
 	return cmd
 }
 
-func run(ctx context.Context, eng *engine.Engine, configFile, output string) error {
-	thread, err := configureEngine(eng, configFile, output)
+func run(ctx context.Context, configFile, output string) error {
+	plugins := plugins.Plugins()
+	thread, err := configureThread(configFile, plugins...)
+	if err != nil {
+		return fmt.Errorf("configuring thread: %w", err)
+	}
+
+	eng := engine.New(plugins...)
+
+	results, err := eng.Run(ctx, thread)
 	if err != nil {
-		return fmt.Errorf("configuring engine: %w", err)
+		return fmt.Errorf("running engine: %w", err)
 	}
 
-	return eng.Run(ctx, thread)
+	return printResults(output, results...)
 }
 
-func configureEngine(eng *engine.Engine, configFile, output string) (*starlark.Thread, error) {
+func printResults(output string, results ...plugins.SourceResult) error {
 	switch output {
-	case "markdown":
-		eng.SetPrinter(&printers.Markdown{})
 	case "json":
-		eng.SetPrinter(&printers.JSON{})
+		out := &printers.JSON{}
+		return out.Print(results...)
+	case "markdown":
+		out := &printers.Markdown{}
+		return out.Print(results...)
 	case "web":
-		eng.SetPrinter(&printers.Web{})
+		out := &printers.Web{}
+		return out.Print(results...)
 	default:
-		return nil, fmt.Errorf("unknown output format %q", output)
+		return fmt.Errorf("unknown output format %q", output)
 	}
+}
 
+func configureThread(configFile string, plugins ...plugins.Plugin) (*starlark.Thread, error) {
 	globals := starlark.StringDict{}
 	starlark.Universe["time"] = time.Module
 
-	builtins.Github(globals, eng)
+	for _, plugin := range plugins {
+		plugin.RegisterBuiltins(globals)
+	}
 
 	thread := &starlark.Thread{Name: "main"}
 

pkg/cmd/root.go

@@ -3,58 +3,64 @@ package engine
 import (
 	"context"
 	"fmt"
+	"slices"
 
+	"github.com/everettraven/synkr/pkg/plugins"
 	"go.starlark.net/starlark"
 )
 
 type Engine struct {
-	sources []Source
-	printer Printer
+	plugins []plugins.Plugin
 }
 
-type Source interface {
-	Fetch(context.Context, *starlark.Thread) ([]any, error)
-	Name() string
-	Project() string
+func New(plugins ...plugins.Plugin) *Engine {
+	return &Engine{
+		plugins: plugins,
+	}
 }
 
-type Printer interface {
-	Print(...SourceResult) error
-}
+// TODO: Pulling data from sources should be asynchronous to improve performance
+func (e *Engine) Run(ctx context.Context, thread *starlark.Thread) ([]plugins.SourceResult, error) {
+	results := []plugins.SourceResult{}
 
-type SourceResult struct {
-	Source  string `json:"source"`
-	Project string `json:"project"`
-	Items   []any  `json:"items"`
-}
+	for _, plugin := range e.plugins {
+		for _, source := range plugin.Sources() {
+			result, err := source.Fetch(ctx, thread)
+			if err != nil {
+				return nil, fmt.Errorf("fetching data for source %q: %w", source.Name(), err)
+			}
 
-func (e *Engine) Run(ctx context.Context, thread *starlark.Thread) error {
-	outputs := []SourceResult{}
-	for _, source := range e.sources {
-		items, err := source.Fetch(ctx, thread)
-		if err != nil {
-			return err
-		}
+			if result == nil {
+				continue
+			}
+
+			if ind := slices.IndexFunc(results, func(e plugins.SourceResult) bool {
+				return e.Source == result.Source && e.Project == result.Project
+			}); ind != -1 {
+				results[ind].Items = appendUniqueResults(results[ind].Items, result.Items...)
+				continue
+			}
 
-		outputs = append(outputs, SourceResult{
-			Source:  source.Name(),
-			Project: source.Project(),
-			Items:   items,
-		})
-	}
 
-	err := e.printer.Print(outputs...)
-	if err != nil {
-		return fmt.Errorf("printing source results: %w", err)
+			results = append(results, *result)
+		}
 	}
 
-	return nil
+	return results, nil
 }
 
-func (e *Engine) AddSource(source Source) {
-	e.sources = append(e.sources, source)
-}
+func appendUniqueResults(base []plugins.SourceEntry, toAppends ...plugins.SourceEntry) []plugins.SourceEntry {
+	out := append([]plugins.SourceEntry{}, base...)
+
+	for _, toAppend := range toAppends {
+		if slices.ContainsFunc(out, func(e plugins.SourceEntry) bool {
+			return e.Identifier() == toAppend.Identifier()
+		}) {
+			continue
+		}
+
+		out = append(out, toAppend)
+	}
 
-func (e *Engine) SetPrinter(printer Printer) {
-	e.printer = printer
+	return out
 }

pkg/engine/engine.go

@@ -0,0 +1,76 @@
+package github
+
+import (
+	"github.com/everettraven/synkr/pkg/builtins"
+	"github.com/google/go-github/v71/github"
+	"go.starlark.net/starlark"
+)
+
+func GithubBuiltinFunc(sourcer *Sourcer) builtins.BuiltinFunc {
+	return func(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
+		var filters *starlark.List
+		var priorities *starlark.List
+		var status starlark.Callable
+		var org starlark.String
+		var repo starlark.String
+
+		// GitHub issue list filters
+		var milestone starlark.String
+		var state starlark.String
+		var assignee starlark.String
+		var creator starlark.String
+		var mentioned starlark.String
+		var labels *starlark.List
+		var sort starlark.String
+		var direction starlark.String
+
+		err := starlark.UnpackArgs("github", args, kwargs,
+			"org", &org,
+			"repo", &repo,
+			"milestone?", &milestone,
+			"state?", &state,
+			"assignee?", &assignee,
+			"creator?", &creator,
+			"mentioned?", &mentioned,
+			"labels?", &labels,
+			"sort?", &sort,
+			"direction?", &direction,
+			"filters?", &filters,
+			"priorities?", &priorities,
+			"status?", &status,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		filterCallables := []starlark.Callable{}
+		if filters != nil {
+			filterCallables = builtins.TypeFromStarlarkList[starlark.Callable](filters)
+		}
+
+		priorityCallables := []starlark.Callable{}
+		if priorities != nil {
+			priorityCallables = builtins.TypeFromStarlarkList[starlark.Callable](priorities)
+		}
+
+		listOpts := &github.IssueListByRepoOptions{
+			Milestone: milestone.GoString(),
+			State:     state.GoString(),
+			Assignee:  assignee.GoString(),
+			Creator:   creator.GoString(),
+			Mentioned: mentioned.GoString(),
+			Labels:    builtins.TypeFromStarlarkList[string](labels),
+			Sort:      sort.GoString(),
+			Direction: direction.GoString(),
+		}
+
+		ghSource := NewSource(org.GoString(), repo.GoString(), filterCallables, priorityCallables, status, listOpts)
+		sourcer.AddSource(ghSource)
+
+		return starlark.None, nil
+	}
+}
+
+func ptr[T any](in T) *T {
+	return &in
+}

pkg/plugins/github/builtin.go

@@ -0,0 +1,23 @@
+package github
+
+import (
+	"github.com/everettraven/synkr/pkg/plugins"
+	"go.starlark.net/starlark"
+)
+
+func init() {
+	plugins.Register(New())
+}
+
+func New() plugins.Plugin {
+	sourcer := &Sourcer{
+		sources: make([]plugins.Source, 0),
+	}
+	return plugins.Plugin{
+		Sourcer: sourcer,
+		Builtins: map[string]*starlark.Builtin{
+			"github": starlark.NewBuiltin("github", GithubBuiltinFunc(sourcer)),
+		},
+		Name: "github",
+	}
+}