Variable LintingRulesConst

Type Declaration

• Readonlyabsolute-file-paths: {
      createSearch: (
          config: AbsoluteFilePathConfig,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "unique">;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              absolutePathRegex: undefined;
              additionalPathFunctions: readonly [];
              ignoreUrls: true;
              include: { allStrings: ...; constructed: ... };
              useAsWd: "@project";
          };
          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, (...)[]>,
          config: AbsoluteFilePathConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlydataframe-access-validation: {
      createSearch: () => FlowrSearchBuilder<
          "all",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { readLoadedData: false };
          description: "Validates the existence 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, (...)[]>,
          config: DataFrameAccessValidationConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlydead-code: {
      createSearch: (
          config: DeadCodeConfig,
      ) => FlowrSearchBuilderOut<"all", [(...)], ParentInformation, "filter">;
      info: {
          certainty: BestEffort;
          defaultConfig: {};
          description: "Marks areas of code that are never reached during execution.";
          name: "Dead Code";
          tags: readonly [Smell, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: LintingResult) => string;
          query: (result: LintingResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: DeadCodeConfig,
          _data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { results: (...)[] };
  }

• Readonlydeprecated-functions: {
      createSearch: (
          _config: DeprecatedFunctionsConfig,
      ) => FlowrSearchBuilderOut<"all", [(...)], ParentInformation, "with">;
      info: {
          certainty: BestEffort;
          defaultConfig: { always: (...)[]; conditionally: Record<(...), (...)> };
          description: "Marks deprecated functions and deprecated arguments of still-current functions, offering the replacement as a quick fix where one is known. A call to a bare name whose package the code never attaches is reported as uncertain, as any function of that name would answer to it.";
          name: "Deprecated Functions";
          tags: readonly [Deprecated, Smell, Usability, Reproducibility, QuickFix];
      };
      prettyPrint: {
          full: (result: DeprecatedFunctionRuleResult) => string;
          query: (result: DeprecatedFunctionRuleResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: DeprecatedFunctionsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyfile-path-validity: {
      createSearch: (
          config: FilePathValidityConfig,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "with">;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              additionalReadFunctions: readonly [];
              additionalWriteFunctions: readonly [];
              checkUrls: false;
              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, QuickFix];
      };
      prettyPrint: {
          full: (result: FilePathValidityResult) => string;
          query: (result: FilePathValidityResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: FilePathValidityConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlynaming-convention: {
      createSearch: (
          _config: NamingConventionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          activeByDefault: false;
          certainty: OverApproximative;
          defaultConfig: { caseing: "auto"; ignoreNonAlpha: true };
          description: "Checks whether 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, (...)[]>,
          config: NamingConventionConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlynetwork-functions: {
      createSearch: (
          config: NetworkFunctionsConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          [(...), (...)],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { fns: (...)[] };
          description: "Marks network functions that execute network operations, such as downloading files or making HTTP requests.";
          name: "Network Functions";
          tags: readonly [Reproducibility, Security, Performance, Smell];
      };
      prettyPrint: {
          full: (result: FunctionsResult) => string;
          query: (result: FunctionsResult) => string;
      };
      processSearchResult: (
          e: FlowrSearchElements<ParentInformation, (...)[]>,
          c: NetworkFunctionsConfig,
          d: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyno-leaked-credentials: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              credentialNamePattern: "(?:password|passwd|pwd|secret|api[_.]?key|api[_.]?token|access[_.]?token|auth[_.]?token|bearer[_.]?token|private[_.]?key|credential)";
              credentialValuePattern: string;
          };
          description: "Detects hardcoded credentials assigned to variables whose names suggest they hold passwords, tokens, or API keys, or whose values match known credential formats (AWS, GitHub, Slack, Stripe, SSH).";
          name: "No Leaked Credentials";
          tags: readonly [Security, Experimental, Smell];
      };
      prettyPrint: {
          full: (result: NoLeakedCredentialsResult) => string;
          query: (result: NoLeakedCredentialsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: NoLeakedCredentialsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyproblematic-inputs: {
      createSearch: (
          config: ProblematicInputsConfig,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              consider: readonly (...)[];
              pipeCommandFunctions: readonly (...)[];
          };
          description: "Detects uses of dynamic calls (e.g. eval, system) with non-constant inputs, and graphics-device calls (pdf, postscript) where a filename starts with '|' indicating a pipe command injection.";
          name: "Problematic inputs";
          tags: readonly [Security, Smell, Readability, Performance];
      };
      prettyPrint: {
          full: (result: ProblematicInputsResult) => string;
          query: (result: ProblematicInputsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: ProblematicInputsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ results: ... }>;
  }

• Readonlyroxygen-arguments: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [(...)],
          ParentInformation,
          "with",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {};
          description: "Checks whether a function has undocumented or overdocumented parameters";
          name: "Roxygen Arguments";
          tags: readonly [Smell, Documentation, Style];
      };
      prettyPrint: {
          full: (result: RoxygenArgsResult) => string;
          query: (result: RoxygenArgsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: MergeableRecord,
      ) => { ".meta": {}; results: (...)[] };
  }

• Readonlyseeded-randomness: {
      createSearch: (
          config: SeededRandomnessConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          [(...), (...), (...)],
          ParentInformation,
          "with",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              randomnessConsumers: readonly [
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
                  (...),
              ];
              randomnessProducers: (...)[];
          };
          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, (...)[]>,
          config: SeededRandomnessConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlysoftware-has-license: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { checkDescriptionFile: true };
          description: "Checks whether the software project provides a license (via a LICENSE file or the DESCRIPTION file License field).";
          name: "Software Has License";
          tags: readonly [Documentation, Usability];
      };
      prettyPrint: {
          full: (result: SoftwareHasLicenseResult) => string;
          query: (result: SoftwareHasLicenseResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: SoftwareHasLicenseConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": {}; results: (...)[] };
  }

• Readonlysoftware-has-tests: {
      createSearch: (
          config: SoftwareHasTestsConfig,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { additionalTestFunctions: readonly [] };
          description: "Checks whether the software project has tests (test files in a test directory or test function calls in R code).";
          name: "Software Has Tests";
          tags: readonly [Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: SoftwareHasTestsResult) => string;
          query: (result: SoftwareHasTestsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: SoftwareHasTestsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => {
          ".meta": { testCallsFound: ...; testFilesFound: ... };
          results: (...)[];
      };
  }

• Readonlystop-call: {
      createSearch: () => FlowrSearchBuilderOut<
          "get",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {};
          description: "Checks whether stop calls without call. argument set to FALSE are used.";
          name: "Stop without call.=False argument";
          tags: readonly [Smell];
      };
      prettyPrint: {
          full: (result: LintingResult) => string;
          query: (result: LintingResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: MergeableRecord,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlysyntactically-valid: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          activeByDefault: false;
          certainty: BestEffort;
          defaultConfig: { disabledFixes: readonly []; preferFix: "remove" };
          description: "Checks whether the code is free of syntax errors, using the configured (error-tolerant) parser, and offers extensible quick-fixes to repair them.";
          name: "Syntactically Valid";
          tags: readonly [Bug, Robustness, QuickFix];
      };
      prettyPrint: {
          full: (result: SyntacticallyValidResult) => string;
          query: (result: SyntacticallyValidResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: SyntacticallyValidConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunclosed-connection: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { closeFns: readonly []; openFns: readonly [] };
          description: "Flags connections that are opened but not closed on every path opening them.";
          name: "Unclosed Connection";
          tags: readonly [Robustness, Smell];
      };
      prettyPrint: {
          full: (result: LintingResult) => string;
          query: (result: LintingResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnclosedConnectionConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyundefined-symbol: {
      createSearch: (
          _config: UndefinedSymbolConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: OverApproximative;
          defaultConfig: {
              checkFunctions: true;
              checkSubscripts: false;
              checkVariables: true;
          };
          description: "Flags functions and variables that are neither defined locally, a base R builtin, nor exported by a loaded package.";
          name: "Undefined Symbol";
          tags: readonly [Bug, Experimental];
      };
      prettyPrint: {
          full: (result: UndefinedSymbolResult) => string;
          query: (result: UndefinedSymbolResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UndefinedSymbolConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunescaped-arguments: {
      createSearch: (
          config: UnescapedArgumentsConfig,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              acceptedInputs: readonly (...)[];
              categories: {
                  database: ...;
                  eval: ...;
                  html: ...;
                  javascript: ...;
                  system: ...;
              };
              disabledCategories: readonly [];
              maxDecentDepth: 5;
          };
          description: "Detects arguments of critical system, evaluation, database, and HTML/JavaScript calls that are not properly escaped.";
          name: "Unescaped Arguments";
          tags: readonly [Security, Smell, Shiny, QuickFix];
      };
      prettyPrint: {
          full: (result: UnescapedArgumentsResult) => string;
          query: (result: UnescapedArgumentsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnescapedArgumentsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunused-definitions: {
      createSearch: (
          config: UnusedDefinitionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              excludeExportedDefinitions: true;
              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, (...)[]>,
          config: UnusedDefinitionConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunused-import: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { whitelist: readonly [] };
          description: "Highlights packages that are attached but never used, so the code runs just the same without them. Requires a signature database, and packages that only do their work on load should be whitelisted in the configuration.";
          name: "Unused Import";
          tags: readonly [Smell, Readability, QuickFix];
      };
      prettyPrint: {
          full: (result: UnusedImportResult) => string;
          query: (result: UnusedImportResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnusedImportConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyuseless-loop: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { loopyFunctions: Set<(...)> };
          description: "Detect loops which only iterate once";
          name: "Useless Loops";
          tags: readonly [Smell, Readability];
      };
      prettyPrint: {
          full: (result: UselessLoopResult) => string;
          query: (result: UselessLoopResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          useLessLoopConfig: UselessLoopConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }