Add basic attempt at local module handling

The idea here is to support a new formatting section, `module`, which is
the module we're currently running in as a replacement for
`prefix(module/we/are/running/in)`.

This attempt is very basic: if the `module` section is requested it:

* Looks for a `go.mod` in the current directory (and errors if we can't
  find or read it)
* Stores the module path from `go.mod`
* Looks for imports that have that path as a prefix when specifying
  ordering

This attempt intentionally does not attempt to:

* Do any more clever searching for `go.mod` (e.g. traverse up/down
  directory tree until we find one)
* Do any handling of multiple module setups, e.g. any module under the
  current directory is just ignored

cmd/gci/gcicommand.go

@@ -33,6 +33,10 @@ func (e *Executor) newGciCommand(use, short, long string, aliases []string, stdI
 			if err != nil {
 				return err
 			}
+			// TOOD: "." is a hack (just to see how things work)
+			if err = gciCfg.LoadModulePaths("."); err != nil {
+				return err
+			}
 			if *debug {
 				log.SetLevel(zapcore.DebugLevel)
 			}

pkg/config/config.go

@@ -88,3 +88,22 @@ func ParseConfig(in string) (*Config, error) {
 
 	return gciCfg, nil
 }
+
+// LoadModulePaths checks if a 'Module' section was requested
+// then looks for a 'go.mod' in dir and loads the module path defined there
+// into the module section
+func (g *Config) LoadModulePaths(dir string) error {
+	var moduleSection *section.Module
+	for i := range g.Sections {
+		s := g.Sections[i]
+		if m, ok := s.(*section.Module); ok {
+			moduleSection = m
+			break
+		}
+	}
+	if moduleSection == nil {
+		// skip collecting Go modules when not needed
+		return nil
+	}
+	return moduleSection.Populate(dir)
+}

pkg/gci/gci_test.go

@@ -26,6 +26,13 @@ func TestRun(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
+			// TOOD: another path hack (we need to load gci's 'go.mod')
+			// which is also hacky since it implicity ties some of our
+			// testcases to that file. It would probably be nicer to explicitly
+			// include all required bits in the testcase itself
+			if err := config.LoadModulePaths("../.."); err != nil {
+				t.Fatal(err)
+			}
 
 			old, new, err := LoadFormat([]byte(testCases[i].in), "", *config)
 			if err != nil {

pkg/gci/testdata.go

@@ -1273,6 +1273,28 @@ import (
 	testing "github.com/daixiang0/test"
 	g "github.com/golang"
 )
+`,
+	},
+	{
+		"basic module",
+		`sections:
+  - Standard
+  - Module
+`,
+		`package main
+
+import (
+	"os"
+	"github.com/daixiang0/gci/cmd/gci"
+)
+`,
+		`package main
+
+import (
+	"os"
+
+	"github.com/daixiang0/gci/cmd/gci"
+)
 `,
 	},
 }

pkg/section/parser.go

@@ -35,6 +35,8 @@ func Parse(data []string) (SectionList, error) {
 			list = append(list, Blank{})
 		} else if s == "alias" {
 			list = append(list, Alias{})
+		} else if s == "module" {
+			list = append(list, &Module{})
 		} else {
 			errString += fmt.Sprintf(" %s", s)
 		}

pkg/section/section.go

@@ -28,7 +28,8 @@ func (list SectionList) String() []string {
 }
 
 func DefaultSections() SectionList {
-	return SectionList{Standard{}, Default{}}
+	// pointer for Module since we need to mutate it
+	return SectionList{Standard{}, Default{}, &Module{}}
 }
 
 func DefaultSectionSeparators() SectionList {

pkg/specificity/specificity.go

@@ -8,6 +8,7 @@ const (
 	StandardClass = 20
 	MatchClass    = 30
 	NameClass     = 40
+	ModuleClass   = 50
 )
 
 // MatchSpecificity is used to determine which section matches an import best