Add github.com/matryer/moq style mocks into mockery

.mockery-moq.yaml

@@ -0,0 +1,23 @@
+quiet: False
+disable-version-string: True
+mockname: "{{.InterfaceName}}Moq"
+filename: "{{.InterfaceName | snakecase }}_moq.go"
+dir: "mocks/moq/{{.PackagePath}}"
+style: moq
+packages:
+  github.com/vektra/mockery/v2/pkg/fixtures:
+    config:
+      include-regex: '.*'
+      exclude-regex: 'RequesterGenerics|UnsafeInterface|requester_unexported'
+      outpkg: test
+      template-map:
+        with-resets: true
+        skip-ensure: false
+        stub-impl: false
+      inpackage: false
+  github.com/vektra/mockery/v2/pkg/fixtures/inpackage:
+    config:
+      dir: "{{.InterfaceDir}}"
+      all: True
+      outpkg: "{{.PackageName}}"
+      inpackage: true

.mockery.yaml

@@ -36,7 +36,6 @@ packages:
             unroll-variadic: False
           - mockname: Expecter
             unroll-variadic: True
-      RequesterReturnElided:
       VariadicNoReturnInterface:
         config:
           with-expecter: True

Taskfile.yml

@@ -21,13 +21,14 @@ tasks:
   mocks.remove:
     desc: remove all mock files
     cmds:
-      - find . -name '*_mock.go' | xargs rm
+      - find . -name '*_mock.go' -o -name '*_moq.go' | xargs rm
       - rm -rf mocks/
 
   mocks.generate:
     desc: generate mockery mocks
     cmds:
       - go run .
+      - go run . --config .mockery-moq.yaml
 
   docker:
     desc: build the mockery docker image

cmd/mockery.go

@@ -12,7 +12,6 @@
 
 	"github.com/chigopher/pathlib"
 	"github.com/mitchellh/go-homedir"
-	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -83,6 +82,7 @@
 	pFlags.Bool("exported", false, "Generates public mocks for private interfaces.")
 	pFlags.Bool("with-expecter", false, "Generate expecter utility around mock's On, Run and Return methods with explicit types. This option is NOT compatible with -unroll-variadic=false")
 	pFlags.StringArray("replace-type", nil, "Replace types")
+	pFlags.String("style", "", "select which mock style to use")
 
 	if err := viperCfg.BindPFlags(pFlags); err != nil {
 		panic(fmt.Sprintf("failed to bind PFlags: %v", err))
@@ -212,10 +212,6 @@
 		return nil
 	}
 
-	var osp pkg.OutputStreamProvider
-	if r.Config.Print {
-		osp = &pkg.StdoutStreamProvider{}
-	}
 	buildTags := strings.Split(r.Config.BuildTags, " ")
 
 	var boilerplate string
@@ -238,7 +234,7 @@
 		if err != nil {
 			return fmt.Errorf("failed to get package from config: %w", err)
 		}
-		parser := pkg.NewParser(buildTags)
+		parser := pkg.NewParser(buildTags, pkg.ParserSkipFunctions(false))
 
 		if err := parser.ParsePackages(ctx, configuredPackages); err != nil {
 			log.Error().Err(err).Msg("unable to parse packages")
@@ -259,7 +255,7 @@
 
 			ifaceCtx := ifaceLog.WithContext(ctx)
 
-			shouldGenerate, err := r.Config.ShouldGenerateInterface(ifaceCtx, iface.QualifiedName, iface.Name)
+			shouldGenerate, err := r.Config.ShouldGenerateInterface(ifaceCtx, iface.QualifiedName, iface.Name, iface.IsFunction)
 			if err != nil {
 				return err
 			}
@@ -269,7 +265,7 @@
 			}
 			ifaceLog.Debug().Msg("config specifies to generate this interface")
 
-			outputter := pkg.NewOutputter(&r.Config, boilerplate, true)
+			outputter := pkg.NewOutputter(&r.Config, boilerplate)
 			if err := outputter.Generate(ifaceCtx, iface); err != nil {
 				return err
 			}
@@ -278,6 +274,11 @@
 		return nil
 	}
 
+	var osp pkg.OutputStreamProvider
+	if r.Config.Print {
+		osp = &pkg.StdoutStreamProvider{}
+	}
+
 	if r.Config.Name != "" && r.Config.All {
 		log.Fatal().Msgf("Specify --name or --all, but not both")
 	} else if (r.Config.FileName != "" || r.Config.StructName != "") && r.Config.All {
@@ -303,7 +304,7 @@
 		log.Fatal().Msgf("Use --name to specify the name of the interface or --all for all interfaces found")
 	}
 
