knative.dev/pkg@v0.0.0-20260602142205-ac97e43f6622/codegen/cmd/injection-gen/generators/factory/targets.go (about)

     1  /*
     2  Copyright 2025 The Knative Authors
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package factory
    18  
    19  import (
    20  	"path/filepath"
    21  
    22  	"k8s.io/gengo/v2/generator"
    23  	"k8s.io/gengo/v2/types"
    24  	"knative.dev/pkg/codegen/cmd/injection-gen/args"
    25  	"knative.dev/pkg/codegen/cmd/injection-gen/generators/client"
    26  	"knative.dev/pkg/codegen/cmd/injection-gen/tags"
    27  )
    28  
    29  func Targets(args *args.Args) []generator.Target {
    30  	packagePath := filepath.Join(args.GetOutputPackagePath(), "informers", "factory")
    31  	packageDir := filepath.Join(args.GetOutputDir(), "informers", "factory")
    32  
    33  	clientGen := client.New(args)
    34  	clientFakeGen := client.NewFake(args)
    35  
    36  	return []generator.Target{
    37  		// Impl
    38  		&generator.SimpleTarget{
    39  			PkgName:       "factory",
    40  			PkgPath:       packagePath,
    41  			PkgDir:        packageDir,
    42  			HeaderComment: args.Boilerplate,
    43  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
    44  				// Impl
    45  				return []generator.Generator{&factoryGenerator{
    46  					GoGenerator: generator.GoGenerator{
    47  						OutputFilename: "factory.go",
    48  					},
    49  					outputPackage:                packagePath,
    50  					cachingClientSetPackage:      clientGen.OutputPackagePath(),
    51  					sharedInformerFactoryPackage: args.ExternalVersionsInformersPackage,
    52  					imports:                      generator.NewImportTracker(),
    53  				}}
    54  			},
    55  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
    56  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
    57  				return tags.NeedsInformerInjection()
    58  			},
    59  		},
    60  		// Fake
    61  		&generator.SimpleTarget{
    62  			PkgName:       "fake",
    63  			PkgPath:       filepath.Join(packagePath, "fake"),
    64  			PkgDir:        filepath.Join(packageDir, "fake"),
    65  			HeaderComment: args.Boilerplate,
    66  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
    67  				// Impl
    68  				return []generator.Generator{&fakeFactoryGenerator{
    69  					GoGenerator: generator.GoGenerator{
    70  						OutputFilename: "fake.go",
    71  					},
    72  					outputPackage:                filepath.Join(packagePath, "fake"),
    73  					factoryInjectionPkg:          packagePath,
    74  					fakeClientInjectionPkg:       clientFakeGen.OutputPackagePath(),
    75  					sharedInformerFactoryPackage: args.ExternalVersionsInformersPackage,
    76  					imports:                      generator.NewImportTracker(),
    77  				}}
    78  			},
    79  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
    80  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
    81  				return tags.NeedsInformerInjection()
    82  			},
    83  		},
    84  
    85  		// FilterFactoryImpl
    86  		&generator.SimpleTarget{
    87  			PkgName:       "filteredFactory",
    88  			PkgPath:       filepath.Join(packagePath, "filtered"),
    89  			PkgDir:        filepath.Join(packageDir, "filtered"),
    90  			HeaderComment: args.Boilerplate,
    91  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
    92  				// Impl
    93  				return []generator.Generator{&filteredFactoryGenerator{
    94  					GoGenerator: generator.GoGenerator{
    95  						OutputFilename: "filtered_factory.go",
    96  					},
    97  					outputPackage:                filepath.Join(packagePath, "filtered"),
    98  					cachingClientSetPackage:      clientGen.OutputPackagePath(),
    99  					sharedInformerFactoryPackage: args.ExternalVersionsInformersPackage,
   100  					imports:                      generator.NewImportTracker(),
   101  				}}
   102  			},
   103  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
   104  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
   105  				return tags.NeedsInformerInjection()
   106  			},
   107  		},
   108  		// FakeFilterFactory
   109  		&generator.SimpleTarget{
   110  			PkgName:       "fakeFilteredFactory",
   111  			PkgPath:       filepath.Join(packagePath, "filtered", "fake"),
   112  			PkgDir:        filepath.Join(packageDir, "filtered", "fake"),
   113  			HeaderComment: args.Boilerplate,
   114  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
   115  				// Impl
   116  				return []generator.Generator{&fakeFilteredFactoryGenerator{
   117  					GoGenerator: generator.GoGenerator{
   118  						OutputFilename: "fake_filtered_factory.go",
   119  					},
   120  					outputPackage:                filepath.Join(packagePath, "filtered", "fake"),
   121  					factoryInjectionPkg:          filepath.Join(packagePath, "filtered"),
   122  					fakeClientInjectionPkg:       clientFakeGen.OutputPackagePath(),
   123  					sharedInformerFactoryPackage: args.ExternalVersionsInformersPackage,
   124  					imports:                      generator.NewImportTracker(),
   125  				}}
   126  			},
   127  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
   128  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
   129  				return tags.NeedsInformerInjection()
   130  			},
   131  		},
   132  	}
   133  }