//设置package包名称以及导入依赖的类
package emailvalidator

import emailvalidator.lexer.{Token, TokenReader}
import emailvalidator.parser.EmailParser

import scala.util.parsing.input.Reader

sealed trait ValidationResult {
  def warnings: Option[List[Warning]] = None
  def isSuccess: Boolean
  def isFailure: Boolean
}

sealed case class Warning (msg:String, explanation:String)

case class Success(override val warnings: Option[List[Warning]] = None) extends ValidationResult {
  override def isFailure = false
  override def isSuccess = true
}


case class Failure(msg:String) extends ValidationResult {
  override def isFailure = true
  override def isSuccess = false
}

object EmailValidator {
  def validate(email:String): Either[Failure,Success] = result(new TokenReader(email))
  def validate(tokenReader: Reader[Token]): Either[Failure,Success] = result(tokenReader)

  private def result(tokenReader: Reader[Token]): Either[Failure, Success] = {
    val parsingResult = EmailParser.parse(tokenReader)
    if (parsingResult.successful) Right(Success())
    else Left(Failure(parsingResult.toString))
  }

} 

//设置package包名称以及导入依赖的类
package sqlpt.thriftplugin

import com.twitter.scrooge.frontend.{NullImporter, ThriftParser}

import scala.util.parsing.input.{CharArrayReader, Reader}
import scala.util.{Success, Try}

object Utils {
  implicit class SequenceForTries[A](tries: Seq[Try[A]]) {
    def sequence: Try[List[A]] =
      tries.foldRight[Try[List[A]]](Success(Nil)) {(t, seq) =>
        for {
          t   <- t
          seq <- seq
        } yield t :: seq
      }
  }

  trait BasicThriftParser {
    def toReader(str: String): Reader[Char] =
      new CharArrayReader(str.toCharArray)

    val thriftParser = new ThriftParser(NullImporter, true)
  }
} 

//设置package包名称以及导入依赖的类
package com.nakoradio.scalc.core.parser

import scala.util.parsing.combinator.RegexParsers
import scala.util.parsing.input.Reader

case class ParserException(message: String) extends Exception


class PatternParser extends RegexParsers {
  final val NUMBER_REGEXP = "[-+]?(\\d+(\\.\\d*)?|\\.\\d+)"

  def number: Parser[BigDecimal] = NUMBER_REGEXP.r ^^ {
    BigDecimal(_)
  }

  def multipliable: Parser[BigDecimal] = "(" ~> summedTerms <~ ")" | number

  def mul: Parser[BigDecimal] = multipliable ~ rep(("*" | "/") ~ multipliable) ^^ {
    case base ~ list => list.foldLeft(base) {
      case (z, "*" ~ n) => z * n
      case (z, "/" ~ n) => if (n != 0) { z / n } else {
        throw ParserException("Division by zero")
      }
    }
  }

  def term: Parser[BigDecimal] = mul | number

  def summedTerms: Parser[BigDecimal] = term ~ rep(("+" | "-") ~ term) ^^ {
    case base ~ list => list.foldLeft(base) {
      case (z, "+" ~ s) => z + s
      case (z, "-" ~ s) => z - s
    }
  }

  def expression: Parser[BigDecimal] = summedTerms

  def nicerError(input: String, message: String, next: Reader[Char]): String = {
    // Until proper error reporting from parser, lets make number parsing errors a bit user friendly
    val nice = message.replace(NUMBER_REGEXP, "number").replaceAll("string matching regex ", "")
    f"Parsing failed due to [$nice] on input [$input] at position [${next.pos.column}]"
  }
} 

//设置package包名称以及导入依赖的类
package importer

import java.io.{Console => _, Reader => _, _}

import importer.Trees._
import importer.parser.TSDefParser
import utl.FramerConfig

case class ParseResult(html: String,css: String)

import scala.util.parsing.input.{PagedSeqReader, Reader}


object FramerParser {
  def parseVnode(s: PagedSeqReader,framerConfig: FramerConfig): ParseResult = {
    val parser = new TSDefParser
    parser.parseDefinitions(s) match {
      case parser.Success(rawCode: List[DeclTree], _) => {
        new Importer().parseVnode(rawCode, "", framerConfig)
      }
      case parser.NoSuccess(msg, next) =>
        println(
          "Parse error at %s\n".format(next.pos.toString)
        )
        ParseResult(
          "Parse error at %s\n".format(next.pos.toString) +
            msg + "\n" +
            next.pos.longString,""
        )
    }
  }
  def parse(s: PagedSeqReader,framerConfig: FramerConfig): ParseResult = {
    val parser = new TSDefParser
    parser.parseDefinitions(s) match {
      case parser.Success(rawCode: List[DeclTree], _) => {
        new Importer().parse(rawCode, "", framerConfig)
      }
      case parser.NoSuccess(msg, next) =>
        println(
          "Parse error at %s\n".format(next.pos.toString)
        )
        ParseResult(
          "Parse error at %s\n".format(next.pos.toString) +
            msg + "\n" +
            next.pos.longString,""
        )
    }
  }
}