-	warnDeprecated(
+	logging.WarnDeprecated(
 		ctx,
 		"use of the packages config will be the only way to generate mocks in v3. Please migrate your config to use the packages feature.",
 		map[string]any{
@@ -395,25 +396,3 @@
 
 	return nil
 }
-
-func warn(ctx context.Context, prefix string, message string, fields map[string]any) {
-	log := zerolog.Ctx(ctx)
-	event := log.Warn()
-	if fields != nil {
-		event = event.Fields(fields)
-	}
-	event.Msgf("%s: %s", prefix, message)
-}
-
-func info(ctx context.Context, prefix string, message string, fields map[string]any) {
-	log := zerolog.Ctx(ctx)
-	event := log.Info()
-	if fields != nil {
-		event = event.Fields(fields)
-	}
-	event.Msgf("%s: %s", prefix, message)
-}
-
-func warnDeprecated(ctx context.Context, message string, fields map[string]any) {
-	warn(ctx, "DEPRECATION", message, fields)
-}

codecov.yml

@@ -1,11 +1,15 @@
 coverage:
   precision: 5
   round: down
-  range: "40...100"
+  range: "0...100"
   status:
     patch:
       default:
-        target: 40%
+        target: 0%
+        threshold: 35%
+        base: auto
+    project:
+      default:
+        target: 0%
         threshold: 35%
         base: auto 
-

docs/configuration.md

@@ -73,14 +73,15 @@ Parameter Descriptions
 | `include-regex`                                        | :fontawesome-solid-x:     | `#!yaml ""`                           | When set, only interface names that match the expression will be generated. This setting is ignored if `all: True` is specified in the configuration. To further refine the interfaces generated, use `exclude-regex`.                               |
 | `inpackage`                                            | :fontawesome-solid-x:     | `#!yaml false`                        | When generating mocks alongside the original interfaces, you must specify `inpackage: True` to inform mockery that the mock is being placed in the same package as the original interface.                                                           |
 | `log-level`                                            | :fontawesome-solid-x:     | `#!yaml "info"`                       | Set the level of the logger                                                                                                                                                                                                                          |
-| `mock-build-tags`                                      | :fontawesome-solid-x:     | `#!yaml ""`                           | Set the build tags of the generated mocks. Read more about the [format](https://pkg.go.dev/cmd/go#hdr-Build_constraints).                                                                                                                             |
+| `mock-build-tags`                                      | :fontawesome-solid-x:     | `#!yaml ""`                           | Set the build tags of the generated mocks. Read more about the [format](https://pkg.go.dev/cmd/go#hdr-Build_constraints).                                                                                                                            |
 | `mockname`                                             | :fontawesome-solid-check: | `#!yaml "Mock{{.InterfaceName}}"`     | The name of the generated mock.                                                                                                                                                                                                                      |
 | `outpkg`                                               | :fontawesome-solid-check: | `#!yaml "{{.PackageName}}"`           | Use `outpkg` to specify the package name of the generated mocks.                                                                                                                                                                                     |
 | [`packages`](features.md#packages-configuration)       | :fontawesome-solid-x:     | `#!yaml null`                         | A dictionary containing configuration describing the packages and interfaces to generate mocks for.                                                                                                                                                  |
 | `print`                                                | :fontawesome-solid-x:     | `#!yaml false`                        | Use `print: True` to have the resulting code printed out instead of written to disk.                                                                                                                                                                 |
 | [`recursive`](features.md#recursive-package-discovery) | :fontawesome-solid-x:     | `#!yaml false`                        | When set to `true` on a particular package, mockery will recursively search for all sub-packages and inject those packages into the config map.                                                                                                      |
 | [`replace-type`](features.md#replace-types)            | :fontawesome-solid-x:     | `#!yaml null`                         | Replaces aliases, packages and/or types during generation.                                                                                                                                                                                           |
-| `tags`                                                 | :fontawesome-solid-x:     | `#!yaml ""`                           | A space-separated list of additional build tags to load packages.                                                                                                                                                                                                                |
+| [`style`](/mockery/features/#mock-styles) | :fontawesome-solid-x: | `#!yaml mockery` | Set the style of mocks to generate. |
+| `tags`                                                 | :fontawesome-solid-x:     | `#!yaml ""`                           | A space-separated list of additional build tags to load packages.                                                                                                                                                                                    |
 | [`with-expecter`](features.md#expecter-structs)        | :fontawesome-solid-x:     | `#!yaml true`                         | Use `with-expecter: True` to generate `EXPECT()` methods for your mocks. This is the preferred way to setup your mocks.                                                                                                                              |
 
 Layouts

docs/features.md

@@ -1,6 +1,123 @@
 Features
 ========
 
+Mock Styles
+------------
+
+:octicons-tag-24: v2.42.0 :material-test-tube:{ .tooltip foo }
+
+!!! warning "ALPHA"
+    This feature is currently in alpha. Usage is not recommended for production applications as the configuration semantics and/or mock behavior might change in future releases.
+
+mockery provides a parameter called `#!yaml style:` that allows you to specify different styles of mock implementations. This parameter defaults to `#!yaml style: mockery`, but you may also provide other values described below:
+
+| style | description |
+|-------|-------------|
+| `mockery` | The default style. Generates the mocks that you typically expect from this project. |
+| `moq` | Generates mocks in the style of [Mat Ryer's project](https://github.com/matryer/moq). |
+
+This table describes the characteristics of each mock style.
+
+| feature | `mockery` | `moq` |
+|---------|-----------|-------|
+| Uses testify | :white_check_mark: | :x: |
+| Strictly typed arguments | :warning:[^1] | :white_check_mark: |
+| Stricly typed return values | :white_check_mark: | :white_check_mark: |
+| Multiple mocks per file | :x: | :x: |
+| Return values mapped from argument values | :white_check_mark: | :x: |
+| Supports generics | :white_check_mark: | :white_check_mark: |
+| 
+
+[^1]: 
+	If you use the `.RunAndReturn` method in the [`.EXPECT()`](/mockery/features/#expecter-structs) structs, you can get strict type safety. Otherwise, `.EXPECT()` methods are type-safe-ish, meaning you'll get compiler errors if you have the incorrect number of arguments, but the types of the arguments themselves are `interface{}` due to the need to specify `mock.Anything` in some cases.
+
+### `mockery`
+
+`mockery` is the default style of mocks you are used to with this project.
+
+### `moq`
+
+The `moq` implementations are generated using similar logic as the project at https://github.com/matryer/moq. The mocks rely on you defining stub functions that will be called directly from each method. For example, assume you have an interface like this:
+
+```go
+type Requester interface {
+	Get(path string) (string, error)
+}
+```
+
+`moq` will create an implementation that looks roughly like this:
+
+```go
+type RequesterMock struct {
+	// GetFunc mocks the Get method.
+	GetFunc func(path string) (string, error)
+
+	// calls tracks calls to the methods.
+	calls struct {
+		// Get holds details about calls to the Get method.
+		Get []struct {
+			// Path is the path argument value.
+			Path string
+		}
+	}
+	lockGet sync.RWMutex
+}
+
+// Get calls GetFunc.
+func (mock *RequesterMock) Get(path string) (string, error) {
+	if mock.GetFunc == nil {
+		panic("RequesterMock.GetFunc: method is nil but Requester.Get was just called")
+	}
+	callInfo := struct {
+		Path string
+	}{
+		Path: path,
+	}
+	mock.lockGet.Lock()
+	mock.calls.Get = append(mock.calls.Get, callInfo)
+	mock.lockGet.Unlock()
+	return mock.GetFunc(path)
+}
+```
+
+The way you interact with this mock in a test would look like this:
+
+```go
+func TestRequester(t *testing.T){
+	requesterMock := &RequesterMock{
+		GetFunc: func(path string) (string, error) {
+			return "value", fmt.Errorf("failed")
+		}
+	}
+}
+```
+
+#### Configuration
+
+A simple basic configuration might look like this:
+
+```yaml
+style: moq
+packages:
+  github.com/vektra/mockery/v2/pkg/fixtures:
+    config:
+      template-map:
+        with-resets: true
+        skip-ensure: true
+        stub-impl: false
+```
+
+The `moq` style is driven entirely off of Go templates. Various features of the moq may be toggled by using the `#! template-map:` mapping. These are the moq-specific parameters:
+
+| name | default | description |
+|------|---------|-------------|
+| `#!yaml with-resets` | `<no value>` | Generates functions that aid in resetting the list of calls made to a mock. |
+| `#!yaml skip-ensure` | `<no value>` | Skips adding a compile-time check that asserts the generated mock properly implements the interface. |
+| `#!yaml stub-impl` | `<no value>` | Sets methods to return the zero value when no mock implementation is provided. |
+
+!!! note
+	Many of the parameters listed in the [parameter descriptions page](/mockery/configuration/#parameter-descriptions) also apply to `moq`.  However, some parameters of `mockery`-styled mocks will not apply to `moq`. Efforts will be made to ensure the documentation is clear on which parameters apply to which style.
+
 Replace Types
 -------------
 

docs/requirements.txt

@@ -1,7 +1,9 @@
 mike @ git+https://github.com/jimporter/mike.git
 mkdocs
 mkdocs-glightbox
-git+https://${GH_TOKEN}@github.com/squidfunk/mkdocs-material-insiders.git
+# replace the below mkdocs-material line below with "mkdocs-material"
+# if you don't have access to the insiders edition.
+git+https://${GH_TOKEN}@github.com/squidfunk/[email protected]
 mkdocs-open-in-new-tab
 cairosvg
 pillow

mkdocs.yml

@@ -31,13 +31,15 @@ theme:
     - content.code.copy
     - content.action.edit
     - content.action.view
+    - content.footnote.tooltips
     - navigation.indexes
     - navigation.sections
     - navigation.tracking
     - toc.follow
 markdown_extensions:
   - admonition
   - attr_list
+  - footnotes
   - md_in_html
   - pymdownx.emoji:
       emoji_index: !!python/name:material.extensions.emoji.twemoji
@@ -53,7 +55,6 @@ markdown_extensions:
       alternate_style: true 
   - toc:
       permalink: true
-
 
 nav:
   - Home: index.md