From 92aab95fbb214a650136ff940a6ac33ae3b72e00 Mon Sep 17 00:00:00 2001 From: Nathan Rijksen Date: Fri, 11 Oct 2024 14:40:10 -0700 Subject: [PATCH] Revert "Merge branch version/0-47-0-RC1 to adopt changes from PR #3531" This reverts commit 28d0d68f0fb20e15c07810aa3153baefc7388a13, reversing changes made to 1827a60e496f3d3a606a09c9d7f40b92cc846b29. --- pkg/buildscript/queries.go | 89 +++----------------- pkg/buildscript/unmarshal.go | 10 --- pkg/buildscript/unmarshal_buildexpression.go | 19 +++-- 3 files changed, 26 insertions(+), 92 deletions(-) diff --git a/pkg/buildscript/queries.go b/pkg/buildscript/queries.go index 55e07927dc..2f4a1a6c54 100644 --- a/pkg/buildscript/queries.go +++ b/pkg/buildscript/queries.go @@ -4,7 +4,6 @@ import ( "strings" "github.com/go-openapi/strfmt" - "github.com/thoas/go-funk" "github.com/ActiveState/cli/internal/errs" "github.com/ActiveState/cli/pkg/platform/api/buildplanner/types" @@ -13,7 +12,6 @@ import ( const ( solveFuncName = "solve" solveLegacyFuncName = "solve_legacy" - srcKey = "src" requirementsKey = "requirements" platformsKey = "platforms" ) @@ -45,10 +43,8 @@ type UnknownRequirement struct { func (r UnknownRequirement) IsRequirement() {} -// Returns the requirements for the given target. -// If no target is given, uses the default target (i.e. the name assigned to 'main'). -func (b *BuildScript) Requirements(targets ...string) ([]Requirement, error) { - requirementsNode, err := b.getRequirementsNode(targets...) +func (b *BuildScript) Requirements() ([]Requirement, error) { + requirementsNode, err := b.getRequirementsNode() if err != nil { return nil, errs.Wrap(err, "Could not get requirements node") } @@ -99,8 +95,8 @@ func (b *BuildScript) Requirements(targets ...string) ([]Requirement, error) { // DependencyRequirements is identical to Requirements except that it only considers dependency type requirements, // which are the most common. // ONLY use this when you know you only need to care about dependencies. -func (b *BuildScript) DependencyRequirements(targets ...string) ([]types.Requirement, error) { - reqs, err := b.Requirements(targets...) +func (b *BuildScript) DependencyRequirements() ([]types.Requirement, error) { + reqs, err := b.Requirements() if err != nil { return nil, errs.Wrap(err, "Could not get requirements") } @@ -113,8 +109,8 @@ func (b *BuildScript) DependencyRequirements(targets ...string) ([]types.Require return deps, nil } -func (b *BuildScript) getRequirementsNode(targets ...string) (*Value, error) { - node, err := b.getSolveNode(targets...) +func (b *BuildScript) getRequirementsNode() (*Value, error) { + node, err := b.getSolveNode() if err != nil { return nil, errs.Wrap(err, "Could not get solve node") } @@ -151,23 +147,7 @@ func getVersionRequirements(v *Value) []types.VersionRequirement { return reqs } -func isSolveFuncName(name string) bool { - return name == solveFuncName || name == solveLegacyFuncName -} - -func (b *BuildScript) getTargetSolveNode(targets ...string) (*Value, error) { - if len(targets) == 0 { - for _, assignment := range b.raw.Assignments { - if assignment.Key != mainKey { - continue - } - if assignment.Value.Ident != nil && *assignment.Value.Ident != "" { - targets = []string{*assignment.Value.Ident} - break - } - } - } - +func (b *BuildScript) getSolveNode() (*Value, error) { var search func([]*Assignment) *Value search = func(assignments []*Assignment) *Value { var nextLet []*Assignment @@ -177,13 +157,7 @@ func (b *BuildScript) getTargetSolveNode(targets ...string) (*Value, error) { continue } - if funk.Contains(targets, a.Key) && a.Value.FuncCall != nil { - return a.Value - } - - if f := a.Value.FuncCall; len(targets) == 0 && f != nil && isSolveFuncName(f.Name) { - // This is coming from a complex build expression with no straightforward way to determine - // a default target. Fall back on a top-level solve node. + if f := a.Value.FuncCall; f != nil && (f.Name == solveFuncName || f.Name == solveLegacyFuncName) { return a.Value } } @@ -195,50 +169,15 @@ func (b *BuildScript) getTargetSolveNode(targets ...string) (*Value, error) { return nil } - if node := search(b.raw.Assignments); node != nil { return node, nil } - return nil, errNodeNotFound -} - -func (b *BuildScript) getSolveNode(targets ...string) (*Value, error) { - node, err := b.getTargetSolveNode(targets...) - if err != nil { - return nil, errs.Wrap(err, "Could not get target node") - } - - // If the target is the solve function, we're done. - if isSolveFuncName(node.FuncCall.Name) { - return node, nil - } - - // Otherwise, the "src" key contains a reference to the solve node. - // For example: - // - // runtime = state_tool_artifacts_v1(src = sources) - // sources = solve(at_time = ..., platforms = [...], requirements = [...], ...) - // - // Look over the build expression again for that referenced node. - for _, arg := range node.FuncCall.Arguments { - if arg.Assignment == nil { - continue - } - a := arg.Assignment - if a.Key == srcKey && a.Value.Ident != nil { - node, err := b.getSolveNode(*a.Value.Ident) - if err != nil { - return nil, errs.Wrap(err, "Could not get solve node from target") - } - return node, nil - } - } return nil, errNodeNotFound } -func (b *BuildScript) getSolveAtTimeValue(targets ...string) (*Value, error) { - node, err := b.getSolveNode(targets...) +func (b *BuildScript) getSolveAtTimeValue() (*Value, error) { + node, err := b.getSolveNode() if err != nil { return nil, errs.Wrap(err, "Could not get solve node") } @@ -252,8 +191,8 @@ func (b *BuildScript) getSolveAtTimeValue(targets ...string) (*Value, error) { return nil, errValueNotFound } -func (b *BuildScript) Platforms(targets ...string) ([]strfmt.UUID, error) { - node, err := b.getPlatformsNode(targets...) +func (b *BuildScript) Platforms() ([]strfmt.UUID, error) { + node, err := b.getPlatformsNode() if err != nil { return nil, errs.Wrap(err, "Could not get platform node") } @@ -265,8 +204,8 @@ func (b *BuildScript) Platforms(targets ...string) ([]strfmt.UUID, error) { return list, nil } -func (b *BuildScript) getPlatformsNode(targets ...string) (*Value, error) { - node, err := b.getSolveNode(targets...) +func (b *BuildScript) getPlatformsNode() (*Value, error) { + node, err := b.getSolveNode() if err != nil { return nil, errs.Wrap(err, "Could not get solve node") } diff --git a/pkg/buildscript/unmarshal.go b/pkg/buildscript/unmarshal.go index ffbab27f9e..8e3fbe8b03 100644 --- a/pkg/buildscript/unmarshal.go +++ b/pkg/buildscript/unmarshal.go @@ -50,15 +50,5 @@ func Unmarshal(data []byte) (*BuildScript, error) { break } - // Verify there are no duplicate key assignments. - // This is primarily to catch duplicate solve nodes for a given target. - seen := make(map[string]bool) - for _, assignment := range raw.Assignments { - if _, exists := seen[assignment.Key]; exists { - return nil, locale.NewInputError(locale.Tl("err_buildscript_duplicate_keys", "Build script has duplicate '{{.V0}}' assignments", assignment.Key)) - } - seen[assignment.Key] = true - } - return &BuildScript{raw}, nil } diff --git a/pkg/buildscript/unmarshal_buildexpression.go b/pkg/buildscript/unmarshal_buildexpression.go index 31da4efed8..7515205e10 100644 --- a/pkg/buildscript/unmarshal_buildexpression.go +++ b/pkg/buildscript/unmarshal_buildexpression.go @@ -102,6 +102,18 @@ func UnmarshalBuildExpression(data []byte, atTime *time.Time) (*BuildScript, err script.raw.AtTime = atTime } + // If the requirements are in legacy object form, e.g. + // requirements = [{"name": "", "namespace": ""}, {...}, ...] + // then transform them into function call form for the AScript format, e.g. + // requirements = [Req(name = "", namespace = ""), Req(...), ...] + requirements, err := script.getRequirementsNode() + if err != nil { + return nil, errs.Wrap(err, "Could not get requirements node") + } + if isLegacyRequirementsList(requirements) { + requirements.List = transformRequirements(requirements).List + } + return script, nil } @@ -258,13 +270,6 @@ func unmarshalFuncCall(path []string, m map[string]interface{}) (*FuncCall, erro if err != nil { return nil, errs.Wrap(err, "Could not parse '%s' function's argument '%s': %v", name, key, valueInterface) } - if key == requirementsKey && isSolveFuncName(name) && isLegacyRequirementsList(value) { - // If the requirements are in legacy object form, e.g. - // requirements = [{"name": "", "namespace": ""}, {...}, ...] - // then transform them into function call form for the AScript format, e.g. - // requirements = [Req(name = "", namespace = ""), Req(...), ...] - value.List = transformRequirements(value).List - } args = append(args, &Value{Assignment: &Assignment{key, value}}) } sort.SliceStable(args, func(i, j int) bool { return args[i].Assignment.Key < args[j].Assignment.Key })