new data layout, plus params in config (#25)

Author: natefinch

CONTRIBUTING.md

@@ -7,6 +7,8 @@ Of course, contributions are more than welcome. Please read these guidelines for
 Development discussion should take place on the #gnorm channel of [gopher
 slack](https://gophers.slack.com/).
 
+There is a separate #gnorm-dev channel that has the github app to post github activity to the channel, to make it easy to follow.
+
 ## Tasks
 
 See the [Nearterm Todos](https://github.com/gnormal/gnorm/projects/1) github

cli/config.go

@@ -97,4 +97,10 @@ type Config struct {
 	// TypeMap and NullableTypeMap must be at the end of your configuration
 	// file.
 	NullableTypeMap map[string]string
+
+	// Params contains any data you may want to pass to your templates.  This is
+	// a good way to make templates reusable with different configuration values
+	// for different situations.  The values in this field will be available in
+	// the .Params value for all templates.
+	Params map[string]interface{}
 }

cli/config_test.go

@@ -0,0 +1,19 @@
+package cli
+
+import (
+	"testing"
+
+	"github.com/BurntSushi/toml"
+)
+
+func TestExampleToml(t *testing.T) {
+	c := Config{}
+	m, err := toml.DecodeFile("gnorm.toml", &c)
+	if err != nil {
+		t.Fatal("error parsing config file", err)
+	}
+	undec := m.Undecoded()
+	if len(undec) > 0 {
+		t.Fatal("Warning: unknown values present in config file:", undec)
+	}
+}

cli/gnorm.toml

@@ -1,23 +1,22 @@
 # ConnStr is the connection string for the database.
-# Postgres example:
-# ConnStr = "dbname=mydb host=127.0.0.1 sslmode=disable user=admin"
 # MySQL example:
 # ConnStr = "root:admin@tcp/"
-ConnStr = ""
+# Postgres example:
+ConnStr = "dbname=mydb host=127.0.0.1 sslmode=disable user=admin"
 
 # DBType holds the type of db you're connecting to.  Possible values are
 # "postgres" or "mysql". 
-DBType = ""
+DBType = "postgres"
 
 # Schemas holds the names of schemas to generate code for.
-Schemas = []
+Schemas = ["public"]
 
 # NameConversion defines how the DBName of tables, schemas, and enums are
 # converted into their Name value.  This is a template that may use all the
 # regular functions.  The "." value is the DB name of the item. Thus, to make an
 # item's Name the same as its DBName, you'd use a template of "{{.}}". To make
 # the Name the PascalCase version, you'd use "{{pascal .}}".
-NameConversion = ""
+NameConversion = "{{.}}"
 
 # IncludeTables is a whitelist of tables to generate data for. Tables not
 # in this list will not be included in data geenrated by gnorm. You cannot
@@ -118,4 +117,12 @@ PostRun = []
 # "character varying" = "sql.NullString"
 # "integer" = "sql.NullInt64"
 # "numeric" = "sql.NullFloat64"
-[NullableTypeMap]
+[NullableTypeMap]
+
+
+# Params contains any data you may want to pass to your templates.  This is a
+# good way to make templates reusable with different configuration values for
+# different situations.  The values in this field will be available in the
+# .Params value for all templates.
+[Params]
+# mySpecalValue = "some value"

cli/parse.go

@@ -16,6 +16,7 @@ import (
 	"gnorm.org/gnorm/database/drivers/postgres"
 	"gnorm.org/gnorm/environ"
 	"gnorm.org/gnorm/run"
+	"gnorm.org/gnorm/run/data"
 )
 
 func parseFile(env environ.Values, file string) (*run.Config, error) {
@@ -61,13 +62,14 @@ func parse(env environ.Values, r io.Reader) (*run.Config, error) {
 	}
 
 	cfg := &run.Config{
-		ConnStr:         c.ConnStr,
-		Schemas:         c.Schemas,
-		NullableTypeMap: c.NullableTypeMap,
-		TypeMap:         c.TypeMap,
-		PostRun:         c.PostRun,
-		ExcludeTables:   exclude,
-		IncludeTables:   include,
+		ConfigData: data.ConfigData{
+			Schemas:         c.Schemas,
+			NullableTypeMap: c.NullableTypeMap,
+			TypeMap:         c.TypeMap,
+			PostRun:         c.PostRun,
+			ExcludeTables:   exclude,
+			IncludeTables:   include,
+		},
 	}
 	d, err := getDriver(strings.ToLower(c.DBType))
 	if err != nil {

cli/parse_test.go

@@ -1,6 +1,10 @@
 package cli
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/BurntSushi/toml"
+)
 
 func TestParseTables(t *testing.T) {
 	tables := []string{"table", "schema.table2"}
@@ -35,6 +39,18 @@ func TestParseTables(t *testing.T) {
 	}
 }
 
+func TestParseGnormTolm(t *testing.T) {
+	c := Config{}
+	m, err := toml.DecodeFile("gnorm.toml", &c)
+	if err != nil {
+		t.Fatal(err)
+	}
+	undec := m.Undecoded()
+	if len(undec) > 0 {
+		t.Fatalf("unknown values present in config file: %s", undec)
+	}
+}
+
 func contains(list []string, s string) bool {
 	for x := range list {
 		if list[x] == s {

cli/sample.go

@@ -25,25 +25,24 @@ package cli
 // }
 // gocog]]]
 const sample = `# ConnStr is the connection string for the database.
-# Postgres example:
-# ConnStr = "dbname=mydb host=127.0.0.1 sslmode=disable user=admin"
 # MySQL example:
 # ConnStr = "root:admin@tcp/"
-ConnStr = ""
+# Postgres example:
+ConnStr = "dbname=mydb host=127.0.0.1 sslmode=disable user=admin"
 
 # DBType holds the type of db you're connecting to.  Possible values are
 # "postgres" or "mysql". 
-DBType = ""
+DBType = "postgres"
 
 # Schemas holds the names of schemas to generate code for.
-Schemas = []
+Schemas = ["public"]
 
 # NameConversion defines how the DBName of tables, schemas, and enums are
 # converted into their Name value.  This is a template that may use all the
 # regular functions.  The "." value is the DB name of the item. Thus, to make an
 # item's Name the same as its DBName, you'd use a template of "{{.}}". To make
 # the Name the PascalCase version, you'd use "{{pascal .}}".
-NameConversion = ""
+NameConversion = "{{.}}"
 
 # IncludeTables is a whitelist of tables to generate data for. Tables not
 # in this list will not be included in data geenrated by gnorm. You cannot
@@ -144,5 +143,13 @@ PostRun = []
 # "character varying" = "sql.NullString"
 # "integer" = "sql.NullInt64"
 # "numeric" = "sql.NullFloat64"
-[NullableTypeMap]`
+[NullableTypeMap]
+
+
+# Params contains any data you may want to pass to your templates.  This is a
+# good way to make templates reusable with different configuration values for
+# different situations.  The values in this field will be available in the
+# .Params value for all templates.
+[Params]
+# mySpecalValue = "some value"`
 // [[[end]]]

database/drivers/mysql/parse.go

@@ -36,9 +36,9 @@ func parse(log *log.Logger, conn string, schemaNames []string, filterTables func
 		return nil, err
 	}
 
-	schemas := make(map[string]map[string]database.Columns, len(schemaNames))
+	schemas := make(map[string]map[string][]*database.Column, len(schemaNames))
 	for _, name := range schemaNames {
-		schemas[name] = map[string]database.Columns{}
+		schemas[name] = map[string][]*database.Column{}
 	}
 
 	for _, t := range tables {
@@ -80,21 +80,20 @@ func parse(log *log.Logger, conn string, schemaNames []string, filterTables func
 		}
 		schema[c.TableName] = append(schema[c.TableName], col)
 		if enum != nil {
-			enum.DBTable = c.TableName
-			enum.DBSchema = c.TableSchema
-			enums[enum.DBSchema] = append(enums[enum.DBSchema], enum)
+			enum.Table = c.TableName
+			enums[c.TableSchema] = append(enums[c.TableSchema], enum)
 		}
 	}
 
 	res := &database.Info{Schemas: make([]*database.Schema, 0, len(schemas))}
 	for _, schema := range schemaNames {
 		tables := schemas[schema]
 		s := &database.Schema{
-			DBName: schema,
-			Enums:  enums[schema],
+			Name:  schema,
+			Enums: enums[schema],
 		}
 		for tname, columns := range tables {
-			s.Tables = append(s.Tables, &database.Table{DBName: tname, DBSchema: schema, Columns: columns})
+			s.Tables = append(s.Tables, &database.Table{Name: tname, Columns: columns})
 		}
 		res.Schemas = append(res.Schemas, s)
 	}
@@ -104,10 +103,10 @@ func parse(log *log.Logger, conn string, schemaNames []string, filterTables func
 
 func toDBColumn(c *columns.Row, log *log.Logger) (*database.Column, *database.Enum, error) {
 	col := &database.Column{
-		DBName:     c.ColumnName,
+		Name:       c.ColumnName,
 		Nullable:   c.IsNullable == "YES",
 		HasDefault: c.ColumnDefault.String != "",
-		DBType:     c.DataType,
+		Type:       c.DataType,
 		Orig:       *c,
 	}
 
@@ -132,7 +131,7 @@ func toDBColumn(c *columns.Row, log *log.Logger) (*database.Column, *database.En
 	// we'll call the enum the same as the column name.
 	// the function above will set the table name etc
 	enum := &database.Enum{
-		DBName: col.DBName,
+		Name: col.Name,
 	}
 	// strip off the enum and parens
 	s := c.ColumnType[5 : len(c.ColumnType)-1]
@@ -141,7 +140,7 @@ func toDBColumn(c *columns.Row, log *log.Logger) (*database.Column, *database.En
 	for x := range vals {
 		enum.Values[x] = &database.EnumValue{
 			// strip off the quotes
-			DBName: vals[x][1 : len(vals[x])-1],
+			Name: vals[x][1 : len(vals[x])-1],
 			// enum values start at 1 in mysql
 			Value: x + 1,
 		}

database/drivers/mysql/templates/schema.gotmpl

@@ -75,6 +75,4 @@ func (f {{$fieldName}}Field) In(vals []{{.}}) WhereClause {
 }
 
 
-
-
-{{end}}
+{{end}}

database/drivers/mysql/templates/table.gotmpl

@@ -1,5 +1,5 @@
 // Code generated by gnorm, DO NOT EDIT!
-
+{{with .Table}}
 package {{toLower .Name}}
 
 import "gnorm.org/gnorm/database/drivers/mysql/gnorm"
@@ -52,3 +52,4 @@ func Query(db gnorm.DB, where gnorm.WhereClause) ([]*Row, error) {
 	return vals, nil
 }
 
+{{end}}