Merge pull request #5 from tomerghelber/develop

First version

Author: tomerghelber

.travis.yml

@@ -13,6 +13,7 @@ cache:
     - $HOME/.cache/coursier
     - $HOME/.ivy2/cache
     - $HOME/.sbt/boot/
+    - $HOME/.m2/repository/
 
 # single test suite, non-parallel build.
 

build.sbt

@@ -2,12 +2,12 @@ name := "mathimatica-parser"
 
 scalaVersion := "2.12.8"
 
-libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2"
-libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3"
-libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.9.2"
+libraryDependencies += "org.scala-lang.modules"     %% "scala-parser-combinators" % "1.1.2"
+libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging"            % "3.9.2"
 
-libraryDependencies += "org.scalatest" %% "scalatest" %  "3.0.8" % Test
-libraryDependencies += "org.scalacheck" %% "scalacheck" %  "1.14.2" % Test
+libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3"  % Test
+libraryDependencies += "org.scalatest"  %% "scalatest"      % "3.0.8"  % Test
+libraryDependencies += "org.scalacheck" %% "scalacheck"     % "1.14.2" % Test
 
 // POM settings for Sonatype
 organization := "com.github.tomerghelber"

project/plugins.sbt

@@ -1,2 +1,2 @@
-addSbtPlugin("io.stryker-mutator" % "sbt-stryker4s" % "0.6.1")
-addSbtPlugin("com.geirsson" % "sbt-ci-release" % "1.2.6")
+addSbtPlugin("io.stryker-mutator" % "sbt-stryker4s"  % "0.6.1")
+addSbtPlugin("com.geirsson"       % "sbt-ci-release" % "1.2.6")

src/main/scala/com/github/tomerghelber/mathematica/ast/ASTNode.scala

@@ -1,74 +1,13 @@
 package com.github.tomerghelber.mathematica.ast
 
-trait ASTNode
+sealed trait ASTNode
 
-case class FunctionNode(name: ASTNode, arguments: Seq[ASTNode]) extends ASTNode
+final case class FunctionNode(name: SymbolNode, arguments: Seq[ASTNode]) extends ASTNode
 
-object PartNode extends ApplyManyFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "Part"
+sealed trait TerminalNode extends ASTNode {
+  def value: String
 }
 
-object CompositionNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "Composition"
-}
-object RightCompositionNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "RightComposition"
-}
-case class DerivativeNode(num: Int, expr: ASTNode) extends ASTNode
-object DifferentialDNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "DifferentialD"
-}
-object IntegrateNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "Integrate"
-}
-
-object SameQNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "SameQ"
-}
-object UnSameQNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "UnSameQ"
-}
-object ForAllNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "ForAll"
-}
-object ExistsNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "Exists"
-}
-object NotExistsNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name: String = "NotExists"
-}
-object EquivalentNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
-  protected val name = "Equivalent"
-}
-object ListNode extends ApplyManyFunctionNode with UnapplyFunctionNode {
-  protected val name = "List"
-}
-
-case class LimitNode(expr1: ASTNode, expr3: ASTNode, expr2: ASTNode) extends ASTNode
-case class MaxLimitNode(expr1: ASTNode, expr3: ASTNode, expr2: ASTNode) extends ASTNode
-case class MinLimitNode(expr1: ASTNode, expr3: ASTNode, expr2: ASTNode) extends ASTNode
-
-case class SpanNode(expr1: ASTNode, expr3: ASTNode, expr2: ASTNode) extends ASTNode
-
-trait ApplyUnaryFunctionNode {
-  protected def name: String
-  def apply(node: ASTNode): FunctionNode = createUnary(node)
-  val createUnary: ASTNode => FunctionNode = first => FunctionNode(SymbolNode(name), Seq(first))
-}
-trait ApplyBinaryFunctionNode {
-  protected def name: String
-  def apply(first: ASTNode, second: ASTNode): FunctionNode = createBinary(first, second)
-  val createBinary: (ASTNode, ASTNode) => FunctionNode = (first, second) => FunctionNode(SymbolNode(name), Seq(first, second))
-}
-trait ApplyManyFunctionNode {
-  protected def name: String
-  def apply(nodes: Seq[ASTNode]): FunctionNode = createMany(nodes)
-  val createMany: Seq[ASTNode] => FunctionNode = nodes => FunctionNode(SymbolNode(name), nodes)
-}
-trait UnapplyFunctionNode {
-  protected def name: String
-  def unapply(arg: FunctionNode): Option[Seq[ASTNode]] = arg match {
-    case FunctionNode(SymbolNode(functionName), arguments) if functionName == name => Some(arguments)
-    case _ => None
-  }
-}
+final case class NumberNode(value: String) extends TerminalNode
+final case class StringNode(value: String) extends TerminalNode
+final case class SymbolNode (value: String) extends TerminalNode

src/main/scala/com/github/tomerghelber/mathematica/ast/BinaryOperationNode.scala

@@ -3,21 +3,21 @@ package com.github.tomerghelber.mathematica.ast
 object NotNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "Not"
 }
