Using of Base64Decoder refactored.

Author: dmitry.naydanov

compiler-settings/src/org/jetbrains/jps/incremental/scala/remote/Base64User.scala

@@ -0,0 +1,14 @@
+package org.jetbrains.jps.incremental.scala.remote
+
+import com.intellij.util.Base64Converter
+/**
+  * User: Dmitry.Naydanov
+  * Date: 19.04.17.
+  */
+
+trait Base64User {
+  def decodeBase64(s: String): String = Base64Converter.decode(s)
+  def decodeBase64(bts: Array[Byte]): Array[Byte] = Base64Converter.decode(bts)
+  def encodeBase64(s: String): String = Base64Converter.encode(s)
+  def encodeBase64(octetString: Array[Byte]): String = Base64Converter.encode(octetString)
+}

compiler-settings/src/org/jetbrains/jps/incremental/scala/remote/RemoteResourceOwner.scala

@@ -3,7 +3,6 @@ package org.jetbrains.jps.incremental.scala.remote
 import java.io._
 import java.net.{InetAddress, Socket}
 
-import com.intellij.util.Base64Converter
 import com.martiansoftware.nailgun.NGConstants
 import org.jetbrains.jps.incremental.messages.BuildMessage.Kind
 import org.jetbrains.jps.incremental.scala._
@@ -12,15 +11,15 @@ import org.jetbrains.jps.incremental.scala._
  * @author Pavel Fatin
  * @author Dmitry Naydanov
  */
