Tests pass!

1 files changed, 10 insertions, 140 deletions

diff --git a/scalatexApi/src/main/scala/scalatex/stages/Compiler.scala b/scalatexApi/src/main/scala/scalatex/stages/Compiler.scala
index 5127945..a305199 100644
--- a/scalatexApi/src/main/scala/scalatex/stages/Compiler.scala
+++ b/scalatexApi/src/main/scala/scalatex/stages/Compiler.scala
@@ -2,7 +2,7 @@ package scalatex
 package stages
 import acyclic.file
 
-import scala.reflect.macros.Context
+import scala.reflect.macros.whitebox.Context
 import scala.reflect.internal.util.{Position, OffsetPosition}
 
 /**
@@ -27,150 +27,20 @@ object Compiler{
         case (curr, Ast.Chain.TypeArgs(str, offset2)) =>
           val TypeApply(fun, args) = c.parse(s"omg$str")
           TypeApply(curr, args)
+        case (curr, Ast.Block(parts, offset)) =>
+          q"$curr(..${compileBlock(parts, offset)})"
       }
-
     }
-    def compileBlock(parts: Seq[Ast.Block.Sub], offset: Int): c.Tree = {
-      val compiledParts = parts.map{
+    def compileBlock(parts: Seq[Ast.Block.Sub], offset: Int): Seq[c.Tree] = {
+      parts.map{
         case Ast.Block.Text(str, offset2) => q"$str"
         case Ast.Chain(code, parts, offset) => compileChain(code, parts, offset)
       }
-      q"Seq[$fragType](..$compiledParts)"
     }
-    ???
-//    def compileTree(frag: Ast): Tree = frag match{
-//      case Ast.Block(parts, offset)
-//
-////      println(s"${frag.offset}\n${literalPos.point}\n${pos.point}\n$frag\n")
-//
-//      val f: Tree = frag match {
-//        case Ast.Block.Text(text, offset) => fragPos.at(q"$text", 0)
-//        case WN.Display(exp, offset) => compileTree(exp)
-//        case WN.Comment(msg, offset) => q""
-//        case WN.ScalaExp(Seq(WN.Simple(first, _), WN.Block(ws, args, content, _)), offset)
-//          if first.startsWith("for(") =>
-//          val fresh = c.fresh()
-//          val skeleton: Tree = c.parse(first + s"{$fresh}").asInstanceOf[Apply]
-////          println("FIRST " + first)
-//          skeleton.foreach{x =>
-//            x
-//            if (x.pos != NoPosition) fragPos.set(x, x.pos.point + 1)
-//          }
-//          val b = content.map(compileTree(_))
-//          def rec(t: Tree): Tree = t match {
-//            case a @ Apply(fun, List(f @ Function(vparams, body))) =>
-//              val f2 = Function(vparams, rec(body))
-//              val a2 = Apply(fun, List(f2))
-//              atPos(a.pos)(a2)
-//              atPos(f.pos)(f2)
-//              a2
-//            case Ident(x: TermName) if x.decoded == fresh =>
-//              q"Seq[$fragType](..$b)"
-//          }
-//          rec(skeleton)
-//
-//        case WN.ScalaExp(WN.Simple(first, _) +: WN.Block(_, None, content1, _) +: rest, offset)
-//          if first.startsWith("if(") =>
-//
-//          val b1 = content1.map(compileTree(_))
-//          val tree = c.parse(first + "{}").asInstanceOf[If]
-//          tree.foreach{x =>
-//            fragPos.set(x, x.pos.point + 1)
-//          }
-//          val If(cond, _, _) = tree
-//          val b2 = rest match{
-//            case Seq(WN.Simple(next, _), WN.Block(_, None, content2, _)) =>
-//              content2.map(compileTree(_))
-//            case Seq() => Nil
-//          }
-//          q"if($cond){ Seq[$fragType](..$b1): $fragType } else { Seq[$fragType](..$b2): $fragType }"
-//
-//        case xx @ WN.ScalaExp(WN.Simple(first, _) +: rest, offset) =>
-//
-//          val firstTree = c.parse(first)
-//
-//          firstTree.foreach{x =>
-//            fragPos.set(x, x.pos.point)
-//          }
-//
-//          val s = rest.foldLeft[Tree](firstTree) {
-//            case (l, WN.Simple(code, _)) =>
-//
-//              val fresh = c.fresh()
-//
-//              val snippet = s"$fresh$code"
-//              val skeleton = c.parse(snippet)
-//
-//              def rec(t: Tree): Tree = {
-//
-//                val res = t match {
-//                  case Apply(fun, args) =>
-//                    for(arg <- args; tree <- arg if tree.pos != NoPosition){
-//                      fragPos.set(tree, tree.pos.point + first.length - fresh.length)
-//                    }
-//
-//                    Apply(rec(fun), args)
-//                  case Select(qualifier, name) => Select(rec(qualifier), name)
-//                  case Ident(x: TermName) if x.decoded == fresh => l
-//                }
-//                fragPos.at(res, t.pos.point + first.length - fresh.length)
-////                println(Position.formatMessage(newPos.asInstanceOf[scala.reflect.internal.util.Position], "", true))
-//                res
-//              }
-//              rec(skeleton)
-//
-//            case (l, WN.Block(ws, None, content, offset)) =>
-//              val contentTrees = content.map(compileTree(_))
-//              fragPos.at(q"$l(..$contentTrees)", offset)
-//
-//            case (l, WN.Block(ws, Some(args), content, offset)) =>
-//
-//              val snippet = s"{$args ()}"
-//              val skeleton = c.parse(snippet)
-//
-//              val Function(vparams, body) = skeleton
-//
-//              vparams.map(_.foreach { t =>
-//                if (t.pos != NoPosition)
-//                  fragPos.set(t, t.pos.point)
-//              })
-//              val contentTrees = content.map{compileTree(_)}
-//
-//              val func = Function(vparams, q"Seq[$fragType](..$contentTrees)")
-//              fragPos.at(func, skeleton.pos.point)
-//              val res = q"$l($func)"
-//              fragPos.at(res, offset)
-//              res
-//          }
-//
-//          s
-//      }
-//      f
-//    }
-//
-//    def compileTemplate(tmpl: WN.Template): Tree = {
-//      val WN.Template(name, comment, params, topImports, imports, subs, content, offset) = tmpl
-//      val fullName = if (name.toString == "") c.fresh("outer") else name
-//
-//      val DefDef(mods, realName, tparams, vparamss, tpt, rhs) = {
-//        val snippet = s"def $fullName$params = {}"
-//        val z = c.parse(snippet).asInstanceOf[DefDef]
-//        z
-//      }
-//
-//      val innerDefs = subs.map(compileTemplate(_))
-//
-//      val body = atPos(literalPos)(q"""{
-//        ..${topImports.map(i => c.parse(i.code))}
-//        ..$innerDefs
-//
-//        Seq[scalatags.Text.all.Frag](..${content.map(compileTree(_))})
-//      }""")
-//
-//      if (name.toString == "") body
-//      else DefDef(mods, realName, tparams, vparamss, tpt, body)
-//    }
-//
-//    atPos(literalPos)(q"${compileTemplate(template)}")
+    val res = q"Seq[$fragType](..${compileBlock(template.parts, template.offset)})"
+    println("::::::::::::::::::::::::::::::::::::::::::::::::")
+    println(res)
+    println("::::::::::::::::::::::::::::::::::::::::::::::::")
+    res
   }
 }
\ No newline at end of file