feat: refactor to apply dry

cmd/codegen/main.go

@@ -24,6 +24,19 @@ func parseFlags() Config {
 	return cfg
 }
 
+func runCommand(ctx context.Context, cmdType codegen.CommandType, cfg string) {
+	cmd, err := codegen.NewCommand(ctx, cmdType, cfg)
+	if err != nil {
+		log.Fatalf("Failed to create command: %s", err)
+	}
+	if err := cmd.Setup(); err != nil {
+		log.Fatalf("Setup failed: %s", err)
+	}
+	if err := cmd.Execute(); err != nil {
+		log.Fatalf("Execution failed: %s", err)
+	}
+}
+
 func main() {
 	cfg := parseFlags()
 
@@ -48,39 +61,12 @@ func main() {
 	}
 
 	if cfg.OpType == "mktp" || cfg.OpType == "mksdk" {
-		cmd, err := codegen.NewCommand(ctx, cmdType, cfg.ConfigFile)
-		if err != nil {
-			log.Fatalf("Failed to create command: %s", err)
-		}
-		if err := cmd.Setup(); err != nil {
-			log.Fatalf("Setup failed: %s", err)
-		}
-		if err := cmd.Execute(); err != nil {
-			log.Fatalf("Execution failed: %s", err)
-		}
+		runCommand(ctx, cmdType, cfg.ConfigFile)
 	} else { // Default behavior to execute both if no specific OpType is provided
 		// Execute SDK
-		cmdSDK, err := codegen.NewCommand(ctx, codegen.CommandTypeSDK, cfg.ConfigFile)
-		if err != nil {
-			log.Fatalf("Failed to create command: %s", err)
-		}
-		if err := cmdSDK.Setup(); err != nil {
-			log.Fatalf("Setup SDK failed: %s", err)
-		}
-		if err := cmdSDK.Execute(); err != nil {
-			log.Fatalf("Execution SDK failed: %s", err)
-		}
+		runCommand(ctx, codegen.CommandTypeSDK, cfg.ConfigFile)
 
 		// Execute Terraform
-		cmdTP, err := codegen.NewCommand(ctx, codegen.CommandTypeTerraform, cfg.ConfigFile)
-		if err != nil {
-			log.Fatalf("Failed to create command: %s", err)
-		}
-		if err := cmdTP.Setup(); err != nil {
-			log.Fatalf("Setup Terraform failed: %s", err)
-		}
-		if err := cmdTP.Execute(); err != nil {
-			log.Fatalf("Execution Terraform failed: %s", err)
-		}
+		runCommand(ctx, codegen.CommandTypeTerraform, cfg.ConfigFile)
 	}
 }

pkg/naming/names.go

@@ -69,50 +69,62 @@ func (o *Namer) NewSlug(name string) string {
 	return ans
 }
 
-// CamelCase returns a camel case version of the given string.
+// CamelCase converts a string to CamelCase format, allowing for optional prefixes/suffixes,
+// and control over the capitalization of the first character. It also skips over templated
+// sections within the string, preserving their original form.
 func CamelCase(prefix, value, suffix string, capitalizeFirstRune bool) string {
-	var b strings.Builder
-	b.Grow(len(prefix) + len(value) + len(suffix))
+	var builder strings.Builder
+	builder.Grow(len(prefix) + len(value) + len(suffix))
 
-	b.WriteString(prefix)
+	builder.WriteString(prefix)
 
-	first := true
-	didFirstRune := false
-	ignoreVar := false
-	for _, r := range value {
-		if ignoreVar {
-			if r == '}' {
-				ignoreVar = false
-			}
+	isFirstCharacter := true
+	hasFirstRuneBeenCapitalized := false
+	isIgnoringTemplate := false
+
+	for _, runeValue := range value {
+		switch runeValue {
+		case '{':
+			isIgnoringTemplate = true
+			isFirstCharacter = true // Reset for the content after template
 			continue
-		} else if r == '{' {
-			ignoreVar = true
-			first = true
+		case '}':
+			isIgnoringTemplate = false
+			continue
+		}
+
+		if isIgnoringTemplate {
 			continue
 		}
 
-		if r == '_' || r == '-' || r == '|' || r == '/' || r == ':' || r == ' ' {
-			first = true
-		} else if first {
-			if didFirstRune {
-				b.WriteRune(unicode.ToTitle(r))
-			} else {
-				if capitalizeFirstRune {
-					b.WriteRune(unicode.ToTitle(r))
-				} else {
-					b.WriteRune(unicode.ToLower(r))
-				}
-				didFirstRune = true
-			}
-			first = false
+		if shouldResetFirstCharacterFlag(runeValue) {
+			isFirstCharacter = true
+		} else if isFirstCharacter {
+			capitalizeAndWriteRune(&builder, runeValue, hasFirstRuneBeenCapitalized || capitalizeFirstRune)
+			hasFirstRuneBeenCapitalized = true
+			isFirstCharacter = false
 		} else {
-			b.WriteRune(r)
+			builder.WriteRune(runeValue)
 		}
 	}
 
-	b.WriteString(suffix)
+	builder.WriteString(suffix)
+	return builder.String()
+}
 
-	return b.String()
+// shouldResetFirstCharacterFlag checks if the given rune is a separator that should trigger
+// the next character to be capitalized in CamelCase conversion.
+func shouldResetFirstCharacterFlag(r rune) bool {
+	return r == '_' || r == '-' || r == '|' || r == '/' || r == ':' || r == ' '
+}
+
+// capitalizeAndWriteRune writes the rune to the builder, capitalizing it if needed.
+func capitalizeAndWriteRune(builder *strings.Builder, r rune, capitalize bool) {
+	if capitalize {
+		builder.WriteRune(unicode.ToTitle(r))
+	} else {
+		builder.WriteRune(unicode.ToLower(r))
+	}
 }
 
 // AlphaNumeric returns an alphanumeric version of the given string.

pkg/properties/normalized.go

@@ -203,26 +203,27 @@ func (spec *Normalization) AddNameVariantsForParams() error {
 	return nil
 }
 
+// AddDefaultTypesForParams ensures all SpecParams within Spec have a default type if not specified.
 func (spec *Normalization) AddDefaultTypesForParams() error {
-	if spec.Spec != nil {
-		if spec.Spec.Params != nil {
-			for _, param := range spec.Spec.Params {
-				if param.Type == "" {
-					param.Type = "string"
-				}
-			}
-		}
-		if spec.Spec.OneOf != nil {
-			for _, param := range spec.Spec.OneOf {
-				if param.Type == "" {
-					param.Type = "string"
-				}
-			}
-		}
+	if spec.Spec == nil {
+		return nil
 	}
+
+	setDefaultParamTypeForMap(spec.Spec.Params)
+	setDefaultParamTypeForMap(spec.Spec.OneOf)
+
 	return nil
 }
 
+// setDefaultParamTypeForMap iterates over a map of SpecParam pointers, setting their Type to "string" if not specified.
+func setDefaultParamTypeForMap(params map[string]*SpecParam) {
+	for _, param := range params {
+		if param.Type == "" {
+			param.Type = "string"
+		}
+	}
+}
+
 func (spec *Normalization) Sanity() error {
 	if spec.Name == "" {
 		return errors.New("name is required")