diff

diff tool for Scala data structures (nested case classes etc)

License

License

GroupId

GroupId

ai.x
ArtifactId

ArtifactId

diff_2.12
Last Version

Last Version

2.0.1
Release Date

Release Date

Type

Type

jar
Description

Description

diff
diff tool for Scala data structures (nested case classes etc)
Project URL

Project URL

http://github.com/xdotai/diff
Project Organization

Project Organization

x.ai
Source Code Management

Source Code Management

https://github.com/xdotai/diff

Download diff_2.12

How to add to project

<!-- https://jarcasting.com/artifacts/ai.x/diff_2.12/ -->
<dependency>
    <groupId>ai.x</groupId>
    <artifactId>diff_2.12</artifactId>
    <version>2.0.1</version>
</dependency>
// https://jarcasting.com/artifacts/ai.x/diff_2.12/
implementation 'ai.x:diff_2.12:2.0.1'
// https://jarcasting.com/artifacts/ai.x/diff_2.12/
implementation ("ai.x:diff_2.12:2.0.1")
'ai.x:diff_2.12:jar:2.0.1'
<dependency org="ai.x" name="diff_2.12" rev="2.0.1">
  <artifact name="diff_2.12" type="jar" />
</dependency>
@Grapes(
@Grab(group='ai.x', module='diff_2.12', version='2.0.1')
)
libraryDependencies += "ai.x" % "diff_2.12" % "2.0.1"
[ai.x/diff_2.12 "2.0.1"]

Dependencies

compile (4)

Group / Artifact Type Version
org.scala-lang : scala-library jar 2.12.8
com.chuusai : shapeless_2.12 jar 2.3.2
org.cvogt : scala-extensions_2.12 jar 0.5.3
org.scalactic : scalactic_2.12 jar 3.0.5

test (1)

Group / Artifact Type Version
org.scalatest : scalatest_2.12 jar 3.0.5

Project Modules

There are no modules declared in this project.

diff

Join the chat at https://gitter.im/xdotai/diff

A tool to visually compare Scala data structures with out of the box support for arbitrary case classes.

Be aware: Collections (List, Seq, etc.) are compared like sets, i.e. ignoring order.

SBT Dependencies

Scala 2.11/2.12

"ai.x" %% "diff" % "2.0.1"

Scala 2.10

Stopped working in 1.2.0 due to what seems like a Scala compiler bug. See https://github.com/xdotai/diff/issues/18

Usage

import ai.x.diff.DiffShow
import ai.x.diff.conversions._
println(  DiffShow.diff[Foo]( before, after ).string  )

Be aware that diff throws an Exception if a DiffShow type class instance for some field can't be found rather than a type error. If you use diff in a testing or debugging scenario that's usually not a problem. The advantage is that the Exception can tell exactly which instance wasn't found. A type error can only point to the outer most class (Foo in this case) even if it is actually one of it's deeply nested fields that is lacking an instance for it's type. Knowing only Foo would not be very helpful to pin point which instance is missing.

Output

example-output

Code

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 before: Foo = Foo(
  Bar( "asdf", 5 ),
  List( 123, 1234 ),
  Some( Bar( "asdf", 5 ) )
)
val after: Foo = Foo(
  Bar( "asdf", 66 ),
  List( 1234 ),
  Some( Bar( "qwer", 5 ) )
)

Helpful tips

import ai.x.diff._

Custom comparison

Sometimes you may need to write your own type class instances. For example for non-case classes that don't compare well using ==.

import ai.x.diff._
import org.joda.time.LocalTime

implicit def localTimeDiffShow: DiffShow[LocalTime] = new DiffShow[LocalTime] {
  def show ( d: LocalTime ) = "LocalTime(" + d.toString + ")"
  def diff( l: LocalTime, r: LocalTime ) =
    if ( l isEqual r ) Identical( l ) else Different( l, r )
}

Ignore parts of data

Sometimes you may want to ignore some parts of your data during comparison. You can do so by type, e.g. for non-deterministic parts like ObjectId, which always differ.

def ignore[T]: DiffShow[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 def LocationIdShow: DiffShow[LocationId] = ignore[LocationId]

Influence comparison in collections

When comparing collections you can influence if two elements should be compared or treated as completely different. Comparing elements shows their partial differences. Not comparing them shows them as added or removed.

implicit def PersonDiffShow[L <: HList](
  implicit
  labelled:  LabelledGeneric.Aux[Person, L],
  hlistShow: Lazy[DiffShowFields[L]]
): DiffShow[Person] = new CaseClassDiffShow[Person, L] {
  override def diffable( left: Person, right: Person ) = left._id === right._id
}
ai.x

x.ai

x.ai is a personal assistant who schedule meetings for you

Versions

Version
2.0.1
2.0