feature: add metric as an alternative to metrics in config file CY-3986

Author: pedrocodacy

cli/src/main/scala/com/codacy/analysis/cli/analysis/AnalyseExecutor.scala

@@ -158,10 +158,9 @@ class AnalyseExecutor(formatter: Formatter,
       getExtraConfiguration(configuration.extraToolConfigurations, tool)
     (for {
       allToolsConfiguration <- configuration.toolConfigurations
-      toolConfiguration <-
-        allToolsConfiguration
-          .find(_.uuid.equalsIgnoreCase(tool.uuid))
-          .toRight[String](s"Could not find configuration for tool ${tool.name}")
+      toolConfiguration <- allToolsConfiguration
+        .find(_.uuid.equalsIgnoreCase(tool.uuid))
+        .toRight[String](s"Could not find configuration for tool ${tool.name}")
     } yield {
       val shouldUseConfigFile = toolConfiguration.notEdited && hasConfigFiles
       val shouldUseRemoteConfiguredPatterns = !shouldUseConfigFile && toolConfiguration.patterns.nonEmpty

cli/src/test/scala/com/codacy/analysis/cli/ToolSelectorSpec.scala

@@ -62,8 +62,8 @@ class ToolSelectorSpec extends Specification with NoLanguageFeatures {
       rubyTools should beRight
       rubyTools must beLike {
         case Right(tools) =>
-          tools.map(_.name) must containTheSameElementsAs(
-            Seq("Brakeman", "Rubocop", "BundlerAudit", "metrics", "duplication"))
+          tools.map(_.names.mkString("/")) must containTheSameElementsAs(
+            Seq("Brakeman", "Rubocop", "BundlerAudit", "metric/metrics", "duplication"))
           tools.flatMap(_.supportedLanguages) must containAllOf(Seq(Languages.Ruby))
       }
     }

core/src/main/scala/com/codacy/analysis/core/analysis/CodacyPluginsAnalyser.scala

@@ -26,9 +26,9 @@ final class CodacyPluginsAnalyser extends Analyser[Try] {
 
     result match {
       case Success(res) =>
-        logger.info(s"Completed analysis for ${tool.name} with ${res.size} results")
+        logger.info(s"Completed analysis for ${tool.names.mkString("/")} with ${res.size} results")
       case Failure(e) =>
-        logger.error(e)(AnalyserError.ToolExecutionFailure("analysis", tool.name).message)
+        logger.error(e)(AnalyserError.ToolExecutionFailure("analysis", tool.names.mkString("/")).message)
     }
 
     result
@@ -47,9 +47,9 @@ final class CodacyPluginsAnalyser extends Analyser[Try] {
 
     result match {
       case Success(res) =>
-        logger.info(s"Completed metrics for ${metricsTool.name} with ${res.size} results")
+        logger.info(s"Completed metrics for ${metricsTool.names.mkString("/")} with ${res.size} results")
       case Failure(e) =>
-        logger.error(e)(AnalyserError.ToolExecutionFailure("metrics", metricsTool.name).message)
+        logger.error(e)(AnalyserError.ToolExecutionFailure("metrics", metricsTool.names.mkString("/")).message)
     }
 
     result.map(_.to[Set])
@@ -66,9 +66,9 @@ final class CodacyPluginsAnalyser extends Analyser[Try] {
 
     result match {
       case Success(res) =>
-        logger.info(s"Completed duplication for ${duplicationTool.name} with ${res.size} results")
+        logger.info(s"Completed duplication for ${duplicationTool.names.mkString("/")} with ${res.size} results")
       case Failure(e) =>
-        logger.error(e)(AnalyserError.ToolExecutionFailure("duplication", duplicationTool.name).message)
+        logger.error(e)(AnalyserError.ToolExecutionFailure("duplication", duplicationTool.names.mkString("/")).message)
     }
 
     result.map(_.to[Set])

core/src/main/scala/com/codacy/analysis/core/files/FileCollector.scala

@@ -53,12 +53,18 @@ trait FileCollector[T[_]] {
 
     val filters =
       Set[Set[Path] => Set[Path]](
-        filterByGlobs(_, exclusionRules.excludePaths.byTool.getOrElse(tool.name, Set.empty)),
+        filterByGlobs(_, getExcludePathsForTool(exclusionRules.excludePaths, tool)),
         filterByLanguage(tool.languageToRun, exclusionRules.allowedExtensionsByLanguage))
     val filteredFiles = filters.foldLeft(target.readableFiles) { case (fs, filter) => filter(fs) }
     target.copy(readableFiles = filteredFiles)
   }
 
+  private def getExcludePathsForTool(excludePaths: ExcludePaths, tool: ITool): Set[Glob] = {
+    tool.names.foldLeft(Set.empty[Glob]){ (accum, next) =>
+        excludePaths.byTool.getOrElse(next,accum)
+    }
+  }
+
   private def filterByGlobs(files: Set[Path], excludeGlobs: Set[Glob]): Set[Path] = {
     if (excludeGlobs.nonEmpty) {
       files.filterNot(file => excludeGlobs.exists(_.matches(file.toString)))

core/src/main/scala/com/codacy/analysis/core/tools/DuplicationTool.scala

@@ -17,7 +17,7 @@ import scala.util.Try
 
 class DuplicationTool(private val duplicationTool: traits.DuplicationTool, val languageToRun: Language) extends ITool {
 
-  override def name: String = "duplication"
+  override def names: Seq[String] = Seq("duplication")
   override def supportedLanguages: Set[Language] = duplicationTool.languages.to[Set]
 
   def run(directory: File,

core/src/main/scala/com/codacy/analysis/core/tools/ITool.scala

@@ -3,7 +3,7 @@ package com.codacy.analysis.core.tools
 import com.codacy.plugins.api.languages.Language
 
 trait ITool {
-  def name: String
+  def names: Seq[String]
   def supportedLanguages: Set[Language]
   def languageToRun: Language
 }

core/src/main/scala/com/codacy/analysis/core/tools/MetricsTool.scala

@@ -18,7 +18,7 @@ import scala.concurrent.duration.Duration
 import scala.util.Try
 
 class MetricsTool(private val metricsTool: traits.MetricsTool, val languageToRun: Language) extends ITool {
-  override def name: String = "metrics"
+  override def names: Seq[String] = Seq("metric", "metrics")
 
   override def supportedLanguages: Set[Language] = metricsTool.languages.to[Set]
 

core/src/main/scala/com/codacy/analysis/core/tools/Tool.scala

@@ -45,8 +45,9 @@ class Tool(fullToolSpec: FullToolSpec, defaultRunTimeout: Duration)(private val
 
   private val logger: Logger = getLogger
 
-  override def name: String = tool.shortName
+  override def names: Seq[String] = Seq(tool.shortName)
   def uuid: String = tool.uuid
+  def name: String = tool.shortName
 
   override def supportedLanguages: Set[Language] = tool.languages
 
@@ -166,12 +167,10 @@ class ToolCollector(toolRepository: ToolRepository) {
       Left(AnalyserError.NoActiveToolInConfiguration)
     } else {
       val toolsIdentified = toolUuids.flatMap { toolUuid =>
-        from(toolUuid, languages).fold(
-          { _ =>
-            logger.warn(s"Failed to get tool for uuid:$toolUuid")
-            Set.empty[Tool]
-          },
-          identity)
+        from(toolUuid, languages).fold({ _ =>
+          logger.warn(s"Failed to get tool for uuid:$toolUuid")
+          Set.empty[Tool]
+        }, identity)
       }
 
       if (toolsIdentified.size != toolUuids.size) {