Variable LintingRulesConst

Type declaration

• Readonlyabsolute-file-paths: {
      createSearch: (
          config: AbsoluteFilePathConfig,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "unique">;
      info: {
          defaultConfig: {
              absolutePathRegex: undefined;
              additionalPathFunctions: readonly [];
              include: { allStrings: false; constructed: true };
              useAsWd: "@script";
          };
          description: "Checks whether file paths are absolute.";
          name: "Absolute Paths";
          tags: readonly [Robustness, Reproducibility, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: AbsoluteFilePathResult) => string;
          query: (result: AbsoluteFilePathResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              {
                  node: (RNode<ParentInformation> | undefined) & RNode<
                      ParentInformation,
                  >;
                  query?: | "config"
                  | "origin"
                  | "dataflow"
                  | "search"
                  | "call-context"
                  | "control-flow"
                  | "dataflow-lens"
                  | "df-shape"
                  | "normalized-ast"
                  | "id-map"
                  | "dataflow-cluster"
                  | "static-slice"
                  | "lineage"
                  | "dependencies"
                  | "location-map"
                  | "happens-before"
                  | "resolve-value"
                  | "project"
                  | "linter";
                  queryResult?: BaseQueryResult;
              }[],
          >,
          config: AbsoluteFilePathConfig,
          data: {
              config: FlowrConfigOptions;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": AbsoluteFilePathMetadata;
          results: AbsoluteFilePathResult[];
      };
  }

• Readonlydataframe-access-validation: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "with",
      >;
      info: {
          defaultConfig: { readLoadedData: false };
          description: "Validates the existance of accessed columns and rows of dataframes.";
          name: "Dataframe Access Validation";
          tags: readonly [Bug, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: DataFrameAccessValidationResult) => string;
          query: (result: DataFrameAccessValidationResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: DataFrameAccessValidationConfig,
          data: {
              config: FlowrConfigOptions;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": DataFrameAccessValidationMetadata;
          results: DataFrameAccessValidationResult[];
      };
  }

• Readonlydeprecated-functions: {
      createSearch: (
          config: DeprecatedFunctionsConfig,
      ) => FlowrSearchBuilderOut<"all", ["with"], ParentInformation, "filter">;
      info: {
          defaultConfig: {
              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",
              ];
          };
          description: "Marks deprecated functions that should not be used anymore.";
          name: "Deprecated Functions";
          tags: readonly [Deprecated, Smell, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: DeprecatedFunctionsResult) => string;
          query: (result: DeprecatedFunctionsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
      ) => {
          ".meta": DeprecatedFunctionsMetadata;
          results: {
              certainty: Definitely;
              function: Identifier;
              range: SourceRange;
          }[];
      };
  }

• Readonlyfile-path-validity: {
      createSearch: (
          config: FilePathValidityConfig,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<
              ParentInformation,
              FlowrSearchElementFromQuery<ParentInformation>[],
          >,
      >;
      info: {
          defaultConfig: {
              additionalReadFunctions: readonly [];
              additionalWriteFunctions: readonly [];
              includeUnknown: false;
          };
          description: "Checks whether file paths used in read and write operations are valid and point to existing files.";
          name: "File Path Validity";
          tags: readonly [Robustness, Reproducibility, Bug];
      };
      prettyPrint: {
          full: (result: FilePathValidityResult) => string;
          query: (result: FilePathValidityResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElementFromQuery<ParentInformation>[],
          >,
          config: FilePathValidityConfig,
          data: {
              config: FlowrConfigOptions;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": FilePathValidityMetadata;
          results: FilePathValidityResult[];
      };
  }

• Readonlynaming-convention: {
      createSearch: (
          _config: NamingConventionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          defaultConfig: { caseing: "auto" };
          description: "Checks wether the symbols conform to a certain naming convention";
          name: "Naming Convention";
          tags: readonly [Style, QuickFix];
      };
      prettyPrint: {
          full: (result: NamingConventionResult) => string;
          query: (result: NamingConventionResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: NamingConventionConfig,
          data: {
              config: FlowrConfigOptions;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": { numBreak: number; numMatches: number };
          results: {
              certainty: LintingCertainty;
              detectedCasing: CasingConvention;
              name: string;
              quickFix: undefined | LintQuickFixReplacement[];
              range: SourceRange;
          }[];
      };
  }

• Readonlyseeded-randomness: {
      createSearch: (
          config: SeededRandomnessConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          ["with", "filter"],
          ParentInformation,
          "with",
      >;
      info: {
          defaultConfig: {
              randomnessConsumers: readonly [
                  "jitter",
                  "sample",
                  "sample.int",
                  "arima.sim",
                  "kmeans",
                  "princomp",
                  "rcauchy",
                  "rchisq",
                  "rexp",
                  "rgamma",
                  "rgeom",
                  "rlnorm",
                  "rlogis",
                  "rmultinom",
                  "rnbinom",
                  "rnorm",
                  "rpois",
                  "runif",
                  "pointLabel",
                  "some",
                  "rbernoulli",
                  "rdunif",
                  "generateSeedVectors",
              ];
              randomnessProducers: readonly [
                  { name: "set.seed"; type: "function" },
                  { name: ".Random.seed"; type: "assignment" },
              ];
          };
          description: "Checks whether randomness-based function calls are preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.";
          name: "Seeded Randomness";
          tags: readonly [Robustness, Reproducibility];
      };
      prettyPrint: {
          full: (
              result: SeededRandomnessResult,
              _meta: SeededRandomnessMeta,
          ) => string;
          query: (
              result: SeededRandomnessResult,
              _meta: SeededRandomnessMeta,
          ) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: SeededRandomnessConfig,
          __namedParameters: {
              config: FlowrConfigOptions;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": SeededRandomnessMeta;
          results: {
              certainty: Definitely;
              function: Identifier;
              range: SourceRange;
          }[];
      };
  }

• Readonlyunused-definitions: {
      createSearch: (
          config: UnusedDefinitionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          defaultConfig: { includeFunctionDefinitions: true };
          description: "Checks for unused definitions.";
          name: "Unused Definitions";
          tags: readonly [Readability, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: UnusedDefinitionResult) => string;
          query: (result: UnusedDefinitionResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: UnusedDefinitionConfig,
          data: {
              config: FlowrConfigOptions;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": UnusedDefinitionMetadata;
          results: UnusedDefinitionResult[];
      };
  }