Merge pull request #8 from xdotai/chris

1.0.1

Author: cvogt

README.md

@@ -8,12 +8,12 @@ Be aware: Collections (List, Seq, etc.) are compared like sets, i.e. ignoring or
 
 ### SBT Dependency
 
-`"ai.x" %% "diff" % "1.0"`
+`"ai.x" %% "diff" % "1.0.1"`
 
 ### Usage
 
 ```scala
-println(  ai.x.diff.DiffShow.diff( before, after ).string  )
+println(  ai.x.diff.DiffShow.diff[Foo]( before, after ).string  )
 ```
 
 #### Output

TODO.txt

@@ -1,6 +1,7 @@
-
 Loose TODO:
 
+- remove fallback implicit and make sure tests pass
+- allow to always show certain fields for selected types even if unchanged in order to see relevant context
 - replace many of the manual type classes with shapeless type class derivation
 - introduce intermediate representation to allow alternative String renderings and allow easy testability of added/removed
 - split Show and Diff

build/build.scala

@@ -7,7 +7,7 @@ import scala.collection.immutable.Seq
 class Build(context: cbt.Context) extends cbt.PublishBuild(context){
   override def defaultScalaVersion = "2.11.8"
 
-  override def defaultVersion = "1.0"
+  override def defaultVersion = "1.0.1"
   override def artifactId = "diff"
   override def groupId = "ai.x"
 

diff.scala

@@ -10,12 +10,6 @@ object `package` {
   def arrow( l: String, r: String ) = l + " -> " + r
   def showChange( l: String, r: String ) = red( l ) + " -> " + green( r )
 }
-/*
-Loose TODO:
-- replace many of the manual type classes with shapeless type class derivation
-- introduce intermediate representation to allow alternative String renderings and allow easy testability of added/removed
-- split Show and Diff
-*/
 
 abstract class Comparison {
   def string: String
@@ -25,15 +19,18 @@ abstract class Comparison {
     case Identical( s ) => create( s )
     case c: Different   => c
   }
+  def isIdentical: Boolean
 }
 case class Identical( string: String ) extends Comparison {
   def create( s: String ) = Identical( s )
+  override def isIdentical = true
 }
 object Identical {
   def apply[T: DiffShow]( value: T ): Identical = Identical( DiffShow.show( value ) )
 }
 case class Different( string: String ) extends Comparison {
   def create( s: String ) = Different( s )
+  override def isIdentical = false
 }
 object Different {
   def apply[T: DiffShow]( left: T, right: T ): Different = Different( DiffShow.show( left ), DiffShow.show( right ) )
@@ -43,7 +40,7 @@ object Different {
 abstract class DiffShow[-T] { // contra-variant to allow Seq type class for List
   def show( t: T ): String
   def diff( left: T, right: T ): Comparison
-  def diffable( left: T, right: T ) = show( left ) == show( right )
+  def diffable( left: T, right: T ) = diff(left, right).isIdentical
 }
 object DiffShow extends DiffShowInstances {
   def apply[T]( implicit diffShow: DiffShow[T] ) = diffShow
@@ -54,7 +51,6 @@ object DiffShow extends DiffShowInstances {
 abstract class DiffShowFields[-T] { // contra-variant to allow Seq type class for List
   def show( t: T ): Map[String, String]
   def diff( left: T, right: T ): Map[String, Comparison]
-  def diffable( left: T, right: T ) = show( left ) == show( right )
 }
 
 abstract class DiffShowFieldsLowPriority {

test/Main.scala

@@ -1,10 +1,64 @@
 import ai.x.diff._
 import scala.collection.immutable.SortedMap
+sealed trait Parent
+case class Bar( s: String, i: Int ) extends Parent
+case class Foo( bar: Bar, b: List[Int], parent: Option[Parent] ) extends Parent
+
+case class Id(int: Int)
+case class Row(id: Id, value: String)
 object Main extends App {
-  sealed trait Parent
-  case class Bar( s: String, i: Int ) extends Parent
-  case class Foo( bar: Bar, b: List[Int], parent: Option[Parent] ) extends Parent
+  val bar = Bar("test",1)
+  val barAsParent: Parent = bar
+  val foo = Foo( bar, Nil, None )
+  val fooAsParent: Parent = foo
+
+  assert( DiffShow.diff( bar, bar ).isIdentical )
+  assert( DiffShow.diff( barAsParent, barAsParent ).isIdentical )
+  assert( DiffShow.diff( bar, barAsParent ).isIdentical )
+  assert( DiffShow.diff( barAsParent, bar ).isIdentical )
+  assert( DiffShow.diff( foo, foo ).isIdentical )
+  assert( DiffShow.diff( foo, fooAsParent ).isIdentical )
+  assert( DiffShow.diff( fooAsParent, foo ).isIdentical )
+  assert( DiffShow.diff( fooAsParent, fooAsParent ).isIdentical )
+
+  assert( !DiffShow.diff[Parent]( bar, foo ).isIdentical )
+  assert( !DiffShow.diff( bar, fooAsParent ).isIdentical )
+  assert( !DiffShow.diff( barAsParent, foo ).isIdentical )
+  assert( !DiffShow.diff( barAsParent, fooAsParent ).isIdentical )
+
+  assert( DiffShow.diff( Seq(bar), Seq(bar) ).isIdentical )
+  // Seqs are compared as Sets
+  assert( DiffShow.diff( Seq(bar), Seq(bar,bar) ).isIdentical )
 
+  assert( !DiffShow.diff[Seq[Parent]]( Seq(foo,bar), Seq(bar) ).isIdentical )
+  assert( !DiffShow.diff[Seq[Parent]]( Seq(foo), Seq(bar) ).isIdentical )
+
+  def ignore[T] = new DiffShow[T] {
+    def show( t: T ) = t.toString
+    def diff( left: T, right: T ) = Identical( "<not compared>" )
+    override def diffable( left: T, right: T ) = true
+  }
+
+  {
+    implicit val ignoreId = ignore[Id]
+    assert( DiffShow.diff( Id(1), Id(1) ).isIdentical )
+    assert( DiffShow.diff( Id(1), Id(2) ).isIdentical )  
+
+    val rowA = Row(Id(1),"foo")
+    val rowB = Row(Id(2),"foo")
+    assert( DiffShow.diff( rowA, rowB ).isIdentical )
+    assert( DiffShow.diff( Seq(rowA), Seq(rowB) ).isIdentical )
+  }
+
+  assert( DiffShow.diff( Id(1), Id(1) ).isIdentical )
+  assert( !DiffShow.diff( Id(1), Id(2) ).isIdentical )  
+
+  val rowA = Row(Id(1),"foo")
+  val rowB = Row(Id(2),"foo")
+  assert( !DiffShow.diff( rowA, rowB ).isIdentical )
+  assert( !DiffShow.diff( Seq(rowA), Seq(rowB) ).isIdentical )
+
+  /*
   val before: Foo = Foo(
     Bar( "asdf", 5 ),
     List( 123, 1234 ),
@@ -19,6 +73,7 @@ object Main extends App {
   println(
     DiffShow.diff( before, after ).string
   )
+  */
 
   {
     implicit def StringDiffShow = new DiffShow[String] {