@eagleoutice/flowr 2.2.15 → 2.3.0

package/util/r-value.d.ts

@@ -0,0 +1,23 @@
+import type { Value, ValueInterval, ValueLogical, ValueNumber, ValueString, ValueVector } from '../dataflow/eval/values/r-value';
+import type { RLogicalValue } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import { type RNumberValue, type RStringValue } from '../r-bridge/lang-4.x/convert-values';
+export declare function isRStringValue(value: unknown): value is RStringValue;
+export declare function isRNumberValue(value: unknown): value is RNumberValue;
+export declare function isRLogicalValue(value: unknown): value is RLogicalValue;
+export declare function unwrapRValue(value: RStringValue | string): string;
+export declare function unwrapRValue(value: RNumberValue | number): number;
+export declare function unwrapRValue(value: RLogicalValue): boolean;
+export declare function unwrapRValue(value: RStringValue | RNumberValue | RLogicalValue | string | number): string | number | boolean;
+export declare function unwrapRValue(value: unknown): string | number | boolean | undefined;
+export declare function unwrapRVector(value: RStringValue[] | string[]): string[];
+export declare function unwrapRVector(value: RNumberValue[] | number[]): number[];
+export declare function unwrapRVector(value: RLogicalValue[]): boolean[];
+export declare function unwrapRVector(value: RStringValue[] | RNumberValue[] | RLogicalValue[] | string[] | number[]): string[] | number[] | boolean[];
+export declare function unwrapRVector(value: unknown): string[] | number[] | boolean[] | (string | number | boolean)[] | undefined;
+export declare function unwrapRValueToString(value: RStringValue | RNumberValue | RLogicalValue | string | number): string;
+export declare function unwrapRValueToString(value: unknown): string | undefined;
+export declare function unliftRValue(value: ValueString): RStringValue | undefined;
+export declare function unliftRValue(value: ValueNumber | ValueInterval): RNumberValue | undefined;
+export declare function unliftRValue(value: ValueLogical): RLogicalValue | undefined;
+export declare function unliftRValue(value: ValueVector): (RStringValue | RNumberValue | RLogicalValue)[] | undefined;
+export declare function unliftRValue(value: Value): RStringValue | RNumberValue | boolean | (RStringValue | RNumberValue | RLogicalValue)[] | undefined;

package/util/r-value.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRStringValue = isRStringValue;
+exports.isRNumberValue = isRNumberValue;
+exports.isRLogicalValue = isRLogicalValue;
+exports.unwrapRValue = unwrapRValue;
+exports.unwrapRVector = unwrapRVector;
+exports.unwrapRValueToString = unwrapRValueToString;
+exports.unliftRValue = unliftRValue;
+const r_value_1 = require("../dataflow/eval/values/r-value");
+const convert_values_1 = require("../r-bridge/lang-4.x/convert-values");
+const assert_1 = require("./assert");
+function isRValue(value) {
+    return isRStringValue(value) || isRNumberValue(value) || isRLogicalValue(value) || typeof value === 'string' || typeof value === 'number';
+}
+function isRStringValue(value) {
+    return typeof value === 'object' && value !== null && 'str' in value && typeof value.str === 'string';
+}
+function isRNumberValue(value) {
+    return typeof value === 'object' && value !== null && 'num' in value && typeof value.num === 'number';
+}
+function isRLogicalValue(value) {
+    return typeof value === 'boolean';
+}
+function unwrapRValue(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    else if (isRStringValue(value)) {
+        return value.str;
+    }
+    else if (isRNumberValue(value)) {
+        return value.num;
+    }
+    else {
+        return undefined;
+    }
+}
+function unwrapRVector(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    else if (value.every(entry => typeof entry === 'string') || value.every(entry => typeof entry === 'number') || value.every(entry => typeof entry === 'boolean')) {
+        return value;
+    }
+    else if (value.every(isRStringValue)) {
+        return value.map(entry => unwrapRValue(entry));
+    }
+    else if (value.every(isRNumberValue)) {
+        return value.map(entry => unwrapRValue(entry));
+    }
+    else if (value.every(isRValue)) {
+        return value.map(entry => unwrapRValue(entry));
+    }
+    else {
+        return undefined;
+    }
+}
+function unwrapRValueToString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else if (typeof value === 'number') {
+        return value.toString();
+    }
+    else if (typeof value === 'boolean') {
+        return value ? convert_values_1.RTrue : convert_values_1.RFalse;
+    }
+    else if (isRStringValue(value)) {
+        return value.str;
+    }
+    else if (isRNumberValue(value)) {
+        return value.num.toString();
+    }
+    else {
+        return undefined;
+    }
+}
+function unliftRValue(value) {
+    if (!(0, r_value_1.isValue)(value)) {
+        return undefined;
+    }
+    const type = value.type;
+    switch (type) {
+        case 'string': {
+            return (0, r_value_1.isValue)(value.value) ? value.value : undefined;
+        }
+        case 'number': {
+            return (0, r_value_1.isValue)(value.value) ? value.value : undefined;
+        }
+        case 'logical': {
+            return (0, r_value_1.isValue)(value.value) && typeof value.value === 'boolean' ? value.value : undefined;
+        }
+        case 'interval': {
+            const start = unliftRValue(value.start);
+            const end = unliftRValue(value.end);
+            return start !== undefined && end !== undefined && start.num === end.num ? start : undefined;
+        }
+        case 'vector': {
+            const values = (0, r_value_1.isValue)(value.elements) ? value.elements.map(unliftRValue) : undefined;
+            return values?.every(assert_1.isNotUndefined) ? values.flat() : undefined;
+        }
+        case 'set': {
+            return (0, r_value_1.isValue)(value.elements) && value.elements.length === 1 ? unliftRValue(value.elements[0]) : undefined;
+        }
+        case 'missing': {
+            return undefined;
+        }
+        default:
+            (0, assert_1.assertUnreachable)(type);
+    }
+}
+//# sourceMappingURL=r-value.js.map

