more log for '_installComponent'

github0null · web-flow · commit b0965018de45 · 2024-08-21T16:56:04.000+08:00
diff --git a/src/DependenceManager.ts b/src/DependenceManager.ts
@@ -79,31 +79,35 @@ export class DependenceManager implements ManagerInterface {
 
         /* 安装此组件的依赖项 */
         if (component.condition) {
-            const result = packageManager.CheckConditionRequire(component.condition, toolchain);
-            if (result == false)
+            // check and get dependences
+            let depList: string[] = [];
+            try {
+                depList= packageManager.checkComponentRequirement(component.condition, toolchain);
+            } catch (error) {
+                GlobalEvent.emit('globalLog.append', `[Warn] ${(<Error>error).message}\n`);
                 throw new Error(`Condition '${component.condition}' is not fit for this component: '${component.groupName}'`);
-            if (Array.isArray(result)) {
-                for (const fullname of result) {
-                    if (!fullname.startsWith('Device.'))
-                        continue; /* 排除非 Device 类型的组件 */
-                    const reqName  = fullname.replace('Device.', '');
-                    const compList = packageManager.FindAllComponents(reqName);
-                    if (compList) {
-                        for (const item of compList) {
-                            if (this.isInstalled(packName, item.groupName))
-                                continue; /* 排除已安装的 */
-                            if (pendingList.includes(item.groupName))
-                                continue; /* 排除队列中已存在的 */
-                            pendingList.push(item.groupName);
-                            GlobalEvent.emit('globalLog.append', `[Info] ${' '.repeat(pendingList.length)}-> install dependence component: ${item.groupName}\n`);
-                            this._installComponent(packName, item, pendingList);
-                            pendingList.pop();
-                        }
-                    } else {
-                        //throw new Error(`Not found required sub component: '${comp}'`);
-                        GlobalEvent.emit('globalLog.append',
-                            `[Warn] ${' '.repeat(pendingList.length)}Not found required sub component: '${reqName}'\n`);
+            }
+            // try install dependences
+            for (const fullname of depList) {
+                if (!fullname.startsWith('Device.'))
+                    continue; /* 排除非 Device 类型的组件 */
+                const reqName  = fullname.replace('Device.', '');
+                const compList = packageManager.FindAllComponents(reqName);
+                if (compList) {
+                    for (const item of compList) {
+                        if (this.isInstalled(packName, item.groupName))
+                            continue; /* 排除已安装的 */
+                        if (pendingList.includes(item.groupName))
+                            continue; /* 排除队列中已存在的 */
+                        pendingList.push(item.groupName);
+                        GlobalEvent.emit('globalLog.append', `[Info] ${' '.repeat(pendingList.length)}-> install dependence component: ${item.groupName}\n`);
+                        this._installComponent(packName, item, pendingList);
+                        pendingList.pop();
                     }
+                } else {
+                    //throw new Error(`Not found required sub component: '${comp}'`);
+                    GlobalEvent.emit('globalLog.append',
+                        `[Warn] ${' '.repeat(pendingList.length)}Not found required sub component: '${reqName}'\n`);
                 }
             }
         }
diff --git a/src/PackageManager.ts b/src/PackageManager.ts
@@ -326,35 +326,36 @@ export class PackageManager {
         this.packRootDir = new File(this.project.ToAbsolutePath(PackageManager.PACK_DIR));
     }
 
-    private _checkConditionGroup(gMap: ConditionMap,
-        cGroup: ConditionGroup, cDev: CurrentDevice, comp_requires: string[], toolchain?: IToolchian): boolean {
+    private _checkConditionGroup(gMap: ConditionMap, 
+        cGroup: ConditionGroup, cDev: CurrentDevice, 
+        comp_requires: string[], toolchain?: IToolchian): void {
 
         const familyInfo = cDev.packInfo.familyList[cDev.familyIndex];
         const devInfo = this.getCurrentDevInfo(cDev);
 
         if (devInfo == undefined) {
-            return false;
+            throw new Error(`No such device info: deviceIndex=${cDev.deviceIndex}`);
         }
 
         for (const con of cGroup.requireList) {
 
             if (toolchain) {
 
                 if (con.compiler && con.compiler !== toolchain.categoryName) {
-                    return false;
+                    throw new Error(`Compiler category '${toolchain.categoryName}' not match, expect: ${con.compiler}`);
                 }
 
                 if (con.compilerOption && con.compilerOption !== toolchain.name) {
-                    return false;
+                    throw new Error(`Compiler name '${toolchain.name}' not match, expect: ${con.compilerOption}`);
                 }
             }
 
             if (con.Dvendor && con.Dvendor !== familyInfo.vendor) {
-                return false;
+                throw new Error(`Family vendor '${familyInfo.vendor}' not match, expect: ${con.Dvendor}`);
             }
 
             if (con.Dname && !con.Dname.test(devInfo.name)) {
-                return false;
+                throw new Error(`Device name '${devInfo.name}' not match, expect: ${con.Dname}`);
             }
 
             if (con.component) {
@@ -365,18 +366,16 @@ export class PackageManager {
                 const _group = gMap.get(con.condition);
                 if (_group) {
                     this._recurseList.push(con.condition);
-                    if (!this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain)) {
-                        return false;
-                    }
+                    this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain);
                 }
             }
         }
 
         if (cGroup.acceptList.length === 0) {
-            return true;
+            return;
         }
 
-        // return true, if one passed
+        // return, if one passed
         let passCount = 0;
         for (const con of cGroup.acceptList) {
 
@@ -418,8 +417,11 @@ export class PackageManager {
                 const _group = gMap.get(con.condition);
                 if (_group) {
                     this._recurseList.push(con.condition);
-                    if (this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain)) {
+                    try {
+                        this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain);
                         passCount++;
+                    } catch (error) {
+                        // nothing todo for accept condition
                     }
                 } else {
                     passCount++;
@@ -429,11 +431,11 @@ export class PackageManager {
             }
 
             if (passCount === 5) {
-                return true;
+                return;
             }
         }
 
-        return false;
+        throw new Error(`Not match any 'accept' conditions !`);
     }
 
     CheckCondition(conditionName: string, toolchain: IToolchian): boolean {
@@ -443,27 +445,32 @@ export class PackageManager {
             const cGroup = cMap.get(conditionName);
             if (cGroup) {
                 this._recurseList = [conditionName];
-                return this._checkConditionGroup(cMap, cGroup, this.currentDevice, [], toolchain);
+                try {
+                    this._checkConditionGroup(cMap, cGroup, this.currentDevice, [], toolchain);
+                    return true;
+                } catch (error) {
+                    return false;
+                }
             }
         }
 
         return true;
     }
 
-    CheckConditionRequire(conditionName: string, toolchain: IToolchian): string[] | boolean {
+    checkComponentRequirement(conditionName: string, toolchain: IToolchian): string[] {
 
         if (this.currentDevice) {
             const cMap = this.currentDevice.packInfo.conditionMap;
             const cGroup = cMap.get(conditionName);
             if (cGroup) {
-                this._recurseList = [conditionName];
                 const components: string[] = [];
-                const pass = this._checkConditionGroup(cMap, cGroup, this.currentDevice, components, toolchain);
-                return pass ? ArrayDelRepetition(components) : false;
+                this._recurseList = [conditionName];
+                this._checkConditionGroup(cMap, cGroup, this.currentDevice, components, toolchain);
+                return ArrayDelRepetition(components);
             }
         }
 
-        return true;
+        return [];
     }
 
     makeComponentGroupName(...names: string[]): string {

Original file line number	Diff line number	Diff line change
`@@ -326,35 +326,36 @@ export class PackageManager {`
`326`	`326`	`this.packRootDir = new File(this.project.ToAbsolutePath(PackageManager.PACK_DIR));`
`327`	`327`	`}`
`328`	`328`
`329`		`- private _checkConditionGroup(gMap: ConditionMap,`
`330`		`- cGroup: ConditionGroup, cDev: CurrentDevice, comp_requires: string[], toolchain?: IToolchian): boolean {`
	`329`	`+ private _checkConditionGroup(gMap: ConditionMap,`
	`330`	`+ cGroup: ConditionGroup, cDev: CurrentDevice,`
	`331`	`+ comp_requires: string[], toolchain?: IToolchian): void {`
`331`	`332`
`332`	`333`	`const familyInfo = cDev.packInfo.familyList[cDev.familyIndex];`
`333`	`334`	`const devInfo = this.getCurrentDevInfo(cDev);`
`334`	`335`
`335`	`336`	`if (devInfo == undefined) {`
`336`		`- return false;`
	`337`	+ throw new Error(`No such device info: deviceIndex=${cDev.deviceIndex}`);
`337`	`338`	`}`
`338`	`339`
`339`	`340`	`for (const con of cGroup.requireList) {`
`340`	`341`
`341`	`342`	`if (toolchain) {`
`342`	`343`
`343`	`344`	`if (con.compiler && con.compiler !== toolchain.categoryName) {`
`344`		`- return false;`
	`345`	+ throw new Error(`Compiler category '${toolchain.categoryName}' not match, expect: ${con.compiler}`);
`345`	`346`	`}`
`346`	`347`
`347`	`348`	`if (con.compilerOption && con.compilerOption !== toolchain.name) {`
`348`		`- return false;`
	`349`	+ throw new Error(`Compiler name '${toolchain.name}' not match, expect: ${con.compilerOption}`);
`349`	`350`	`}`
`350`	`351`	`}`
`351`	`352`
`352`	`353`	`if (con.Dvendor && con.Dvendor !== familyInfo.vendor) {`
`353`		`- return false;`
	`354`	+ throw new Error(`Family vendor '${familyInfo.vendor}' not match, expect: ${con.Dvendor}`);
`354`	`355`	`}`
`355`	`356`
`356`	`357`	`if (con.Dname && !con.Dname.test(devInfo.name)) {`
`357`		`- return false;`
	`358`	+ throw new Error(`Device name '${devInfo.name}' not match, expect: ${con.Dname}`);
`358`	`359`	`}`
`359`	`360`
`360`	`361`	`if (con.component) {`
`@@ -365,18 +366,16 @@ export class PackageManager {`
`365`	`366`	`const _group = gMap.get(con.condition);`
`366`	`367`	`if (_group) {`
`367`	`368`	`this._recurseList.push(con.condition);`
`368`		`- if (!this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain)) {`
`369`		`- return false;`
`370`		`- }`
	`369`	`+ this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain);`
`371`	`370`	`}`
`372`	`371`	`}`
`373`	`372`	`}`
`374`	`373`
`375`	`374`	`if (cGroup.acceptList.length === 0) {`
`376`		`- return true;`
	`375`	`+ return;`
`377`	`376`	`}`
`378`	`377`
`379`		`- // return true, if one passed`
	`378`	`+ // return, if one passed`
`380`	`379`	`let passCount = 0;`
`381`	`380`	`for (const con of cGroup.acceptList) {`
`382`	`381`
`@@ -418,8 +417,11 @@ export class PackageManager {`
`418`	`417`	`const _group = gMap.get(con.condition);`
`419`	`418`	`if (_group) {`
`420`	`419`	`this._recurseList.push(con.condition);`
`421`		`- if (this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain)) {`
	`420`	`+ try {`
	`421`	`+ this._checkConditionGroup(gMap, _group, cDev, comp_requires, toolchain);`
`422`	`422`	`passCount++;`
	`423`	`+ } catch (error) {`
	`424`	`+ // nothing todo for accept condition`
`423`	`425`	`}`
`424`	`426`	`} else {`
`425`	`427`	`passCount++;`
`@@ -429,11 +431,11 @@ export class PackageManager {`
`429`	`431`	`}`
`430`	`432`
`431`	`433`	`if (passCount === 5) {`
`432`		`- return true;`
	`434`	`+ return;`
`433`	`435`	`}`
`434`	`436`	`}`
`435`	`437`
`436`		`- return false;`
	`438`	+ throw new Error(`Not match any 'accept' conditions !`);
`437`	`439`	`}`
`438`	`440`
`439`	`441`	`CheckCondition(conditionName: string, toolchain: IToolchian): boolean {`
`@@ -443,27 +445,32 @@ export class PackageManager {`
`443`	`445`	`const cGroup = cMap.get(conditionName);`
`444`	`446`	`if (cGroup) {`
`445`	`447`	`this._recurseList = [conditionName];`
`446`		`- return this._checkConditionGroup(cMap, cGroup, this.currentDevice, [], toolchain);`
	`448`	`+ try {`
	`449`	`+ this._checkConditionGroup(cMap, cGroup, this.currentDevice, [], toolchain);`
	`450`	`+ return true;`
	`451`	`+ } catch (error) {`
	`452`	`+ return false;`
	`453`	`+ }`
`447`	`454`	`}`
`448`	`455`	`}`
`449`	`456`
`450`	`457`	`return true;`
`451`	`458`	`}`
`452`	`459`
`453`		`- CheckConditionRequire(conditionName: string, toolchain: IToolchian): string[] \| boolean {`
	`460`	`+ checkComponentRequirement(conditionName: string, toolchain: IToolchian): string[] {`
`454`	`461`
`455`	`462`	`if (this.currentDevice) {`
`456`	`463`	`const cMap = this.currentDevice.packInfo.conditionMap;`
`457`	`464`	`const cGroup = cMap.get(conditionName);`
`458`	`465`	`if (cGroup) {`
`459`		`- this._recurseList = [conditionName];`
`460`	`466`	`const components: string[] = [];`
`461`		`- const pass = this._checkConditionGroup(cMap, cGroup, this.currentDevice, components, toolchain);`
`462`		`- return pass ? ArrayDelRepetition(components) : false;`
	`467`	`+ this._recurseList = [conditionName];`
	`468`	`+ this._checkConditionGroup(cMap, cGroup, this.currentDevice, components, toolchain);`
	`469`	`+ return ArrayDelRepetition(components);`
`463`	`470`	`}`
`464`	`471`	`}`
`465`	`472`
`466`		`- return true;`
	`473`	`+ return [];`
`467`	`474`	`}`
`468`	`475`
`469`	`476`	`makeComponentGroupName(...names: string[]): string {`