code style

Author: FunkeMT

src/main/scala/de/htwg/scalala/advancedDsl/Main.scala

@@ -12,58 +12,62 @@ object Main {
         |  instrument Marimba
         |  plays chord(c,d,e)
         |
-        |musician guitar_1
-        |  instrument Guitar
-        |  plays loop(a,b)
-        |
-        |musician drummer_1
-        |  instrument Drum
-        |  plays loop(HiHatClosed)
-        |
         |play with tempo 50
         |  piano_1,
         |  marimba_1 at 12,
-        |  marimba_1 at 7,
-        |  guitar_1,
-        |  drummer_1
+        |  marimba_1 at 7
       """.stripMargin
 
     val in2 =
-      """musician piano_1
+      """musician piano_left
         |  instrument Piano
-        |  plays c,d
+        |  plays d,a,h,a,d,a,d,a,h,d,h,d,a
+        |
+        |musician piano_right
+        |  instrument Piano
+        |  plays d/16,e/16,f.sharp,a,f.sharp,e/8,d.dot / 2,f.sharp,a/8,chord(d,g,h),d/8,c,a,chord(a,d/2,c.sharp / 2)
         |
         |play with tempo 50
-        |  pi
+        |  piano_left,
+        |  piano_right
       """.stripMargin
 
-    //parse(in)
-    autoComplete(in2)
+    val in3 =
+      """musician piano_1
+        |  instrument Piano
+        |  plays c,c.sharp,c.flat,c.dot,c/2,c/4,c/8,c/16, c.sharp/2,chord(c.sharp,d.flat),c,+c,-c,++c,--c
+        |
+        |play with tempo 30
+        |   piano_1
+      """.stripMargin
+
+    parse(in3)
+    //autoComplete(in3)
   }
 
-    def parse(inputStr: String) = {
-      val parser = new Reader
-      parser.parseAll(parser.song, inputStr) match {
-        case parser.Success(r, n) => {
-          println("Success:")
-          println(r)
+  def parse(inputStr: String) = {
+    val parser = new Reader
+    parser.parseAll(parser.song, inputStr) match {
+      case parser.Success(r, n) => {
+        println("Success:")
+        println(r)
 
-          val interpreter = new Interpreter(r)
-          try {
-            interpreter.run
-          } catch {
-            case e: RuntimeException => println("Error: " + e.printStackTrace())
-          }
+        val interpreter = new Interpreter(r)
+        try {
+          interpreter.run
+        } catch {
+          case e: RuntimeException => println("Error: " + e.printStackTrace())
         }
-        case parser.Error(msg, n) => println("Error: " + msg)
-        case parser.Failure(msg, n) => println("Error: " + msg)
-        case _ =>
       }
+      case parser.Error(msg, n) => println("Error: " + msg)
+      case parser.Failure(msg, n) => println("Error: " + msg)
+      case _ =>
     }
+  }
 
-    def autoComplete(inputStr: String) = {
-      val parserAC = new ReaderAutoComplete
-      val autoComp = parserAC.autoCompletion(parserAC.song, inputStr)
-      println(autoComp)
-    }
+  def autoComplete(inputStr: String) = {
+    val parserAC = new ReaderAutoComplete
+    val autoComp = parserAC.autoCompletion(parserAC.song, inputStr)
+    println(autoComp)
+  }
 }

src/main/scala/de/htwg/scalala/advancedDsl/Note.scala

@@ -30,6 +30,6 @@ case class Note(name: String, accidental: String = "", duration: Int = 0, octave
       case "+" => n = n +
       case "-" => n = n -
     }
-    n.ticks(if (duration > 0) 16/duration else 16)
+    n.ticks(if (duration > 0) 16 / duration else 16)
   }
 }

src/main/scala/de/htwg/scalala/advancedDsl/Reader.scala

@@ -14,19 +14,15 @@ class Reader extends StandardTokenParsers {
     "plays",
     "tempo",
     "at",
-    "c" , "d" , "e" , "f" , "g" , "a" , "h",
+    "c", "d", "e", "f", "g", "a", "h",
     "2", "4", "8", "16",
-    "sharp", "flat", "dot"
-  )
+    "sharp", "flat", "dot")
   lexical.delimiters += (",", "(", ")", "/", ".", "+", "-")
 
-
   def song: Parser[Song] = rep(musician | track) ^^ {
     s => new Song(s)
   }
 
-
-
   def musician: Parser[Musician] = ("musician" ~> ident) ~ ("instrument" ~> instrument) ~ ("plays" ~> (loopElements | noteElements)) ^^ {
     case m ~ i ~ e => new Musician(m, i, e)
   }
@@ -36,8 +32,6 @@ class Reader extends StandardTokenParsers {
     case p ~ t ~ m => new Track(m, t.get)
   }
 
-
-
   def instrument: Parser[Instrument] = ident ^^ {
     case i => new Instrument(i)
   }
@@ -50,8 +44,6 @@ class Reader extends StandardTokenParsers {
     case l => new LoopElement(l)
   }
 
-
-
   def tempo: Parser[Int] = "with" ~> "tempo" ~> numericLit ^^ {
     n => n.toInt
   }
@@ -60,8 +52,6 @@ class Reader extends StandardTokenParsers {
     m => m
   }
 
-
-
   def noteElement: Parser[NoteElement] = chord | note ^^ {
     e => e
   }
@@ -75,8 +65,6 @@ class Reader extends StandardTokenParsers {
     n => n.toInt
   }
 
-
-
   def note: Parser[Note] = opt(octave) ~ ("c" | "d" | "e" | "f" | "g" | "a" | "h") ~ opt("." ~> accidental) ~ opt("/" ~> duration) ^^ {
     case o ~ n ~ a ~ d => new Note(n, a.getOrElse(""), d.getOrElse(0), o.getOrElse(List[String]()))
   }
@@ -85,8 +73,6 @@ class Reader extends StandardTokenParsers {
     case n => new Chord(n)
   }
 
-
-
   def octave: Parser[List[String]] = rep("+" | "-") ^^ {
     o => o
   }
@@ -99,9 +85,6 @@ class Reader extends StandardTokenParsers {
     d => d.toInt
   }
 
-
-
-
   def parseAll[T](p: Parser[T], in: String): ParseResult[T] = {
     phrase(p)(new lexical.Scanner(in))
   }