@eagleoutice/flowr 2.2.14 → 2.2.16

package/linter/rules/absolute-path.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ABSOLUTE_PATH = void 0;
+const linter_format_1 = require("../linter-format");
+const objects_1 = require("../../util/objects");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const range_1 = require("../../util/range");
+const dfg_1 = require("../../util/mermaid/dfg");
+const linter_tags_1 = require("../linter-tags");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const strings_1 = require("../../util/text/strings");
+const r_string_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-string");
+const assert_1 = require("../../util/assert");
+const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
+const write_functions_1 = require("../../queries/catalog/dependencies-query/function-info/write-functions");
+const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
+const source_functions_1 = require("../../queries/catalog/dependencies-query/function-info/source-functions");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const dependencies_query_format_1 = require("../../queries/catalog/dependencies-query/dependencies-query-format");
+const resolve_argument_1 = require("../../dataflow/eval/resolve/resolve-argument");
+const path_1 = __importDefault(require("path"));
+function inferWd(file, wd) {
+    if (wd === '@script') {
+        // we can use the script path as the working directory
+        return file;
+    }
+    else if (wd === '@home') {
+        // we can use the home directory as the working directory
+        return process.env.HOME || process.env.USERPROFILE || '';
+    }
+    else {
+        return wd;
+    }
+}
+// this can be improved by respecting raw strings and supporting more scenarios
+function buildQuickFix(str, filePath, wd) {
+    if (!wd || !(0, r_string_1.isRString)(str)) {
+        return undefined;
+    }
+    return [{
+            type: 'replace',
+            range: str.location,
+            description: `Replace with a relative path to \`${filePath}\``,
+            replacement: str.content.quotes + '.' + path_1.default.sep + path_1.default.relative(wd, filePath) + str.content.quotes
+        }];
+}
+/** return all strings constructable by these functions */
+const PathFunctions = {
+    'file.path': (df, vtx, config) => {
+        const fsep = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, undefined, 'fsep', true);
+        // in the future we can access `.Platform$file.sep` here
+        const sepValues = new Array(...fsep?.values()?.flatMap(s => [...s].filter(assert_1.isNotUndefined)) ?? [path_1.default.sep]);
+        if (sepValues.some(s => s === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(s))) {
+            // if we have no fsep, we cannot construct a path
+            return undefined;
+        }
+        const args = (0, resolve_argument_1.getArgumentStringValue)(config.solver.variables, df, vtx, 'unnamed', undefined, true);
+        const argValues = args ? Array.from(args.values()).flatMap(v => [...v]) : [];
+        if (!argValues || argValues.length === 0 || argValues.some(v => v === dependencies_query_format_1.Unknown || (0, assert_1.isUndefined)(v))) {
+            // if we have no arguments, we cannot construct a path
+            return undefined;
+        }
+        const results = [];
+        for (const val of sepValues) {
+            results.push(argValues.join(val));
+        }
+        return results;
+    }
+};
+exports.ABSOLUTE_PATH = {
+    /* this can be done better once we have types */
+    createSearch: (config) => {
+        let q;
+        if (config.include.allStrings) {
+            q = flowr_search_builder_1.Q.all().filter(type_1.RType.String);
+        }
+        else {
+            q = flowr_search_builder_1.Q.fromQuery({
+                type: 'dependencies',
+                // we use the dependencies query to give us all functions that take a file path as input
+                ignoreDefaultFunctions: true,
+                readFunctions: read_functions_1.ReadFunctions.concat(write_functions_1.WriteFunctions, source_functions_1.SourceFunctions, config.additionalPathFunctions),
+            });
+        }
+        if (config.include.constructed) {
+            q = q.merge(flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionCall).with(search_enrichers_1.Enrichment.CallTargets));
+            /* in the future we want to directly check whether this is one of the supported functions */
+        }
+        return q.unique();
+    },
+    processSearchResult: (elements, config, data) => {
+        const metadata = {
+            totalConsidered: 0,
+            totalUnknown: 0
+        };
+        const regex = config.absolutePathRegex ? new RegExp(config.absolutePathRegex) : undefined;
+        return {
+            results: elements.getElements().flatMap(element => {
+                metadata.totalConsidered++;
+                const node = element.node;
+                const wd = inferWd(node.info.file, config.useAsWd);
+                if ((0, r_string_1.isRString)(node)) {
+                    if (node.content.str.length >= 3 && (0, strings_1.isAbsolutePath)(node.content.str, regex)) {
+                        return [{
+                                certainty: linter_format_1.LintingCertainty.Maybe,
+                                filePath: node.content.str,
+                                range: node.info.fullRange ?? node.location,
+                                quickFix: buildQuickFix(node, node.content.str, wd)
+                            }];
+                    }
+                    else {
+                        return [];
+                    }
+                }
+                else if (element.queryResult) {
+                    const result = element.queryResult;
+                    const mappedStrings = result.readData.filter(r => r.source !== dependencies_query_format_1.Unknown && (0, strings_1.isAbsolutePath)(r.source, regex)).map(r => {
+                        const elem = data.normalize.idMap.get(r.nodeId);
+                        return {
+                            certainty: linter_format_1.LintingCertainty.Definitely,
+                            filePath: r.source,
+                            range: elem?.info.fullRange ?? elem?.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1),
+                            quickFix: buildQuickFix(elem, r.source, wd)
+                        };
+                    });
+                    if (mappedStrings.length > 0) {
+                        return mappedStrings;
+                    }
+                    else if (result.readData.every(r => r.source !== dependencies_query_format_1.Unknown)) {
+                        // if we have no absolute paths, but all paths are known, we can return an empty array
+                        return [];
+                    }
+                }
+                else {
+                    const dfNode = data.dataflow.graph.getVertex(node.info.id);
+                    if ((0, vertex_1.isFunctionCallVertex)(dfNode)) {
+                        const handler = PathFunctions[dfNode.name ?? ''];
+                        const strings = handler ? handler(data.dataflow.graph, dfNode, data.config) : [];
+                        if (strings) {
+                            return strings.filter(s => (0, strings_1.isAbsolutePath)(s, regex)).map(str => ({
+                                certainty: linter_format_1.LintingCertainty.Maybe,
+                                filePath: str,
+                                range: node.info.fullRange ?? node.location ?? (0, range_1.rangeFrom)(-1, -1, -1, -1)
+                            }));
+                        }
+                    }
+                    // check whether the df node is a function call that returns a file path
+                }
+                metadata.totalUnknown++;
+                return undefined;
+            }).filter(assert_1.isNotUndefined).map(r => (0, objects_1.compactRecord)(r)),
+            '.meta': metadata
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)} is not absolute`
+    },
+    info: {
+        name: 'Absolute Paths',
+        description: 'Checks whether file paths are absolute.',
+        tags: [linter_tags_1.LintingRuleTag.Robustness, linter_tags_1.LintingRuleTag.Reproducibility, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.QuickFix],
+        defaultConfig: {
+            include: {
+                constructed: true,
+                allStrings: false
+            },
+            additionalPathFunctions: [],
+            absolutePathRegex: undefined,
+            useAsWd: '@script'
+        }
+    }
+};
+//# sourceMappingURL=absolute-path.js.map

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

@@ -0,0 +1,43 @@
+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';
+import { LintingRuleTag } from '../linter-tags';
+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 {
+    totalDeprecatedCalls: number;
+    totalDeprecatedFunctionDefinitions: number;
+}
+export declare const DEPRECATED_FUNCTIONS: {
+    readonly createSearch: (config: DeprecatedFunctionsConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with", "filter"], 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/flowr-search").FlowrSearchElement<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>[]>) => {
+        results: {
+            certainty: LintingCertainty.Definitely;
+            function: Identifier;
+            range: SourceRange;
+        }[];
+        '.meta': DeprecatedFunctionsMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: DeprecatedFunctionsResult) => string;
+        readonly full: (result: DeprecatedFunctionsResult) => string;
+    };
+    readonly info: {
+        readonly name: "Deprecated Functions";
+        readonly tags: readonly [LintingRuleTag.Deprecated, LintingRuleTag.Smell, LintingRuleTag.Usability, LintingRuleTag.Reproducibility];
+        readonly description: "Marks deprecated functions that should not be used anymore.";
+        readonly defaultConfig: {
+            readonly deprecatedFunctions: readonly ["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/deprecated-functions.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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");
+const flowr_search_filters_1 = require("../../search/flowr-search-filters");
+const linter_tags_1 = require("../linter-tags");
+exports.DEPRECATED_FUNCTIONS = {
+    createSearch: (config) => flowr_search_builder_1.Q.all()
+        .with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true })
+        .filter({
+        name: flowr_search_filters_1.FlowrFilter.MatchesEnrichment,
+        args: {
+            enrichment: search_enrichers_1.Enrichment.CallTargets,
+            test: (0, flowr_search_filters_1.testFunctionsIgnoringPackage)(config.deprecatedFunctions)
+        }
+    }),
+    processSearchResult: (elements) => {
+        const metadata = {
+            totalDeprecatedCalls: 0,
+            totalDeprecatedFunctionDefinitions: 0
+        };
+        return {
+            results: elements.getElements()
+                .flatMap(element => {
+                metadata.totalDeprecatedCalls++;
+                return (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CallTargets).targets.map(target => {
+                    metadata.totalDeprecatedFunctionDefinitions++;
+                    return {
+                        range: element.node.info.fullRange,
+                        target: target
+                    };
+                });
+            })
+                .map(element => ({
+                certainty: linter_format_1.LintingCertainty.Definitely,
+                function: element.target,
+                range: element.range
+            })),
+            '.meta': metadata
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Function \`${result.function}\` called at ${(0, dfg_1.formatRange)(result.range)} is deprecated`
+    },
+    info: {
+        name: 'Deprecated Functions',
+        tags: [linter_tags_1.LintingRuleTag.Deprecated, linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Usability, linter_tags_1.LintingRuleTag.Reproducibility],
+        description: 'Marks deprecated functions that should not be used anymore.',
+        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=deprecated-functions.js.map

package/linter/rules/{2-file-path-validity.d.ts → file-path-validity.d.ts}

@@ -4,6 +4,7 @@ import type { SourceRange } from '../../util/range';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { FlowrSearchElementFromQuery } from '../../search/flowr-search';
 import type { FunctionInfo } from '../../queries/catalog/dependencies-query/function-info/function-info';
+import { LintingRuleTag } from '../linter-tags';
 export interface FilePathValidityResult extends LintingResult {
     filePath: string;
     range: SourceRange;
@@ -30,19 +31,28 @@ export interface FilePathValidityMetadata extends MergeableRecord {
     totalWritesBeforeAlways: number;
     totalValid: number;
 }
-export declare const R2_FILE_PATH_VALIDITY: {
+export declare const FILE_PATH_VALIDITY: {
     readonly createSearch: (config: FilePathValidityConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"from-query", [], ParentInformation, import("../../search/flowr-search").FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>>;
     readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>, config: FilePathValidityConfig, data: {
         normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
         dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
     }) => {
         results: FilePathValidityResult[];
         ".meta": FilePathValidityMetadata;
     };
-    readonly prettyPrint: (result: FilePathValidityResult) => string;
-    readonly defaultConfig: {
-        readonly additionalReadFunctions: [];
-        readonly additionalWriteFunctions: [];
-        readonly includeUnknown: false;
+    readonly info: {
+        readonly name: "File Path Validity";
+        readonly description: "Checks whether file paths used in read and write operations are valid and point to existing files.";
+        readonly tags: readonly [LintingRuleTag.Robustness, LintingRuleTag.Reproducibility, LintingRuleTag.Bug];
+        readonly defaultConfig: {
+            readonly additionalReadFunctions: readonly [];
+            readonly additionalWriteFunctions: readonly [];
+            readonly includeUnknown: false;
+        };
+    };
+    readonly prettyPrint: {
+        readonly query: (result: FilePathValidityResult) => string;
+        readonly full: (result: FilePathValidityResult) => string;
     };
 };

package/linter/rules/{2-file-path-validity.js → file-path-validity.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.R2_FILE_PATH_VALIDITY = void 0;
+exports.FILE_PATH_VALIDITY = 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 dependencies_query_format_1 = require("../../queries/catalog/dependencies-query/dependencies-query-format");
 const built_in_source_1 = require("../../dataflow/internal/process/functions/call/built-in/built-in-source");
 const logic_1 = require("../../util/logic");
-const config_1 = require("../../config");
 const retriever_1 = require("../../r-bridge/retriever");
 const read_functions_1 = require("../../queries/catalog/dependencies-query/function-info/read-functions");
 const write_functions_1 = require("../../queries/catalog/dependencies-query/function-info/write-functions");
 const extract_cfg_1 = require("../../control-flow/extract-cfg");
 const happens_before_1 = require("../../control-flow/happens-before");
-exports.R2_FILE_PATH_VALIDITY = {
+const linter_tags_1 = require("../linter-tags");
+exports.FILE_PATH_VALIDITY = {
     createSearch: (config) => flowr_search_builder_1.Q.fromQuery({
         type: 'dependencies',
         // we only want to check read and write functions, so we explicitly clear all others
@@ -53,14 +53,14 @@ exports.R2_FILE_PATH_VALIDITY = {
                     }
                 }
                 // check if any write to the same file happens before the read, and exclude this case if so
-                const writesToFile = results.writtenData.filter(r => samePath(r.destination, matchingRead.source));
+                const writesToFile = results.writtenData.filter(r => samePath(r.destination, matchingRead.source, data.config.solver.resolveSource?.ignoreCapitalization));
                 const writesBefore = writesToFile.map(w => (0, happens_before_1.happensBefore)(cfg, w.nodeId, element.node.info.id));
                 if (writesBefore.some(w => w === logic_1.Ternary.Always)) {
                     metadata.totalWritesBeforeAlways++;
                     return [];
                 }
                 // check if the file exists!
-                const paths = (0, built_in_source_1.findSource)(matchingRead.source, {
+                const paths = (0, built_in_source_1.findSource)(data.config.solver.resolveSource, matchingRead.source, {
                     referenceChain: element.node.info.file ? [(0, retriever_1.requestFromInput)(`file://${element.node.info.file}`)] : []
                 });
                 if (paths && paths.length) {
@@ -76,18 +76,26 @@ exports.R2_FILE_PATH_VALIDITY = {
             '.meta': metadata
         };
     },
-    prettyPrint: result => `Path ${result.filePath} at ${(0, dfg_1.formatRange)(result.range)}`,
-    defaultConfig: {
-        additionalReadFunctions: [],
-        additionalWriteFunctions: [],
-        includeUnknown: false
+    info: {
+        name: 'File Path Validity',
+        description: 'Checks whether file paths used in read and write operations are valid and point to existing files.',
+        tags: [linter_tags_1.LintingRuleTag.Robustness, linter_tags_1.LintingRuleTag.Reproducibility, linter_tags_1.LintingRuleTag.Bug],
+        defaultConfig: {
+            additionalReadFunctions: [],
+            additionalWriteFunctions: [],
+            includeUnknown: false
+        }
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Path \`${result.filePath}\` at ${(0, dfg_1.formatRange)(result.range)} does not point to a valid file`
     }
 };
-function samePath(a, b) {
-    if ((0, config_1.getConfig)().solver.resolveSource?.ignoreCapitalization === true) {
+function samePath(a, b, ignoreCapitalization) {
+    if (ignoreCapitalization === true) {
         a = a.toLowerCase();
         b = b.toLowerCase();
     }
     return a === b;
 }
-//# sourceMappingURL=2-file-path-validity.js.map
+//# sourceMappingURL=file-path-validity.js.map

package/linter/rules/naming-convention.d.ts

@@ -0,0 +1,71 @@
+import type { DataflowGraph } from '../../dataflow/graph/graph';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { MergeableRecord } from '../../util/objects';
+import type { SourceRange } from '../../util/range';
+import type { LintQuickFixReplacement, LintingResult } from '../linter-format';
+import { LintingCertainty } from '../linter-format';
+import { LintingRuleTag } from '../linter-tags';
+export declare enum CasingConvention {
+    CamelCase = "camelCase",
+    PascalCase = "PascalCase",
+    SnakeCase = "snake_case",
+    ConstantCase = "CONSTANT_CASE",
+    CamelSnakeCase = "camel_Snake_Case",
+    PascalSnakeCase = "Pascal_Snake_Case",
+    Unknown = "unknown"
+}
+export interface NamingConventionResult extends LintingResult {
+    name: string;
+    detectedCasing: CasingConvention;
+    range: SourceRange;
+}
+/**
+ * It is planned to have a config like ESLint
+ */
+export interface NamingConventionConfig extends MergeableRecord {
+    caseing: CasingConvention | 'auto';
+}
+export interface NamingConventionMetadata extends MergeableRecord {
+    /** number of symbols matching the casing convetion */
+    numMatches: number;
+    /** number of symbols breaking the casing convetion */
+    numBreak: number;
+}
+export declare function detectCasing(identifier: string): CasingConvention;
+export declare function getMostUsedCasing(symbols: {
+    detectedCasing: CasingConvention;
+}[]): CasingConvention;
+export declare function fixCasing(identifier: string, convention: CasingConvention): string;
+export declare function createNamingConventionQuickFixes(graph: DataflowGraph, nodeId: NodeId, replacement: string, conv: CasingConvention): LintQuickFixReplacement[] | undefined;
+export declare const NAMING_CONVENTION: {
+    readonly createSearch: (_config: NamingConventionConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["filter"], 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/flowr-search").FlowrSearchElement<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: NamingConventionConfig, data: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        config: import("../../config").FlowrConfigOptions;
+    }) => {
+        results: {
+            quickFix: LintQuickFixReplacement[] | undefined;
+            certainty: LintingCertainty;
+            detectedCasing: CasingConvention;
+            name: string;
+            range: SourceRange;
+        }[];
+        '.meta': {
+            numMatches: number;
+            numBreak: number;
+        };
+    };
+    readonly prettyPrint: {
+        readonly query: (result: NamingConventionResult) => string;
+        readonly full: (result: NamingConventionResult) => string;
+    };
+    readonly info: {
+        readonly name: "Naming Convention";
+        readonly description: "Checks wether the symbols conform to a certain naming convention";
+        readonly tags: readonly [LintingRuleTag.Style, LintingRuleTag.QuickFix];
+        readonly defaultConfig: {
+            readonly caseing: CasingConvention.PascalCase;
+        };
+    };
+};

package/linter/rules/naming-convention.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAMING_CONVENTION = exports.CasingConvention = void 0;
+exports.detectCasing = detectCasing;
+exports.getMostUsedCasing = getMostUsedCasing;
+exports.fixCasing = fixCasing;
+exports.createNamingConventionQuickFixes = createNamingConventionQuickFixes;
+const vertex_1 = require("../../dataflow/graph/vertex");
+const dfg_get_symbol_refs_1 = require("../../dataflow/origin/dfg-get-symbol-refs");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const assert_1 = require("../../util/assert");
+const dfg_1 = require("../../util/mermaid/dfg");
+const linter_format_1 = require("../linter-format");
+const linter_tags_1 = require("../linter-tags");
+var CasingConvention;
+(function (CasingConvention) {
+    CasingConvention["CamelCase"] = "camelCase";
+    CasingConvention["PascalCase"] = "PascalCase";
+    CasingConvention["SnakeCase"] = "snake_case";
+    CasingConvention["ConstantCase"] = "CONSTANT_CASE";
+    CasingConvention["CamelSnakeCase"] = "camel_Snake_Case";
+    CasingConvention["PascalSnakeCase"] = "Pascal_Snake_Case";
+    CasingConvention["Unknown"] = "unknown";
+})(CasingConvention || (exports.CasingConvention = CasingConvention = {}));
+function detectCasing(identifier) {
+    if (identifier.trim() === '') {
+        return CasingConvention.Unknown;
+    }
+    const upper = identifier.toUpperCase();
+    const lower = identifier.toLowerCase();
+    const isAllUpper = identifier === upper;
+    const isAllLower = identifier === lower;
+    if (identifier.includes('_')) {
+        if (isAllUpper) { // CONSTANT_CASE
+            return CasingConvention.ConstantCase;
+        }
+        else if (isAllLower) { // snake_case
+            return CasingConvention.SnakeCase;
+        }
+        // Returns true if the letter after an _ is uppercase
+        function expectUpperAfterScore(identifier) {
+            for (let i = 0; i < identifier.length - 1; i++) {
+                if (identifier[i] === '_') {
+                    if (identifier[i + 1] !== upper[i + 1]) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        if (identifier[0] === lower[0] && expectUpperAfterScore(identifier)) { // camel_Snake_Case
+            return CasingConvention.CamelSnakeCase;
+        }
+        else if (identifier[0] === upper[0] && expectUpperAfterScore(identifier)) { // Pascal_Snake_Case
+            return CasingConvention.PascalSnakeCase;
+        }
+    }
+    else {
+        if (identifier[0] === lower[0]) { // camelCase
+            return CasingConvention.CamelCase;
+        }
+        else if (identifier[0] === upper[0]) { // PascalCase
+            return CasingConvention.PascalCase;
+        }
+    }
+    return CasingConvention.Unknown;
+}
+function getMostUsedCasing(symbols) {
+    const map = new Map();
+    for (const symbol of symbols) {
+        const o = map.get(symbol.detectedCasing) ?? 0;
+        map.set(symbol.detectedCasing, o + 1);
+    }
+    return [...map].reduce((p, c) => p[1] > c[1] ? p : c)[0];
+}
+function fixCasing(identifier, convention) {
+    const tokens = identifier.split(/(?=[A-Z])|_/).map(s => s.toLowerCase());
+    const firstUp = (s) => `${s[0].toUpperCase()}${s.substring(1)}`;
+    switch (convention) {
+        case CasingConvention.CamelCase: // camelCase
+            return `${tokens[0]}${tokens.slice(1).map(firstUp).join('')}`;
+        case CasingConvention.PascalCase: // PascalCase
+            return tokens.map(firstUp).join('');
+        case CasingConvention.SnakeCase: // snake_case
+            return tokens.join('_');
+        case CasingConvention.ConstantCase: // CONSTANT_CASE
+            return tokens.map(s => s.toUpperCase()).join('_');
+        case CasingConvention.CamelSnakeCase: // camel_Snake_Case
+            return `${tokens[0]}_${tokens.slice(1).map(firstUp).join('_')}`;
+        case CasingConvention.PascalSnakeCase: // Pascal_Snake_Case
+            return tokens.map(firstUp).join('_');
+        case CasingConvention.Unknown:
+            return identifier;
+        default:
+            (0, assert_1.assertUnreachable)(convention);
+    }
+}
+function createNamingConventionQuickFixes(graph, nodeId, replacement, conv) {
+    const refs = (0, dfg_get_symbol_refs_1.getAllRefsToSymbol)(graph, nodeId);
+    const idMap = graph.idMap;
+    if (refs === undefined || idMap === undefined) {
+        return undefined;
+    }
+    const result = [];
+    for (const ref of refs) {
+        const node = idMap.get(ref);
+        if (node === undefined) {
+            continue;
+        }
+        const range = node.info.fullRange;
+        if (range) {
+            // In case of a function call we only need to include the name, not the '()'
+            range[3] = range[1] + node.lexeme.length - 1;
+            result.push({
+                type: 'replace',
+                replacement: replacement,
+                description: `Rename to match naming convention ${conv}`,
+                range: range
+            });
+        }
+    }
+    return result.length === 0 ?
+        undefined : // We sort so that when applied in order the fixes will start from the end of the line to avoid conflicts
+        result.sort((a, b) => a.range[0] == b.range[0] ? b.range[1] - a.range[1] : b.range[0] - a.range[0]);
+}
+exports.NAMING_CONVENTION = {
+    createSearch: (_config) => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.VariableDefinition),
+    processSearchResult: (elements, config, data) => {
+        const symbols = elements.getElements()
+            .map(m => ({
+            certainty: linter_format_1.LintingCertainty.Definitely,
+            detectedCasing: detectCasing(m.node.lexeme),
+            name: m.node.lexeme,
+            range: m.node.info.fullRange,
+            id: m.node.info.id
+        }));
+        const casing = config.caseing === 'auto' ? getMostUsedCasing(symbols) : config.caseing;
+        const results = symbols.filter(m => m.detectedCasing !== casing)
+            .map(({ id, ...m }) => ({
+            ...m,
+            quickFix: createNamingConventionQuickFixes(data.dataflow.graph, id, fixCasing(m.name, casing), casing)
+        }));
+        return {
+            results: results,
+            '.meta': {
+                numMatches: symbols.length - results.length,
+                numBreak: results.length
+            }
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Identifier '${result.name}' at ${(0, dfg_1.formatRange)(result.range)} (${result.detectedCasing})`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Identifier '${result.name}' at ${(0, dfg_1.formatRange)(result.range)} follows wrong convention: ${result.detectedCasing}`
+    },
+    info: {
+        name: 'Naming Convention',
+        description: 'Checks wether the symbols conform to a certain naming convention',
+        tags: [linter_tags_1.LintingRuleTag.Style, linter_tags_1.LintingRuleTag.QuickFix],
+        defaultConfig: {
+            caseing: CasingConvention.PascalCase
+        }
+    }
+};
+//# sourceMappingURL=naming-convention.js.map