package/util/range.d.ts

@@ -45,7 +45,7 @@ export declare function getRangeEnd(p: SourceRange | undefined): SourcePosition
  * @param ec - end column
  */
 export declare function rangeFrom(sl: number | string, sc: number | string, el: number | string, ec: number | string): SourceRange;
-export declare function mergeRanges(...rs: SourceRange[]): SourceRange;
+export declare function mergeRanges(...rs: (SourceRange | undefined)[]): SourceRange;
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
  */
@@ -64,3 +64,7 @@ export declare function addRanges([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl,
  * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
  */
 export declare function rangeCompare([r1sl, r1sc, ,]: SourceRange, [r2sl, r2sc, ,]: SourceRange): number;
+/**
+ * Checks if the first range is a subset of the second range.
+ */
+export declare function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): boolean;

package/util/range.js

@@ -8,6 +8,7 @@ exports.rangeStartsCompletelyBefore = rangeStartsCompletelyBefore;
 exports.rangesOverlap = rangesOverlap;
 exports.addRanges = addRanges;
 exports.rangeCompare = rangeCompare;
+exports.rangeIsSubsetOf = rangeIsSubsetOf;
 const assert_1 = require("./assert");
 function getRangeStart(p) {
     return p === undefined ? undefined : [p[0], p[1]];
@@ -27,11 +28,12 @@ function rangeFrom(sl, sc, el, ec) {
     return [Number(sl), Number(sc), Number(el), Number(ec)];
 }
 function mergeRanges(...rs) {
-    (0, assert_1.guard)(rs.length > 0, 'Cannot merge no ranges');
-    return rs.reduce(([sl, sc, el, ec], [nsl, nsc, nel, nec]) => [
+    const rsSafe = rs.filter(assert_1.isNotUndefined);
+    (0, assert_1.guard)(rsSafe.length > 0, 'Cannot merge no ranges');
+    return rsSafe.reduce(([sl, sc, el, ec], [nsl, nsc, nel, nec]) => [
         ...(sl < nsl || (sl === nsl && sc < nsc) ? [sl, sc] : [nsl, nsc]),
         ...(el > nel || (el === nel && ec > nec) ? [el, ec] : [nel, nec])
-    ], rs[0]);
+    ], rsSafe[0]);
 }
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
@@ -64,4 +66,10 @@ function rangeCompare([r1sl, r1sc, ,], [r2sl, r2sc, ,]) {
         return r1sl - r2sl;
     }
 }
+/**
+ * Checks if the first range is a subset of the second range.
+ */
+function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
+    return r1sl >= r2sl && r1sc >= r2sc && r1el <= r2el && r1ec <= r2ec;
+}
 //# sourceMappingURL=range.js.map

package/util/text/strings.d.ts

@@ -19,3 +19,9 @@ export declare function joinWithLast(strs: readonly string[], { join, last, join
     last?: string;
     joinTwo?: string;
 }): string;
+/**
+ * Check if the given path is an absolute path.
+ */
+export declare function isAbsolutePath(p: string, regex: RegExp | undefined): boolean;
+/** collect '-' at the start until '[' or '(' is reached, then drop the same from the end if present otherwise return the value as is */
+export declare function dropRawStringSurround(value: string): string;

package/util/text/strings.js

@@ -1,9 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startAndEndsWith = startAndEndsWith;
 exports.withoutWhitespace = withoutWhitespace;
 exports.longestCommonPrefix = longestCommonPrefix;
 exports.joinWithLast = joinWithLast;