-object AndNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+object AndNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "And"
 }
-object NandNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+object NandNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "Nand"
 }
-object XorNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+object XorNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "Xor"
 }
-object XnorNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+object XnorNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "Xnor"
 }
-object OrNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+object OrNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "Or"
 }
-object NorNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+object NorNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
   protected val name: String = "Nor"
 }

src/main/scala/com/github/tomerghelber/mathematica/ast/DiscreteOperationNode.scala

@@ -0,0 +1,17 @@
+package com.github.tomerghelber.mathematica.ast
+
+object DNode extends ApplyBinaryFunctionNode {
+  override protected val name: String = "D"
+}
+object DelNode extends ApplyBinaryFunctionNode {
+  override protected val name: String = "Del"
+}
+object DiscreteShiftNode extends ApplyBinaryFunctionNode {
+  override protected val name: String = "DiscreteShift"
+}
+object DiscreteRatioNode extends ApplyBinaryFunctionNode {
+  override protected val name: String = "DiscreteRatio"
+}
+object DifferenceDeltaNode extends ApplyBinaryFunctionNode {
+  override protected val name: String = "DifferenceDelta"
+}

src/main/scala/com/github/tomerghelber/mathematica/ast/ExpressionTestingNode.scala

@@ -0,0 +1,8 @@
+package com.github.tomerghelber.mathematica.ast
+
+object SameQNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "SameQ"
+}
+object UnSameQNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "UnSameQ"
+}

src/main/scala/com/github/tomerghelber/mathematica/ast/FunctionNodeHelpers.scala

@@ -0,0 +1,30 @@
+package com.github.tomerghelber.mathematica.ast
+
+sealed trait FunctionNodeSymbol {
+  protected val name: String
+  lazy val symbol: SymbolNode = SymbolNode(name)
+}
+trait ApplyUnaryFunctionNode extends FunctionNodeSymbol {
+  def apply(node: ASTNode): FunctionNode = createUnary(node)
+  val createUnary: ASTNode => FunctionNode = first => FunctionNode(SymbolNode(name), Seq(first))
+}
+trait ApplyBinaryFunctionNode extends FunctionNodeSymbol {
+  def apply(first: ASTNode, second: ASTNode): FunctionNode = createBinary(first, second)
+  val createBinary: (ASTNode, ASTNode) => FunctionNode =
+    (first, second) => FunctionNode(SymbolNode(name), Seq(first, second))
+}
+trait ApplyTernaryFunctionNode extends FunctionNodeSymbol {
+  def apply(first: ASTNode, second: ASTNode, third: ASTNode): FunctionNode = createTernary(first, second, third)
+  val createTernary: (ASTNode, ASTNode, ASTNode) => FunctionNode =
+    (first, second, third) => FunctionNode(SymbolNode(name), Seq(first, second, third))
+}
+trait ApplyManyFunctionNode extends FunctionNodeSymbol {
+  def apply(nodes: Seq[ASTNode]): FunctionNode = createMany(nodes)
+  val createMany: Seq[ASTNode] => FunctionNode = nodes => FunctionNode(SymbolNode(name), nodes)
+}
+trait UnapplyFunctionNode extends FunctionNodeSymbol {
+  def unapply(arg: ASTNode): Option[Seq[ASTNode]] = arg match {
+    case FunctionNode(functionSymbol, arguments) if functionSymbol == symbol => Some(arguments)
+    case _ => None
+  }
+}

src/main/scala/com/github/tomerghelber/mathematica/ast/FunctionOperationNode.scala

@@ -0,0 +1,26 @@
+package com.github.tomerghelber.mathematica.ast
+
+import scala.util.Try
+
+object DerivativeNode {
+  private val name: String = "Derivative"
+  lazy val symbol: SymbolNode = SymbolNode(name)
+
+  def apply(num: Int, expr: ASTNode): FunctionNode = create(num, expr)
+
+  def create: (Int, ASTNode) => FunctionNode =
+    (num: Int, expr: ASTNode) => FunctionNode(symbol, Seq(NumberNode(num.toString), expr))
+
+  def unapply(arg: ASTNode): Option[(Int, ASTNode)] = arg match {
+    case FunctionNode(functionSymbol, Seq(NumberNode(num), expr))
+      if functionSymbol == symbol && Try(num.toInt).isSuccess =>
+      Some((num.toInt, expr))
+    case _ => None
+  }
+}
+object DifferentialDNode extends ApplyUnaryFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "DifferentialD"
+}
+object IntegrateNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "Integrate"
+}

src/main/scala/com/github/tomerghelber/mathematica/ast/FunctionalOperationNode.scala

@@ -0,0 +1,11 @@
+package com.github.tomerghelber.mathematica.ast
+
+object PartNode extends ApplyManyFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "Part"
+}
+object CompositionNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "Composition"
+}
+object RightCompositionNode extends ApplyBinaryFunctionNode with UnapplyFunctionNode {
+  protected val name: String = "RightComposition"
+}