Add Less, LessOrEqual parser

src/main/scala/pl/edu/agh/kis/eis/ndl/constraint/OrderedConstraint.scala

@@ -3,12 +3,14 @@ package pl.edu.agh.kis.eis.ndl.constraint
 import pl.edu.agh.kis.eis.ndl.VarOrAtom
 
 
-trait OrderedConstraint[A <: Ordered[A]] extends Constraint[A]
+trait OrderedConstraint[A] extends Constraint[A]
 
-case class Less[A <: Ordered[A]](l: VarOrAtom[A], r: VarOrAtom[A]) extends OrderedConstraint[A] {
-  override def matches(l: A, r: A): Boolean = l < r
+case class Less[A](l: VarOrAtom[A], r: VarOrAtom[A])(implicit ordering: Ordering[A]) extends
+  OrderedConstraint[A] {
+  override def matches(l: A, r: A): Boolean = ordering.lt(l, r)
 }
 
-case class LessOrEqual[A <: Ordered[A]](l: VarOrAtom[A], r: VarOrAtom[A]) extends OrderedConstraint[A] {
-  override def matches(l: A, r: A): Boolean = l <= r
+case class LessOrEqual[A](l: VarOrAtom[A], r: VarOrAtom[A])(implicit ordering: Ordering[A]) extends
+  OrderedConstraint[A] {
+  override def matches(l: A, r: A): Boolean = ordering.lteq(l, r)
 }

src/main/scala/pl/edu/agh/kis/eis/ndl/parser/ConstraintParser.scala

@@ -4,8 +4,11 @@ import pl.edu.agh.kis.eis.ndl.Functor
 import pl.edu.agh.kis.eis.ndl.constraint._
 
 trait ConstraintParser[Domain] {
-  def constraints: PartialFunction[Functor[Domain], Constraint[Domain]] = {
+  def constraints()(implicit ordering: Ordering[Domain]): PartialFunction[Functor[Domain],
+    Constraint[Domain]] = {
     case Functor("=", a1, a2) => Equal(a1, a2)
     case Functor("\\=", a1, a2) => Distinct(a1, a2)
+    case Functor("<", a1, a2) => Less(a1, a2)
+    case Functor("<=", a1, a2) => LessOrEqual(a1, a2)
   }
 }
\ No newline at end of file

src/main/scala/pl/edu/agh/kis/eis/ndl/parser/FunctorParser.scala

@@ -10,7 +10,7 @@ class FunctorParser extends JavaTokenParsers {
   def variable: Parser[Variable[Int]] = "[A-Za-z]+".r ^^ Variable[Int]
   def const: Parser[Const[Int]] = wholeNumber ^^ { number => Const(number.toInt) }
   def param: Parser[VarOrAtom[Int]] = const | variable
-  def functorName: Parser[String] = "[A-Za-z=\\\\]+".r
+  def functorName: Parser[String] = "[A-Za-z=\\\\<]+".r
   def functorArgs: Parser[Functor[Int]] = functorName ~ rep1(param) ^^ {
     case name ~ params => Functor[Int](name, params: _*)
   }

src/main/scala/pl/edu/agh/kis/eis/ndl/parser/NDLParser.scala

@@ -20,12 +20,4 @@ class NDLParser extends FunctorParser with ConstraintParser[FunctorParser#Domain
   }
 
   def query: Parser[List[Functor[Int]]] = braced(braced(functorArgs).+)
-
-  // TODO replace parser tests and remove functions below
-  def termToPlaceholder(q: String): Functor[Int] = term(q).get
-  def parseIntQuery(q: String): List[Functor[Int]] = {
-    query(new CharSequenceReader(q)).get
-  }
-  def term(q: String): ParseResult[Functor[Int]] = functor(new CharSequenceReader(q))
-  def query(q: String): ParseResult[List[Functor[Int]]] = query(new CharSequenceReader(q))
 }

src/test/scala/pl/edu/agh/kis/eis/ndl/FunctorParserSpec.scala

 package pl.edu.agh.kis.eis.ndl
 
 import org.scalatest.{FlatSpec, Matchers}
-import pl.edu.agh.kis.eis.ndl.parser.NDLParser
+import pl.edu.agh.kis.eis.ndl.parser.FunctorParser
 
 class FunctorParserSpec extends FlatSpec with Matchers {
-  val parser = new NDLParser
+  val parser = new FunctorParser
 
-  // FIXME rewrite using new interface
   "Functor with arity 2" should "be returned" in {
-    parser.termToPlaceholder("(fact a 1)") should equal(
+    parser.parse(parser.functor, "(fact a 1)").get should equal(
       Functor("fact", Variable[Int]("a"), Const(1)))
   }
-
-  "Query" should "be parsed" in {
-    parser.parseIntQuery("((fact x) (fact y z))") should equal(Seq(
-      Functor("fact", Variable[Int]("x")),
-      Functor("fact", Variable[Int]("y"), Variable[Int]("z"))))
-  }
-
-
 }

src/test/scala/pl/edu/agh/kis/eis/ndl/parser/ConstraintParserSpec.scala

 package pl.edu.agh.kis.eis.ndl.parser
 
 import org.scalatest.{FlatSpec, Matchers}
-import pl.edu.agh.kis.eis.ndl.constraint.{Distinct, Equal}
+import pl.edu.agh.kis.eis.ndl.constraint.{Distinct, Equal, Less, LessOrEqual}
 import pl.edu.agh.kis.eis.ndl.{Const, VarOrAtom, Variable}
 
 class ConstraintParserSpec extends FlatSpec with Matchers {
@@ -29,7 +29,7 @@ class ConstraintParserSpec extends FlatSpec with Matchers {
     cases.foreach { output =>
       val input = buildExp(output)("=")
       val functor = functorParser.parse(functorParser.functor, input)
-      val parseResult = functor.map(constraintParser.constraints)
+      val parseResult = functor.map(constraintParser.constraints())
       parseResult should equal(functorParser.Success((Equal[Domain] _).tupled(output),
         parseResult.next))
     }
@@ -39,9 +39,29 @@ class ConstraintParserSpec extends FlatSpec with Matchers {
     cases.foreach { output =>
       val input = buildExp(output)("\\=")
       val functor = functorParser.parse(functorParser.functor, input)
-      val parseResult = functor.map(constraintParser.constraints)
+      val parseResult = functor.map(constraintParser.constraints())
       parseResult should equal(functorParser.Success((Distinct[Domain] _).tupled(output),
         parseResult.next))
     }
   }
+
+  it should "parse Less constraint" in {
+    cases.foreach { output =>
+      val input = buildExp(output)("<")
+      val functor = functorParser.parse(functorParser.functor, input)
+      val parseResult = functor.map(constraintParser.constraints())
+      parseResult should equal(functorParser.Success((Less[Domain] _).tupled(output),
+        parseResult.next))
+    }
+  }
+
+  it should "parse LessOrEqual constraint" in {
+    cases.foreach { output =>
+      val input = buildExp(output)("<=")
+      val functor = functorParser.parse(functorParser.functor, input)
+      val parseResult = functor.map(constraintParser.constraints())
+      parseResult should equal(functorParser.Success((LessOrEqual[Domain] _).tupled(output),
+        parseResult.next))
+    }
+  }
 }