clean: Update logging and use new parser

Author: rtfpessoa

src/main/resources/logback-test.xml

@@ -4,15 +4,16 @@ import com.codacy.configuration.parser.{CommandConfiguration, ConfigurationParsi
 import com.codacy.di.Components
 import com.codacy.helpers.LoggerHelper
 import com.codacy.model.configuration.{FinalConfig, ReportConfig}
+import com.typesafe.scalalogging.LazyLogging
 
-object CodacyCoverageReporter extends ConfigurationParsingApp {
+object CodacyCoverageReporter extends ConfigurationParsingApp with LazyLogging {
 
   def run(commandConfig: CommandConfiguration): Unit = {
     val components = new Components(commandConfig)
 
     val validatedConfig = components.validatedConfig
 
-    val logger = LoggerHelper.logger(getClass, validatedConfig)
+    LoggerHelper.setLoggerLevel(logger, validatedConfig.baseConfig.debug)
 
     logger.debug(validatedConfig.toString)
 

src/main/scala/com/codacy/CodacyCoverageReporter.scala

@@ -3,10 +3,8 @@ package com.codacy.di
 import com.codacy.api.client.CodacyClient
 import com.codacy.api.service.CoverageServices
 import com.codacy.configuration.parser.CommandConfiguration
-import com.codacy.helpers.LoggerHelper
 import com.codacy.model.configuration.Configuration
 import com.codacy.rules.{ConfigurationRules, ReportRules}
-import rapture.json.jsonBackends.play._
 
 class Components(private val cmdConfig: CommandConfiguration) {
   lazy val validatedConfig: Configuration = configRules.validatedConfig

src/main/scala/com/codacy/di/Components.scala

@@ -1,29 +1,16 @@
 package com.codacy.helpers
 
 import ch.qos.logback.classic.Level
-import com.codacy.configuration.parser.CommandConfiguration
-import com.codacy.model.configuration.Configuration
-import org.log4s.Logger
+import com.typesafe.scalalogging.Logger
 
 object LoggerHelper {
 
-  def logger(clazz: Class[_], config: CommandConfiguration): Logger =
-    getLogger(clazz, config.baseConfig.debug.fold(false)(_ => true))
-
-  def logger(clazz: Class[_], config: Configuration): Logger =
-    getLogger(clazz, config.baseConfig.debug)
-
-  private def getLogger(clazz: Class[_], debug: Boolean): org.log4s.Logger = {
-    val logger = org.log4s.getLogger(clazz)
-    setLoggerLevel(logger, debug)
-    logger
-  }
-
-  private def setLoggerLevel(logger: org.log4s.Logger, debug: Boolean): Unit = {
+  def setLoggerLevel(logger: Logger, debug: Boolean): Unit = {
     if (debug) {
-      logger.logger
+      logger.underlying
         .asInstanceOf[ch.qos.logback.classic.Logger]
         .setLevel(Level.DEBUG)
     }
   }
+
 }

src/main/scala/com/codacy/helpers/LoggerHelper.scala

@@ -2,7 +2,7 @@ package com.codacy.model.configuration
 
 import java.io.File
 
-import com.codacy.api.Language
+import com.codacy.plugins.api.languages.{Language, Languages}
 
 sealed trait Configuration {
   def baseConfig: BaseConfig
@@ -17,10 +17,7 @@ case class ReportConfig(
     prefix: String
 ) extends Configuration {
 
-  lazy val language: Language.Value =
-    Language.values.find(_.toString == languageStr).getOrElse(Language.NotDefined)
-
-  lazy val hasKnownLanguage: Boolean = language != Language.NotDefined
+  lazy val language: Option[Language] = Languages.fromName(languageStr)
 }
 
 case class FinalConfig(baseConfig: BaseConfig) extends Configuration

src/main/scala/com/codacy/model/configuration/Configuration.scala

@@ -6,14 +6,15 @@ import cats.implicits._
 import com.codacy.configuration.parser.{BaseCommandConfig, CommandConfiguration, Final, Report}
 import com.codacy.helpers.LoggerHelper
 import com.codacy.model.configuration.{BaseConfig, Configuration, FinalConfig, ReportConfig}
+import com.typesafe.scalalogging.LazyLogging
 
 import scala.language.implicitConversions
 import scala.util.Try
 
-class ConfigurationRules(cmdConfig: CommandConfiguration) {
+class ConfigurationRules(cmdConfig: CommandConfiguration) extends LazyLogging {
   private val publicApiBaseUrl = "https://api.codacy.com"
 
-  private val logger = LoggerHelper.logger(getClass, cmdConfig)
+  LoggerHelper.setLoggerLevel(logger, cmdConfig.baseConfig.debug)
 
   lazy val validatedConfig: Configuration = {
     val config = validateConfig(cmdConfig)
@@ -43,7 +44,7 @@ class ConfigurationRules(cmdConfig: CommandConfiguration) {
   private def validateReportConfig(reportConfig: Report): Either[String, ReportConfig] = {
     def validate(reportConf: ReportConfig) = {
       reportConf match {
-        case config if !config.hasKnownLanguage && !config.forceLanguage =>
+        case config if config.language.isEmpty && !config.forceLanguage =>
           Left(s"Invalid language ${config.languageStr}")
 
         case _ =>

src/main/scala/com/codacy/rules/ConfigurationRules.scala

@@ -3,24 +3,22 @@ package com.codacy.rules
 import java.io.File
 
 import cats.implicits._
+import com.codacy.api.CoverageReport
 import com.codacy.api.client.{FailedResponse, SuccessfulResponse}
 import com.codacy.api.helpers.FileHelper
 import com.codacy.api.helpers.vcs.{CommitInfo, GitClient}
 import com.codacy.api.service.CoverageServices
-import com.codacy.api.{CoverageFileReport, CoverageReport}
 import com.codacy.helpers.LoggerHelper
 import com.codacy.model.configuration.{BaseConfig, Configuration, FinalConfig, ReportConfig}
-import com.codacy.parsers.CoverageParserFactory
+import com.codacy.parsers.CoverageParser
 import com.codacy.transformation.PathPrefixer
-import org.log4s.Logger
-import rapture.json.jsonBackends.play._
-import rapture.json.{Json, Serializer}
+import com.typesafe.scalalogging.LazyLogging
 
 import scala.util.{Failure, Success}
 
-class ReportRules(config: Configuration, coverageServices: => CoverageServices) {
+class ReportRules(config: Configuration, coverageServices: => CoverageServices) extends LazyLogging {
 
-  private val logger: Logger = LoggerHelper.logger(getClass, config)
+  LoggerHelper.setLoggerLevel(logger, config.baseConfig.debug)
 
   private val rootProjectDir = new File(System.getProperty("user.dir"))
 
@@ -45,8 +43,10 @@ class ReportRules(config: Configuration, coverageServices: => CoverageServices)
       logger.debug(s"Project token: ${config.baseConfig.projectToken}")
       logger.info(s"Parsing coverage data from: ${config.coverageReport.getAbsolutePath} ...")
 
-      CoverageParserFactory
-        .withCoverageReport(config.language, rootProjectDir, config.coverageReport)(transform(_)(config) {
+      CoverageParser
+        .parse(rootProjectDir, config.coverageReport)
+        .map(transform(_)(config))
+        .flatMap {
           case report if report.fileReports.isEmpty =>
             Left("The provided coverage report generated an empty result.")
 
@@ -57,7 +57,6 @@ class ReportRules(config: Configuration, coverageServices: => CoverageServices)
             val codacyReportFile = new File(codacyReportFilename)
 
             logger.debug(report.toString)
-            implicit val ser = implicitly[Serializer[CoverageFileReport, Json]]
             FileHelper.writeJsonToFile(codacyReportFile, report)
 
             logUploadedFileInfo(codacyReportFile)
@@ -69,8 +68,7 @@ class ReportRules(config: Configuration, coverageServices: => CoverageServices)
                 val message = handleFailedResponse(failed)
                 Left(s"Failed to upload report: $message")
             }
-        })
-        .joinRight
+        }
     }
   }
 
@@ -91,13 +89,11 @@ class ReportRules(config: Configuration, coverageServices: => CoverageServices)
     }
   }
 
-  private def transform[A](report: CoverageReport)(config: ReportConfig)(f: CoverageReport => A): A = {
+  private def transform(report: CoverageReport)(config: ReportConfig): CoverageReport = {
     val transformations = Set(new PathPrefixer(config.prefix))
-    val transformedReport = transformations.foldLeft(report) { (report, transformation) =>
+    transformations.foldLeft(report) { (report, transformation) =>
       transformation.execute(report)
     }
-
-    f(transformedReport)
   }
 
   def finalReport(config: FinalConfig): Either[String, String] = {
@@ -129,4 +125,5 @@ class ReportRules(config: Configuration, coverageServices: => CoverageServices)
 
     maybeCommitUUID.flatMap(block)
   }
+
 }

src/main/scala/com/codacy/rules/ReportRules.scala

@@ -2,14 +2,14 @@ package com.codacy.rules
 
 import java.io.File
 
-import com.codacy.api.Language
 import com.codacy.configuration.parser.{BaseCommandConfig, Report}
 import com.codacy.di.Components
 import com.codacy.model.configuration.ReportConfig
+import com.codacy.plugins.api.languages.Languages
 import org.scalatest.Inside._
 import org.scalatest._
 
-class ConfigurationRulesTest extends FlatSpec with Matchers {
+class ConfigurationRulesTest extends FlatSpec with Matchers with OptionValues {
 
   val projToken = "1234adasdsdw333"
   val coverageFile = new File("coverage.xml")
@@ -23,7 +23,7 @@ class ConfigurationRulesTest extends FlatSpec with Matchers {
   "ConfigurationRules" should "transform configuration" in {
     inside(components.validatedConfig) {
       case config: ReportConfig =>
-        config.language should be(Language.Scala)
+        config.language.value should be(Languages.Scala)
         config.coverageReport.toString should be("coverage.xml")
     }
 
@@ -34,7 +34,7 @@ class ConfigurationRulesTest extends FlatSpec with Matchers {
       case config: ReportConfig =>
         val result = components.reportRules.coverageWithTokenAndCommit(config)
 
-        result should be(Left("could not parse report, unrecognized report format (tried: Cobertura, Jacoco)"))
+        result should be(Left("Could not parse report, unrecognized report format (tried: Cobertura, Jacoco)"))
     }
   }