+exports.isAbsolutePath = isAbsolutePath;
+exports.dropRawStringSurround = dropRawStringSurround;
+const path_1 = __importDefault(require("path"));
 /**
  * Check if the given string starts and ends with the given letter
  */
@@ -51,4 +57,33 @@ function joinWithLast(strs, { join = ', ', last = ', and ', joinTwo = ' and ' }
     }
     return strs.slice(0, -1).join(join) + last + strs[strs.length - 1];
 }
+/**
+ * Check if the given path is an absolute path.
+ */
+function isAbsolutePath(p, regex) {
+    return regex?.test(p) || p.startsWith('/') || p.startsWith('\\') ||
+        /[a-zA-Z]:[\\/]/.test(p) || // Windows absolute path
+        path_1.default.normalize(p + '/') === path_1.default.normalize(path_1.default.resolve(p) + '/');
+}
+const CorrespondingClose = {
+    '(': ')',
+    '[': ']',
+    '{': '}'
+};
+/** collect '-' at the start until '[' or '(' is reached, then drop the same from the end if present otherwise return the value as is */
+function dropRawStringSurround(value) {
+    const dashCount = value.match(/^-*/)?.[0].length ?? 0;
+    const open = value[dashCount];
+    if (open === '[' || open === '(' || open === '{') {
+        // if the value starts with a dash and then a bracket, we drop the dashes at the end
+        const end = value.endsWith(CorrespondingClose[open] + '-'.repeat(dashCount)) ? dashCount : undefined;
+        if (end !== undefined) {
+            return value.slice(dashCount + 1, -end - 1);
+        }
+        else {
+            return value;
+        }
+    }
+    return value;
+}
 //# sourceMappingURL=strings.js.map

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.2.15';
+const version = '2.3.0';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }

package/linter/rules/1-deprecated-functions.d.ts

@@ -1,34 +0,0 @@
-import type { LintingResult } from '../linter-format';
-import { LintingCertainty } from '../linter-format';
-import type { MergeableRecord } from '../../util/objects';
-import type { SourceRange } from '../../util/range';
-import type { Identifier } from '../../dataflow/environments/identifier';
-export interface DeprecatedFunctionsResult extends LintingResult {
-    function: string;
-    range: SourceRange;
-}
-export interface DeprecatedFunctionsConfig extends MergeableRecord {
-    /**
-     * The list of function names that should be marked as deprecated.
-     */
-    deprecatedFunctions: string[];
-}
-export interface DeprecatedFunctionsMetadata extends MergeableRecord {
-    totalRelevant: number;
-    totalNotDeprecated: number;
-}
-export declare const R1_DEPRECATED_FUNCTIONS: {
-    readonly createSearch: (_config: DeprecatedFunctionsConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/search-executor/search-enrichers").EnrichedFlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
-    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: DeprecatedFunctionsConfig) => {
-        results: {
-            certainty: LintingCertainty.Definitely;
-            function: Identifier;
-            range: SourceRange;
-        }[];
-        '.meta': DeprecatedFunctionsMetadata;
-    };
-    readonly prettyPrint: (result: DeprecatedFunctionsResult) => string;
-    readonly defaultConfig: {
-        readonly deprecatedFunctions: ["all_equal", "arrange_all", "distinct_all", "filter_all", "group_by_all", "summarise_all", "mutate_all", "select_all", "vars", "all_vars", "id", "failwith", "select_vars", "rename_vars", "select_var", "current_vars", "bench_tbls", "compare_tbls", "compare_tbls2", "eval_tbls", "eval_tbls2", "location", "changes", "combine", "do", "funs", "add_count_", "add_tally_", "arrange_", "count_", "distinct_", "do_", "filter_", "funs_", "group_by_", "group_indices_", "mutate_", "tally_", "transmute_", "rename_", "rename_vars_", "select_", "select_vars_", "slice_", "summarise_", "summarize_", "summarise_each", "src_local", "tbl_df", "add_rownames", "group_nest", "group_split", "with_groups", "nest_by", "progress_estimated", "recode", "sample_n", "top_n", "transmute", "fct_explicit_na", "aes_", "aes_auto", "annotation_logticks", "is.Coord", "coord_flip", "coord_map", "is.facet", "fortify", "is.ggproto", "guide_train", "is.ggplot", "qplot", "is.theme", "gg_dep", "liply", "isplit2", "list_along", "cross", "invoke", "at_depth", "prepend", "rerun", "splice", "`%@%`", "rbernoulli", "rdunif", "when", "update_list", "map_raw", "accumulate", "reduce_right", "flatten", "map_dfr", "as_vector", "transpose", "melt_delim", "melt_fwf", "melt_table", "read_table2", "str_interp", "as_tibble", "data_frame", "tibble_", "data_frame_", "lst_", "as_data_frame", "as.tibble", "frame_data", "trunc_mat", "is.tibble", "tidy_names", "set_tidy_names", "repair_names", "extract_numeric", "complete_", "drop_na_", "expand_", "crossing_", "nesting_", "extract_", "fill_", "gather_", "nest_", "separate_rows_", "separate_", "spread_", "unite_", "unnest_", "extract", "gather", "nest_legacy", "separate_rows", "separate", "spread"];
-    };
-};

