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

     1  /*
     2  Copyright 2019 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 generators
    18  
    19  import (
    20  	"strings"
    21  
    22  	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
    23  	"k8s.io/gengo/v2"
    24  	"k8s.io/gengo/v2/generator"
    25  	"k8s.io/gengo/v2/namer"
    26  	"k8s.io/gengo/v2/types"
    27  
    28  	"knative.dev/pkg/codegen/cmd/injection-gen/args"
    29  	"knative.dev/pkg/codegen/cmd/injection-gen/generators/client"
    30  	"knative.dev/pkg/codegen/cmd/injection-gen/generators/duck"
    31  	"knative.dev/pkg/codegen/cmd/injection-gen/generators/factory"
    32  	"knative.dev/pkg/codegen/cmd/injection-gen/generators/informers"
    33  	"knative.dev/pkg/codegen/cmd/injection-gen/generators/reconciler"
    34  	"knative.dev/pkg/codegen/cmd/injection-gen/tags"
    35  )
    36  
    37  type genFunc func(*args.Args, string, clientgentypes.GroupVersion, string, []*types.Type) []generator.Target
    38  
    39  // Packages makes the client package definition.
    40  func Targets(context *generator.Context, args *args.Args) []generator.Target {
    41  	var packageList []generator.Target
    42  
    43  	groupGoNames := make(map[string]string)
    44  	for _, inputDir := range args.InputDirs {
    45  		p := context.Universe.Package(inputDir)
    46  
    47  		var gv clientgentypes.GroupVersion
    48  
    49  		parts := strings.Split(p.Path, "/")
    50  		gv.Group = clientgentypes.Group(parts[len(parts)-2])
    51  		gv.Version = clientgentypes.Version(parts[len(parts)-1])
    52  
    53  		groupPackageName := gv.Group.NonEmpty()
    54  
    55  		// If there's a comment of the form "// +groupName=somegroup" or
    56  		// "// +groupName=somegroup.foo.bar.io", use the first field (somegroup) as the name of the
    57  		// group when generating.
    58  		if tags, err := gengo.ExtractFunctionStyleCommentTags("+", nil, p.Comments); err != nil {
    59  			panic(err)
    60  		} else if override := tags["groupName"]; override != nil {
    61  			gv.Group = clientgentypes.Group(override[0].Value)
    62  		}
    63  
    64  		// If there's a comment of the form "// +groupGoName=SomeUniqueShortName", use that as
    65  		// the Go group identifier in CamelCase. It defaults
    66  		groupGoNames[groupPackageName] = namer.IC(strings.SplitN(gv.Group.NonEmpty(), ".", 2)[0])
    67  		if tags, err := gengo.ExtractFunctionStyleCommentTags("+", nil, p.Comments); err != nil {
    68  			panic(err)
    69  		} else if override := tags["groupGoName"]; override != nil {
    70  			groupGoNames[groupPackageName] = namer.IC(override[0].Value)
    71  		}
    72  
    73  		var typesWithInformers []*types.Type
    74  		var duckTypes []*types.Type
    75  		var reconcilerTypes []*types.Type
    76  
    77  		for _, t := range p.Types {
    78  			tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
    79  			if tags.NeedsInformerInjection() {
    80  				typesWithInformers = append(typesWithInformers, t)
    81  			}
    82  			if tags.NeedsDuckInjection() {
    83  				duckTypes = append(duckTypes, t)
    84  			}
    85  			if tags.NeedsReconciler(t, args) {
    86  				reconcilerTypes = append(reconcilerTypes, t)
    87  			}
    88  		}
    89  
    90  		sources := []struct {
    91  			types     []*types.Type
    92  			generator genFunc
    93  		}{
    94  			{types: typesWithInformers, generator: informers.Targets},
    95  			{types: duckTypes, generator: duck.Targets},
    96  			{types: reconcilerTypes, generator: reconciler.Targets},
    97  		}
    98  
    99  		for _, source := range sources {
   100  			if len(source.types) != 0 {
   101  				orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
   102  				source.types = orderer.OrderTypes(source.types)
   103  				targets := source.generator(args, groupPackageName, gv, groupGoNames[groupPackageName], source.types)
   104  				packageList = append(packageList, targets...)
   105  			}
   106  		}
   107  	}
   108  
   109  	// Generate the client and fake.
   110  	packageList = append(packageList, client.Targets(args)...)
   111  
   112  	// // Generate the informer factory and fake.
   113  	packageList = append(packageList, factory.Targets(args)...)
   114  
   115  	return packageList
   116  }