From 0886f5b38edc44cf3589bdefc5d6560092ec6972 Mon Sep 17 00:00:00 2001 From: Peter Feerick <5500713+pfeerick@users.noreply.github.com> Date: Tue, 17 Nov 2026 20:22:09 +1000 Subject: [PATCH 1/6] feat(targets): limit option flag values to releases via value_constraints Option flag definitions (global or per tag) can now carry `value_constraints`, a map of value -> semver constraint. A constrained value is only accepted for releases matching the constraint: - build requests using it on other releases are rejected with "option flag not supported by release: = requires release , got " - each release exposes the values it excludes as `exclude_flags`, computed at load time like `exclude_targets` - constraints on values not listed in `values` fail to load targets.json limits AR (Arabic, colorlcd) to >= 3.0.0-0, since it does not exist before EdgeTX 3.0 and older color builds fail to compile. The UI hides excluded values for the selected release. Co-Authored-By: Claude Opus 5.5 --- artifactory/build_request.go | 16 +++ artifactory/build_request_test.go | 40 ++++++ targets.json | 5 +- targets/targets_def.go | 132 +++++++++++++++-- targets/targets_test.go | 171 +++++++++++++++++++++++ ui/src/components/jobs/JobCreateForm.tsx | 14 +- ui/src/hooks/useTargets.ts | 2 + 7 files changed, 366 insertions(+), 14 deletions(-) diff --git a/artifactory/build_request.go b/artifactory/build_request.go index a99b520..bd1a711 100644 --- a/artifactory/build_request.go +++ b/artifactory/build_request.go @@ -16,6 +16,8 @@ var ( ErrReleaseNotSupported = errors.New("release not supported") ErrTargetNotSupported = errors.New("target not supported") ErrOptionFlagNotSupported = errors.New("option flag not supported") + + ErrOptionFlagNotSupportedByRelease = errors.New("option flag not supported by release") ) type OptionFlag struct { @@ -43,6 +45,10 @@ func (e *BuildRequestError) Error() string { return fmt.Sprintf("%s: %s", e.Err.Error(), e.What) } +func (e *BuildRequestError) Unwrap() error { + return e.Err +} + func NewBuildRequest() *BuildRequest { return &BuildRequest{ defs: targets.GetTargets(), @@ -78,6 +84,16 @@ func (req *BuildRequest) Validate() error { What: flag.String(), } } + ok, constraint := req.defs.IsOptionFlagSupportedByRelease( + req.Target, flag.Name, flag.Value, req.Release, + ) + if !ok { + return &BuildRequestError{ + Err: ErrOptionFlagNotSupportedByRelease, + What: fmt.Sprintf("%s requires release %s, got %s", + flag.String(), constraint, req.Release), + } + } } return nil } diff --git a/artifactory/build_request_test.go b/artifactory/build_request_test.go index 71b55fe..a462978 100644 --- a/artifactory/build_request_test.go +++ b/artifactory/build_request_test.go @@ -4,6 +4,7 @@ import ( "testing" "github.com/edgetx/cloudbuild/artifactory" + "github.com/edgetx/cloudbuild/targets" "github.com/stretchr/testify/assert" ) @@ -36,3 +37,42 @@ func TestBuildHashIsTheSameForDiffOrderFlagArrays(t *testing.T) { assert.Equal(t, req1.HashTargetAndFlags(), req2.HashTargetAndFlags()) } + +func TestValidateOptionFlagRelease(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(`{ + "releases": { + "nightly": { "sha": "000", "sem_ver": "v3.0.0" }, + "v2.12.5": { "sha": "211" } + }, + "flags": { + "language": { "build_flag": "TRANSLATIONS", "values": ["EN"] } + }, + "tags": { + "colorlcd": { "flags": { "language": { + "values": ["AR"], "value_constraints": { "AR": ">= 3.0.0-0" } + }}} + }, + "targets": { + "tx16s": { "description": "TX16S", "tags": ["colorlcd"] }, + "x7": { "description": "X7" } + } + }`), "") + assert.Nil(t, err) + + prev := targets.GetTargets() + targets.SetTargets(defs) + defer targets.SetTargets(prev) + + ar := []artifactory.OptionFlag{{Name: "language", Value: "AR"}} + + assert.Nil(t, artifactory.NewBuildRequestWithParams("nightly", "tx16s", ar).Validate()) + + err = artifactory.NewBuildRequestWithParams("v2.12.5", "tx16s", ar).Validate() + assert.ErrorIs(t, err, artifactory.ErrOptionFlagNotSupportedByRelease) + assert.EqualError(t, err, + "option flag not supported by release: language=AR requires release >=3.0.0-0, got v2.12.5") + + // value unknown for the target: unchanged error + err = artifactory.NewBuildRequestWithParams("nightly", "x7", ar).Validate() + assert.ErrorIs(t, err, artifactory.ErrOptionFlagNotSupported) +} diff --git a/targets.json b/targets.json index a8501a5..98de9f4 100644 --- a/targets.json +++ b/targets.json @@ -138,7 +138,10 @@ "colorlcd": { "flags": { "language": { - "values": ["AR", "CN", "HE", "JP", "SK", "TW"] + "values": ["AR", "CN", "HE", "JP", "SK", "TW"], + "value_constraints": { + "AR": ">= 3.0.0-0" + } } } }, diff --git a/targets/targets_def.go b/targets/targets_def.go index a5bcb37..7d6c4b9 100644 --- a/targets/targets_def.go +++ b/targets/targets_def.go @@ -27,9 +27,10 @@ var ( // absurdly high version. NightlyVersion = semver.New(math.MaxUint64, 0, 0, "", "") - ErrMissingSHA = errors.New("missing SHA") - ErrMissingRef = errors.New("missing ref") - ErrInvalidSchema = errors.New("invalid URL schema") + ErrMissingSHA = errors.New("missing SHA") + ErrMissingRef = errors.New("missing ref") + ErrInvalidSchema = errors.New("invalid URL schema") + ErrInvalidValueConstraint = errors.New("value constraint for undefined value") ) type RemoteAPI struct { @@ -40,8 +41,11 @@ type RemoteAPI struct { type Release struct { SHA string `json:"sha"` ExcludeTargets []string `json:"exclude_targets,omitempty"` - BuildContainer string `json:"build_container,omitempty"` - SemVer string `json:"sem_ver,omitempty"` + // ExcludeFlags maps an option flag name to the values that this release + // does not support (computed from OptionFlag.ValueConstraints). + ExcludeFlags map[string][]string `json:"exclude_flags,omitempty"` + BuildContainer string `json:"build_container,omitempty"` + SemVer string `json:"sem_ver,omitempty"` update bool version *semver.Version } @@ -49,6 +53,10 @@ type Release struct { type OptionFlag struct { BuildFlag string `json:"build_flag,omitempty"` Values []string `json:"values"` + // ValueConstraints optionally limits individual values to the releases + // matching a semver constraint (e.g. {"AR": ">= 3.0.0-0"}). Values + // without an entry are supported by every release. + ValueConstraints map[string]semver.Constraints `json:"value_constraints,omitempty"` } type BuildFlags map[string]string @@ -167,6 +175,26 @@ func (opts OptionFlags) HasOptionValue(name, value string) bool { return false } +// supportsRelease reports whether value may be used with release r. +func (opt *OptionFlag) supportsRelease(value string, r *Release) bool { + if c, ok := opt.ValueConstraints[value]; ok { + return c.Check(r.version) + } + return true +} + +func (opts OptionFlags) validateValueConstraints(scope string) error { + for name, opt := range opts { + for value := range opt.ValueConstraints { + if !slices.Contains(opt.Values, value) { + return fmt.Errorf("%s: flag %q, value %q: %w", + scope, name, value, ErrInvalidValueConstraint) + } + } + } + return nil +} + func (target *Target) SupportsRelease(r *Release) bool { if len(target.VersionSupported.String()) > 0 { return target.VersionSupported.Check(r.version) @@ -186,7 +214,11 @@ func (def *TargetsDef) UnmarshalJSON(text []byte) error { if err := tmp.fillSemVer(); err != nil { return err } + if err := tmp.validateValueConstraints(); err != nil { + return err + } tmp.fillExcludeTargets() + tmp.fillExcludeFlags() *def = tmp return nil @@ -244,6 +276,47 @@ func (def *TargetsDef) fillExcludeTargets() { } } +func (def *TargetsDef) validateValueConstraints() error { + if err := def.OptionFlags.validateValueConstraints("flags"); err != nil { + return err + } + for name, tag := range def.Tags { + if err := tag.Flags.validateValueConstraints("tags." + name); err != nil { + return err + } + } + return nil +} + +// fillExcludeFlags computes Release.ExcludeFlags: for each release, the flag +// values (global or from any tag) whose value constraint excludes it. +func (def *TargetsDef) fillExcludeFlags() { + for k := range def.Releases { + r := def.Releases[k] + r.ExcludeFlags = nil + exclude := func(opts OptionFlags) { + for name, opt := range opts { + for value := range opt.ValueConstraints { + if !opt.supportsRelease(value, r) { + if r.ExcludeFlags == nil { + r.ExcludeFlags = make(map[string][]string) + } + r.ExcludeFlags[name] = append(r.ExcludeFlags[name], value) + } + } + } + } + exclude(def.OptionFlags) + for _, tag := range def.Tags { + exclude(tag.Flags) + } + for name, values := range r.ExcludeFlags { + slices.Sort(values) + r.ExcludeFlags[name] = slices.Compact(values) + } + } +} + func (def *TargetsDef) fillSemVer() error { for k := range def.Releases { r := def.Releases[k] @@ -285,23 +358,58 @@ func (def *TargetsDef) IsTargetSupported(name, ref string) bool { return target.SupportsRelease(r) } -func (def *TargetsDef) IsOptionFlagSupported(target, name, value string) bool { - if def.OptionFlags.HasOptionValue(name, value) { - return true +// optionFlagDefs returns the definitions of flag name that apply to target: +// the global one first (if any), followed by those of the target's tags. +func (def *TargetsDef) optionFlagDefs(target, name string) []OptionFlag { + defs := make([]OptionFlag, 0, 1) + if opt, ok := def.OptionFlags[name]; ok { + defs = append(defs, opt) } - if t, ok := def.Targets[target]; ok { for _, tag := range t.Tags { - tagDef, ok := def.Tags[tag] - if ok && tagDef.Flags.HasOptionValue(name, value) { - return true + if tagDef, ok := def.Tags[tag]; ok { + if opt, ok := tagDef.Flags[name]; ok { + defs = append(defs, opt) + } } } } + return defs +} +// IsOptionFlagSupported reports whether value is a known value of flag name +// for target, regardless of the release. +func (def *TargetsDef) IsOptionFlagSupported(target, name, value string) bool { + for _, opt := range def.optionFlagDefs(target, name) { + if slices.Contains(opt.Values, value) { + return true + } + } return false } +// IsOptionFlagSupportedByRelease reports whether value of flag name may be +// used for target at release ref, i.e. no applicable definition listing that +// value has a constraint excluding the release. When it may not, the +// offending constraint is returned (empty if ref is unknown). +func (def *TargetsDef) IsOptionFlagSupportedByRelease(target, name, value, ref string) (bool, string) { + v, err := NewVersionRef(ref) + if err != nil { + return false, "" + } + r, ok := def.Releases[*v] + if !ok { + return false, "" + } + for _, opt := range def.optionFlagDefs(target, name) { + if slices.Contains(opt.Values, value) && !opt.supportsRelease(value, r) { + c := opt.ValueConstraints[value] + return false, c.String() + } + } + return true, "" +} + func (def *TargetsDef) GetCommitHashByRef(ref string) string { v, err := NewVersionRef(ref) if err != nil { diff --git a/targets/targets_test.go b/targets/targets_test.go index 63ca1fa..4cd55a9 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -1,6 +1,9 @@ package targets_test import ( + "encoding/json" + "os" + "slices" "testing" semver "github.com/Masterminds/semver/v3" @@ -124,3 +127,171 @@ func TestExcludeTargets(t *testing.T) { assert.Nil(t, err) assert.Equal(t, []string{"t123", "x123"}, excl) } + +var flagConstraintsJSON = `{ + "releases": { + "nightly": { "sha": "000", "sem_ver": "v3.0.0" }, + "v3.0.0": { "sha": "300" }, + "v3.0.0-rc1": { "sha": "301" }, + "v2.12.6-rc1": { "sha": "212" }, + "v2.12.5": { "sha": "211" } + }, + "flags": { + "language": { + "build_flag": "TRANSLATIONS", + "values": ["EN", "FR"], + "value_constraints": { "FR": "< 2.12.5" } + } + }, + "tags": { + "colorlcd": { + "flags": { + "language": { + "values": ["AR", "CN"], + "value_constraints": { "AR": ">= 3.0.0-0" } + } + } + } + }, + "targets": { + "color": { "description": "Color radio", "tags": ["colorlcd"] }, + "bw": { "description": "B&W radio" } + } +}` + +func TestOptionFlagValueConstraints(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") + assert.Nil(t, err) + + tests := []struct { + target, value, ref string + supported bool + constraint string + }{ + // unconstrained values work everywhere + {"color", "CN", "v2.12.5", true, ""}, + {"color", "EN", "v2.12.5", true, ""}, + // AR only from 3.0.0, including its pre-releases and nightly + {"color", "AR", "v2.12.5", false, ">=3.0.0-0"}, + {"color", "AR", "v2.12.6-rc1", false, ">=3.0.0-0"}, + {"color", "AR", "v3.0.0-rc1", true, ""}, + {"color", "AR", "v3.0.0", true, ""}, + {"color", "AR", "nightly", true, ""}, + // global value constraints apply to every target + {"bw", "FR", "v2.12.5", false, "<2.12.5"}, + {"color", "FR", "nightly", false, "<2.12.5"}, + // unknown release + {"color", "CN", "v9.9.9", false, ""}, + } + for _, tt := range tests { + ok, c := defs.IsOptionFlagSupportedByRelease(tt.target, "language", tt.value, tt.ref) + assert.Equal(t, tt.supported, ok, "%s %s@%s", tt.target, tt.value, tt.ref) + assert.Equal(t, tt.constraint, c, "%s %s@%s", tt.target, tt.value, tt.ref) + } + + // release-independent check is unchanged + assert.True(t, defs.IsOptionFlagSupported("color", "language", "AR")) + assert.False(t, defs.IsOptionFlagSupported("bw", "language", "AR")) +} + +func TestExcludeFlags(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") + assert.Nil(t, err) + + assert.Equal(t, map[string][]string{"language": {"AR", "FR"}}, defs.Releases[ref(t, "v2.12.5")].ExcludeFlags) + assert.Equal(t, map[string][]string{"language": {"AR", "FR"}}, defs.Releases[ref(t, "v2.12.6-rc1")].ExcludeFlags) + assert.Equal(t, map[string][]string{"language": {"FR"}}, defs.Releases[ref(t, "v3.0.0-rc1")].ExcludeFlags) + assert.Equal(t, map[string][]string{"language": {"FR"}}, defs.Releases[ref(t, "nightly")].ExcludeFlags) + + // no constraints: no exclude_flags at all + defs, err = targets.ReadTargetsDefFromBytes([]byte(targetsJSON), "") + assert.Nil(t, err) + for _, r := range defs.Releases { + assert.Nil(t, r.ExcludeFlags) + } +} + +func TestValueConstraintsJSON(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") + assert.Nil(t, err) + + data, err := json.Marshal(defs) + assert.Nil(t, err) + + var out struct { + Releases map[string]struct { + ExcludeFlags map[string][]string `json:"exclude_flags"` + } `json:"releases"` + Tags map[string]struct { + Flags map[string]map[string]any `json:"flags"` + } `json:"tags"` + } + assert.Nil(t, json.Unmarshal(data, &out)) + assert.Equal(t, []string{"AR", "FR"}, out.Releases["v2.12.5"].ExcludeFlags["language"]) + assert.Equal(t, + map[string]any{"AR": ">=3.0.0-0"}, + out.Tags["colorlcd"].Flags["language"]["value_constraints"]) + + // flags without constraints don't grow a new field + defs, err = targets.ReadTargetsDefFromBytes([]byte(targetsJSON), "") + assert.Nil(t, err) + data, err = json.Marshal(defs) + assert.Nil(t, err) + assert.NotContains(t, string(data), "value_constraints") + assert.NotContains(t, string(data), "exclude_flags") +} + +func TestInvalidValueConstraints(t *testing.T) { + undefinedValue := `{ + "releases": { "v1.0.0": { "sha": "1" } }, + "tags": { "colorlcd": { "flags": { "language": { + "values": ["CN"], "value_constraints": { "AR": ">= 3.0.0-0" } + }}}} + }` + _, err := targets.ReadTargetsDefFromBytes([]byte(undefinedValue), "") + assert.ErrorIs(t, err, targets.ErrInvalidValueConstraint) + + badConstraint := `{ + "releases": { "v1.0.0": { "sha": "1" } }, + "flags": { "language": { + "values": ["AR"], "value_constraints": { "AR": "not a constraint" } + }} + }` + _, err = targets.ReadTargetsDefFromBytes([]byte(badConstraint), "") + assert.NotNil(t, err) +} + +// The shipped targets.json must load, and AR must be limited to >= 3.0.0. +func TestShippedTargetsJSON(t *testing.T) { + data, err := os.ReadFile("../targets.json") + assert.Nil(t, err) + + // json.Unmarshal rather than ReadTargetsDefFromBytes: releases have no + // SHA in the file, they are resolved from the git repo at runtime. + var defs targets.TargetsDef + assert.Nil(t, json.Unmarshal(data, &defs)) + + var color string + for name, target := range defs.Targets { + if slices.Contains(target.Tags, "colorlcd") { + color = name + break + } + } + assert.NotEmpty(t, color) + + for k, r := range defs.Releases { + ok, _ := defs.IsOptionFlagSupportedByRelease(color, "language", "AR", k.String()) + v, err := semver.NewVersion(k.String()) + want := k.String() == "nightly" || (err == nil && v.Major() >= 3) + assert.Equal(t, want, ok, "AR @ %s", k.String()) + assert.Equal(t, want, !slices.Contains(r.ExcludeFlags["language"], "AR"), "exclude_flags @ %s", k.String()) + } +} + +func ref(t *testing.T, s string) targets.VersionRef { + t.Helper() + r, err := targets.NewVersionRef(s) + assert.Nil(t, err) + return *r +} diff --git a/ui/src/components/jobs/JobCreateForm.tsx b/ui/src/components/jobs/JobCreateForm.tsx index 0be1857..ef280de 100644 --- a/ui/src/components/jobs/JobCreateForm.tsx +++ b/ui/src/components/jobs/JobCreateForm.tsx @@ -178,9 +178,21 @@ function JobCreateForm({ messageApi, onFinish }: Props) { flags[key].values = Array.from(valueSet.values()); } } + + // remove values not supported by the selected release + const excludeFlags = targets?.releases[currentRelease]?.exclude_flags ?? {}; + for (const [key, excluded] of Object.entries(excludeFlags)) { + if (!Object.hasOwn(flags, key)) continue; + const values = flags[key].values.filter((v) => !excluded.includes(v)); + if (values.length > 0) { + flags[key] = { ...flags[key], values }; + } else { + delete flags[key]; + } + } return flags; }, - [targets, currentTarget] + [targets, currentTarget, currentRelease] ); const [selectedFlags, setSelectedFlags] = useState([]); diff --git a/ui/src/hooks/useTargets.ts b/ui/src/hooks/useTargets.ts index eb55463..121795f 100644 --- a/ui/src/hooks/useTargets.ts +++ b/ui/src/hooks/useTargets.ts @@ -5,6 +5,8 @@ import { useQuery } from "@tanstack/react-query"; interface Release { sha: string; exclude_targets?: string[]; + // flag name -> values not supported by this release + exclude_flags?: Record; } interface Tag { From 8b8d063ad54fd7fb24f39ea886c1c41981daed9a Mon Sep 17 00:00:00 2001 From: Peter Feerick <5500713+pfeerick@users.noreply.github.com> Date: Tue, 17 Nov 2026 20:27:12 +1000 Subject: [PATCH 2/6] feat(targets): limit HE, RU, UA and KO to the releases that have them Per EdgeTX's RADIO_LANGUAGES (radio/src/CMakeLists.txt): - HE first appears in 2.9.0 - RU and UA first appear in 2.10.0 - KO first appears in 2.11.0 v2.8.5 and v2.9.4 are still offered, so builds with these languages on older releases are now refused. 2.12 added no new radio languages. Co-Authored-By: Claude Opus 5.5 --- targets.json | 10 ++++++++-- targets/targets_test.go | 33 ++++++++++++++++++++++++++------- 2 files changed, 34 insertions(+), 9 deletions(-) diff --git a/targets.json b/targets.json index 98de9f4..731650f 100644 --- a/targets.json +++ b/targets.json @@ -95,7 +95,12 @@ "RU", "SE", "UA" - ] + ], + "value_constraints": { + "KO": ">= 2.11.0-0", + "RU": ">= 2.10.0-0", + "UA": ">= 2.10.0-0" + } }, "fai_mode": { "build_flag": "FAI", @@ -140,7 +145,8 @@ "language": { "values": ["AR", "CN", "HE", "JP", "SK", "TW"], "value_constraints": { - "AR": ">= 3.0.0-0" + "AR": ">= 3.0.0-0", + "HE": ">= 2.9.0-0" } } } diff --git a/targets/targets_test.go b/targets/targets_test.go index 4cd55a9..3826efd 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -261,7 +261,9 @@ func TestInvalidValueConstraints(t *testing.T) { assert.NotNil(t, err) } -// The shipped targets.json must load, and AR must be limited to >= 3.0.0. +// The shipped targets.json must load, and languages must only be offered +// from the release where they appear in EdgeTX's RADIO_LANGUAGES +// (radio/src/CMakeLists.txt). func TestShippedTargetsJSON(t *testing.T) { data, err := os.ReadFile("../targets.json") assert.Nil(t, err) @@ -280,13 +282,30 @@ func TestShippedTargetsJSON(t *testing.T) { } assert.NotEmpty(t, color) - for k, r := range defs.Releases { - ok, _ := defs.IsOptionFlagSupportedByRelease(color, "language", "AR", k.String()) - v, err := semver.NewVersion(k.String()) - want := k.String() == "nightly" || (err == nil && v.Major() >= 3) - assert.Equal(t, want, ok, "AR @ %s", k.String()) - assert.Equal(t, want, !slices.Contains(r.ExcludeFlags["language"], "AR"), "exclude_flags @ %s", k.String()) + // language -> first EdgeTX release that has it + firstRelease := map[string]string{ + "HE": "2.9.0", + "RU": "2.10.0", + "UA": "2.10.0", + "KO": "2.11.0", + "AR": "3.0.0", } + for lang, first := range firstRelease { + minVersion := semver.MustParse(first) + for k, r := range defs.Releases { + v, err := semver.NewVersion(k.String()) + want := k.String() == "nightly" || (err == nil && !v.LessThan(minVersion)) + ok, _ := defs.IsOptionFlagSupportedByRelease(color, "language", lang, k.String()) + assert.Equal(t, want, ok, "%s @ %s", lang, k.String()) + assert.Equal(t, want, !slices.Contains(r.ExcludeFlags["language"], lang), + "exclude_flags %s @ %s", lang, k.String()) + } + } + + // older releases are still offered, so the limits above are exercised + oldest, err := targets.NewVersionRef("v2.8.5") + assert.Nil(t, err) + assert.Contains(t, defs.Releases, *oldest) } func ref(t *testing.T, s string) targets.VersionRef { From 6374806aad3f2fbce577b5891df1dec9f6e4c433 Mon Sep 17 00:00:00 2001 From: Peter <5500713+pfeerick@users.noreply.github.com> Date: Tue, 17 Nov 2026 20:59:53 +1000 Subject: [PATCH 3/6] fix(targets): KO is a colour LCD only language Korean support (EdgeTX/edgetx#6118, "feat(color): ...") only added LVGL fonts; there is no B&W (stdlcd) Korean font, so B&W builds can't render it. Move KO from the global language values to the colorlcd tag, keeping its >= 2.11.0-0 limit. Co-Authored-By: Claude Opus 5.5 --- targets.json | 7 +++---- targets/targets_test.go | 11 +++++++++++ 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/targets.json b/targets.json index 731650f..15452d6 100644 --- a/targets.json +++ b/targets.json @@ -88,7 +88,6 @@ "FI", "FR", "IT", - "KO", "NL", "PL", "PT", @@ -97,7 +96,6 @@ "UA" ], "value_constraints": { - "KO": ">= 2.11.0-0", "RU": ">= 2.10.0-0", "UA": ">= 2.10.0-0" } @@ -143,10 +141,11 @@ "colorlcd": { "flags": { "language": { - "values": ["AR", "CN", "HE", "JP", "SK", "TW"], + "values": ["AR", "CN", "HE", "JP", "KO", "SK", "TW"], "value_constraints": { "AR": ">= 3.0.0-0", - "HE": ">= 2.9.0-0" + "HE": ">= 2.9.0-0", + "KO": ">= 2.11.0-0" } } } diff --git a/targets/targets_test.go b/targets/targets_test.go index 3826efd..5895b74 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -302,6 +302,17 @@ func TestShippedTargetsJSON(t *testing.T) { } } + // languages without B&W (stdlcd) fonts must only be offered to colour + // targets, e.g. KO only has LVGL fonts (EdgeTX/edgetx#6118) + colorOnly := []string{"AR", "CN", "HE", "JP", "KO", "SK", "TW"} + for name, target := range defs.Targets { + isColor := slices.Contains(target.Tags, "colorlcd") + for _, lang := range colorOnly { + assert.Equal(t, isColor, defs.IsOptionFlagSupported(name, "language", lang), + "%s on %s", lang, name) + } + } + // older releases are still offered, so the limits above are exercised oldest, err := targets.NewVersionRef("v2.8.5") assert.Nil(t, err) From 4148e60803c7944de10f224902b6680348f894b2 Mon Sep 17 00:00:00 2001 From: Peter <5500713+pfeerick@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:36:17 +1000 Subject: [PATCH 4/6] refactor(targets): rename value_constraints to version_supported Use the same name for flag value limits as for target limits, so targets.json reads consistently: `version_supported` is a constraint on a target, and a map from value to constraint on a flag. Document version_supported, exclude_targets and exclude_flags in the README and the public API doc, including the `-0` rule for constraints that should match pre-releases and how to remove a whole flag from some releases. Co-Authored-By: Claude Opus 5.5 --- README.md | 43 +++++++++++++++++++++++++++++++ artifactory/build_request_test.go | 2 +- doc/PublicAPI.md | 11 ++++++++ targets.json | 4 +-- targets/targets_def.go | 36 +++++++++++++------------- targets/targets_test.go | 40 ++++++++++++++++++---------- 6 files changed, 102 insertions(+), 34 deletions(-) diff --git a/README.md b/README.md index 0d46dfb..797a571 100644 --- a/README.md +++ b/README.md @@ -164,3 +164,46 @@ EBUILD_TARGETS=http://local-mirror:8080/gitweb.cgi?p=EdgeTX/cloudbuild.git;a=blo # This is the default refresh interval in seconds EBUILD_TARGETS_REFRESH_INTERVAL=300 ``` + +## Limiting targets and flag values to releases + +Some radios and option values only exist in some EdgeTX releases. In +`targets.json`, `version_supported` limits them with a +[semver constraint](https://github.com/Masterminds/semver#checking-version-constraints), +checked against each release's version (`sem_ver` if set, e.g. `nightly`): + +```json +"targets": { + "newradio": { "description": "Example New Radio", "version_supported": ">= 3.0.0-0" } +}, +"tags": { + "colorlcd": { + "flags": { + "language": { + "values": ["AR", "CN"], + "version_supported": { "AR": ">= 3.0.0-0" } + } + } + } +} +``` + +- On a target it's a single constraint. On a flag (global or under a tag) + it's a map from value to constraint, and values without an entry are + supported by every release. Each key must be listed in `values`. +- To remove a whole flag from some releases, constrain every one of its + values (e.g. `{"YES": "< 3.0.0-0", "NO": "< 3.0.0-0"}`). Clients drop a + flag with no values left. Remember to constrain any value added later too. +- Build requests that use an unsupported target or value for the requested + release are rejected. +- The API exposes the result per release as `exclude_targets` and + `exclude_flags`, so clients can hide what a release can't build. + +**Add `-0` to the version in minimum constraints** (`>= 3.0.0-0`, not +`>= 3.0.0`) when pre-releases should be included. A constraint without a +pre-release part never matches pre-releases, so if `v3.0.0-rc1` is listed +in `releases`, `>= 3.0.0` excludes it (and every other pre-release). +`-0` is the lowest possible pre-release, so `>= 3.0.0-0` matches all 3.0 +pre-releases as well as `v3.0.0` and later. This only matters for releases +with a pre-release version: `nightly` uses `sem_ver` (e.g. `v3.0.0`), which +isn't one. diff --git a/artifactory/build_request_test.go b/artifactory/build_request_test.go index a462978..f66a1b1 100644 --- a/artifactory/build_request_test.go +++ b/artifactory/build_request_test.go @@ -49,7 +49,7 @@ func TestValidateOptionFlagRelease(t *testing.T) { }, "tags": { "colorlcd": { "flags": { "language": { - "values": ["AR"], "value_constraints": { "AR": ">= 3.0.0-0" } + "values": ["AR"], "version_supported": { "AR": ">= 3.0.0-0" } }}} }, "targets": { diff --git a/doc/PublicAPI.md b/doc/PublicAPI.md index 33b78c7..3910afa 100644 --- a/doc/PublicAPI.md +++ b/doc/PublicAPI.md @@ -7,6 +7,17 @@ This endpoint allows for retrieving the supported targets and build options. It returns the configured `targets.json` (see [here](../targets.json)). +Each release also includes what it can't build, computed from the +`version_supported` constraints (see the +[README](../README.md#limiting-targets-and-flag-values-to-releases)): + +- `exclude_targets`: targets not supported by this release. +- `exclude_flags`: option flag values not supported by this release, as a map + from flag name to values, e.g. `{"language": ["AR"]}`. + +Both are omitted when empty. Clients should hide these for the selected +release; build requests using them are rejected. + #### CURL ```sh diff --git a/targets.json b/targets.json index 15452d6..8665b78 100644 --- a/targets.json +++ b/targets.json @@ -95,7 +95,7 @@ "SE", "UA" ], - "value_constraints": { + "version_supported": { "RU": ">= 2.10.0-0", "UA": ">= 2.10.0-0" } @@ -142,7 +142,7 @@ "flags": { "language": { "values": ["AR", "CN", "HE", "JP", "KO", "SK", "TW"], - "value_constraints": { + "version_supported": { "AR": ">= 3.0.0-0", "HE": ">= 2.9.0-0", "KO": ">= 2.11.0-0" diff --git a/targets/targets_def.go b/targets/targets_def.go index 7d6c4b9..d10dc5b 100644 --- a/targets/targets_def.go +++ b/targets/targets_def.go @@ -27,10 +27,10 @@ var ( // absurdly high version. NightlyVersion = semver.New(math.MaxUint64, 0, 0, "", "") - ErrMissingSHA = errors.New("missing SHA") - ErrMissingRef = errors.New("missing ref") - ErrInvalidSchema = errors.New("invalid URL schema") - ErrInvalidValueConstraint = errors.New("value constraint for undefined value") + ErrMissingSHA = errors.New("missing SHA") + ErrMissingRef = errors.New("missing ref") + ErrInvalidSchema = errors.New("invalid URL schema") + ErrInvalidVersionSupported = errors.New("version_supported for undefined value") ) type RemoteAPI struct { @@ -42,7 +42,7 @@ type Release struct { SHA string `json:"sha"` ExcludeTargets []string `json:"exclude_targets,omitempty"` // ExcludeFlags maps an option flag name to the values that this release - // does not support (computed from OptionFlag.ValueConstraints). + // does not support (computed from OptionFlag.VersionSupported). ExcludeFlags map[string][]string `json:"exclude_flags,omitempty"` BuildContainer string `json:"build_container,omitempty"` SemVer string `json:"sem_ver,omitempty"` @@ -53,10 +53,10 @@ type Release struct { type OptionFlag struct { BuildFlag string `json:"build_flag,omitempty"` Values []string `json:"values"` - // ValueConstraints optionally limits individual values to the releases + // VersionSupported optionally limits individual values to the releases // matching a semver constraint (e.g. {"AR": ">= 3.0.0-0"}). Values // without an entry are supported by every release. - ValueConstraints map[string]semver.Constraints `json:"value_constraints,omitempty"` + VersionSupported map[string]semver.Constraints `json:"version_supported,omitempty"` } type BuildFlags map[string]string @@ -177,18 +177,18 @@ func (opts OptionFlags) HasOptionValue(name, value string) bool { // supportsRelease reports whether value may be used with release r. func (opt *OptionFlag) supportsRelease(value string, r *Release) bool { - if c, ok := opt.ValueConstraints[value]; ok { + if c, ok := opt.VersionSupported[value]; ok { return c.Check(r.version) } return true } -func (opts OptionFlags) validateValueConstraints(scope string) error { +func (opts OptionFlags) validateVersionSupported(scope string) error { for name, opt := range opts { - for value := range opt.ValueConstraints { + for value := range opt.VersionSupported { if !slices.Contains(opt.Values, value) { return fmt.Errorf("%s: flag %q, value %q: %w", - scope, name, value, ErrInvalidValueConstraint) + scope, name, value, ErrInvalidVersionSupported) } } } @@ -214,7 +214,7 @@ func (def *TargetsDef) UnmarshalJSON(text []byte) error { if err := tmp.fillSemVer(); err != nil { return err } - if err := tmp.validateValueConstraints(); err != nil { + if err := tmp.validateVersionSupported(); err != nil { return err } tmp.fillExcludeTargets() @@ -276,12 +276,12 @@ func (def *TargetsDef) fillExcludeTargets() { } } -func (def *TargetsDef) validateValueConstraints() error { - if err := def.OptionFlags.validateValueConstraints("flags"); err != nil { +func (def *TargetsDef) validateVersionSupported() error { + if err := def.OptionFlags.validateVersionSupported("flags"); err != nil { return err } for name, tag := range def.Tags { - if err := tag.Flags.validateValueConstraints("tags." + name); err != nil { + if err := tag.Flags.validateVersionSupported("tags." + name); err != nil { return err } } @@ -289,14 +289,14 @@ func (def *TargetsDef) validateValueConstraints() error { } // fillExcludeFlags computes Release.ExcludeFlags: for each release, the flag -// values (global or from any tag) whose value constraint excludes it. +// values (global or from any tag) whose version_supported constraint excludes it. func (def *TargetsDef) fillExcludeFlags() { for k := range def.Releases { r := def.Releases[k] r.ExcludeFlags = nil exclude := func(opts OptionFlags) { for name, opt := range opts { - for value := range opt.ValueConstraints { + for value := range opt.VersionSupported { if !opt.supportsRelease(value, r) { if r.ExcludeFlags == nil { r.ExcludeFlags = make(map[string][]string) @@ -403,7 +403,7 @@ func (def *TargetsDef) IsOptionFlagSupportedByRelease(target, name, value, ref s } for _, opt := range def.optionFlagDefs(target, name) { if slices.Contains(opt.Values, value) && !opt.supportsRelease(value, r) { - c := opt.ValueConstraints[value] + c := opt.VersionSupported[value] return false, c.String() } } diff --git a/targets/targets_test.go b/targets/targets_test.go index 5895b74..6205f7b 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -140,7 +140,7 @@ var flagConstraintsJSON = `{ "language": { "build_flag": "TRANSLATIONS", "values": ["EN", "FR"], - "value_constraints": { "FR": "< 2.12.5" } + "version_supported": { "FR": "< 2.12.5" } } }, "tags": { @@ -148,7 +148,7 @@ var flagConstraintsJSON = `{ "flags": { "language": { "values": ["AR", "CN"], - "value_constraints": { "AR": ">= 3.0.0-0" } + "version_supported": { "AR": ">= 3.0.0-0" } } } } @@ -159,7 +159,7 @@ var flagConstraintsJSON = `{ } }` -func TestOptionFlagValueConstraints(t *testing.T) { +func TestOptionFlagVersionSupported(t *testing.T) { defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") assert.Nil(t, err) @@ -177,7 +177,7 @@ func TestOptionFlagValueConstraints(t *testing.T) { {"color", "AR", "v3.0.0-rc1", true, ""}, {"color", "AR", "v3.0.0", true, ""}, {"color", "AR", "nightly", true, ""}, - // global value constraints apply to every target + // global version_supported constraints apply to every target {"bw", "FR", "v2.12.5", false, "<2.12.5"}, {"color", "FR", "nightly", false, "<2.12.5"}, // unknown release @@ -211,7 +211,7 @@ func TestExcludeFlags(t *testing.T) { } } -func TestValueConstraintsJSON(t *testing.T) { +func TestFlagVersionSupportedJSON(t *testing.T) { defs, err := targets.ReadTargetsDefFromBytes([]byte(flagConstraintsJSON), "") assert.Nil(t, err) @@ -230,31 +230,45 @@ func TestValueConstraintsJSON(t *testing.T) { assert.Equal(t, []string{"AR", "FR"}, out.Releases["v2.12.5"].ExcludeFlags["language"]) assert.Equal(t, map[string]any{"AR": ">=3.0.0-0"}, - out.Tags["colorlcd"].Flags["language"]["value_constraints"]) + out.Tags["colorlcd"].Flags["language"]["version_supported"]) - // flags without constraints don't grow a new field - defs, err = targets.ReadTargetsDefFromBytes([]byte(targetsJSON), "") + // flags without constraints don't grow a new field, and releases don't + // get exclude_flags (targets have their own, unrelated version_supported) + defs, err = targets.ReadTargetsDefFromBytes([]byte(`{ + "releases": { "v1.0.0": { "sha": "1" } }, + "flags": { "language": { "build_flag": "TRANSLATIONS", "values": ["EN"] } }, + "tags": { "colorlcd": { "flags": { "language": { "values": ["CN"] } } } }, + "targets": { "t1": { "description": "T1", "tags": ["colorlcd"] } } + }`), "") assert.Nil(t, err) data, err = json.Marshal(defs) assert.Nil(t, err) - assert.NotContains(t, string(data), "value_constraints") + var plain struct { + Flags map[string]map[string]any `json:"flags"` + Tags map[string]struct { + Flags map[string]map[string]any `json:"flags"` + } `json:"tags"` + } + assert.Nil(t, json.Unmarshal(data, &plain)) + assert.NotContains(t, plain.Flags["language"], "version_supported") + assert.NotContains(t, plain.Tags["colorlcd"].Flags["language"], "version_supported") assert.NotContains(t, string(data), "exclude_flags") } -func TestInvalidValueConstraints(t *testing.T) { +func TestInvalidFlagVersionSupported(t *testing.T) { undefinedValue := `{ "releases": { "v1.0.0": { "sha": "1" } }, "tags": { "colorlcd": { "flags": { "language": { - "values": ["CN"], "value_constraints": { "AR": ">= 3.0.0-0" } + "values": ["CN"], "version_supported": { "AR": ">= 3.0.0-0" } }}}} }` _, err := targets.ReadTargetsDefFromBytes([]byte(undefinedValue), "") - assert.ErrorIs(t, err, targets.ErrInvalidValueConstraint) + assert.ErrorIs(t, err, targets.ErrInvalidVersionSupported) badConstraint := `{ "releases": { "v1.0.0": { "sha": "1" } }, "flags": { "language": { - "values": ["AR"], "value_constraints": { "AR": "not a constraint" } + "values": ["AR"], "version_supported": { "AR": "not a constraint" } }} }` _, err = targets.ReadTargetsDefFromBytes([]byte(badConstraint), "") From f4b762416d89f57877b04e15193706eafc11a511 Mon Sep 17 00:00:00 2001 From: Peter <5500713+pfeerick@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:48:38 +1000 Subject: [PATCH 5/6] feat(targets): limit whole flags to releases, drop power_led_blue from 3.0 A flag's `version_supported` is now a single constraint for the whole flag, like a target's, so a flag can be removed from some releases without listing every value. Per-value limits move to `values_version_supported`. The two can be combined: a value is supported only if both allow the release. A flag with every value excluded is reported in exclude_flags with all its values, so clients drop it without any change. POWER_LED_BLUE was removed in EdgeTX 3.0, so limit power_led_blue to releases before 3.0.0 (nightly included in the exclusion). Co-Authored-By: Claude Opus 5.5 --- README.md | 62 +++++++---- artifactory/build_request_test.go | 15 ++- doc/PublicAPI.md | 2 +- targets.json | 7 +- targets/targets_def.go | 66 +++++++----- targets/targets_test.go | 165 +++++++++++++++++++++++++----- 6 files changed, 234 insertions(+), 83 deletions(-) diff --git a/README.md b/README.md index 797a571..e78d21c 100644 --- a/README.md +++ b/README.md @@ -167,43 +167,61 @@ EBUILD_TARGETS_REFRESH_INTERVAL=300 ## Limiting targets and flag values to releases -Some radios and option values only exist in some EdgeTX releases. In -`targets.json`, `version_supported` limits them with a -[semver constraint](https://github.com/Masterminds/semver#checking-version-constraints), +Some radios, options and option values only exist in some EdgeTX releases. +In `targets.json` they can be limited with +[semver constraints](https://github.com/Masterminds/semver#checking-version-constraints), checked against each release's version (`sem_ver` if set, e.g. `nightly`): +| Field | On | Limits | +|---|---|---| +| `version_supported` | a target | the target | +| `version_supported` | a flag | the whole flag, i.e. every value in that definition | +| `values_version_supported` | a flag | individual values, as a map from value to constraint | + ```json "targets": { "newradio": { "description": "Example New Radio", "version_supported": ">= 3.0.0-0" } }, +"flags": { + "power_led_blue": { + "build_flag": "POWER_LED_BLUE", + "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" + } +}, "tags": { "colorlcd": { "flags": { "language": { "values": ["AR", "CN"], - "version_supported": { "AR": ">= 3.0.0-0" } + "values_version_supported": { "AR": ">= 3.0.0-0" } } } } } ``` -- On a target it's a single constraint. On a flag (global or under a tag) - it's a map from value to constraint, and values without an entry are - supported by every release. Each key must be listed in `values`. -- To remove a whole flag from some releases, constrain every one of its - values (e.g. `{"YES": "< 3.0.0-0", "NO": "< 3.0.0-0"}`). Clients drop a - flag with no values left. Remember to constrain any value added later too. -- Build requests that use an unsupported target or value for the requested - release are rejected. +- A flag's `version_supported` and `values_version_supported` can be + combined: a value is supported only if both allow the release. Keys of + `values_version_supported` must be listed in `values`. +- Flags are defined globally and per tag. A constraint only applies to the + definition it's in, so a flag defined in several places is limited in + each. +- Build requests that use an unsupported target, flag or value for the + requested release are rejected. - The API exposes the result per release as `exclude_targets` and - `exclude_flags`, so clients can hide what a release can't build. - -**Add `-0` to the version in minimum constraints** (`>= 3.0.0-0`, not -`>= 3.0.0`) when pre-releases should be included. A constraint without a -pre-release part never matches pre-releases, so if `v3.0.0-rc1` is listed -in `releases`, `>= 3.0.0` excludes it (and every other pre-release). -`-0` is the lowest possible pre-release, so `>= 3.0.0-0` matches all 3.0 -pre-releases as well as `v3.0.0` and later. This only matters for releases -with a pre-release version: `nightly` uses `sem_ver` (e.g. `v3.0.0`), which -isn't one. + `exclude_flags`, so clients can hide what a release can't build. A flag + with all its values excluded is dropped by clients. + +**Use `-0` on the version in constraints** (`>= 3.0.0-0`, `< 3.0.0-0`) +when pre-releases should follow the same rule as releases. A constraint +without a pre-release part never matches pre-releases, so if pre-releases +are listed in `releases`: + +- `>= 3.0.0` excludes `v3.0.0-rc1`; `>= 3.0.0-0` includes it. +- `< 3.0.0` also excludes `v2.12.6-rc1`; `< 3.0.0-0` includes 2.x + pre-releases and excludes 3.0 ones. + +`-0` is the lowest possible pre-release, so `3.0.0-0` sits just before every +3.0 pre-release. This only matters for releases with a pre-release version: +`nightly` uses `sem_ver` (e.g. `v3.0.0`), which isn't one. diff --git a/artifactory/build_request_test.go b/artifactory/build_request_test.go index f66a1b1..2febc03 100644 --- a/artifactory/build_request_test.go +++ b/artifactory/build_request_test.go @@ -45,11 +45,15 @@ func TestValidateOptionFlagRelease(t *testing.T) { "v2.12.5": { "sha": "211" } }, "flags": { - "language": { "build_flag": "TRANSLATIONS", "values": ["EN"] } + "language": { "build_flag": "TRANSLATIONS", "values": ["EN"] }, + "power_led_blue": { + "build_flag": "POWER_LED_BLUE", "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" + } }, "tags": { "colorlcd": { "flags": { "language": { - "values": ["AR"], "version_supported": { "AR": ">= 3.0.0-0" } + "values": ["AR"], "values_version_supported": { "AR": ">= 3.0.0-0" } }}} }, "targets": { @@ -75,4 +79,11 @@ func TestValidateOptionFlagRelease(t *testing.T) { // value unknown for the target: unchanged error err = artifactory.NewBuildRequestWithParams("nightly", "x7", ar).Validate() assert.ErrorIs(t, err, artifactory.ErrOptionFlagNotSupported) + + // whole flag limited to releases before 3.0 + blue := []artifactory.OptionFlag{{Name: "power_led_blue", Value: "NO"}} + assert.Nil(t, artifactory.NewBuildRequestWithParams("v2.12.5", "x7", blue).Validate()) + err = artifactory.NewBuildRequestWithParams("nightly", "x7", blue).Validate() + assert.EqualError(t, err, + "option flag not supported by release: power_led_blue=NO requires release <3.0.0-0, got nightly") } diff --git a/doc/PublicAPI.md b/doc/PublicAPI.md index 3910afa..8abf3d4 100644 --- a/doc/PublicAPI.md +++ b/doc/PublicAPI.md @@ -8,7 +8,7 @@ This endpoint allows for retrieving the supported targets and build options. It returns the configured `targets.json` (see [here](../targets.json)). Each release also includes what it can't build, computed from the -`version_supported` constraints (see the +`version_supported` and `values_version_supported` constraints (see the [README](../README.md#limiting-targets-and-flag-values-to-releases)): - `exclude_targets`: targets not supported by this release. diff --git a/targets.json b/targets.json index 8665b78..129d8df 100644 --- a/targets.json +++ b/targets.json @@ -95,7 +95,7 @@ "SE", "UA" ], - "version_supported": { + "values_version_supported": { "RU": ">= 2.10.0-0", "UA": ">= 2.10.0-0" } @@ -110,7 +110,8 @@ }, "power_led_blue": { "build_flag": "POWER_LED_BLUE", - "values": ["YES", "NO"] + "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" }, "pxx1": { "build_flag": "PXX1", @@ -142,7 +143,7 @@ "flags": { "language": { "values": ["AR", "CN", "HE", "JP", "KO", "SK", "TW"], - "version_supported": { + "values_version_supported": { "AR": ">= 3.0.0-0", "HE": ">= 2.9.0-0", "KO": ">= 2.11.0-0" diff --git a/targets/targets_def.go b/targets/targets_def.go index d10dc5b..c0654f9 100644 --- a/targets/targets_def.go +++ b/targets/targets_def.go @@ -27,10 +27,10 @@ var ( // absurdly high version. NightlyVersion = semver.New(math.MaxUint64, 0, 0, "", "") - ErrMissingSHA = errors.New("missing SHA") - ErrMissingRef = errors.New("missing ref") - ErrInvalidSchema = errors.New("invalid URL schema") - ErrInvalidVersionSupported = errors.New("version_supported for undefined value") + ErrMissingSHA = errors.New("missing SHA") + ErrMissingRef = errors.New("missing ref") + ErrInvalidSchema = errors.New("invalid URL schema") + ErrInvalidValuesVersionSupported = errors.New("values_version_supported for undefined value") ) type RemoteAPI struct { @@ -42,7 +42,7 @@ type Release struct { SHA string `json:"sha"` ExcludeTargets []string `json:"exclude_targets,omitempty"` // ExcludeFlags maps an option flag name to the values that this release - // does not support (computed from OptionFlag.VersionSupported). + // does not support (computed from the OptionFlag version constraints). ExcludeFlags map[string][]string `json:"exclude_flags,omitempty"` BuildContainer string `json:"build_container,omitempty"` SemVer string `json:"sem_ver,omitempty"` @@ -53,10 +53,14 @@ type Release struct { type OptionFlag struct { BuildFlag string `json:"build_flag,omitempty"` Values []string `json:"values"` - // VersionSupported optionally limits individual values to the releases - // matching a semver constraint (e.g. {"AR": ">= 3.0.0-0"}). Values - // without an entry are supported by every release. - VersionSupported map[string]semver.Constraints `json:"version_supported,omitempty"` + // VersionSupported optionally limits the whole flag (every value in this + // definition) to the releases matching a semver constraint, like + // Target.VersionSupported (e.g. "< 3.0.0-0"). + VersionSupported *semver.Constraints `json:"version_supported,omitempty"` + // ValuesVersionSupported optionally limits individual values, as a map + // from value to constraint (e.g. {"AR": ">= 3.0.0-0"}). Values without an + // entry are only limited by VersionSupported. + ValuesVersionSupported map[string]semver.Constraints `json:"values_version_supported,omitempty"` } type BuildFlags map[string]string @@ -175,20 +179,25 @@ func (opts OptionFlags) HasOptionValue(name, value string) bool { return false } -// supportsRelease reports whether value may be used with release r. -func (opt *OptionFlag) supportsRelease(value string, r *Release) bool { - if c, ok := opt.VersionSupported[value]; ok { - return c.Check(r.version) +// releaseConstraint reports whether value may be used with release r. When +// it may not, the constraint that excludes it is returned: the whole-flag +// one first, then the value's own. +func (opt *OptionFlag) releaseConstraint(value string, r *Release) (bool, string) { + if opt.VersionSupported != nil && !opt.VersionSupported.Check(r.version) { + return false, opt.VersionSupported.String() } - return true + if c, ok := opt.ValuesVersionSupported[value]; ok && !c.Check(r.version) { + return false, c.String() + } + return true, "" } -func (opts OptionFlags) validateVersionSupported(scope string) error { +func (opts OptionFlags) validateValuesVersionSupported(scope string) error { for name, opt := range opts { - for value := range opt.VersionSupported { + for value := range opt.ValuesVersionSupported { if !slices.Contains(opt.Values, value) { return fmt.Errorf("%s: flag %q, value %q: %w", - scope, name, value, ErrInvalidVersionSupported) + scope, name, value, ErrInvalidValuesVersionSupported) } } } @@ -214,7 +223,7 @@ func (def *TargetsDef) UnmarshalJSON(text []byte) error { if err := tmp.fillSemVer(); err != nil { return err } - if err := tmp.validateVersionSupported(); err != nil { + if err := tmp.validateValuesVersionSupported(); err != nil { return err } tmp.fillExcludeTargets() @@ -276,12 +285,12 @@ func (def *TargetsDef) fillExcludeTargets() { } } -func (def *TargetsDef) validateVersionSupported() error { - if err := def.OptionFlags.validateVersionSupported("flags"); err != nil { +func (def *TargetsDef) validateValuesVersionSupported() error { + if err := def.OptionFlags.validateValuesVersionSupported("flags"); err != nil { return err } for name, tag := range def.Tags { - if err := tag.Flags.validateVersionSupported("tags." + name); err != nil { + if err := tag.Flags.validateValuesVersionSupported("tags." + name); err != nil { return err } } @@ -289,15 +298,16 @@ func (def *TargetsDef) validateVersionSupported() error { } // fillExcludeFlags computes Release.ExcludeFlags: for each release, the flag -// values (global or from any tag) whose version_supported constraint excludes it. +// values (global or from any tag) excluded by their flag's version_supported +// or their own values_version_supported constraint. func (def *TargetsDef) fillExcludeFlags() { for k := range def.Releases { r := def.Releases[k] r.ExcludeFlags = nil exclude := func(opts OptionFlags) { for name, opt := range opts { - for value := range opt.VersionSupported { - if !opt.supportsRelease(value, r) { + for _, value := range opt.Values { + if ok, _ := opt.releaseConstraint(value, r); !ok { if r.ExcludeFlags == nil { r.ExcludeFlags = make(map[string][]string) } @@ -402,9 +412,11 @@ func (def *TargetsDef) IsOptionFlagSupportedByRelease(target, name, value, ref s return false, "" } for _, opt := range def.optionFlagDefs(target, name) { - if slices.Contains(opt.Values, value) && !opt.supportsRelease(value, r) { - c := opt.VersionSupported[value] - return false, c.String() + if !slices.Contains(opt.Values, value) { + continue + } + if ok, c := opt.releaseConstraint(value, r); !ok { + return false, c } } return true, "" diff --git a/targets/targets_test.go b/targets/targets_test.go index 6205f7b..1f8d9f8 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -140,7 +140,7 @@ var flagConstraintsJSON = `{ "language": { "build_flag": "TRANSLATIONS", "values": ["EN", "FR"], - "version_supported": { "FR": "< 2.12.5" } + "values_version_supported": { "FR": "< 2.12.5" } } }, "tags": { @@ -148,7 +148,7 @@ var flagConstraintsJSON = `{ "flags": { "language": { "values": ["AR", "CN"], - "version_supported": { "AR": ">= 3.0.0-0" } + "values_version_supported": { "AR": ">= 3.0.0-0" } } } } @@ -230,7 +230,7 @@ func TestFlagVersionSupportedJSON(t *testing.T) { assert.Equal(t, []string{"AR", "FR"}, out.Releases["v2.12.5"].ExcludeFlags["language"]) assert.Equal(t, map[string]any{"AR": ">=3.0.0-0"}, - out.Tags["colorlcd"].Flags["language"]["version_supported"]) + out.Tags["colorlcd"].Flags["language"]["values_version_supported"]) // flags without constraints don't grow a new field, and releases don't // get exclude_flags (targets have their own, unrelated version_supported) @@ -250,51 +250,149 @@ func TestFlagVersionSupportedJSON(t *testing.T) { } `json:"tags"` } assert.Nil(t, json.Unmarshal(data, &plain)) - assert.NotContains(t, plain.Flags["language"], "version_supported") - assert.NotContains(t, plain.Tags["colorlcd"].Flags["language"], "version_supported") + for _, key := range []string{"version_supported", "values_version_supported"} { + assert.NotContains(t, plain.Flags["language"], key) + assert.NotContains(t, plain.Tags["colorlcd"].Flags["language"], key) + } assert.NotContains(t, string(data), "exclude_flags") } +var wholeFlagJSON = `{ + "releases": { + "nightly": { "sha": "0", "sem_ver": "v3.0.0" }, + "v3.0.0-rc1": { "sha": "1" }, + "v2.12.6-rc1": { "sha": "2" }, + "v2.12.5": { "sha": "3" }, + "v2.10.6": { "sha": "4" } + }, + "flags": { + "power_led_blue": { + "build_flag": "POWER_LED_BLUE", + "values": ["YES", "NO"], + "version_supported": "< 3.0.0-0" + }, + "new_opt": { + "build_flag": "NEW_OPT", + "values": ["YES", "NO", "X"], + "version_supported": ">= 2.12.0-0", + "values_version_supported": { "X": ">= 3.0.0-0" } + } + }, + "targets": { "t": { "description": "T" } } +}` + +func TestWholeFlagVersionSupported(t *testing.T) { + defs, err := targets.ReadTargetsDefFromBytes([]byte(wholeFlagJSON), "") + assert.Nil(t, err) + + tests := []struct { + flag, value, ref string + supported bool + constraint string + }{ + // whole flag removed from 3.0, pre-releases included + {"power_led_blue", "YES", "v2.12.5", true, ""}, + {"power_led_blue", "NO", "v2.12.6-rc1", true, ""}, + {"power_led_blue", "YES", "v3.0.0-rc1", false, "<3.0.0-0"}, + {"power_led_blue", "NO", "nightly", false, "<3.0.0-0"}, + // flag from 2.12 plus one value from 3.0: the flag limit is checked first + {"new_opt", "YES", "v2.10.6", false, ">=2.12.0-0"}, + {"new_opt", "X", "v2.10.6", false, ">=2.12.0-0"}, + {"new_opt", "YES", "v2.12.5", true, ""}, + {"new_opt", "X", "v2.12.5", false, ">=3.0.0-0"}, + {"new_opt", "X", "nightly", true, ""}, + } + for _, tt := range tests { + ok, c := defs.IsOptionFlagSupportedByRelease("t", tt.flag, tt.value, tt.ref) + assert.Equal(t, tt.supported, ok, "%s=%s @ %s", tt.flag, tt.value, tt.ref) + assert.Equal(t, tt.constraint, c, "%s=%s @ %s", tt.flag, tt.value, tt.ref) + } + + // clients drop a flag whose values are all excluded + excl := func(release string) map[string][]string { + return defs.Releases[ref(t, release)].ExcludeFlags + } + assert.Equal(t, map[string][]string{"new_opt": {"NO", "X", "YES"}}, excl("v2.10.6")) + assert.Equal(t, map[string][]string{"new_opt": {"X"}}, excl("v2.12.5")) + assert.Equal(t, map[string][]string{"power_led_blue": {"NO", "YES"}}, excl("nightly")) + + // served as a plain string, like a target's version_supported + data, err := json.Marshal(defs) + assert.Nil(t, err) + var out struct { + Flags map[string]map[string]any `json:"flags"` + } + assert.Nil(t, json.Unmarshal(data, &out)) + assert.Equal(t, "<3.0.0-0", out.Flags["power_led_blue"]["version_supported"]) + assert.NotContains(t, out.Flags["power_led_blue"], "values_version_supported") + + // invalid whole-flag constraints fail to load + _, err = targets.ReadTargetsDefFromBytes([]byte(`{ + "releases": { "v1.0.0": { "sha": "1" } }, + "flags": { "f": { "values": ["YES"], "version_supported": "not a constraint" } } + }`), "") + assert.NotNil(t, err) +} + func TestInvalidFlagVersionSupported(t *testing.T) { undefinedValue := `{ "releases": { "v1.0.0": { "sha": "1" } }, "tags": { "colorlcd": { "flags": { "language": { - "values": ["CN"], "version_supported": { "AR": ">= 3.0.0-0" } + "values": ["CN"], "values_version_supported": { "AR": ">= 3.0.0-0" } }}}} }` _, err := targets.ReadTargetsDefFromBytes([]byte(undefinedValue), "") - assert.ErrorIs(t, err, targets.ErrInvalidVersionSupported) + assert.ErrorIs(t, err, targets.ErrInvalidValuesVersionSupported) badConstraint := `{ "releases": { "v1.0.0": { "sha": "1" } }, "flags": { "language": { - "values": ["AR"], "version_supported": { "AR": "not a constraint" } + "values": ["AR"], "values_version_supported": { "AR": "not a constraint" } }} }` _, err = targets.ReadTargetsDefFromBytes([]byte(badConstraint), "") assert.NotNil(t, err) } -// The shipped targets.json must load, and languages must only be offered -// from the release where they appear in EdgeTX's RADIO_LANGUAGES -// (radio/src/CMakeLists.txt). -func TestShippedTargetsJSON(t *testing.T) { +// loadShippedTargets loads the shipped targets.json. json.Unmarshal rather +// than ReadTargetsDefFromBytes: releases have no SHA in the file, they are +// resolved from the git repo at runtime. +func loadShippedTargets(t *testing.T) *targets.TargetsDef { + t.Helper() data, err := os.ReadFile("../targets.json") assert.Nil(t, err) - - // json.Unmarshal rather than ReadTargetsDefFromBytes: releases have no - // SHA in the file, they are resolved from the git repo at runtime. var defs targets.TargetsDef assert.Nil(t, json.Unmarshal(data, &defs)) - var color string + // older releases are still offered, so the limits tested are exercised + oldest, err := targets.NewVersionRef("v2.8.5") + assert.Nil(t, err) + assert.Contains(t, defs.Releases, *oldest) + return &defs +} + +func colorTarget(t *testing.T, defs *targets.TargetsDef) string { + t.Helper() for name, target := range defs.Targets { if slices.Contains(target.Tags, "colorlcd") { - color = name - break + return name } } - assert.NotEmpty(t, color) + t.Fatal("no colorlcd target") + return "" +} + +// isAtLeast reports whether release ref is >= minVersion (nightly always is). +func isAtLeast(ref string, minVersion *semver.Version) bool { + v, err := semver.NewVersion(ref) + return ref == "nightly" || (err == nil && !v.LessThan(minVersion)) +} + +// Languages must only be offered from the release where they appear in +// EdgeTX's RADIO_LANGUAGES (radio/src/CMakeLists.txt). +func TestShippedTargetsLanguageReleases(t *testing.T) { + defs := loadShippedTargets(t) + color := colorTarget(t, defs) // language -> first EdgeTX release that has it firstRelease := map[string]string{ @@ -307,17 +405,19 @@ func TestShippedTargetsJSON(t *testing.T) { for lang, first := range firstRelease { minVersion := semver.MustParse(first) for k, r := range defs.Releases { - v, err := semver.NewVersion(k.String()) - want := k.String() == "nightly" || (err == nil && !v.LessThan(minVersion)) + want := isAtLeast(k.String(), minVersion) ok, _ := defs.IsOptionFlagSupportedByRelease(color, "language", lang, k.String()) assert.Equal(t, want, ok, "%s @ %s", lang, k.String()) assert.Equal(t, want, !slices.Contains(r.ExcludeFlags["language"], lang), "exclude_flags %s @ %s", lang, k.String()) } } +} - // languages without B&W (stdlcd) fonts must only be offered to colour - // targets, e.g. KO only has LVGL fonts (EdgeTX/edgetx#6118) +// Languages without B&W (stdlcd) fonts must only be offered to colour +// targets, e.g. KO only has LVGL fonts (EdgeTX/edgetx#6118). +func TestShippedTargetsColorOnlyLanguages(t *testing.T) { + defs := loadShippedTargets(t) colorOnly := []string{"AR", "CN", "HE", "JP", "KO", "SK", "TW"} for name, target := range defs.Targets { isColor := slices.Contains(target.Tags, "colorlcd") @@ -326,13 +426,22 @@ func TestShippedTargetsJSON(t *testing.T) { "%s on %s", lang, name) } } - - // older releases are still offered, so the limits above are exercised - oldest, err := targets.NewVersionRef("v2.8.5") - assert.Nil(t, err) - assert.Contains(t, defs.Releases, *oldest) } +// POWER_LED_BLUE was removed in EdgeTX 3.0. +func TestShippedTargetsPowerLedBlue(t *testing.T) { + defs := loadShippedTargets(t) + v3 := semver.MustParse("3.0.0-0") + for k, r := range defs.Releases { + want := !isAtLeast(k.String(), v3) + for _, value := range []string{"YES", "NO"} { + ok, _ := defs.IsOptionFlagSupportedByRelease("x9d", "power_led_blue", value, k.String()) + assert.Equal(t, want, ok, "power_led_blue=%s @ %s", value, k.String()) + } + assert.Equal(t, want, len(r.ExcludeFlags["power_led_blue"]) == 0, + "exclude_flags power_led_blue @ %s", k.String()) + } +} func ref(t *testing.T, s string) targets.VersionRef { t.Helper() r, err := targets.NewVersionRef(s) From 7ddaf3d3e1cca909e003068692c4ce8eba8c4b3c Mon Sep 17 00:00:00 2001 From: Peter <5500713+pfeerick@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:51:59 +1000 Subject: [PATCH 6/6] fix(targets): kcx_btaudio is only available from EdgeTX 3.0 KCX_BTAUDIO was added to the TX15 and TX16S MK3 targets on main (EdgeTX/edgetx#6777, #7056) and isn't in any 2.12 release; the 2.12.6 backports (EdgeTX/edgetx#8070) note it's main-only. On 2.12, CMake ignores the unknown option, so the build succeeds without the feature. Limit the flag to releases from 3.0.0. Co-Authored-By: Claude Opus 5.5 --- targets.json | 3 ++- targets/targets_test.go | 32 +++++++++++++++++++++++--------- 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/targets.json b/targets.json index 129d8df..2c728e5 100644 --- a/targets.json +++ b/targets.json @@ -187,7 +187,8 @@ "flags": { "kcx_btaudio": { "build_flag": "KCX_BTAUDIO", - "values": ["YES"] + "values": ["YES"], + "version_supported": ">= 3.0.0-0" } } } diff --git a/targets/targets_test.go b/targets/targets_test.go index 1f8d9f8..e4e3878 100644 --- a/targets/targets_test.go +++ b/targets/targets_test.go @@ -428,18 +428,32 @@ func TestShippedTargetsColorOnlyLanguages(t *testing.T) { } } -// POWER_LED_BLUE was removed in EdgeTX 3.0. -func TestShippedTargetsPowerLedBlue(t *testing.T) { +// Whole flags that only exist in some EdgeTX releases. +func TestShippedTargetsFlagReleases(t *testing.T) { defs := loadShippedTargets(t) v3 := semver.MustParse("3.0.0-0") - for k, r := range defs.Releases { - want := !isAtLeast(k.String(), v3) - for _, value := range []string{"YES", "NO"} { - ok, _ := defs.IsOptionFlagSupportedByRelease("x9d", "power_led_blue", value, k.String()) - assert.Equal(t, want, ok, "power_led_blue=%s @ %s", value, k.String()) + tests := []struct { + flag, target string + values []string + supported func(ref string) bool + }{ + // POWER_LED_BLUE was removed in EdgeTX 3.0 + {"power_led_blue", "x9d", []string{"YES", "NO"}, + func(ref string) bool { return !isAtLeast(ref, v3) }}, + // KCX BT audio is main-only (EdgeTX/edgetx#6777, #7056), not in 2.12 + {"kcx_btaudio", "tx15", []string{"YES"}, + func(ref string) bool { return isAtLeast(ref, v3) }}, + } + for _, tt := range tests { + for k, r := range defs.Releases { + want := tt.supported(k.String()) + for _, value := range tt.values { + ok, _ := defs.IsOptionFlagSupportedByRelease(tt.target, tt.flag, value, k.String()) + assert.Equal(t, want, ok, "%s=%s @ %s", tt.flag, value, k.String()) + } + assert.Equal(t, want, len(r.ExcludeFlags[tt.flag]) == 0, + "exclude_flags %s @ %s", tt.flag, k.String()) } - assert.Equal(t, want, len(r.ExcludeFlags["power_led_blue"]) == 0, - "exclude_flags power_led_blue @ %s", k.String()) } } func ref(t *testing.T, s string) targets.VersionRef {