prepare for release 1.0.0

Author: rtfpessoa

build.sbt

@@ -2,10 +2,57 @@ resolvers += "Typesafe Repo" at "http://repo.typesafe.com/typesafe/releases/"
 
 name := """codacy-engine-scala-seed"""
 
-version := "1.0-SNAPSHOT"
+version := "1.0.0"
+
+scalaVersion := "2.10.5"
+
+crossScalaVersions := Seq("2.10.5", "2.11.7")
+
+scalacOptions := Seq("-deprecation", "-feature", "-unchecked", "-Ywarn-adapted-args", "-Xlint", "-Xfatal-warnings")
+
+organization := "com.codacy"
+
+libraryDependencies += "com.typesafe.play" %% "play-json" % "2.3.8"
 
 organization := "com.codacy"
 
-scalaVersion := "2.11.7"
+organizationName := "Codacy"
+
+organizationHomepage := Some(new URL("https://www.codacy.com"))
+
+publishMavenStyle := true
+
+publishArtifact in Test := false
+
+pomIncludeRepository := { _ => false}
+
+publishTo := {
+  val nexus = "https://oss.sonatype.org/"
+  if (version.value.trim.endsWith("SNAPSHOT"))
+    Some("snapshots" at nexus + "content/repositories/snapshots")
+  else
+    Some("releases" at nexus + "service/local/staging/deploy/maven2")
+}
+
+startYear := Some(2015)
+
+description := "Library to develop Codacy tool plugins"
+
+licenses := Seq("The Apache Software License, Version 2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0.txt"))
+
+homepage := Some(url("http://www.github.com/codacy/codacy-engine-scala-seed/"))
 
-libraryDependencies += "com.typesafe.play" %% "play-json" % "2.3.8"
+pomExtra :=
+  <scm>
+    <url>http://www.github.com/codacy/codacy-engine-scala-seed</url>
+    <connection>scm:git:git@github.com:codacy/codacy-engine-scala-seed.git</connection>
+    <developerConnection>scm:git:https://github.com/codacy/codacy-engine-scala-seed.git</developerConnection>
+  </scm>
+    <developers>
+      <developer>
+        <id>johannegger</id>
+        <name>Johann</name>
+        <email>johann [at] codacy.com</email>
+        <url>https://github.com/johannegger</url>
+      </developer>
+    </developers>

project/plugins.sbt

@@ -0,0 +1,15 @@
+import sbt._
+
+resolvers ++= Seq(
+  DefaultMavenRepository,
+  "Typesafe Repository" at "http://repo.typesafe.com/typesafe/releases/",
+  "Sonatype snapshots" at "http://oss.sonatype.org/content/repositories/snapshots/",
+  Classpaths.typesafeReleases,
+  Classpaths.sbtPluginReleases
+)
+
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "0.5.1")
+
+addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0")
+
+addSbtPlugin("com.timushev.sbt" % "sbt-updates" % "0.1.9")

src/main/scala/codacy/dockerApi/DockerEngine.scala

@@ -1,9 +1,9 @@
 package codacy.dockerApi
 
+import codacy.dockerApi.DockerEnvironment._
 import play.api.libs.json.Json
 
 import scala.util.{Failure, Success}
