code-style

Files (1)

• SKILL.md

SKILL.md (first lines)

# Code Style for openstack-k8s-operators Operators

This skill applies and enforces Go code style best practices for openstack-k8s-operators operators, following openstack-k8s-operators conventions and gopls modernize recommendations.

## Code Style Guidelines

### 1. **Modern Go Syntax**

Based on gopls modernize and lib-common patterns:

#### Slice Declaration

```go
// Bad: Old style
var items []string = []string{}

// Good: Modern style
var items []string
```

#### Map Declaration

```go
// Bad: Old style
var configs map[string]interface{} = make(map[string]interface{})

// Good: Modern style
var configs = make(map[string]interface{})
```

#### String Building

```go
// Bad: Inefficient concatenation
result := ""
for _, item := range items {
    result += item + "\n"
}

// Good: Use strings.Builder
var builder strings.Builder
for _, item := range items {
    builder.WriteString(item)
    builder.WriteString("\n")
}
result := builder.String()
```

### 2. **Controller-Runtime Patterns**

#### Error Handling

```go
// Good: Proper error wrapping
if err := r.Get(ctx, req.NamespacedName, &instance); err != nil {
    if errors.IsNotFound(err) {
        return ctrl.Result{}, nil
    }
    return ctrl.Result{}, fmt.Errorf("failed to get instance: %w", err)
}
```

#### Logging

```go
// Good: Structured logging with context
log := ctrl.LoggerFrom(ctx).WithValues("instance", instance.Name)
log.Info("Starting reconciliation")
```

#### Status Updates

```go
// Good: Proper status condition handling
meta.SetStatusCondition(&instance.Status.Conditions, metav1.Condition{
    Type:    "Ready",
    Status:  metav1.ConditionTrue,
    Reason:  "ReconciliationSuccessful",
    Message: "Instance successfully reconciled",
})
```

### 3. **Error Handling**

```go
// Bad: capitalized error string
return fmt.Errorf("Failed to create configmap")

// Good: lowercase, no punctuation, wrapped with context
return fmt.Errorf("failed to create configmap: %w", err)
```

```go
// Bad: unnecessary else after error return
if err != nil {
    return err
} else {
    doSomething()
}

// Good: normal flow at minimal indentation
if err != nil {
    return err
}
doSomething()
```

```go
// Bad: discarding errors
result, _ := someFunction()

// Good: always handle errors
result, err := someFunction()
if err != nil {
    return fmt.Errorf("failed to do something: %w", err)
}
```

### 4. **Naming Conventions**

From openstack-k8s-operators/devskills, MIT.

More from openstack-k8s-operators/devskills