From 6dac631a9339cbffe1e238248a66d12f38bdebda Mon Sep 17 00:00:00 2001
From: Aaron L <aaron@bettercoder.net>
Date: Sun, 26 Jun 2016 23:54:23 -0700
Subject: [PATCH] Add new functions to support more templating

- Add joinSlices
- Add ways to pull apart a slice of SQLColumnDef
- Try to stop generating join tables (but it still gens for some reason)
---
 bdb/keys.go                 | 28 ++++++++++++++++++++++++++--
 output.go                   | 10 ++++++++++
 strmangle/strmangle.go      | 17 +++++++++++++++++
 strmangle/strmangle_test.go | 29 +++++++++++++++++++++++++++++
 templates.go                |  1 +
 5 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/bdb/keys.go b/bdb/keys.go
index fce3d68..8729f70 100644
--- a/bdb/keys.go
+++ b/bdb/keys.go
@@ -34,9 +34,33 @@ func (s SQLColumnDef) String() string {
 	return fmt.Sprintf("%s %s", s.Name, s.Type)
 }
 
+// SQLColumnDefs has small helper functions
+type SQLColumnDefs []SQLColumnDef
+
+// Names returns all the names
+func (s SQLColumnDefs) Names() []string {
+	names := make([]string, len(s))
+
+	for i, sqlDef := range s {
+		names[i] = sqlDef.Name
+	}
+
+	return names
+}
+
+// Types returns all the types
+func (s SQLColumnDefs) Types() []string {
+	types := make([]string, len(s))
+
+	for i, sqlDef := range s {
+		types[i] = sqlDef.Type
+	}
+
+	return types
+}
+
 // SQLColDefinitions creates a definition in sql format for a column
-// example: id int64, thingName string
-func SQLColDefinitions(cols []Column, names []string) []SQLColumnDef {
+func SQLColDefinitions(cols []Column, names []string) SQLColumnDefs {
 	ret := make([]SQLColumnDef, len(names))
 
 	for i, n := range names {
diff --git a/output.go b/output.go
index 7e56a45..307d6c9 100644
--- a/output.go
+++ b/output.go
@@ -84,6 +84,11 @@ type executeTemplateData struct {
 }
 
 func executeTemplates(e executeTemplateData) error {
+	if e.data.Table.IsJoinTable {
+		return nil
+	}
+	fmt.Println(e.data.Table.Name, e.data.Table.IsJoinTable)
+
 	var out [][]byte
 	var imps imports
 
@@ -112,6 +117,11 @@ func executeTemplates(e executeTemplateData) error {
 }
 
 func executeSingletonTemplates(e executeTemplateData) error {
+	if e.data.Table.IsJoinTable {
+		return nil
+	}
+	fmt.Println(e.data.Table.Name, e.data.Table.IsJoinTable)
+
 	rgxRemove := regexp.MustCompile(`[0-9]+_`)
 
 	for _, template := range e.templates {
diff --git a/strmangle/strmangle.go b/strmangle/strmangle.go
index 06b263a..886b4a6 100644
--- a/strmangle/strmangle.go
+++ b/strmangle/strmangle.go
@@ -150,3 +150,20 @@ func DriverUsesLastInsertID(driverName string) bool {
 func Substring(start, end int, str string) string {
 	return str[start:end]
 }
+
+// JoinSlices merges two string slices of equal length
+func JoinSlices(sep string, a, b []string) []string {
+	lna, lnb := len(a), len(b)
+	if lna != lnb {
+		panic("joinSlices: can only merge slices of same length")
+	} else if lna == 0 {
+		return nil
+	}
+
+	ret := make([]string, len(a))
+	for i, elem := range a {
+		ret[i] = fmt.Sprintf("%s%s%s", elem, sep, b[i])
+	}
+
+	return ret
+}
diff --git a/strmangle/strmangle_test.go b/strmangle/strmangle_test.go
index 3e712cf..ce4001e 100644
--- a/strmangle/strmangle_test.go
+++ b/strmangle/strmangle_test.go
@@ -191,3 +191,32 @@ func TestSubstring(t *testing.T) {
 		t.Errorf("substring was wrong: %q", got)
 	}
 }
+
+func TestJoinSlices(t *testing.T) {
+	t.Parallel()
+
+	ret := JoinSlices("", nil, nil)
+	if ret != nil {
+		t.Error("want nil, got:", ret)
+	}
+
+	ret = JoinSlices(" ", []string{"one", "two"}, []string{"three", "four"})
+	if got := ret[0]; got != "one three" {
+		t.Error("ret element was wrong:", got)
+	}
+	if got := ret[1]; got != "two four" {
+		t.Error("ret element was wrong:", got)
+	}
+}
+
+func TestJoinSlicesFail(t *testing.T) {
+	t.Parallel()
+
+	defer func() {
+		if recover() == nil {
+			t.Error("did not panic")
+		}
+	}()
+
+	JoinSlices("", nil, []string{"hello"})
+}
diff --git a/templates.go b/templates.go
index 3c8fb91..9d7eaba 100644
--- a/templates.go
+++ b/templates.go
@@ -123,6 +123,7 @@ var templateFunctions = template.FuncMap{
 
 	// String Slice ops
 	"join":              func(sep string, slice []string) string { return strings.Join(slice, sep) },
+	"joinSlices":        strmangle.JoinSlices,
 	"stringMap":         strmangle.StringMap,
 	"hasElement":        strmangle.HasElement,
 	"prefixStringSlice": strmangle.PrefixStringSlice,