feat: add alphabetical option (#26)

Author: manuelarte

.github/workflows/pr-checks.yml

@@ -40,7 +40,7 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v7
         with:
-          version: v2.1.0
+          version: v2.1.1
 
   spell:
     name: "Spell check"

README.md

@@ -1,19 +1,47 @@
+# 🧐 FuncOrder
+
 [![Go Report Card](https://goreportcard.com/badge/github.com/manuelarte/funcorder)](https://goreportcard.com/report/github.com/manuelarte/funcorder)
 ![version](https://img.shields.io/github/v/release/manuelarte/funcorder)
 
 - [🧐 FuncOrder](#-funcorder)
-  - [⬇️ Getting Started](#-getting-started)
+  - [⬇️ Getting Started](#️-getting-started)
+    - [As A Golangci-lint linter](#as-a-golangci-lint-linter)
+    - [Standalone application](#standalone-application)
   - [🚀 Features](#-features)
     - [Check exported methods are placed before non-exported methods](#check-exported-methods-are-placed-before-non-exported-methods)
     - [Check `Constructors` functions are placed after struct declaration](#check-constructors-functions-are-placed-after-struct-declaration)
+    - [Check Constructors/Methods are sorted alphabetically](#check-constructorsmethods-are-sorted-alphabetically)
   - [Resources](#resources)
 
-# 🧐 FuncOrder
-
 Go Linter to check Functions/Methods Order.
 
 ## ⬇️ Getting Started
 
+### As a golangci-lint linter
+
+Define the rules in your `golangci-lint` configuration file, e.g:
+
+```yaml
+linters:
+  enable:
+    - funcorder
+    ...
+
+  settings:
+    funcorder:
+      # Checks that constructors are placed after the structure declaration.
+      # Default: true
+      constructor: false
+      # Checks if the exported methods of a structure are placed before the non-exported ones.
+      # Default: true
+      struct-method: false
+      # Checks if the constructors and/or structure methods are sorted alphabetically.
+      # Default: false
+      alphabetical: true
+```
+
+### Standalone application
+
 Install FuncOrder linter using
 
 ```bash
@@ -23,13 +51,14 @@ go install github.com/manuelarte/funcorder@latest
 And then use it with
 
 ```
-funcorder [-constructor=true|false] [-struct-method=true|false] ./...
+funcorder [-constructor=true|false] [-struct-method=true|false] [-alphabetical=true|false] ./...
 ```
 
 Parameters:
 
-- `constructor`: `true|false` (default `true`) Check that constructor is placed after struct declaration and before struct's methods.
-- `struct-method`: `true|false` (default `true`) Check that exported struct's methods are declared before non-exported.
+- `constructor`: `true|false` (default `true`) Checks that constructors are placed after the structure declaration.
+- `struct-method`: `true|false` (default `true`) Checks if the exported methods of a structure are placed before the non-exported ones.
+- `alphabetical`: `true|false` (default `false`) Checks if the constructors and/or structure methods are sorted alphabetically.
 
 ## 🚀 Features
 
@@ -137,6 +166,98 @@ func NewMyStruct() MyStruct {
 </tbody>
 </table>
 
+### Check Constructors/Methods are sorted alphabetically
+
+This rule checks:
+
+- `Constructor` functions are sorted alphabetically (if `constructor` setting/parameter is `true`).
+- `Methods` are sorted alphabetically (if `struct-method` setting/parameter is `true`) for each group (exported and non-exported).
+
+<table>
+<thead><tr><th>❌ Bad</th><th>✅ Good</th></tr></thead>
+<tbody>
+<tr><td>
+
+```go
+type MyStruct struct {
+    Name string
+}
+
+func NewMyStruct() MyStruct {
+    return MyStruct{Name: "John"}
+}
+
+// ❌ constructor "NewAMyStruct" should be placed 
+// before "NewMyStruct"
+func NewAMyStruct() MyStruct {
+    return MyStruct{Name: "John"}
+}
+
+func (m MyStruct) GoodMorning() string {
+    return "good morning"
+}
+
+// ❌ method "GoodAfternoon" should be placed 
+// before "GoodMorning"
+func (m MyStruct) GoodAfternoon() string {
+    return "good afternoon"
+}
+
+func (m MyStruct) hello() string {
+ return "hello"
+}
+
+// ❌ method "bye" should be placed 
+// before "hello"
+func (m MyStruct) bye() string {
+    return "bye"
+}
+
+...
+```
+
+</td><td>
+
+```go
+type MyStruct struct {
+    Name string
+}
+
+// ✅ constructors sorted alphabetically
+func NewAMyStruct() MyStruct {
+    return MyStruct{Name: "John"}
+}
+
+func NewMyStruct() MyStruct {
+    return MyStruct{Name: "John"}
+}
+
+// ✅ exported methods sorted alphabetically
+func (m MyStruct) GoodAfternoon() string {
+    return "good afternoon"
+}
+
+func (m MyStruct) GoodMorning() string {
+    return "good morning"
+}
+
+// ✅ non-exported methods sorted alphabetically
+func (m MyStruct) bye() string {
+    return "bye"
+}
+
+func (m MyStruct) hello() string {
+    return "hello"
+}
+
+...
+```
+
+</td></tr>
+
+</tbody>
+</table>
+
 ## Resources
 
 - Following Uber Style Guidelines about [function-grouping-and-ordering](https://github.com/uber-go/guide/blob/master/style.md#function-grouping-and-ordering)

analyzer/analyzer.go

@@ -14,6 +14,7 @@ import (
 const (
 	ConstructorCheckName  = "constructor"
 	StructMethodCheckName = "struct-method"
+	AlphabeticalCheckName = "alphabetical"
 )
 
 func NewAnalyzer() *analysis.Analyzer {
@@ -27,27 +28,33 @@ func NewAnalyzer() *analysis.Analyzer {
 	}
 
 	a.Flags.BoolVar(&f.constructorCheck, ConstructorCheckName, true,
-		"Enable/disable feature to check constructors are placed after struct declaration")
+		"Checks that constructors are placed after the structure declaration.")
 	a.Flags.BoolVar(&f.structMethodCheck, StructMethodCheckName, true,
-		"Enable/disable feature to check whether the exported struct's methods "+
-			"are placed before the non-exported")
+		"Checks if the exported methods of a structure are placed before the non-exported ones.")
+	a.Flags.BoolVar(&f.alphabeticalCheck, AlphabeticalCheckName, false,
+		"Checks if the constructors and/or structure methods are sorted alphabetically.")
 
 	return a
 }
 
 type funcorder struct {
 	constructorCheck  bool
 	structMethodCheck bool
+	alphabeticalCheck bool
 }
 
 func (f *funcorder) run(pass *analysis.Pass) (any, error) {
 	var enabledCheckers features.Feature
 	if f.constructorCheck {
-		enabledCheckers |= features.ConstructorCheck
+		enabledCheckers.Enable(features.ConstructorCheck)
 	}
 
 	if f.structMethodCheck {
-		enabledCheckers |= features.StructMethodCheck
+		enabledCheckers.Enable(features.StructMethodCheck)
+	}
+
+	if f.alphabeticalCheck {
+		enabledCheckers.Enable(features.AlphabeticalCheck)
 	}
 
 	fp := fileprocessor.NewFileProcessor(enabledCheckers)

analyzer/analyzer_test.go

@@ -13,9 +13,16 @@ func TestAnalyzer(t *testing.T) {
 		options  map[string]string
 	}{
 		{
-			desc:     "all",
+			desc:     "default",
 			patterns: "simple",
 		},
+		{
+			desc:     "all options",
+			patterns: "simple-alphabetical",
+			options: map[string]string{
+				AlphabeticalCheckName: "true",
+			},
+		},
 		{
 			desc:     "constructor check only",
 			patterns: "constructor-check",
@@ -24,6 +31,15 @@ func TestAnalyzer(t *testing.T) {
 				StructMethodCheckName: "false",
 			},
 		},
+		{
+			desc:     "constructor check and alphabetical",
+			patterns: "constructor-check-alphabetical",
+			options: map[string]string{
+				ConstructorCheckName:  "true",
+				StructMethodCheckName: "false",
+				AlphabeticalCheckName: "true",
+			},
+		},
 		{
 			desc:     "method check only",
 			patterns: "struct-method-check",
@@ -32,6 +48,15 @@ func TestAnalyzer(t *testing.T) {
 				StructMethodCheckName: "true",
 			},
 		},
+		{
+			desc:     "alphabetical method check",
+			patterns: "struct-method-check-alphabetical",
+			options: map[string]string{
+				ConstructorCheckName:  "false",
+				StructMethodCheckName: "true",
+				AlphabeticalCheckName: "true",
+			},
+		},
 	}
 
 	for _, test := range testCases {

analyzer/testdata/src/constructor-check-alphabetical/constructors_after_struct_methods.go

@@ -0,0 +1,22 @@
+package simple
+
+type MyStruct2 struct {
+	Name string
+}
+
+func (m MyStruct2) GetName() string {
+	return m.Name
+}
+
+func (m *MyStruct2) SetName(name string) {
+	m.Name = name
+}
+
+func NewOtherMyStruct2() (m *MyStruct2) { // want `constructor "NewOtherMyStruct2" for struct "MyStruct2" should be placed before struct method "GetName"`
+	m = &MyStruct2{Name: "John"}
+	return
+}
+
+func NewMyStruct2() *MyStruct2 { // want `constructor "NewMyStruct2" for struct "MyStruct2" should be placed before struct method "GetName"` `constructor \"NewMyStruct2\" for struct \"MyStruct2\" should be placed before constructor \"NewOtherMyStruct2\"`
+	return &MyStruct2{Name: "John"}
+}

analyzer/testdata/src/constructor-check-alphabetical/constructors_before_struct.go

@@ -0,0 +1,30 @@
+package simple
+
+func NewOtherMyStruct() (m *MyStruct) { // want `should be placed after the struct declaration`
+	m = &MyStruct{Name: "John"}
+	return
+}
+
+func NewMyStruct() *MyStruct { // want `should be placed after the struct declaration` `constructor \"NewMyStruct\" for struct \"MyStruct\" should be placed before constructor \"NewOtherMyStruct\"`
+	return &MyStruct{Name: "John"}
+}
+
+func MustMyStruct() *MyStruct { // want `should be placed after the struct declaration` `constructor \"MustMyStruct\" for struct \"MyStruct\" should be placed before constructor \"NewMyStruct\"`
+	return NewMyStruct()
+}
+
+type MyStruct struct {
+	Name string
+}
+
+func (m MyStruct) lenName() int {
+	return len(m.Name)
+}
+
+func (m MyStruct) GetName() string {
+	return m.Name
+}
+
+func (m *MyStruct) SetName(name string) {
+	m.Name = name
+}

analyzer/testdata/src/constructor-check-alphabetical/constructors_not_sorted_alphabetical.go

@@ -0,0 +1,29 @@
+package simple
+
+type Greetings struct {
+}
+
+func NewOtherGreetings() (m *Greetings) {
+	m = &Greetings{}
+	return
+}
+
+func NewGreetings() *Greetings { // want `constructor \"NewGreetings\" for struct \"Greetings\" should be placed before constructor \"NewOtherGreetings\"`
+	return &Greetings{}
+}
+
+func (m Greetings) GoodMorning() string {
+	return "hello"
+}
+
+func (m *Greetings) GoodAfternoon(name string) string {
+	return "bye"
+}
+
+func (m Greetings) hello() string {
+	return "hello"
+}
+
+func (m *Greetings) bye(name string) string {
+	return "bye"
+}

analyzer/testdata/src/constructor-check-alphabetical/struct_not_declared_in_file.go

@@ -0,0 +1,13 @@
+package simple
+
+import (
+	"time"
+)
+
+func NewOtherWayMyStruct() MyStruct {
+	return MyStruct{Name: "John"}
+}
+
+func NewTimeStruct() time.Time {
+	return time.Now()
+}

analyzer/testdata/src/simple-alphabetical/constructors_after_struct_methods.go

@@ -0,0 +1,22 @@
+package simple
+
+type MyStruct2 struct {
+	Name string
+}
+
+func (m MyStruct2) GetName() string {
+	return m.Name
+}
+
+func (m *MyStruct2) SetName(name string) {
+	m.Name = name
+}
+
+func NewOtherMyStruct2() (m *MyStruct2) { // want `constructor \"NewOtherMyStruct2\" for struct \"MyStruct2\" should be placed before struct method \"GetName\"`
+	m = &MyStruct2{Name: "John"}
+	return
+}
+
+func NewMyStruct2() *MyStruct2 { // want `constructor \"NewMyStruct2\" for struct \"MyStruct2\" should be placed before struct method \"GetName\"` `constructor \"NewMyStruct2\" for struct \"MyStruct2\" should be placed before constructor \"NewOtherMyStruct2\"`
+	return &MyStruct2{Name: "John"}
+}