-import DockerEnvironment._
 
 abstract class DockerEngine(Tool: Tool) {
 
@@ -13,7 +13,7 @@ abstract class DockerEngine(Tool: Tool) {
         //search for our config
         val maybePatterns = maybeConfig.flatMap(_.tools.collectFirst { case config if config.name == spec.name =>
           val allPatternIds = spec.patterns.map(_.patternId)
-          config.patterns.filter{ case pattern => allPatternIds.contains(pattern.patternId) }
+          config.patterns.filter { case pattern => allPatternIds.contains(pattern.patternId) }
         })
         val maybeFiles = maybeConfig.flatMap(_.files.map(_.map { case path =>
           sourcePath.resolve(path.value)
@@ -27,7 +27,7 @@ abstract class DockerEngine(Tool: Tool) {
       }
     } match {
       case Success(results) =>
-        results.map{ case result =>
+        results.map { case result =>
           println(Json.stringify(Json.toJson(result)))
         }.toList
 

src/main/scala/codacy/dockerApi/DockerEnvironment.scala

@@ -1,6 +1,7 @@
 package codacy.dockerApi
 
 import java.nio.file.{Files, Paths}
+
 import play.api.data.validation.ValidationError
 import play.api.libs.json.{JsError, JsPath, Json}
 

src/main/scala/codacy/dockerApi/package.scala

@@ -4,68 +4,107 @@ import java.nio.file.Path
 
 import play.api.libs.json._
 
+import scala.language.reflectiveCalls
 import scala.util.Try
 
 package dockerApi {
 
-  abstract class Formats[W <: AnyVal{ val value:B },B](apply_ : (B => W)) extends (B => W){ self =>
+abstract class Formats[W <: AnyVal {val value : B}, B](apply_ : (B => W)) extends (B => W) {
+  self =>
 
-    implicit def writes(implicit writes: Writes[B]):Writes[W] = Writes(
-      (_:W).value match{ case value:B@unchecked => writes.writes(value) }
-    )
+  implicit def writes(implicit writes: Writes[B]): Writes[W] = Writes(
+    (_: W).value match { case value: B@unchecked => writes.writes(value) }
+  )
 
-    implicit def reads(implicit reads: Reads[B]):Reads[W] = reads.map( self.apply )
+  implicit def reads(implicit reads: Reads[B]): Reads[W] = reads.map(self.apply)
 
-    override def apply(v1: B): W = apply_(v1)
-  }
+  override def apply(v1: B): W = apply_(v1)
+}
+
+trait Tool {
+  def apply(path: Path, conf: Option[Seq[PatternDef]], files: Option[Set[Path]])(implicit spec: Spec): Try[Iterable[Result]]
+}
+
+final class PatternId(val value: String) extends AnyVal {
+  override def toString = value.toString
+}
+
+final class SourcePath(val value: String) extends AnyVal {
+  override def toString = value.toString
+}
+
+final class ResultMessage(val value: String) extends AnyVal {
+  override def toString = value.toString
+}
+
+final class ResultLine(val value: Int) extends AnyVal {
+  override def toString = value.toString
+}
+
+final class ToolName(val value: String) extends AnyVal {
+  override def toString = value.toString
+}
+
+final class ErrorMessage(val value: String) extends AnyVal {
+  override def toString = value.toString
+}
+
+final class ParameterName(val value: String) extends AnyVal {
+  override def toString = value.toString
+}
+
+object PatternId extends Formats[PatternId, String](new PatternId(_))
+
+object SourcePath extends Formats[SourcePath, String](new SourcePath(_))
+
+object ResultMessage extends Formats[ResultMessage, String](new ResultMessage(_))
+
+object ResultLine extends Formats[ResultLine, Int](new ResultLine(_))
+
+object ToolName extends Formats[ToolName, String](new ToolName(_))
+
+object ErrorMessage extends Formats[ErrorMessage, String](new ErrorMessage(_))
+
+object ParameterName extends Formats[ParameterName, String](new ParameterName(_))
+
+case class ParameterDef(name: ParameterName, value: JsValue)
+
+case class PatternDef(patternId: PatternId, parameters: Option[Set[ParameterDef]])
+
+case class ToolConfig(name: ToolName, patterns: Seq[PatternDef])
+
+private[dockerApi] case class FullConfig(tools: Set[ToolConfig], files: Option[Set[SourcePath]])
+
+//there are other fields like name and description but i don't care about them inside the tool
+case class ParameterSpec(name: ParameterName, default: JsValue)
+
+case class PatternSpec(patternId: PatternId, parameters: Option[Set[ParameterSpec]])
+
+case class Spec(name: ToolName, patterns: Set[PatternSpec])
+
+sealed trait Result
+
+final case class Issue(filename: SourcePath, message: ResultMessage, patternId: PatternId, line: ResultLine) extends Result
+
+final case class FileError(filename: SourcePath, message: Option[ErrorMessage]) extends Result
 
-  trait Tool{ def apply(path: Path,conf: Option[Seq[PatternDef]], files:Option[Set[Path]])(implicit spec: Spec): Try[Iterable[Result]] }
-  final class PatternId     (val value:String) extends AnyVal{ override def toString = value.toString }
-  final class SourcePath    (val value:String) extends AnyVal{ override def toString = value.toString }
-  final class ResultMessage (val value:String) extends AnyVal{ override def toString = value.toString }
-  final class ResultLine    (val value:Int   ) extends AnyVal{ override def toString = value.toString }
-  final class ToolName      (val value:String) extends AnyVal{ override def toString = value.toString }
-  final class ErrorMessage  (val value:String) extends AnyVal{ override def toString = value.toString }
-  final class ParameterName (val value:String) extends AnyVal{ override def toString = value.toString }
-
-  object PatternId     extends Formats[PatternId    , String]( new PatternId(_)     )
-  object SourcePath    extends Formats[SourcePath   , String]( new SourcePath(_)    )
-  object ResultMessage extends Formats[ResultMessage, String]( new ResultMessage(_) )
-  object ResultLine    extends Formats[ResultLine   , Int   ]( new ResultLine(_)    )
-  object ToolName      extends Formats[ToolName     , String]( new ToolName(_)      )
-  object ErrorMessage  extends Formats[ErrorMessage , String]( new ErrorMessage(_)  )
-  object ParameterName extends Formats[ParameterName, String]( new ParameterName(_) )
-
-  case class ParameterDef(name:ParameterName,value:JsValue)
-  case class PatternDef(patternId: PatternId, parameters:Option[Set[ParameterDef]])
-  case class ToolConfig(name:ToolName, patterns:Seq[PatternDef])
-
-  private[dockerApi] case class FullConfig(tools:Set[ToolConfig],files:Option[Set[SourcePath]])
-  //there are other fields like name and description but i don't care about them inside the tool
-  case class ParameterSpec(name:ParameterName, default:JsValue)
-  case class PatternSpec(patternId: PatternId, parameters:Option[Set[ParameterSpec]])
-
-  case class Spec(name:ToolName,patterns:Set[PatternSpec])
-
-  sealed trait Result
-  final case class Issue(filename:SourcePath, message:ResultMessage, patternId:PatternId, line: ResultLine) extends Result
-  final case class FileError(filename:SourcePath, message:Option[ErrorMessage]) extends Result
 }
 
 package object dockerApi {
 
-  private[this] def asReader[A](jsResult: JsResult[A]): Reads[A] = Reads[A]((_:JsValue) => jsResult)
-  implicit def toValue[A] = (a:AnyVal{ def value:A }) => a.value
+  private[this] def asReader[A](jsResult: JsResult[A]): Reads[A] = Reads[A]((_: JsValue) => jsResult)
+
+  implicit def toValue[A] = (a: AnyVal {def value: A}) => a.value
 
   implicit lazy val specReader: Reads[Spec] = {
     implicit val r1 = Json.reads[ParameterSpec]
     implicit val r0 = Json.reads[PatternSpec]
     Json.reads[Spec]
   }
 
-  implicit def configReader(implicit spec:Spec): Reads[FullConfig] = {
+  implicit def configReader(implicit spec: Spec): Reads[FullConfig] = {
     implicit val r1 = Json.reads[ParameterDef]
-    implicit val r0 = Json.reads[PatternDef]/*.flatMap{ case pattern =>
+    implicit val r0 = Json.reads[PatternDef] /*.flatMap{ case pattern =>
 
       val filtered =
         if (spec.patterns.exists(_.patternId == pattern.patternId)) JsSuccess(pattern)
@@ -76,7 +115,7 @@ package object dockerApi {
 
     implicit val r2 = Reads.set(Json.reads[ToolConfig])
 
-    Json.reads[FullConfig]/*.flatMap{ case fullCfg =>
+    Json.reads[FullConfig] /*.flatMap{ case fullCfg =>
       val ps = fullCfg.tools.collectFirst{ case tool if tool.name == spec.name =>
         if(tool.patterns.isEmpty) JsError("no patterns selected")
         else JsSuccess(fullCfg)
@@ -90,14 +129,14 @@ package object dockerApi {
     lazy val issueWrites = Json.writes[Issue]
     lazy val errorWrites = Json.writes[FileError]
 
-    Writes[Result]{ (result:Result) =>
-      val base = result match{
-        case issue:Issue     => issueWrites.writes(issue)
-        case error:FileError => errorWrites.writes(error)
+    Writes[Result] { (result: Result) =>
+      val base = result match {
+        case issue: Issue => issueWrites.writes(issue)
+        case error: FileError => errorWrites.writes(error)
       }
 
-      (base,result.getClass.getTypeName.split('.').lastOption) match{
-        case (o:JsObject,Some(tpe)) => o ++ Json.obj("type" -> tpe )
+      (base, result.getClass.getTypeName.split('.').lastOption) match {
+        case (o: JsObject, Some(tpe)) => o ++ Json.obj("type" -> tpe)
         case other => base
       }
     }