docs: Disable Go reformatting (#1000)

(This is a new version of #961. I can't push to the original branch
anymore.)

---

Upgrade to latest markdownfmt
which does not reformat Go source code blocks by default.

With this change, formatting of code blocks in Fx docs will be
consistent
instead of some being gofmt-ed to use tabs,
and others using 2 spaces (per our 'region' script).

This is a landable version of #961 without any temporary version pins.

.gitignore

@@ -12,4 +12,5 @@ coverage.txt
 /.bin
 /.cache
 /bin
-.vscode
+.vscode
+.mdoxcache

docs/annotate.md

@@ -95,7 +95,7 @@ into an interface consumed by another function.
 
    ```go mdox-exec='region ex/annotate/cast.go interface'
    type HTTPClient interface {
-   	Do(*http.Request) (*http.Response, error)
+     Do(*http.Request) (*http.Response, error)
    }
 
    // This is a compile-time check that verifies

docs/get-started/another-handler.md

@@ -9,35 +9,35 @@ Let's add another.
    // HelloHandler is an HTTP handler that
    // prints a greeting to the user.
    type HelloHandler struct {
-   	log *zap.Logger
+     log *zap.Logger
    }
 
    // NewHelloHandler builds a new HelloHandler.
    func NewHelloHandler(log *zap.Logger) *HelloHandler {
-   	return &HelloHandler{log: log}
+     return &HelloHandler{log: log}
    }
    ```
 
 2. Implement the `Route` interface for this handler.
 
    ```go mdox-exec='region ex/get-started/06-another-handler/main.go hello-methods'
    func (*HelloHandler) Pattern() string {
-   	return "/hello"
+     return "/hello"
    }
 
    func (h *HelloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-   	body, err := io.ReadAll(r.Body)
-   	if err != nil {
-   		h.log.Error("Failed to read request", zap.Error(err))
-   		http.Error(w, "Internal server error", http.StatusInternalServerError)
-   		return
-   	}
-
-   	if _, err := fmt.Fprintf(w, "Hello, %s\n", body); err != nil {
-   		h.log.Error("Failed to write response", zap.Error(err))
-   		http.Error(w, "Internal server error", http.StatusInternalServerError)
-   		return
-   	}
+     body, err := io.ReadAll(r.Body)
+     if err != nil {
+       h.log.Error("Failed to read request", zap.Error(err))
+       http.Error(w, "Internal server error", http.StatusInternalServerError)
+       return
+     }
+
+     if _, err := fmt.Fprintf(w, "Hello, %s\n", body); err != nil {
+       h.log.Error("Failed to write response", zap.Error(err))
+       http.Error(w, "Internal server error", http.StatusInternalServerError)
+       return
+     }
    }
    ```
 
@@ -103,10 +103,10 @@ Let's add another.
    // NewServeMux builds a ServeMux that will route requests
    // to the given routes.
    func NewServeMux(route1, route2 Route) *http.ServeMux {
-   	mux := http.NewServeMux()
-   	mux.Handle(route1.Pattern(), route1)
-   	mux.Handle(route2.Pattern(), route2)
-   	return mux
+     mux := http.NewServeMux()
+     mux.Handle(route1.Pattern(), route1)
+     mux.Handle(route2.Pattern(), route2)
+     return mux
    }
    ```
 

docs/get-started/echo-handler.md

@@ -15,14 +15,14 @@ Let's fix that.
 
    // NewEchoHandler builds a new EchoHandler.
    func NewEchoHandler() *EchoHandler {
-   	return &EchoHandler{}
+     return &EchoHandler{}
    }
 
    // ServeHTTP handles an HTTP request to the /echo endpoint.
    func (*EchoHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-   	if _, err := io.Copy(w, r.Body); err != nil {
-   		fmt.Fprintln(os.Stderr, "Failed to handle request:", err)
-   	}
+     if _, err := io.Copy(w, r.Body); err != nil {
+       fmt.Fprintln(os.Stderr, "Failed to handle request:", err)
+     }
    }
    ```
 
@@ -46,9 +46,9 @@ Let's fix that.
    // NewServeMux builds a ServeMux that will route requests
    // to the given EchoHandler.
    func NewServeMux(echo *EchoHandler) *http.ServeMux {
-   	mux := http.NewServeMux()
-   	mux.Handle("/echo", echo)
-   	return mux
+     mux := http.NewServeMux()
+     mux.Handle("/echo", echo)
+     return mux
    }
    ```
 

docs/get-started/http-server.md

@@ -10,8 +10,8 @@ Let's add an HTTP server to it.
    // NewHTTPServer builds an HTTP server that will begin serving requests
    // when the Fx application starts.
    func NewHTTPServer(lc fx.Lifecycle) *http.Server {
-   	srv := &http.Server{Addr: ":8080"}
-   	return srv
+     srv := &http.Server{Addr: ":8080"}
+     return srv
    }
    ```
 
@@ -23,32 +23,32 @@ Let's add an HTTP server to it.
 
    ```go mdox-exec='region ex/get-started/02-http-server/main.go full'
    func NewHTTPServer(lc fx.Lifecycle) *http.Server {
-   	srv := &http.Server{Addr: ":8080"}
-   	lc.Append(fx.Hook{
-   		OnStart: func(ctx context.Context) error {
-   			ln, err := net.Listen("tcp", srv.Addr)
-   			if err != nil {
-   				return err
-   			}
-   			fmt.Println("Starting HTTP server at", srv.Addr)
-   			go srv.Serve(ln)
-   			return nil
-   		},
-   		OnStop: func(ctx context.Context) error {
-   			return srv.Shutdown(ctx)
-   		},
-   	})
-   	return srv
+     srv := &http.Server{Addr: ":8080"}
+     lc.Append(fx.Hook{
+       OnStart: func(ctx context.Context) error {
+         ln, err := net.Listen("tcp", srv.Addr)
+         if err != nil {
+           return err
+         }
+         fmt.Println("Starting HTTP server at", srv.Addr)
+         go srv.Serve(ln)
+         return nil
+       },
+       OnStop: func(ctx context.Context) error {
+         return srv.Shutdown(ctx)
+       },
+     })
+     return srv
    }
    ```
 
 3. Provide this to your Fx application above with `fx.Provide`.
 
    ```go mdox-exec='region ex/get-started/02-http-server/main.go provide-server'
    func main() {
-   	fx.New(
-   		fx.Provide(NewHTTPServer),
-   	).Run()
+     fx.New(
+       fx.Provide(NewHTTPServer),
+     ).Run()
    }
    ```
 
@@ -70,10 +70,10 @@ Let's add an HTTP server to it.
 5. To fix that, add an `fx.Invoke` that requests the constructed server.
 
    ```go mdox-exec='region ex/get-started/02-http-server/main.go app'
-   	fx.New(
-   		fx.Provide(NewHTTPServer),
-   		fx.Invoke(func(*http.Server) {}),
-   	).Run()
+     fx.New(
+       fx.Provide(NewHTTPServer),
+       fx.Invoke(func(*http.Server) {}),
+     ).Run()
    ```
 
 6. Run the application again.

docs/get-started/logger.md

@@ -28,11 +28,11 @@ but you should be able to use any logging system.
 
    ```go mdox-exec='region ex/get-started/04-logger/main.go echo-init'
    type EchoHandler struct {
-   	log *zap.Logger
+     log *zap.Logger
    }
 
    func NewEchoHandler(log *zap.Logger) *EchoHandler {
-   	return &EchoHandler{log: log}
+     return &EchoHandler{log: log}
    }
    ```
 
@@ -41,9 +41,9 @@ but you should be able to use any logging system.
 
    ```go mdox-exec='region ex/get-started/04-logger/main.go echo-serve'
    func (h *EchoHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-   	if _, err := io.Copy(w, r.Body); err != nil {
-   		h.log.Warn("Failed to handle request", zap.Error(err))
-   	}
+     if _, err := io.Copy(w, r.Body); err != nil {
+       h.log.Warn("Failed to handle request", zap.Error(err))
+     }
    }
    ```
 

docs/get-started/many-handlers.md

@@ -13,11 +13,11 @@ Let's do that.
 
    ```go mdox-exec='region ex/get-started/07-many-handlers/main.go mux'
    func NewServeMux(routes []Route) *http.ServeMux {
-   	mux := http.NewServeMux()
-   	for _, route := range routes {
-   		mux.Handle(route.Pattern(), route)
-   	}
-   	return mux
+     mux := http.NewServeMux()
+     for _, route := range routes {
+       mux.Handle(route.Pattern(), route)
+     }
+     return mux
    }
    ```
 
@@ -40,11 +40,11 @@ Let's do that.
    // AsRoute annotates the given constructor to state that
    // it provides a route to the "routes" group.
    func AsRoute(f any) any {
-   	return fx.Annotate(
-   		f,
-   		fx.As(new(Route)),
-   		fx.ResultTags(`group:"routes"`),
-   	)
+     return fx.Annotate(
+       f,
+       fx.As(new(Route)),
+       fx.ResultTags(`group:"routes"`),
+     )
    }
    ```
 

docs/get-started/minimal.md

@@ -11,7 +11,7 @@ This application won't do anything yet except print a bunch of logs.
    import "go.uber.org/fx"
 
    func main() {
-   	fx.New().Run()
+     fx.New().Run()
    }
    ```
 

docs/get-started/registration.md

@@ -16,18 +16,18 @@ Let's try to fix this.
    // Route is an http.Handler that knows the mux pattern
    // under which it will be registered.
    type Route interface {
-   	http.Handler
+     http.Handler
 
-   	// Pattern reports the path at which this is registered.
-   	Pattern() string
+     // Pattern reports the path at which this is registered.
+     Pattern() string
    }
    ```
 
 2. Modify `EchoHandler` to implement this interface.
 
    ```go mdox-exec='region ex/get-started/05-registration/main.go echo-pattern'
    func (*EchoHandler) Pattern() string {
-   	return "/echo"
+     return "/echo"
    }
    ```
 
@@ -52,9 +52,9 @@ Let's try to fix this.
    // NewServeMux builds a ServeMux that will route requests
    // to the given Route.
    func NewServeMux(route Route) *http.ServeMux {
-   	mux := http.NewServeMux()
-   	mux.Handle(route.Pattern(), route)
-   	return mux
+     mux := http.NewServeMux()
+     mux.Handle(route.Pattern(), route)
+     return mux
    }
    ```
 

docs/modules.md

@@ -22,10 +22,10 @@ To write an Fx module:
 
    ```go mdox-exec='region ex/modules/module.go provide'
    var Module = fx.Module("server",
-   	fx.Provide(
-   		New,
-   		parseConfig,
-   	),
+     fx.Provide(
+       New,
+       parseConfig,
+     ),
    )
    ```
 
@@ -34,11 +34,11 @@ To write an Fx module:
 
    ```go mdox-exec='region ex/modules/module.go invoke'
    var Module = fx.Module("server",
-   	fx.Provide(
-   		New,
-   		parseConfig,
-   	),
-   	fx.Invoke(startServer),
+     fx.Provide(
+       New,
+       parseConfig,
+     ),
+     fx.Invoke(startServer),
    )
    ```
 
@@ -47,12 +47,13 @@ To write an Fx module:
 
    ```go mdox-exec='region ex/modules/module.go decorate'
    var Module = fx.Module("server",
-   	fx.Provide(
-   		New,
-   		parseConfig,
-   	),
-   	fx.Invoke(startServer),
-   	fx.Decorate(wrapLogger),
+     fx.Provide(
+       New,
+       parseConfig,
+     ),
+     fx.Invoke(startServer),
+     fx.Decorate(wrapLogger),
+
    )
    ```
 

docs/parameter-objects.md

@@ -48,10 +48,10 @@ To use parameter objects in Fx, take the following steps:
 
    ```go mdox-exec='region ex/parameter-objects/define.go fields'
    type ClientParams struct {
-   	fx.In
+     fx.In
 
-   	Config     ClientConfig
-   	HTTPClient *http.Client
+     Config     ClientConfig
+     HTTPClient *http.Client
    }
    ```
 
@@ -100,11 +100,11 @@ the new fields must be **optional**.
 
    ```go mdox-exec='region ex/parameter-objects/extend.go full'
    type Params struct {
-   	fx.In
+     fx.In
 
-   	Config     ClientConfig
-   	HTTPClient *http.Client
-   	Logger     *zap.Logger `optional:"true"`
+     Config     ClientConfig
+     HTTPClient *http.Client
+     Logger *zap.Logger `optional:"true"`
    }
    ```