@codacy/tools-scalastyle-1 0.3.0

package/dist/index.js

@@ -0,0 +1,1440 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_tooling2 = require("@codacy/tooling");
+
+// src/adapter.ts
+var import_tooling = require("@codacy/tooling");
+var import_fast_xml_parser = require("fast-xml-parser");
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_os = __toESM(require("os"));
+
+// src/patterns.json
+var patterns_default = [
+  {
+    id: "ScalaStyle_BlockImportChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Block Imports",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_CaseBraceChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Braces in Case Clauses",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_ClassNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Class Naming Conventions",
+    enabled: true,
+    parameters: [
+      {
+        name: "regex",
+        default: "^[A-Z][A-Za-z]*$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_ClassTypeParameterChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Class Type Parameter Naming Convention",
+    enabled: true,
+    parameters: [
+      {
+        name: "regex",
+        default: "^[A-Z_]$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_CovariantEqualsChecker",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Covariant Equals Method Without Proper Override",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_CurliesImportChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Curlies Imports",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_CyclomaticComplexityChecker",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Cyclomatic Complexity Limits",
+    enabled: true,
+    parameters: [
+      {
+        name: "countCases",
+        default: "true",
+        description: "countCases"
+      },
+      {
+        name: "maximum",
+        default: "10",
+        description: "maximum"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_DeprecatedJavaChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Using Deprecated Java Annotations",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_DisallowSpaceAfterTokenChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Space After Token",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_DisallowSpaceBeforeTokenChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Space Before Token",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_EmptyClassChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Empty Class Braces",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_EmptyInterpolatedStringChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Empty Interpolated Strings",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_EnsureSingleSpaceAfterTokenChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Ensure Single Space After Token",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_EnsureSingleSpaceBeforeTokenChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Ensure Single Space Before Token",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_EqualsHashCodeChecker",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Ensure equals and hashCode are both defined",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_FieldNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Field Names",
+    enabled: true,
+    parameters: [
+      {
+        name: "objectFieldRegex",
+        default: "^[A-Z][A-Za-z0-9]*$",
+        description: "objectFieldRegex"
+      },
+      {
+        name: "regex",
+        default: "^[a-z][A-Za-z0-9]*$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_FileLengthChecker",
+    category: "Complexity",
+    severityLevel: "Info",
+    title: "Enforce File Length Limit",
+    enabled: true,
+    parameters: [
+      {
+        name: "maxFileLength",
+        default: "1500",
+        description: "maxFileLength"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_FileLineLengthChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce File Line Length Limit",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreImports",
+        default: "false",
+        description: "ignoreImports"
+      },
+      {
+        name: "maxLineLength",
+        default: "160",
+        description: "maxLineLength"
+      },
+      {
+        name: "tabSize",
+        default: "4",
+        description: "tabSize"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_FileTabChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Tabs in File",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_ForBraceChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Braces in For Comprehensions",
+    enabled: true,
+    parameters: [
+      {
+        name: "singleLineAllowed",
+        default: "false",
+        description: "singleLineAllowed"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_ForLoopChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Readable For Loop Syntax",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_HeaderMatchesChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce File Header Matches",
+    enabled: true,
+    parameters: [
+      {
+        name: "header",
+        default: "",
+        description: "header"
+      },
+      {
+        name: "regex",
+        default: "false",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_IfBraceChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce If Statement Braces",
+    enabled: true,
+    parameters: [
+      {
+        name: "doubleLineAllowed",
+        default: "false",
+        description: "doubleLineAllowed"
+      },
+      {
+        name: "singleLineAllowed",
+        default: "true",
+        description: "singleLineAllowed"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_IllegalImportsChecker",
+    category: "Compatibility",
+    severityLevel: "Warning",
+    title: "Disallow Illegal Imports",
+    enabled: true,
+    parameters: [
+      {
+        name: "illegalImports",
+        default: "sun._,java.awt._",
+        description: "illegalImports"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_ImportGroupingChecker",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Enforce Import Grouping",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_ImportOrderChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Import Order",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_IndentationChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Indentation",
+    enabled: true,
+    parameters: [
+      {
+        name: "classParamIndentSize",
+        default: "4",
+        description: "classParamIndentSize"
+      },
+      {
+        name: "methodParamIndentSize",
+        default: "2",
+        description: "methodParamIndentSize"
+      },
+      {
+        name: "tabSize",
+        default: "2",
+        description: "tabSize"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_LowercasePatternMatchChecker",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Lowercase Pattern Match Variable",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_MagicNumberChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Magic Numbers",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignore",
+        default: "-1,0,1,2",
+        description: "ignore"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_MethodArgumentNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Method Argument Names Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreRegex",
+        default: "^$",
+        description: "ignoreRegex"
+      },
+      {
+        name: "regex",
+        default: "^[a-z][A-Za-z0-9]*$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_MethodLengthChecker",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Long Methods",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreComments",
+        default: "false",
+        description: "ignoreComments"
+      },
+      {
+        name: "ignoreEmpty",
+        default: "false",
+        description: "ignoreEmpty"
+      },
+      {
+        name: "maxLength",
+        default: "50",
+        description: "maxLength"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_MethodNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Method Naming Conventions",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreOverride",
+        default: "false",
+        description: "ignoreOverride"
+      },
+      {
+        name: "ignoreRegex",
+        default: "^$",
+        description: "ignoreRegex"
+      },
+      {
+        name: "regex",
+        default: "^[a-z][A-Za-z0-9]*(_=)?$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_MultipleStringLiteralsChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Multiple String Literals",
+    enabled: true,
+    parameters: [
+      {
+        name: "allowed",
+        default: "1",
+        description: "allowed"
+      },
+      {
+        name: "ignoreRegex",
+        default: '^""$',
+        description: "ignoreRegex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_NamedArgumentChecker",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Enforce Named Arguments",
+    enabled: true,
+    parameters: [
+      {
+        name: "checkString",
+        default: "false",
+        description: "checkString"
+      },
+      {
+        name: "ignoreMethod",
+        default: "^set.+$",
+        description: "ignoreMethod"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_NewLineAtEofChecker",
+    category: "Compatibility",
+    severityLevel: "Info",
+    title: "Enforce New Line At End Of File",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NoCloneChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Using Clone Method",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NoFinalizeChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Using finalize Method",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NonASCIICharacterChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Non-ASCII Characters",
+    enabled: true,
+    parameters: [
+      {
+        name: "allowStringLiterals",
+        default: "false",
+        description: "allowStringLiterals"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_NoNewLineAtEofChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow New Line at End of File",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NotImplementedErrorUsage",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Not Implemented Error Usage",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NoWhitespaceAfterLeftBracketChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Whitespace After Left Bracket",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NoWhitespaceBeforeLeftBracketChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Whitespace Before Left Bracket",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NoWhitespaceBeforeRightBracketChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Whitespace Before Right Bracket",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_NullChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Using Null",
+    enabled: true,
+    parameters: [
+      {
+        name: "allowNullChecks",
+        default: "true",
+        description: "allowNullChecks"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_NumberOfMethodsInTypeChecker",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Limit on Number of Methods in Type",
+    enabled: true,
+    parameters: [
+      {
+        name: "maxMethods",
+        default: "30",
+        description: "maxMethods"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_NumberOfTypesChecker",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Limit Number of Types per File",
+    enabled: true,
+    parameters: [
+      {
+        name: "maxTypes",
+        default: "20",
+        description: "maxTypes"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_ObjectNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Object Naming Conventions",
+    enabled: true,
+    parameters: [
+      {
+        name: "regex",
+        default: "^[A-Z][A-Za-z]*$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_OverrideJavaChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce use of Scala override keyword",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_PackageNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Package Naming Conventions",
+    enabled: true,
+    parameters: [
+      {
+        name: "regex",
+        default: "^[a-z]+$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_PackageObjectNamesChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Package Object Naming Conventions",
+    enabled: true,
+    parameters: [
+      {
+        name: "regex",
+        default: "^[a-z][A-Za-z]*$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_ParameterNumberChecker",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Methods with Too Many Parameters",
+    enabled: true,
+    parameters: [
+      {
+        name: "maxParameters",
+        default: "8",
+        description: "maxParameters"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_PatternMatchAlignChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Pattern Match Alignment",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_ProcedureDeclarationChecker",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Procedure Style Declarations",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_PublicMethodsHaveTypeChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Public Methods Have Explicit Return Type",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreOverride",
+        default: "false",
+        description: "ignoreOverride"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_RedundantIfChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant If Expressions",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_RegexChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Custom Checks Using Regular Expressions",
+    enabled: true,
+    parameters: [
+      {
+        name: "line",
+        default: "false",
+        description: "line"
+      },
+      {
+        name: "regex",
+        default: "",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_ReturnChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Use of Return",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_ScalaDocChecker",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce ScalaDoc Usage",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreOverride",
+        default: "false",
+        description: "ignoreOverride"
+      },
+      {
+        name: "ignoreRegex",
+        default: "^$",
+        description: "ignoreRegex"
+      },
+      {
+        name: "ignoreTokenTypes",
+        default: "^$",
+        description: "ignoreTokenTypes"
+      },
+      {
+        name: "indentStyle",
+        default: "anydoc",
+        description: "indentStyle"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_SimplifyBooleanExpressionChecker",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Simplify Boolean Expression",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_SpaceAfterCommentStartChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Space After Comment Start",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_SpacesAfterPlusChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Spaces Around Plus Operator",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_SpacesBeforePlusChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Spaces Before Plus Operator",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_StructuralTypeChecker",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Avoid Structural Types",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_ThrowChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Throw Statements",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_TodoCommentChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Todo and Fixme Comments",
+    enabled: true,
+    parameters: [
+      {
+        name: "words",
+        default: "TODO|FIXME",
+        description: "words"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_TokenChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Check Presence of Specific Token",
+    enabled: true,
+    parameters: [
+      {
+        name: "regex",
+        default: "^$",
+        description: "regex"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_UnderscoreImportChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Underscore Imports",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_UppercaseLChecker",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Lowercase L in Identifiers",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_VarFieldChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Using Var Fields",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_VarLocalChecker",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Mutable Local Variables (var Local)",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_WhileBraceChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Braces for While Loops",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_WhileChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Using While Loops",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "ScalaStyle_WhitespaceEndOfLineChecker",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Whitespace at End of Line",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignoreWhitespaceLines",
+        default: "false",
+        description: "ignoreWhitespaceLines"
+      }
+    ]
+  },
+  {
+    id: "ScalaStyle_XmlLiteralChecker",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid XML Literals",
+    enabled: true,
+    parameters: []
+  }
+];
+
+// src/adapter.ts
+var TOOL_ID = "ScalaStyle";
+var SCALASTYLE_VERSION = "1.5.1";
+var JAR_NAME = "scalastyle.jar";
+var JAR_URL = "https://repo1.maven.org/maven2/com/beautiful-scala/scalastyle_2.13/1.5.1/scalastyle_2.13-1.5.1-assembly.jar";
+var JAVA_VERSION_RANGE = ">=8";
+var FILE_LEVEL_CHECKERS = /* @__PURE__ */ new Set([
+  "FileLengthChecker",
+  "FileLineLengthChecker",
+  "FileTabChecker",
+  "HeaderMatchesChecker",
+  "IndentationChecker",
+  "NewLineAtEofChecker",
+  "RegexChecker",
+  "WhitespaceEndOfLineChecker"
+]);
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "Security",
+  "ErrorProne",
+  "CodeStyle",
+  "Compatibility",
+  "Performance",
+  "UnusedCode",
+  "Complexity",
+  "BestPractice",
+  "Documentation"
+]);
+var PATTERN_META = new Map(
+  patterns_default.map((p) => [
+    p.id,
+    {
+      category: VALID_CATEGORIES.has(p.category) ? p.category : "BestPractice",
+      severity: p.severityLevel ?? "Info"
+    }
+  ])
+);
+function ruleMetadata(patternId) {
+  return PATTERN_META.get(patternId) ?? { category: "CodeStyle", severity: "Info" };
+}
+var xmlParser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  isArray: (name) => name === "file" || name === "error",
+  processEntities: {
+    enabled: true,
+    maxTotalExpansions: 1e5
+  }
+});
+function getLineContent(lines, lineNumber) {
+  return lines[lineNumber - 1] ?? "";
+}
+async function readFileLines(filePath) {
+  try {
+    const content = await import_promises.default.readFile(filePath, "utf-8");
+    return content.split("\n");
+  } catch {
+    return [];
+  }
+}
+function buildResult(startedAt, completedAt, issues, errors, filesAnalyzed) {
+  const durationMs = completedAt.getTime() - startedAt.getTime();
+  return {
+    metadata: {
+      startedAt: startedAt.toISOString(),
+      completedAt: completedAt.toISOString(),
+      durationMs
+    },
+    issues,
+    errors,
+    summary: {
+      toolId: TOOL_ID,
+      status: errors.some((e) => e.level === "error") ? "partial" : "success",
+      issueCount: issues.length,
+      errorCount: errors.length,
+      durationMs,
+      filesAnalyzed
+    }
+  };
+}
+function derivePatternId(source) {
+  const lastDot = source.lastIndexOf(".");
+  const checkerName = lastDot >= 0 ? source.substring(lastDot + 1) : source;
+  return `${TOOL_ID}_${checkerName}`;
+}
+function checkerNameToFqcn(checkerName) {
+  const namespace = FILE_LEVEL_CHECKERS.has(checkerName) ? "org.scalastyle.file" : "org.scalastyle.scalariform";
+  return `${namespace}.${checkerName}`;
+}
+async function resolveJarPath(ctx) {
+  const jarPath = import_path.default.join(ctx.toolInstallDir, JAR_NAME);
+  try {
+    await import_promises.default.access(jarPath);
+    return jarPath;
+  } catch {
+    return null;
+  }
+}
+async function resolveJavaBinary(ctx) {
+  const jreDir = import_path.default.join(ctx.globalDir, "runtimes", "java-17");
+  const javaBin = import_path.default.join(jreDir, "bin", "java");
+  try {
+    await import_promises.default.access(javaBin);
+    return javaBin;
+  } catch {
+  }
+  if (process.env.JAVA_HOME) {
+    const javaHome = import_path.default.join(process.env.JAVA_HOME, "bin", "java");
+    try {
+      await import_promises.default.access(javaHome);
+      return javaHome;
+    } catch {
+    }
+  }
+  return "java";
+}
+function generateScalastyleConfig(patterns) {
+  const checks = [];
+  for (const pattern of patterns) {
+    const prefix = `${TOOL_ID}_`;
+    if (!pattern.patternId.startsWith(prefix)) continue;
+    const checkerName = pattern.patternId.slice(prefix.length);
+    const fqcn = checkerNameToFqcn(checkerName);
+    const params = pattern.parameters ?? {};
+    const mergedParams = Object.entries(params).map(
+      ([key, val]) => ({ name: key, value: val })
+    );
+    if (REQUIRES_USER_PARAMS.has(checkerName) && mergedParams.length === 0) {
+      continue;
+    }
+    if (mergedParams.length > 0) {
+      const paramLines = mergedParams.map(
+        (p) => `      <parameter name="${escapeXml(p.name)}">${escapeXml(p.value)}</parameter>`
+      ).join("\n");
+      checks.push(
+        `  <check level="warning" class="${fqcn}" enabled="true">
+    <parameters>
+${paramLines}
+    </parameters>
+  </check>`
+      );
+    } else {
+      checks.push(`  <check level="warning" class="${fqcn}" enabled="true" />`);
+    }
+  }
+  const lines = [
+    `<scalastyle>`,
+    `  <name>Generated configuration</name>`,
+    ...checks,
+    `</scalastyle>`
+  ];
+  return lines.join("\n") + "\n";
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var REQUIRES_USER_PARAMS = /* @__PURE__ */ new Set([
+  "HeaderMatchesChecker",
+  // needs `header` parameter
+  "RegexChecker",
+  // needs `regex` parameter
+  "TokenChecker"
+  // needs `regex` parameter
+]);
+var CONFIG_FILE_CANDIDATES = ["scalastyle_config.xml", "scalastyle-config.xml"];
+var adapter = {
+  id: TOOL_ID,
+  displayName: "Scalastyle",
+  preferredVersion: SCALASTYLE_VERSION,
+  compatibleVersions: ">=1.0.0",
+  website: "http://www.scalastyle.org/",
+  languages: ["Scala"],
+  filePatterns: ["**/*.scala"],
+  supportedOS: ["linux", "darwin", "win32"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  prerequisites: [
+    {
+      name: "Java",
+      versionRange: JAVA_VERSION_RANGE,
+      preferredVersion: "17",
+      checkCommand: "java -version"
+    }
+  ],
+  /**
+   * Checks whether Scalastyle is available by detecting Java and the JAR.
+   *
+   * Reports Java as a dependency. Scalastyle is considered available if:
+   * 1. Java 8+ is found on the system or in the Codacy-managed JRE
+   * 2. The Scalastyle assembly JAR exists in the tool install directory
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    const javaInfo = await (0, import_tooling.findJava)(JAVA_VERSION_RANGE, ctx.logger).catch(() => null);
+    const dependencies = javaInfo ? [{ name: "Java", available: true, version: javaInfo.version, installation: "global" }] : [{ name: "Java", available: false, reason: `Java (${JAVA_VERSION_RANGE}) not found` }];
+    if (!javaInfo) {
+      const jreDir = import_path.default.join(ctx.globalDir, "runtimes", "java-17");
+      const javaBin = import_path.default.join(jreDir, "bin", "java");
+      try {
+        await import_promises.default.access(javaBin);
+        dependencies[0] = {
+          name: "Java",
+          available: true,
+          version: "17",
+          installation: "codacy"
+        };
+      } catch {
+        return {
+          available: false,
+          reason: "Java runtime not found (required for Scalastyle)",
+          installHint: "Install JDK 8+, or run with --install-dependencies for auto-download",
+          dependencies
+        };
+      }
+    }
+    const jarPath = await resolveJarPath(ctx);
+    if (jarPath) {
+      ctx.logger.debug("Scalastyle available", { toolId: TOOL_ID, version: SCALASTYLE_VERSION });
+      return {
+        available: true,
+        version: SCALASTYLE_VERSION,
+        path: jarPath,
+        installation: "codacy",
+        dependencies
+      };
+    }
+    ctx.logger.debug("Scalastyle JAR not found", { toolId: TOOL_ID });
+    return {
+      available: false,
+      reason: `Scalastyle JAR not found at ${import_path.default.join(ctx.toolInstallDir, JAR_NAME)}`,
+      installHint: "Run with --install-dependencies to auto-download, or manually place the JAR",
+      dependencies
+    };
+  },
+  /**
+   * Installs Scalastyle by ensuring a JRE is available and downloading
+   * the assembly JAR from Maven Central.
+   *
+   * Uses ensureJre() to download Adoptium Temurin JDK 17 if no system Java
+   * is found, then downloads the Scalastyle assembly JAR.
+   */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    const java = await (0, import_tooling.ensureJre)(ctx.globalDir, JAVA_VERSION_RANGE, ctx.logger);
+    if (!java) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "requirementCheck",
+          kind: "MissingPrerequisite",
+          message: `Java (${JAVA_VERSION_RANGE}) could not be found or downloaded. Scalastyle requires a JDK/JRE.`,
+          level: "error"
+        }
+      };
+    }
+    try {
+      ctx.logger.info(`Downloading Scalastyle ${SCALASTYLE_VERSION} JAR...`);
+      const jarPath = await (0, import_tooling.downloadJar)(JAR_URL, ctx.toolInstallDir, JAR_NAME, ctx.logger);
+      ctx.logger.info(`Downloaded Scalastyle to ${jarPath}`);
+      return { success: true, installedPath: jarPath, installedVersion: SCALASTYLE_VERSION };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "toolInstall",
+          kind: "InstallError",
+          message: `Failed to download Scalastyle JAR: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        }
+      };
+    }
+  },
+  /**
+   * Checks for Scalastyle configuration files in the repository root.
+   *
+   * Looks for `scalastyle_config.xml` or `scalastyle-config.xml` (in that order).
+   * Returns the first found file.
+   */
+  async checkLocalConfigurationFile(ctx) {
+    ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    for (const candidate of CONFIG_FILE_CANDIDATES) {
+      const candidatePath = import_path.default.join(ctx.repositoryRoot, candidate);
+      try {
+        await import_promises.default.access(candidatePath);
+        ctx.logger.debug("Local config found", { toolId: TOOL_ID, path: candidatePath });
+        return { found: true, path: candidatePath };
+      } catch {
+      }
+    }
+    return { found: false };
+  },
+  /**
+   * Runs Scalastyle via `java -cp scalastyle.jar org.scalastyle.Main` against
+   * the target files and converts the Checkstyle XML output into Codacy Issue objects.
+   *
+   * Config resolution:
+   * - If `useLocalConfigurationFile` is true and a local config is found,
+   *   passes `--config <path>` to use the project's scalastyle config.
+   * - If patterns are specified and no local config is in use, generates
+   *   a temporary `scalastyle_config.xml` with the enabled checks.
+   * - Otherwise (no local config and no patterns), skips execution.
+   *
+   * Key details:
+   * - Scalastyle takes directories (not file lists) as source input.
+   *   We pass the repository root and then filter the output by targetFiles.
+   * - `--xmlOutput <tmpFile>` writes Checkstyle-format XML to a temp file.
+   * - The `source` attribute in XML is an FQCN like
+   *   `org.scalastyle.scalariform.MagicNumberChecker`.
+   *   We extract the last segment and prefix with `ScalaStyle_`.
+   *
+   * Exit codes: 0 = success, 1 = violations or error.
+   *
+   * Never throws — all errors are captured in the returned `errors` array.
+   */
+  async analyze(ctx, codacyConfig) {
+    const startMs = Date.now();
+    ctx.logger.info("Starting analysis", { toolId: TOOL_ID, fileCount: ctx.targetFiles.length });
+    const startedAt = /* @__PURE__ */ new Date();
+    const issues = [];
+    const errors = [];
+    if (ctx.targetFiles.length === 0) {
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, 0);
+    }
+    const useLocal = codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile;
+    if (!useLocal && codacyConfig.patterns.length === 0) {
+      ctx.logger.info("Skipping analysis: no local config and no patterns enabled", {
+        toolId: TOOL_ID
+      });
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    }
+    const javaBin = await resolveJavaBinary(ctx);
+    const jarPath = await resolveJarPath(ctx);
+    if (!jarPath) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "MissingPrerequisite",
+        message: `Scalastyle JAR not found at ${import_path.default.join(ctx.toolInstallDir, JAR_NAME)}. Run install first.`,
+        level: "error"
+      });
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    }
+    const tmpDir = await import_promises.default.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "scalastyle-"));
+    const reportFile = import_path.default.join(tmpDir, "scalastyle-output.xml");
+    let generatedConfigPath = null;
+    let configPath;
+    if (useLocal) {
+      configPath = codacyConfig.localConfigurationFile;
+    } else if (codacyConfig.patterns.length > 0) {
+      const configXml = generateScalastyleConfig(codacyConfig.patterns);
+      generatedConfigPath = import_path.default.join(ctx.generatedConfigDir, "scalastyle_config.xml");
+      await import_promises.default.mkdir(ctx.generatedConfigDir, { recursive: true });
+      await import_promises.default.writeFile(generatedConfigPath, configXml, "utf-8");
+      configPath = generatedConfigPath;
+      ctx.logger.debug("Generated Scalastyle config", {
+        configPath: generatedConfigPath,
+        checksCount: configXml.split("<check ").length - 1
+      });
+    } else {
+      await cleanupTmpDir(tmpDir);
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    }
+    const args = [
+      "-cp",
+      jarPath,
+      "org.scalastyle.Main",
+      "--config",
+      configPath,
+      "--xmlOutput",
+      reportFile,
+      ctx.repositoryRoot
+    ];
+    const targetFileSet = new Set(ctx.targetFiles.map((f) => import_path.default.normalize(f)));
+    try {
+      const { stderr, exitCode } = await (0, import_tooling.spawnTool)(javaBin, args, {
+        cwd: ctx.repositoryRoot,
+        logger: ctx.logger
+      });
+      if (exitCode > 1) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "toolInvoke",
+          kind: "NonZeroExit",
+          message: `Scalastyle exited with code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`,
+          level: "error"
+        });
+        await cleanupTmpDir(tmpDir);
+        if (generatedConfigPath) await import_promises.default.unlink(generatedConfigPath).catch(() => {
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      let xmlContent;
+      try {
+        xmlContent = await import_promises.default.readFile(reportFile, "utf-8");
+      } catch {
+        if (stderr && stderr.trim()) {
+          errors.push({
+            toolId: TOOL_ID,
+            phase: "outputParse",
+            kind: "ParseWarning",
+            message: `Scalastyle stderr: ${stderr.trim()}`,
+            level: "warning"
+          });
+        }
+        await cleanupTmpDir(tmpDir);
+        if (generatedConfigPath) await import_promises.default.unlink(generatedConfigPath).catch(() => {
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      if (!xmlContent.trim()) {
+        await cleanupTmpDir(tmpDir);
+        if (generatedConfigPath) await import_promises.default.unlink(generatedConfigPath).catch(() => {
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      let files;
+      try {
+        const parsed = xmlParser.parse(xmlContent);
+        const rawFiles = parsed?.checkstyle?.file;
+        files = rawFiles ? Array.isArray(rawFiles) ? rawFiles : [rawFiles] : [];
+      } catch (err) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "MalformedOutput",
+          message: `Failed to parse Scalastyle XML output: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        });
+        await cleanupTmpDir(tmpDir);
+        if (generatedConfigPath) await import_promises.default.unlink(generatedConfigPath).catch(() => {
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+      for (const file of files) {
+        const filePath = file["@_name"];
+        if (!filePath) continue;
+        const rawErrors = file.error;
+        const fileErrors = rawErrors ? Array.isArray(rawErrors) ? rawErrors : [rawErrors] : [];
+        if (fileErrors.length === 0) continue;
+        const relPath = import_path.default.isAbsolute(filePath) ? import_path.default.relative(ctx.repositoryRoot, filePath) : filePath;
+        if (!targetFileSet.has(import_path.default.normalize(relPath))) continue;
+        const absolutePath = import_path.default.resolve(ctx.repositoryRoot, relPath);
+        const lines = await readFileLines(absolutePath);
+        for (const error of fileErrors) {
+          const source = error["@_source"] ?? "";
+          if (!source) continue;
+          const patternId = derivePatternId(source);
+          if (enabledPatterns.size > 0 && !enabledPatterns.has(patternId)) {
+            continue;
+          }
+          const line = parseInt(error["@_line"], 10) || 1;
+          const column = parseInt(error["@_column"] ?? "1", 10) || 1;
+          const meta = ruleMetadata(patternId);
+          issues.push({
+            filePath: relPath,
+            patternId,
+            toolId: TOOL_ID,
+            line,
+            column,
+            message: error["@_message"],
+            lineContent: getLineContent(lines, line),
+            category: meta.category,
+            severity: meta.severity
+          });
+        }
+      }
+      const stderrFiltered = stderr.split("\n").filter((line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return false;
+        if (trimmed.startsWith("Processed")) return false;
+        if (trimmed.startsWith("Found")) return false;
+        return true;
+      }).join("\n").trim();
+      if (stderrFiltered) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "ParseWarning",
+          message: `Scalastyle stderr: ${stderrFiltered}`,
+          level: "warning"
+        });
+      }
+      await cleanupTmpDir(tmpDir);
+    } catch (invokeErr) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `Failed to run Scalastyle: ${invokeErr instanceof Error ? invokeErr.message : String(invokeErr)}`,
+        level: "error"
+      });
+      await cleanupTmpDir(tmpDir);
+    } finally {
+      if (generatedConfigPath) {
+        await import_promises.default.unlink(generatedConfigPath).catch(() => {
+        });
+      }
+    }
+    const durationMs = Date.now() - startMs;
+    ctx.logger.info("Analysis complete", {
+      toolId: TOOL_ID,
+      issueCount: issues.length,
+      errorCount: errors.length,
+      durationMs
+    });
+    return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+  }
+};
+async function cleanupTmpDir(tmpDir) {
+  try {
+    await import_promises.default.rm(tmpDir, { recursive: true });
+  } catch {
+  }
+}
+
+// src/index.ts
+var index_default = (0, import_tooling2.defineToolAdapter)(adapter);