-trait RemoteResourceOwner {
+trait RemoteResourceOwner extends Base64User {
   protected val address: InetAddress
   protected val port: Int
 
   protected val currentDirectory = System.getProperty("user.dir")
   protected val serverAlias = "compile-server"
 
   def send(command: String, arguments: Seq[String], client: Client) {
-    val encodedArgs = arguments.map(s => Base64Converter.encode(s.getBytes("UTF-8")))
+    val encodedArgs = arguments.map(s => encodeBase64(s.getBytes("UTF-8")))
     using(new Socket(address, port)) { socket =>
       using(new DataOutputStream(new BufferedOutputStream(socket.getOutputStream))) { output =>
         createChunks(command, encodedArgs).foreach(_.writeTo(output))
@@ -43,7 +42,7 @@ trait RemoteResourceOwner {
           return
         case Chunk(NGConstants.CHUNKTYPE_STDOUT, data) =>
           try {
-            val event = Event.fromBytes(Base64Converter.decode(data))
+            val event = Event.fromBytes(decodeBase64(data))
             processor.process(event)
           } catch {
             case e: Exception =>

compiler-settings/src/org/jetbrains/jps/incremental/scala/remote/play/SbtWatcherMain.scala

@@ -3,17 +3,16 @@ package org.jetbrains.jps.incremental.scala.remote.play
 import java.io.{BufferedWriter, OutputStreamWriter, PrintStream}
 import java.net.{InetAddress, Socket}
 
-import com.intellij.util.Base64Converter
 import com.martiansoftware.nailgun.NGContext
 import org.jetbrains.jps.incremental.messages.BuildMessage
-import org.jetbrains.jps.incremental.scala.remote.MessageEvent
+import org.jetbrains.jps.incremental.scala.remote.{Base64User, MessageEvent}
 import org.jetbrains.jps.incremental.scala.remote.play.WatcherCommands._
 
 /**
  * User: Dmitry.Naydanov
  * Date: 12.02.15.
  */
-object SbtWatcherMain {
+object SbtWatcherMain extends Base64User {
   private val IT_COMPLETED_MESSAGE = "Waiting for source changes... (press enter to interrupt)"
   private val MESSAGE_LIMIT = 12
   private val WAIT_TIME = 150
@@ -30,15 +29,15 @@ object SbtWatcherMain {
 
   private def handle(arguments: Seq[String], out: PrintStream) {
     def write2source(message: String) {
-      out.write(Base64Converter.encode(MessageEvent(BuildMessage.Kind.INFO, message, None, None, None).toBytes).getBytes)
+      out.write(encodeBase64(MessageEvent(BuildMessage.Kind.INFO, message, None, None, None).toBytes).getBytes)
     }
 
     def createConsumer(delegate: MessageConsumer) = new CachingMessageConsumer(delegate) {
       override protected def needFlush(msg: String, msgCount: Int): Boolean =
         msg.trim.endsWith(IT_COMPLETED_MESSAGE) || msgCount > MESSAGE_LIMIT
     }
 
-    val decoded = arguments map Base64Converter.decode
+    val decoded = arguments map decodeBase64
 
     decoded.head match {
       case cm@(START | LOOP) =>
@@ -55,12 +54,12 @@ object SbtWatcherMain {
               writer.close()
             }
             catch {
-              case ex: Exception =>
+              case _: Exception =>
             }
           }
         } else new MessageConsumer {
           override def consume(message: String) {
-            val encoded = Base64Converter.encode(MessageEvent(BuildMessage.Kind.INFO, message, None, None, None).toBytes)
+            val encoded = encodeBase64(MessageEvent(BuildMessage.Kind.INFO, message, None, None, None).toBytes)
             out write encoded.getBytes
           }
         }

jps-plugin/src/org/jetbrains/jps/incremental/scala/local/worksheet/WorksheetServer.scala

@@ -4,11 +4,10 @@ import java.io._
 import java.net.URL
 import java.nio.ByteBuffer
 
-import com.intellij.util.Base64Converter
 import com.martiansoftware.nailgun.ThreadLocalPrintStream
 import org.jetbrains.jps.incremental.scala.data.CompilerJars
 import org.jetbrains.jps.incremental.scala.local.worksheet.compatibility.WorksheetArgsJava
-import org.jetbrains.jps.incremental.scala.remote.{Arguments, EventGeneratingClient, WorksheetOutputEvent}
+import org.jetbrains.jps.incremental.scala.remote.{Arguments, Base64User, EventGeneratingClient, WorksheetOutputEvent}
 
 import scala.collection.JavaConverters._
 
@@ -76,7 +75,7 @@ object WorksheetServer {
 
   case class ReplArgs(sessionId: String, codeChunk: String)
 
-  class MyEncodingOutputStream(delegateOut: PrintStream, standalone: Boolean) extends OutputStream {
+  class MyEncodingOutputStream(delegateOut: PrintStream, standalone: Boolean) extends OutputStream with Base64User {
     private var capacity = 1200
     private var buffer = ByteBuffer.allocate(capacity)
 
@@ -102,7 +101,7 @@ object WorksheetServer {
       if (buffer.position() == 0) return
       val event = WorksheetOutputEvent(new String(buffer.array(), 0, buffer.position()))
       buffer.clear()
-      val encode = Base64Converter.encode(event.toBytes)
+      val encode = encodeBase64(event.toBytes)
       delegateOut.write(if (standalone && !encode.endsWith("=")) (encode + "=").getBytes else encode.getBytes)
     }
   }

jps-plugin/src/org/jetbrains/jps/incremental/scala/remote/Main.scala

@@ -4,7 +4,6 @@ package remote
 import java.io._
 import java.util.{Timer, TimerTask}
 
-import com.intellij.util.Base64Converter
 import com.martiansoftware.nailgun.NGContext
 import org.jetbrains.jps.incremental.messages.BuildMessage.Kind
 import org.jetbrains.jps.incremental.scala.local.LocalServer
@@ -14,11 +13,11 @@ import org.jetbrains.jps.incremental.scala.local.worksheet.WorksheetServer
  * @author Pavel Fatin
  * @author Dmitry Naydanov         
  */
-object Main {
+object Main extends Base64User {
   private val Server = new LocalServer()
   private val worksheetServer = new WorksheetServer
 
-  private var shutdownTimer: Timer = null
+  private var shutdownTimer: Timer = _
 
   def nailMain(context: NGContext) {
     cancelShutdown()
@@ -31,25 +30,7 @@ object Main {
   }
 
   private def make(arguments: Seq[String], out: PrintStream, standalone: Boolean) {
-    var hasErrors = false
-
-    val client = {
-      val eventHandler = (event: Event) => {
-        val encode = Base64Converter.encode(event.toBytes)
-        out.write((if (standalone && !encode.endsWith("=")) encode + "=" else encode).getBytes)
-      }
-      new EventGeneratingClient(eventHandler, out.checkError) {
-        override def error(text: String, source: Option[File], line: Option[Long], column: Option[Long]) {
-          hasErrors = true
-          super.error(text, source, line, column)
-        }
-
-        override def message(kind: Kind, text: String, source: Option[File], line: Option[Long], column: Option[Long]) {
-          if (kind == Kind.ERROR) hasErrors = true
-          super.message(kind, text, source, line, column)
-        }
-      }
-    }
+    val client = new MyEventGeneratingClient(standalone, out)
 
     val oldOut = System.out
     // Suppress any stdout data, interpret such data as error
@@ -59,15 +40,15 @@ object Main {
       val args = {
         val strings = arguments.map {
           arg => 
-            val s = new String(Base64Converter.decode(arg.getBytes), "UTF-8")
+            val s = new String(decodeBase64(arg.getBytes), "UTF-8")
             if (s == "#STUB#") "" else s
         }
         Arguments.from(strings)
       }
-      
+
       if (!worksheetServer.isRepl(args)) Server.compile(args.sbtData, args.compilerData, args.compilationData, client)
 
-      if (!hasErrors) worksheetServer.loadAndRun(args, out, client, standalone)
+      if (!client.hadErrors) worksheetServer.loadAndRun(args, out, client, standalone)
     } catch {
       case e: Throwable => 
         client.trace(e)
@@ -91,4 +72,26 @@ object Main {
       shutdownTimer.schedule(shutdownTask, delayMs)
     }
   }
+  
+  class MyEventGeneratingClient(standalone: Boolean, out: PrintStream) extends EventGeneratingClient(
+    (event: Event) => {
+      val encode = encodeBase64(event.toBytes)
+      out.write((if (standalone && !encode.endsWith("=")) encode + "=" else encode).getBytes)
+    }, 
+    out.checkError
+  ) {
+    private var hasErrors = false
+
+    def hadErrors: Boolean = hasErrors
+    
+    override def error(text: String, source: Option[File], line: Option[Long], column: Option[Long]) {
+      hasErrors = true
+      super.error(text, source, line, column)
+    }
+
+    override def message(kind: Kind, text: String, source: Option[File], line: Option[Long], column: Option[Long]) {
+      if (kind == Kind.ERROR) hasErrors = true
+      super.message(kind, text, source, line, column)
+    }
+  }
 }

jps-plugin/src/org/jetbrains/jps/incremental/scala/remote/play/SbtWatcherMain.scala

@@ -2,17 +2,16 @@ package org.jetbrains.jps.incremental.scala.remote.play
 
 import java.io.PrintStream
 
-import com.intellij.util.Base64Converter
 import com.martiansoftware.nailgun.NGContext
 import org.jetbrains.jps.incremental.messages.BuildMessage
-import org.jetbrains.jps.incremental.scala.remote.MessageEvent
+import org.jetbrains.jps.incremental.scala.remote.{Base64User, MessageEvent}
 import org.jetbrains.jps.incremental.scala.remote.play.WatcherCommands._
 
 /**
  * User: Dmitry.Naydanov
  * Date: 12.02.15.
  */
-object SbtWatcherMain {
+object SbtWatcherMain extends Base64User {
   private var currentExec: Option[(SbtWatcherExec, Seq[String])] = None
 
   def nailMain(context: NGContext) {
@@ -26,7 +25,7 @@ object SbtWatcherMain {
   private def handle(arguments: Seq[String], out: PrintStream) {
     val messageConsumer = new MessageConsumer {
       override def consume(message: String) {
-        out.write(Base64Converter.encode(MessageEvent(BuildMessage.Kind.INFO, message, None, None, None).toBytes).getBytes)
+        out.write(encodeBase64(MessageEvent(BuildMessage.Kind.INFO, message, None, None, None).toBytes).getBytes)
       }
     }
 

src/org/jetbrains/plugins/scala/worksheet/server/RemoteServerConnector.scala

@@ -14,7 +14,6 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ModuleRootManager
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiManager
-import com.intellij.util.Base64Converter
 import org.jetbrains.jps.incremental.ModuleLevelBuilder.ExitCode
 import org.jetbrains.jps.incremental.messages.BuildMessage
 import org.jetbrains.jps.incremental.messages.BuildMessage.Kind
@@ -33,7 +32,8 @@ import org.jetbrains.plugins.scala.worksheet.ui.{WorksheetEditorPrinterBase, Wor
  * Date: 1/28/14
  */
 class RemoteServerConnector(module: Module, worksheet: File, output: File, worksheetClassName: String, 
-  replArgs: Option[ReplModeArgs], needsCheck: Boolean) extends RemoteServerConnectorBase(module: Module, Seq(worksheet), output, needsCheck) {
+                            replArgs: Option[ReplModeArgs], needsCheck: Boolean) 
+  extends RemoteServerConnectorBase(module: Module, Seq(worksheet), output, needsCheck) with Base64User {
 
   val runType: WorksheetMakeType = WorksheetCompiler.getRunType(module.getProject)
 
@@ -68,8 +68,8 @@ class RemoteServerConnector(module: Module, worksheet: File, output: File, works
           val eventClient = new ClientEventProcessor(client)
 
           val encodedArgs = arguments map {
-            case "" => Base64Converter.encode("#STUB#" getBytes "UTF-8")
-            case s => Base64Converter.encode(s getBytes "UTF-8")
+            case "" => encodeBase64("#STUB#" getBytes "UTF-8")
+            case s => encodeBase64(s getBytes "UTF-8")
           }
 
           val errorHandler = new ErrorHandler {
@@ -84,7 +84,7 @@ class RemoteServerConnector(module: Module, worksheet: File, output: File, works
           }
 
           new NonServerRunner(project, Some(errorHandler)).buildProcess(encodedArgs, (text: String) => {
-            val event = Event.fromBytes(Base64Converter.decode(text.getBytes("UTF-8")))
+            val event = Event.fromBytes(decodeBase64(text.getBytes("UTF-8")))
             eventClient.process(event)
           })
       }