package/linter/rules/1-deprecated-functions.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.R1_DEPRECATED_FUNCTIONS = void 0;
-const linter_format_1 = require("../linter-format");
-const flowr_search_builder_1 = require("../../search/flowr-search-builder");
-const dfg_1 = require("../../util/mermaid/dfg");
-const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
-exports.R1_DEPRECATED_FUNCTIONS = {
-    createSearch: (_config) => flowr_search_builder_1.Q.all().with(search_enrichers_1.Enrichment.CallTargets),
-    processSearchResult: (elements, config) => {
-        const metadata = {
-            totalRelevant: 0,
-            totalNotDeprecated: 0
-        };
-        return {
-            results: elements.getElements()
-                .flatMap(element => {
-                const targets = (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CallTargets).targets;
-                // if there is a call target that is not built-in (ie a custom function), we don't want to mark it as deprecated
-                // eventually we'd want to solve this with an argument to the CallTargets enrichment like satisfiesCallTargets does!
-                if (targets.some(t => typeof t !== 'string')) {
-                    return [];
-                }
-                return targets.map(target => {
-                    metadata.totalRelevant++;
-                    return {
-                        range: element.node.info.fullRange,
-                        target: target
-                    };
-                });
-            })
-                .filter(element => {
-                if (config.deprecatedFunctions.includes(element.target)) {
-                    return true;
-                }
-                else {
-                    metadata.totalNotDeprecated++;
-                    return false;
-                }
-            })
-                .map(element => ({
-                certainty: linter_format_1.LintingCertainty.Definitely,
-                function: element.target,
-                range: element.range
-            })),
-            '.meta': metadata
-        };
-    },
-    prettyPrint: result => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)}`,
-    defaultConfig: {
-        deprecatedFunctions: ['all_equal', 'arrange_all', 'distinct_all', 'filter_all', 'group_by_all', 'summarise_all', 'mutate_all', 'select_all', 'vars', 'all_vars', 'id', 'failwith', 'select_vars', 'rename_vars', 'select_var', 'current_vars', 'bench_tbls', 'compare_tbls', 'compare_tbls2', 'eval_tbls', 'eval_tbls2', 'location', 'changes', 'combine', 'do', 'funs', 'add_count_', 'add_tally_', 'arrange_', 'count_', 'distinct_', 'do_', 'filter_', 'funs_', 'group_by_', 'group_indices_', 'mutate_', 'tally_', 'transmute_', 'rename_', 'rename_vars_', 'select_', 'select_vars_', 'slice_', 'summarise_', 'summarize_', 'summarise_each', 'src_local', 'tbl_df', 'add_rownames', 'group_nest', 'group_split', 'with_groups', 'nest_by', 'progress_estimated', 'recode', 'sample_n', 'top_n', 'transmute', 'fct_explicit_na', 'aes_', 'aes_auto', 'annotation_logticks', 'is.Coord', 'coord_flip', 'coord_map', 'is.facet', 'fortify', 'is.ggproto', 'guide_train', 'is.ggplot', 'qplot', 'is.theme', 'gg_dep', 'liply', 'isplit2', 'list_along', 'cross', 'invoke', 'at_depth', 'prepend', 'rerun', 'splice', '`%@%`', 'rbernoulli', 'rdunif', 'when', 'update_list', 'map_raw', 'accumulate', 'reduce_right', 'flatten', 'map_dfr', 'as_vector', 'transpose', 'melt_delim', 'melt_fwf', 'melt_table', 'read_table2', 'str_interp', 'as_tibble', 'data_frame', 'tibble_', 'data_frame_', 'lst_', 'as_data_frame', 'as.tibble', 'frame_data', 'trunc_mat', 'is.tibble', 'tidy_names', 'set_tidy_names', 'repair_names', 'extract_numeric', 'complete_', 'drop_na_', 'expand_', 'crossing_', 'nesting_', 'extract_', 'fill_', 'gather_', 'nest_', 'separate_rows_', 'separate_', 'spread_', 'unite_', 'unnest_', 'extract', 'gather', 'nest_legacy', 'separate_rows', 'separate', 'spread',]
-    }
-};
-//# sourceMappingURL=1-deprecated-functions.js.map

package/util/cfg/cfg.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=cfg.js.map