feat: Increase version restrictions for node switching #7631
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -227,5 +227,6 @@ export namespace Setting { | |
| id: number; | ||
| addr: string; | ||
| status: string; | ||
| version: string; | ||
| } | ||
| } | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,42 @@ | ||
| export function compareVersion(version1: string, version2: string): boolean { | ||
| const v1s = extractNumbers(version1); | ||
| const v2s = extractNumbers(version2); | ||
|
|
||
| const maxLen = Math.max(v1s.length, v2s.length); | ||
| v1s.push(...new Array(maxLen - v1s.length).fill('0')); | ||
| v2s.push(...new Array(maxLen - v2s.length).fill('0')); | ||
|
|
||
| for (let i = 0; i < maxLen; i++) { | ||
| const v1 = parseInt(v1s[i], 10); | ||
| const v2 = parseInt(v2s[i], 10); | ||
| if (v1 !== v2) { | ||
| return v1 > v2; | ||
| } | ||
| } | ||
| return true; | ||
| } | ||
|
|
||
| function extractNumbers(version: string): string[] { | ||
| const numbers: string[] = []; | ||
| let start = -1; | ||
| for (let i = 0; i < version.length; i++) { | ||
| if (isDigit(version[i])) { | ||
| if (start === -1) { | ||
| start = i; | ||
| } | ||
| } else { | ||
| if (start !== -1) { | ||
| numbers.push(version.slice(start, i)); | ||
| start = -1; | ||
| } | ||
| } | ||
| } | ||
| if (start !== -1) { | ||
| numbers.push(version.slice(start)); | ||
| } | ||
| return numbers; | ||
| } | ||
|
|
||
| function isDigit(char: string): boolean { | ||
| return /^\d$/.test(char); | ||
| } | ||
|
Member
There was a problem hiding this comment. The code does not appear to have any immediate syntax errors. However, there are some improvements that could be made:
Here's an updated version: function extractNumbers(version: string): string[] {
const numbers: string[] = [];
let startAtLastChar = false;
for (let i = 0; i < version.length; i++) {
const char = version[i];
// If digit at current position matches the last non-digit character,
// ensure it has its starting index set correctly before appending the number part.
if (!startAtLastChar && isDigit(char)) {
startAtLastChar = { startAtThisPosition: i };
if (numbers[0]) {
console.log('StartAtFirstPos', startAtFirstPos)
} else if (numbers && numbers[numbers.length-1].length === 0) {
console.log('startOnNewLine')
numbers.push('');
}
}
// Only append a number part when we've reached end of current line
if (char !== ',' && !isDigit(char)) break;
if (!startAtLastChar) continue;
if (typeof startAtLastChar.startAtThisPosition == 'undefined') continue ;To summarize the key improvements from these suggestions: * Extract just one group of consecutive characters between commas as "digits" instead of trying to find groups of numbers across multiple lines or spaces
* Make sure that each number starts itself (on separate lines), ensuring you handle both leading zeros properly
```
Member
There was a problem hiding this comment. The provided code snippet contains several inconsistencies and errors that require attention before being released. Here's an overview of these issues:
For instance, to address these concerns, you would need to implement explicit validations such as checking the inputs for alphabetic/numeric values rather than relying solely on regular expression matching. Additionally, implementing basic type safety checks could prevent runtime errors during compile time. Here’s a simplified approach with improved error handling and additional optimizations: import { strict as assert } from 'assert';
/**
* Compares two version strings based on how numerically each number part should be compared when concatenated together,
* considering negative sign prefixing as necessary.
*
* @param version1 The first version string representing the major/minor/patch numbers of interest.
* @param version2 The second version string also representing the same information.
* @returns true if there is no mismatch between version parts (e.g., if both versions can be safely added directly),
* false otherwise due to invalid input or numerical anomalies leading to incorrect comparisons.
*/
function isValidCompareVersion(version1: string, version2: string): boolean {
const partsA = extractPartsFromVersions(version1);
const partsB = extractPartsFromVersions(version2);
// Validate input types
if (!Array.isArray(partsA) || !Array.isArray(partsB)) {
throw new Error("Inputs must be arrays");
}
// Compare valid elements by concatenating them together
for (const parts of [partsA, partsB]) {
if (isValidElementsByCombiningElements(partsWithMajorMinorsToArrays(parts))) {
return true; // No mismatches found between consecutive sections after combining their individual parts
}
}
return false; // Some section(s) had mismatches
}
// Helper functions used in comparison logic
/**
* Extracts all digit characters from a given string, returns empty array if none available.
* @param str String containing digits to process.
* @returns An array of extracted digits.
*/
function extractDigits(str: string): string[] {
return str.match(/\d+/g)?.map((digit) => digit.trim()) ?? [];
}
function isValidElementsByCombiningElements(elements: string[]): boolean {
try {
return combineIntoValidStringsAndValidateResult(elements);
} catch (_) {} // Catch any unexpected issues encountered while attempting to validate combined results
return false;
}
// Main comparison logic for validity check of version strings
function combineIntoValidStringsAndValidateResult(combinedElements: string[]): boolean {
const sortedCombinedElements = [...combinedElements].sort();
let hasMismatches = false;
// Loop through combined elements to ensure every element is valid
for (let i = 1; i < sortedCombinedElements.length; i++) {
if (parseInt(sortedCombinedElements[i], 10) <= parseInt(sortedCombinedElements[i - 1], 10)) {
hasMismatches = true;
}
}
return !hasMismatches && sortedCombinedElements[0].length == 6 ? true : false;
}Keep refining this implementation as per specific requirements and consider adding proper error messages to assist in diagnosing problems related to inconsistent data structures within version strings. This revised solution now adheres more strictly to good coding practices aiming at maintaining efficiency and robustness over its entire lifecycle from initial development till release into production. |
||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Based on my knowledge up to 2021-09-01, the provided code appears fine with no apparent issues or need for changes. It seems quite standardized within its current context of a project addressing node versions among other things and offers clear options like upgrading now, downloading source files, etc. However, I would still recommend running it through some basic linting tools to ensure there might be specific improvements that can enhance its efficiency or legibility (if you're using this kind of code).