feat: support multiple name convention for component and field names (ignite#1236)

Author: lumtis

changelog.md

@@ -6,6 +6,7 @@
 
 - The `--release` flag for the `build` command adds the ability to release binaries in a tarball with a checksum file.
 - Added the flag `--no-default-module` to the command `starport app` to prevent scaffolding a default module when creating a new app
+- Added support for multiple naming conventions for component names and field names
 
 ## `v0.16.1`
 

integration/cmd_app_test.go

@@ -26,7 +26,7 @@ func TestGenerateAnApp(t *testing.T) {
 
 func TestGenerateAnAppWithNoDefaultModule(t *testing.T) {
 	var (
-		env  = newEnv(t)
+		env     = newEnv(t)
 		appName = "blog"
 	)
 
@@ -56,7 +56,6 @@ func TestGenerateAnAppWithNoDefaultModule(t *testing.T) {
 	env.EnsureAppIsSteady(path)
 }
 
-
 func TestGenerateAnAppWithWasm(t *testing.T) {
 	var (
 		env  = newEnv(t)

integration/cmd_ibc_test.go

@@ -69,7 +69,7 @@ func TestCreateIBCPacket(t *testing.T) {
 
 	env.Must(env.Exec("create a packet",
 		step.NewSteps(step.New(
-			step.Exec("starport", "packet", "bar", "text", "--module", "foo", "--ack", "ack1:string,ack2:int,ack3:bool"),
+			step.Exec("starport", "packet", "bar", "text", "--module", "foo", "--ack", "foo:string,bar:int,foobar:bool"),
 			step.Workdir(path),
 		)),
 	))

integration/cmd_message_test.go

@@ -16,22 +16,22 @@ func TestGenerateAnAppWithMessage(t *testing.T) {
 
 	env.Must(env.Exec("create a message",
 		step.NewSteps(step.New(
-			step.Exec("starport", "message", "foo", "text", "vote:int", "like:bool", "-r", "foo,bar:int,foobar:bool"),
+			step.Exec("starport", "message", "do-foo", "text", "vote:int", "like:bool", "-r", "foo,bar:int,foobar:bool"),
 			step.Workdir(path),
 		)),
 	))
 
 	env.Must(env.Exec("should prevent creating an existing message",
 		step.NewSteps(step.New(
-			step.Exec("starport", "message", "foo", "bar"),
+			step.Exec("starport", "message", "do-foo", "bar"),
 			step.Workdir(path),
 		)),
 		ExecShouldError(),
 	))
 
 	env.Must(env.Exec("create a second message",
 		step.NewSteps(step.New(
-			step.Exec("starport", "message", "bar", "bar"),
+			step.Exec("starport", "message", "do-bar", "bar"),
 			step.Workdir(path),
 		)),
 	))
@@ -45,7 +45,7 @@ func TestGenerateAnAppWithMessage(t *testing.T) {
 
 	env.Must(env.Exec("create a message in a module",
 		step.NewSteps(step.New(
-			step.Exec("starport", "message", "foo", "text", "--module", "foo", "--desc", "foo bar foobar", "--response", "foo,bar:int,foobar:bool"),
+			step.Exec("starport", "message", "do-foo", "text", "--module", "foo", "--desc", "foo bar foobar", "--response", "foo,bar:int,foobar:bool"),
 			step.Workdir(path),
 		)),
 	))

starport/pkg/field/field.go

@@ -0,0 +1,81 @@
+// Package field provides methods to parse a field provided in a command with the format name:type
+package field
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/tendermint/starport/starport/pkg/multiformatname"
+)
+
+const (
+	TypeString = "string"
+	TypeBool   = "bool"
+	TypeInt32  = "int32"
+	TypeUint64 = "uint64"
+)
+
+// Field represents a field inside a structure for a component
+// it can a field contained in a type or inside the response of a query, etc...
+type Field struct {
+	Name         multiformatname.Name
+	Datatype     string
+	DatatypeName string
+}
+
+// parseFields parses the provided fields, analyses the types and checks there is no duplicated field
+func ParseFields(fields []string, isForbiddenField func(string) error) ([]Field, error) {
+	// Used to check duplicated field
+	existingFields := make(map[string]bool)
+
+	var parsedFields []Field
+	for _, field := range fields {
+		fieldSplit := strings.Split(field, ":")
+		if len(fieldSplit) > 2 {
+			return parsedFields, fmt.Errorf("invalid field format: %s, should be 'name' or 'name:type'", field)
+		}
+
+		name, err := multiformatname.NewName(fieldSplit[0])
+		if err != nil {
+			return parsedFields, err
+		}
+
+		// Ensure the field name is not a Go reserved name, it would generate an incorrect code
+		if err := isForbiddenField(name.LowerCamel); err != nil {
+			return parsedFields, fmt.Errorf("%s can't be used as a field name: %s", name, err.Error())
+		}
+
+		// Ensure the field is not duplicated
+		if _, exists := existingFields[name.LowerCamel]; exists {
+			return parsedFields, fmt.Errorf("the field %s is duplicated", name.Original)
+		}
+		existingFields[name.LowerCamel] = true
+
+		// Parse the type if it is provided, otherwise string is used by defaut
+		datatypeName, datatype := TypeString, TypeString
+		isTypeSpecified := len(fieldSplit) == 2
+		if isTypeSpecified {
+			acceptedTypes := map[string]string{
+				"string": TypeString,
+				"bool":   TypeBool,
+				"int":    TypeInt32,
+				"uint":   TypeUint64,
+			}
+
+			if t, ok := acceptedTypes[fieldSplit[1]]; ok {
+				datatype = t
+				datatypeName = fieldSplit[1]
+			} else {
+				return parsedFields, fmt.Errorf("the field type %s doesn't exist", fieldSplit[1])
+			}
+		}
+
+		parsedFields = append(parsedFields, Field{
+			Name:         name,
+			Datatype:     datatype,
+			DatatypeName: datatypeName,
+		})
+	}
+
+	return parsedFields, nil
+}

starport/pkg/field/field_test.go

@@ -0,0 +1,96 @@
+package field_test
+
+import (
+	"errors"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/starport/starport/pkg/field"
+	"github.com/tendermint/starport/starport/pkg/multiformatname"
+	"testing"
+)
+
+var (
+	noCheck       = func(string) error { return nil }
+	alwaysInvalid = func(string) error { return errors.New("invalid name") }
+)
+
+type testCases struct {
+	provided []string
+	expected []field.Field
+}
+
+func TestParseFields(t *testing.T) {
+	names := []string{
+		"foo",
+		"bar",
+		"fooBar",
+		"bar-foo",
+		"foo_foo",
+	}
+	cases := testCases{
+		provided: []string{
+			names[0],
+			names[1] + ":string",
+			names[2] + ":bool",
+			names[3] + ":int",
+			names[4] + ":uint",
+		},
+		expected: []field.Field{
+			{
+				Datatype:     "string",
+				DatatypeName: "string",
+			},
+			{
+				Datatype:     "string",
+				DatatypeName: "string",
+			},
+			{
+				Datatype:     "bool",
+				DatatypeName: "bool",
+			},
+			{
+				Datatype:     "int32",
+				DatatypeName: "int",
+			},
+			{
+				Datatype:     "uint64",
+				DatatypeName: "uint",
+			},
+		},
+	}
+	for i, name := range names {
+		cases.expected[i].Name, _ = multiformatname.NewName(name)
+	}
+
+	actual, err := field.ParseFields(cases.provided, noCheck)
+	require.NoError(t, err)
+	require.Equal(t, cases.expected, actual)
+
+	// No field provided
+	actual, err = field.ParseFields([]string{}, noCheck)
+	require.NoError(t, err)
+	require.Empty(t, actual)
+}
+
+func TestParseFields2(t *testing.T) {
+	// test failing cases
+
+	// check doesn't pass
+	_, err := field.ParseFields([]string{"foo"}, alwaysInvalid)
+	require.Error(t, err)
+
+	// duplicated field
+	_, err = field.ParseFields([]string{"foo", "foo:int"}, noCheck)
+	require.Error(t, err)
+
+	// invalid type
+	_, err = field.ParseFields([]string{"foo:invalid"}, alwaysInvalid)
+	require.Error(t, err)
+
+	// invalid field name
+	_, err = field.ParseFields([]string{"foo@bar:int"}, alwaysInvalid)
+	require.Error(t, err)
+
+	// invalid format
+	_, err = field.ParseFields([]string{"foo:int:int"}, alwaysInvalid)
+	require.Error(t, err)
+}

starport/pkg/multiformatname/multiformatname.go

@@ -0,0 +1,56 @@
+// Package multiformatname provides names automatically converted into multiple naming convention
+package multiformatname
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/iancoleman/strcase"
+)
+
+// MultiFormatName represents a name with multiple naming convention representations
+// Supported naming convention are: camel, pascal, and kebab cases
+type Name struct {
+	Original   string
+	LowerCamel string
+	UpperCamel string
+	Kebab      string
+}
+
+// NewMultiFormatName returns a new multi-format name from a name
+func NewName(name string) (Name, error) {
+	if err := CheckName(name); err != nil {
+		return Name{}, err
+	}
+
+	return Name{
+		Original:   name,
+		LowerCamel: strcase.ToLowerCamel(name),
+		UpperCamel: strcase.ToCamel(name),
+		Kebab:      strcase.ToKebab(name),
+	}, nil
+}
+
+// CheckName checks name validity
+func CheckName(name string) error {
+	if name == "" {
+		return errors.New("name cannot be empty")
+	}
+
+	// check  characters
+	c := name[0]
+	authorized := ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
+	if !authorized {
+		return fmt.Errorf("name cannot contain %v as first character", string(c))
+	}
+
+	for _, c := range name[1:] {
+		// A name can contains letter, hyphen or underscore
+		authorized := ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '-' || c == '_'
+		if !authorized {
+			return fmt.Errorf("name cannot contain %v", string(c))
+		}
+	}
+
+	return nil
+}

starport/pkg/multiformatname/multiformatname_test.go

@@ -0,0 +1,70 @@
+package multiformatname_test
+
+import (
+	"fmt"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/starport/starport/pkg/multiformatname"
+	"testing"
+)
+
+func TestNewMultiFormatName(t *testing.T) {
+	// [valueToTest, lowerCamel, upperCamel, kebabCase]
+	cases := [][4]string{
+		{"foo", "foo", "Foo", "foo"},
+		{"fooBar", "fooBar", "FooBar", "foo-bar"},
+		{"foo-bar", "fooBar", "FooBar", "foo-bar"},
+		{"foo_bar", "fooBar", "FooBar", "foo-bar"},
+		{"foo_barFoobar", "fooBarFoobar", "FooBarFoobar", "foo-bar-foobar"},
+		{"foo_-_bar", "fooBar", "FooBar", "foo---bar"},
+		{"foo_-_Bar", "fooBar", "FooBar", "foo---bar"},
+		{"fooBAR", "fooBAR", "FooBAR", "foo-bar"},
+		{"fooBar123", "fooBar123", "FooBar123", "foo-bar-123"},
+	}
+
+	// test cases
+	for _, testCase := range cases {
+		name, err := multiformatname.NewName(testCase[0])
+		require.NoError(t, err)
+		require.Equal(
+			t,
+			testCase[0],
+			name.Original,
+		)
+		require.Equal(
+			t,
+			testCase[1],
+			name.LowerCamel,
+			fmt.Sprintf("%s should be converted to the correct lower camel format", testCase[0]),
+		)
+		require.Equal(
+			t,
+			testCase[2],
+			name.UpperCamel,
+			fmt.Sprintf("%s should be converted the correct upper camel format", testCase[0]),
+		)
+		require.Equal(
+			t,
+			testCase[3],
+			name.Kebab,
+			fmt.Sprintf("%s should be converted the correct kebab format", testCase[0]),
+		)
+	}
+}
+
+func TestNewMultiFormatName2(t *testing.T) {
+	// Test forbidden names
+	cases := []string{
+		"",
+		"foo bar",
+		"1foo",
+		"-foo",
+		"_foo",
+		"@foo",
+	}
+
+	// test cases
+	for _, testCase := range cases {
+		_, err := multiformatname.NewName(testCase)
+		require.Error(t, err)
+	}
+}