pax_global_header00006660000000000000000000000064140323307570014516gustar00rootroot0000000000000052 comment=65e81b03edd8407901118216e4a6f1168e683e97 stringdiff-0.3.2/000077500000000000000000000000001403233075700136575ustar00rootroot00000000000000stringdiff-0.3.2/.github/000077500000000000000000000000001403233075700152175ustar00rootroot00000000000000stringdiff-0.3.2/.github/workflows/000077500000000000000000000000001403233075700172545ustar00rootroot00000000000000stringdiff-0.3.2/.github/workflows/ci.yml000066400000000000000000000072511403233075700203770ustar00rootroot00000000000000# This file was automatically generated by sbt-github-actions using the # githubWorkflowGenerate task. You should add and commit this file to # your git repository. It goes without saying that you shouldn't edit # this file by hand! Instead, if you wish to make changes, you should # change your sbt build configuration to revise the workflow description # to meet your needs, then regenerate this file. name: Continuous Integration on: pull_request: branches: ['*'] push: branches: ['*'] tags: [v*] env: PGP_PASSPHRASE: ${{ secrets.PGP_PASSPHRASE }} SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }} SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }} PGP_SECRET: ${{ secrets.PGP_SECRET }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} jobs: build: name: Build and Test strategy: matrix: os: [ubuntu-latest] scala: [2.13.5, 3.0.0-RC2] java: [openjdk@1.11.0] runs-on: ${{ matrix.os }} steps: - name: Checkout current branch (full) uses: actions/checkout@v2 with: fetch-depth: 0 - name: Setup Java and Scala uses: olafurpg/setup-scala@v10 with: java-version: ${{ matrix.java }} - name: Cache sbt uses: actions/cache@v2 with: path: | ~/.sbt ~/.ivy2/cache ~/.coursier/cache/v1 ~/.cache/coursier/v1 ~/AppData/Local/Coursier/Cache/v1 ~/Library/Caches/Coursier/v1 key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }} - name: Check that workflows are up to date run: sbt ++${{ matrix.scala }} githubWorkflowCheck - name: Build project run: sbt ++${{ matrix.scala }} test - name: Compress target directories run: tar cf targets.tar target stringdiff/.jvm/target stringdiff/.js/target project/target - name: Upload target directories uses: actions/upload-artifact@v2 with: name: target-${{ matrix.os }}-${{ matrix.scala }}-${{ matrix.java }} path: targets.tar publish: name: Publish Artifacts needs: [build] if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v')) strategy: matrix: os: [ubuntu-latest] scala: [2.13.5] java: [openjdk@1.11.0] runs-on: ${{ matrix.os }} steps: - name: Checkout current branch (full) uses: actions/checkout@v2 with: fetch-depth: 0 - name: Setup Java and Scala uses: olafurpg/setup-scala@v10 with: java-version: ${{ matrix.java }} - name: Cache sbt uses: actions/cache@v2 with: path: | ~/.sbt ~/.ivy2/cache ~/.coursier/cache/v1 ~/.cache/coursier/v1 ~/AppData/Local/Coursier/Cache/v1 ~/Library/Caches/Coursier/v1 key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }} - name: Download target directories (2.13.5) uses: actions/download-artifact@v2 with: name: target-${{ matrix.os }}-2.13.5-${{ matrix.java }} - name: Inflate target directories (2.13.5) run: | tar xf targets.tar rm targets.tar - name: Download target directories (3.0.0-RC2) uses: actions/download-artifact@v2 with: name: target-${{ matrix.os }}-3.0.0-RC2-${{ matrix.java }} - name: Inflate target directories (3.0.0-RC2) run: | tar xf targets.tar rm targets.tar - run: sbt ++${{ matrix.scala }} ci-releasestringdiff-0.3.2/.github/workflows/clean.yml000066400000000000000000000044401403233075700210630ustar00rootroot00000000000000# This file was automatically generated by sbt-github-actions using the # githubWorkflowGenerate task. You should add and commit this file to # your git repository. It goes without saying that you shouldn't edit # this file by hand! Instead, if you wish to make changes, you should # change your sbt build configuration to revise the workflow description # to meet your needs, then regenerate this file. name: Clean on: push jobs: delete-artifacts: name: Delete Artifacts runs-on: ubuntu-latest env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} steps: - name: Delete artifacts run: | # Customize those three lines with your repository and credentials: REPO=${GITHUB_API_URL}/repos/${{ github.repository }} # A shortcut to call GitHub API. ghapi() { curl --silent --location --user _:$GITHUB_TOKEN "$@"; } # A temporary file which receives HTTP response headers. TMPFILE=/tmp/tmp.$$ # An associative array, key: artifact name, value: number of artifacts of that name. declare -A ARTCOUNT # Process all artifacts on this repository, loop on returned "pages". URL=$REPO/actions/artifacts while [[ -n "$URL" ]]; do # Get current page, get response headers in a temporary file. JSON=$(ghapi --dump-header $TMPFILE "$URL") # Get URL of next page. Will be empty if we are at the last page. URL=$(grep '^Link:' "$TMPFILE" | tr ',' '\n' | grep 'rel="next"' | head -1 | sed -e 's/.*.*//') rm -f $TMPFILE # Number of artifacts on this page: COUNT=$(( $(jq <<<$JSON -r '.artifacts | length') )) # Loop on all artifacts on this page. for ((i=0; $i < $COUNT; i++)); do # Get name of artifact and count instances of this name. name=$(jq <<<$JSON -r ".artifacts[$i].name?") ARTCOUNT[$name]=$(( $(( ${ARTCOUNT[$name]} )) + 1)) id=$(jq <<<$JSON -r ".artifacts[$i].id?") size=$(( $(jq <<<$JSON -r ".artifacts[$i].size_in_bytes?") )) printf "Deleting '%s' #%d, %'d bytes\n" $name ${ARTCOUNT[$name]} $size ghapi -X DELETE $REPO/actions/artifacts/$id done donestringdiff-0.3.2/.gitignore000066400000000000000000000000221403233075700156410ustar00rootroot00000000000000target .idea .bsp stringdiff-0.3.2/.scalafmt.conf000066400000000000000000000011211403233075700163710ustar00rootroot00000000000000version=2.7.3 style = defaultWithAlign align.openParenCallSite = true align.openParenDefnSite = true align.arrowEnumeratorGenerator = true maxColumn = 180 continuationIndent.defnSite = 2 assumeStandardLibraryStripMargin = true danglingParentheses.defnSite = true danglingParentheses.callSite = true rewrite.rules = [AvoidInfix, ExpandImportSelectors, RedundantParens, SortModifiers] docstrings = JavaDoc newlines.afterCurlyLambda = preserve docstrings.style = Asterisk docstrings.oneline = unfold trailingCommas = "never" optIn.breaksInsideChains = true includeCurlyBraceInSelectChains = true stringdiff-0.3.2/CHANGELOG.md000066400000000000000000000002251403233075700154670ustar00rootroot00000000000000# Changelog ### 0.3.2 Scala 3-RC2. ### 0.3.1 Myers algorithm. ### 0.2.0 Better diffing in complicated scenarios. ### 0.1.0 * initial release stringdiff-0.3.2/LICENSE.md000066400000000000000000000020711403233075700152630ustar00rootroot00000000000000# The MIT License (MIT) Copyright 2020 Iurii Malchenko Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. stringdiff-0.3.2/README.md000066400000000000000000000162411403233075700151420ustar00rootroot00000000000000![Maven Central](https://img.shields.io/maven-central/v/app.tulz/stringdiff_sjs1_2.13.svg) ## app.tulz.diff Myers diff algorithm in Scala. ```scala "app.tulz" %%% "stringdiff" % "0.3.1" ``` ### Overview The core algorithm is a Scala translation of the Python implementation described here: https://blog.robertelder.org/diff-algorithm/ Additionally, the following is implemented on top of it: * interpretation of the algorithm's output * customizable formatting of the interpreted result into a string (with a few provided out of the box formatters) * additional transformations for when the input is expected to be a sequence of tokens (`TokenDiff`) ### Interpretation The core algorithm outputs a set of instructions to get from `SeqA` to `SeqB`, something like this: ``` in order to get from s1="bcdefgzio" to s2="abcxyfgi": Insert a from s2 before position 0 into s1. Delete d from s1 at position 2 in s1. Insert x from s2 before position 3 into s1. Insert y from s2 before position 3 into s1. Delete e from s1 at position 3 in s1. Delete z from s1 at position 6 in s1. Delete o from s1 at position 8 in s1. ``` It's hard to work with it. Also, it is somewhat tricky at first to understand how to follow these instructions (try it! :) ). `MyersInterpret` object parses the raw output into a `List[DiffElement]`: ```scala trait DiffElement[Repr] object DiffElement { final case class InBoth[Repr](v: Repr) extends DiffElement[Repr] final case class InFirst[Repr](v: Repr) extends DiffElement[Repr] final case class InSecond[Repr](v: Repr) extends DiffElement[Repr] final case class Diff[Repr](x: Repr, y: Repr) extends DiffElement[Repr] } ``` The result of the interpretation (without any transformations applied) for the same example: ```scala StringDiff .raw( "bcdefgzio", "abcxyfgi", collapse = false ).mkString("[\n ", "\n ", "\n]") ``` ``` [ InSecond(a) InBoth(bc) InFirst(d) InSecond(x) InSecond(y) InFirst(e) InBoth(fg) InFirst(z) InBoth(i) InFirst(o) ] ``` ### Collapsing By default, diff functions will collapse the diff: ```scala StringDiff .raw( "bcdefgzio", "abcxyfgi", collapse = true // default is true ).mkString("[\n ", "\n ", "\n]") ``` ``` [ InSecond(a) InBoth(bc) Diff(de,xy) InBoth(fg) InFirst(z) InBoth(i) InFirst(o) ] ``` Here, the following list of `DiffElement`s: ``` [ InFirst(d) InSecond(x) InSecond(y) InFirst(e) ] ``` got collapsed into a single one: ``` [ Diff(de,xy) ] ``` In a nutshell, collapsing removes empty elements and joins same or otherwise "join-able" subsequent `DiffElement`s. Examples: * any `InFirst`, `InLast`, `Diff` or `InBoth` gets removed if the element is empty * `Diff` becomes `InFirst` or `InSecond` if one the elements is empty * `InFirst(a)+InFirst(b) -> InFirst(ab)` * `InFirst(a)+InSecond(b) -> Diff(a,b)` * `InSecond(a)+InDiff(b,c) -> Diff(ab,c)` * etc ### Diff'ing sequences: ```scala SeqDiff .seq( Seq(1, 2, 3, 4, 5).toIndexedSeq, Seq(1, 2, 8, 3, 8, 4, 5, 0).toIndexedSeq ).mkString("[\n ", "\n ", "\n]") ``` ``` [ InBoth(Vector(1, 2)) InSecond(Vector(8)) InBoth(Vector(3)) InSecond(Vector(8)) InBoth(Vector(4, 5)) InSecond(Vector(0)) ] ``` ### Diff'ing strings: ##### Raw diff AST: ```scala println( StringDiff.diff( "bcdefgzio", "abcxyfgi" ) ) ``` ``` [ InSecond(a) InBoth(bc) Diff(de,xy) InBoth(fg) InFirst(z) InBoth(i) InFirst(o) ] ``` ##### Text output: ```scala println( StringDiff.text( "bcdefgzio", "abcxyfgi" ) ) ``` ``` [∅|a]]bc][de|xy]]fg][z|∅]]i][o|∅] ``` ##### ANSI color output: ```scala println( StringDiff.ansi( "bcdefgzio", "abcxyfgi" ) ) ``` ![screenshot1](doc/images/screenshot1.png) (default formatters highlight missing text with yellow, extraneous text — with red, and matching text is underlined) ### Diff'ing tokens When the inputs are strings that are expected to contain whitespace-separated tokens, `TokenDiff` will try to make the diff more comprehensible in terms of tokens (while preserving the accuracy). ```scala println( TokenDiff.ansi( "match-1 match-2 diff-1 diff-2 match-3 match-4 diff-1 diff-2 match-1 match-2 diff-1 match-3 match-4 diff-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", "prefix-1 match-1 match-2 diff-3 match-3 match-4 match-1 match-2 diff-2 diff-3 match-3 match-4 diff-2 match-1 match-2 match-3 match-4" ) ) ``` ![screenshot3](doc/images/screenshot3.png) With a `StringDiff` the output would look like the following: ```scala println( StringDiff.ansi( "match-1 match-2 diff-1 diff-2 match-3 match-4 diff-1 diff-2 match-1 match-2 diff-1 match-3 match-4 diff-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", "prefix-1 match-1 match-2 diff-3 match-3 match-4 match-1 match-2 diff-2 diff-3 match-3 match-4 diff-2 match-1 match-2 match-3 match-4" ) ) ``` ![screenshot4](doc/images/screenshot3.png) ##### Inline diffs for both strings ```scala println( TokenDiff.ansiBoth( "match-1 match-2 diff-1 diff-2 match-3 match-4 diff-1 diff-2 match-1 match-2 diff-1 match-3 match-4 diff-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", "prefix-1 match-1 match-2 diff-3 match-3 match-4 match-1 match-2 diff-2 diff-3 match-3 match-4 diff-2 match-1 match-2 match-3 match-4" ) ) ``` ![screenshot3](doc/images/screenshot5.png) ### Usage ##### Diff'ing `Seq`s: ``` SeqDiff.seq( Seq(1, 2, 3), Seq(2, 3, 4) ) ``` ##### Diff'ing `Strings`s: ``` StringDiff.ansi("abc", "acb") // OR StringDiff("abc", "acb") StringDiff.ansiBoth("abc", "acb") StringDiff.text("abc", "acb") StringDiff.diff("abc", "acb") StringDiff.raw("abc", "acb") ``` ##### Diff'ing `Strings`s with tokens: ``` TokenDiff.ansi("abc", "acb") // OR TokenDiff("abc", "acb") TokenDiff.ansiBoth("abc", "acb") TokenDiff.text("abc", "acb") TokenDiff.diff("abc", "acb") TokenDiff.raw("abc", "acb") ``` ### Custom formatters Formatters are instances of the `DiffFormat[Out]` trait: ```scala trait DiffFormat[Out] { def apply(diff: List[DiffElement[String]]): Out } ``` ```scala object MyFormat extends DiffFormat[MyDiffOutput] { ... } val diff: MyDiffOutput = MyFormat(StringDiff("abc", "acb")) ``` For example, the `TextDiffFormat` is implemented like this: ```scala object TextDiffFormat extends DiffFormat[String] { import DiffElement._ def apply(diff: List[DiffElement[String]]): String = { val sb = new StringBuilder diff.foreach { case InBoth(both) => sb.append("]") sb.appendAll(both) sb.append("]") case InSecond(second) => sb.append("[∅|") sb.appendAll(second) sb.append("]") case InFirst(first) => sb.append("[") sb.appendAll(first) sb.append("|∅]") case Diff(first, second) => sb.append("[") sb.appendAll(first) sb.append("|") sb.appendAll(second) sb.append("]") case _ => } sb.toString() } ``` ## Author Iurii Malchenko – [@yurique](https://twitter.com/yurique) ## License `stringdiff` is provided under the [MIT license](https://github.com/tulz-app/stringdiff/blob/main/LICENSE.md). stringdiff-0.3.2/build.sbt000066400000000000000000000035541403233075700154770ustar00rootroot00000000000000inThisBuild( List( organization := "app.tulz", homepage := Some(url("https://github.com/tulz-app/stringdiff")), licenses := List("MIT" -> url("https://github.com/tulz-app/stringdiff/blob/main/LICENSE.md")), scmInfo := Some(ScmInfo(url("https://github.com/tulz-app/stringdiff"), "scm:git@github.com/tulz-app/laminext.git")), developers := List(Developer("yurique", "Iurii Malchenko", "i@yurique.com", url("https://github.com/yurique"))), scalaVersion := ScalaVersions.v213, description := "String diff for Scala", crossScalaVersions := Seq( ScalaVersions.v213, ScalaVersions.v3RC2 ), Test / publishArtifact := false, Test / parallelExecution := false, githubWorkflowJavaVersions := Seq("openjdk@1.11.0"), githubWorkflowTargetTags ++= Seq("v*"), githubWorkflowPublishTargetBranches := Seq(RefPredicate.StartsWith(Ref.Tag("v"))), githubWorkflowPublish := Seq(WorkflowStep.Sbt(List("ci-release"))), githubWorkflowEnv ~= (_ ++ Map( "PGP_PASSPHRASE" -> s"$${{ secrets.PGP_PASSPHRASE }}", "PGP_SECRET" -> s"$${{ secrets.PGP_SECRET }}", "SONATYPE_PASSWORD" -> s"$${{ secrets.SONATYPE_PASSWORD }}", "SONATYPE_USERNAME" -> s"$${{ secrets.SONATYPE_USERNAME }}" )) ) ) lazy val noPublish = Seq( publishLocal / skip := true, publish / skip := true, publishTo := Some(Resolver.file("Unused transient repository", file("target/unusedrepo"))) ) lazy val stringdiff = crossProject(JVMPlatform, JSPlatform) .crossType(CrossType.Pure) .in(file("stringdiff")) .settings( ScalaOptions.fixOptions, libraryDependencies ++= Seq( "org.scalatest" %%% "scalatest" % "3.2.7" % Test ) ) lazy val root = project .in(file(".")) .settings(noPublish) .settings( name := "app.tulz.stringdiff" ) .aggregate( stringdiff.js, stringdiff.jvm ) stringdiff-0.3.2/doc/000077500000000000000000000000001403233075700144245ustar00rootroot00000000000000stringdiff-0.3.2/doc/images/000077500000000000000000000000001403233075700156715ustar00rootroot00000000000000stringdiff-0.3.2/doc/images/screenshot1.png000066400000000000000000000045701403233075700206430ustar00rootroot00000000000000PNG  IHDR' ?IDATx^s_TRq%NR1:VծVFHHXӲ:@d$ !q|$;;)ە5z=NNLçj{zzyUA T!!B !!B !!B !!B !!B !!B afn~f3cmK?x]D4vƵ; Hug^,YYUE9NC^"ŌtǐP6hCLa.-iF&gشyCcCgACz"VeWCn^̄‹-ox}=qMj{e;? A yj3"C5ˤ۞Vn_nKiF&g+" =G 8N((&]Uī,^_TDj{2?*^2%:S փ6өӌL~Ap|p<ޚb \e9C{f7 ӳmNl袿{޾abi _͚ ̻:vbywؽڸKv [44 K+J:~-2ɯ> 0iu oM~ Gc}v! ޣ]w9 AuMGZv{_'O/]T֙վ`29uUm)C:||~W}nUZc( 7@E Q6j< gG 8!aY{`r_\3K"f6'y e "0wxkZm?<>h+v?* x YKϻ㳃JzrַR.CfyĄKιu!L8@gyx`ֿț;s^K=<CTk a(del5~ bQ,24yil%8jBk:)S,^Tיվ ]+^׹tij'k"ks/$㳃 Ģ0#_̐ QXZ %K x>HL 0 ~?/)o4#<:uO=6ːרykg%$a)Х3dRXљilϪ]2їtD?M'*A21>;ȸ" ÕDeSEE"ד*.*uXrREElT 1OgV@v ÆwexLIs9?SXY!ه eH@P eH@P eH@P eH@P eH@P eH@PGO>?IENDB`stringdiff-0.3.2/doc/images/screenshot2.png000066400000000000000000000110431403233075700206350ustar00rootroot00000000000000PNG  IHDR7IDATx^wEe̜3g93Y< d__Hv(%㊊"Ι[NUuLsү;uϭoA!BHB!dMB! 4B!$h4 !BH(hB!P$B!@I!BBFB!&!B MB! 4B!$h4 !BH(hB!P$B!@I!BBFB!&!B MB! 4B!$h4 !BH(dhsѾش'D6QU|X *-ψ%OaqiYbg='͓V5I>k? /+ G5yΛ{o++H2Qj{IN|?5%ӐLc ?B*習u11=ғϤ,de/~!R*8ksIk2;ntk#yye<㚗6.~PϹOĵxOAnJK!D#M:Gg)2j4g9Ty#q>P\>LZYU' 5Kif?PZ==wD: luYزXǞ(;EYjFbŎW!H Lk#꾒L-pM1q!V[OOFzC23vc[i-Zq^͒42听L͙#ň5(?R<(|j_4N \1(߹@Ln^Lic49n0P;4,Mi BL%m9wڳ<==cFˋ* yꜥغ֌/X95 oב103;\Q#as!vf]4O|Uٸ嬺כOuO/1 i2[xʿSgʴ=iv^}hJF3*s3q; BF6.˺* F7YRTݓV! !?wL,]Ls-15P/V 6P;ԾrHD03*mw,eƆ/id"кu[mJjeIUzt%ߕT&Hͼ!uO4nP*SgJ?4ɶCCFLD} t'6l2ti痢yCv~_1}@\}eהHC]w|ˆ$׊ A K0CV$e}KF=^D}c洙ļJ\E4]ǷZtF4_:~)BEϋs]{M+Իi]OmLe:u("h׸뛪ьZē{*.@ToI1_q}5xM023 9*D1[;/N)nFcG4&`=.guEjǢ.~nm4 N`g)B3WE|ɐjfgjZ}p&F+\k,a4K5RU}ct&"6 ox3_FkV}ɋQ$7bMBr̾TODS5Qi_&@~H;Z20L+jUҐ񂩗Yk +~c 1[N|!eIDMQi;fJㅍ@ҾF:i{m4`*!CG,%; A sKAhlBf4(گk0[;ߕ?t,,# !Ifˬ\ܼRK<;F3ſUK*m{21Ηn# ͒0u>tX-e8;Qh^X:7dG[ 6m4IkuhA=YgЌfq |8/L^ӳSMG8FHrhN,l_wu'=Č#6! F&u!!l §8{[7ן5i[(16zJC9yu[ 2ml!A0 ̈́7Tu_w%2cc nXQh|/NoO"R}Gi0[2l9XᷳKzIaoLkG4 34bc{Gg"64ag#7DkRGN7uA/~CCr*s'ĝGXq&Ғ s/ a||QАVfG;0KDD}z4w ldD2_?֫Cȇ&6z:A4R׉3E挦;40w-ӟRgk ;Iew@abkзJd&4ӳ:^| wɋa0Lھt5TfpSMD~6g<+yTu0C=05 I#?zLM3#騐Ny֙"cF3]ПMP4-}KyP~E>@G7-'` B৑f ďn4 !B &!B MB! 4B!$h4 !BH(hB!P$B!@I!BBFB!&!B MB! 4B!$h4 !BH(hB!P$B!@I!BBFB!&!B MB! 4B!$h4 !BH( 5+'IENDB`stringdiff-0.3.2/doc/images/screenshot3.png000066400000000000000000000132051403233075700206400ustar00rootroot00000000000000PNG  IHDRE. LIDATx^ٗV~z$O8̙YY{޻մ1c6f0wjex0&x6=$kn-Us֕Ju+) n3܍E@&0(2A L`Pd" E@&0(2A L`Pd" 2(}ĩ[jk%e6snT=,ˈQ-j`޿k~ZgRdZx`Ŭ9O4wV5iܒwJoB 4yNrjȑSԪN5aԢ\LR,.Iu[t~Xܖ_lyVir4uBjVIl6NO5 ,OJ/HTck!xHJFr|vq:$} YkTM{JcV$(T[uU\LB%m)Ǹ$֭-leCqTmUٽ=dQ5fwKz:RNMoDQٞ9+mk:t"n~S/ZUݘnu꾹OA?S-^vd͉ӷlSONFmZIyjg/Q=$à:4UnjofNr[{k%+yY^)9x;[6u[<_y >Lt:kyxц1wr[~%[？S 3XVvVMMqc'u}5שZk::?,zθq{T&3VDx/+yԨ.]-9޺S }5eaS6A)M[\FUS-5}hi[r1moUڒ1n8[sjҶX}Zvn9M59_hQ_QvzrV OP~%[YEQ ɏ ^4LSI;ZŦYFֽI952阼{-?zg{ZANW-^: 6캬v>:x._Y={Gtg^FHG^u,_vD:VFѺu/9dWU~Cw:Ҵ^f#{ޅLIDޯζu:$9e;> Ǽ)t2'IudrL])_8ؙBqOx%[YX JooN΂56$9̴ڴ5gMW^r ϪV)kEmI0+I=Nql3p`}/} mrO: vM.jH[timKY=ErǴv+?N/+=yKqd[YP:qrYo%2hryg8b[JunxQH~// j<9͟sjĦ9orjhlW*Lyu~N^-Zz>R{=7Ygq/8eYzEM-E-9\͞^W=7˗8J38nBNrŀ$(y-^,ڣNN-{^cTOF%r-Ӝ$J#'gt ջ/gɌFqǖ_lyVVb iҴ]|# E'.qUzOSS#'5eaM{cVVPZGAԮ]Emi[3{-eny[] 2౶kLIzn,X -le|ޗWu^˼k-∣jePdإ'֜V=Aۙ?Ad{GNWVUHn 8[qt v重SwYO: L]n򻟧t.S}t Nmmݙ+ƿ.ھV"w^ү;ꟹJ-z3o#Sd#7m)i2e%˅|+{}=92+3Inӑ_GmԻ.N\R6k'l?ZxnO__6XŻ+I۽V5b,8XEdDN39 z^) xoQ%sI Qw dkw:~;-dInݶV"nR9qs[^=*ozYOCAAɛIߜ7wV=ɴ闊HMmHJ޷Hء;+ ӱSδmkK$LcOi-/}WǝA&'l}kW3ŦK:p9+e^i?<^PnWc%]zO`܊垰{J=} QDcE݌$ۻ=\y~.GdaM{cV&n(udvݞ>(m"qkct}ﴵ%WVqQT+$,[GˠȂ{ZKez(?Ay>t$d0D:2-׬>658biym2("̒!mo <%%Ѽv'S&]w˃:2C.eB^KAdd=LC(={\veko]'_!k~r?gv]֮N^>nt;%M\$!;Y.ˍ[^գ槭(|SO'6? /~AҲ`&s߄ŪN3t:v:deodi+ {JgvM3.HRA:e~gڢY+R{dV'(re~fܫ>gɀM(Y/j; O[ٍIĬC?i?L=Y=aYժ4} m")"Ļ+")iX΃6v*Kč݁ Eo9O?]֓ 'J#:"{yG%e6$d bޣWTȌ srar_[i" r1zBt=k.c>}ń9r$i߿J]&zAHi}YBYjZ'Wn/) URbS ZdYVM\ }=Aw4C%Ҿ!VrDR,5l*iڨ*_%m"MqkA*lҖ|nZo7g#<U*2^ E:9"x,eWYa13l?{u&X1~2+f]exRysZsۇe5f]eGynj8=Ǭ̶%ߡqTaYe}82yz{Od$~9 F!V rpw!ʥ!uPVE@&0(2A L`Pd" E@&0(2A Lu'20IENDB`stringdiff-0.3.2/doc/images/screenshot4.png000066400000000000000000000136001403233075700206400ustar00rootroot00000000000000PNG  IHDR3)GIDATx^}5$O'y'~?F>VC{DBF I .qXBB :@]|`4<ɓ䯩̧FSS]==;}z4飾U[]եXj\%wЉD^t"/:NE'xщD^t"/:NE'xщD^MDw~&-d݆f52cfYf2] ҆W4k7ffZûy5nIFdڰ^x醚Ucɺy_K/]jvu,7 g-Z>:Ǭ_[(PNvKtNkTx͜g怽fCכU;k֗Kgkv8y$3u|]uǒ6xšٗV1m_|Z_L1yR=p =$,H2׽6KjU亱xXn:=ucZ3fu{ }O|y"tOJKBGFs_e*R3L'#OB;r"(dfH^J+^Peټ#zF)|-gͽY_~K^&#OLe;RJGL9˪YyIs2׶P#o7լS޾iiw흾'޵OߝǵMj6]Lwϩm|Ғ?;ؖG dH(BTTCx2UO3vH}E%MGJop}%;%;6$!"tOJKBG^^Y%/KԍaSَ4Qd#W{mCBJkD#2ƨUJi}O4Ny};*+~䫒9~o_^οFn=ʛ%45_|d=|b+f(/Ww޲g`tSw"1[`n̏t\͡GJ?Ec`d$P{>A·g[2_o涻|xdټ۶a w;,4#kfڧ!LJʿە>ҌN[1]w=w=nJߺQ[q^3?6-dL%ztht.S] q5IJOx !nYG[xLvT7ݍKOK9Kj\ } ՝{=I(w?Z{ER7/"u_<ъPqD;z%˵C:tSaSlWM9Pi#f~yg~e<(/S։ }ȱƫ'/{2Ej%e=ᣧjtu"<[8VC[ K%dS^hq|ۈoR5*{d^~46$Y/I`ƭ{jfu"?]fG̏:Wn>l3@ҒGY.ڿ;|wE!Mh.h6Pv|j<7{; K6U\x"Ud(޴4i]5\\Rx-'&뜩2\KmHRVhqS[=~(ǧ'To9jKj dE,\z xq˂<ݢC|q]luc(xӽƭ;&ͥjN'5z!⻷=/-}?/QW#+B辸S7eڎ JG#W\z~VΓ2}sCB⋇4i?=аEe&#򈣼LY'ZSrKU۹'Sԉ2H/=:Dn n>nϝk_<. ~O#\)m:Ho^.J-g|f^^mT(=zT OoTak;>kHǷJݻ^ې} zG5[ -mL`նY ϴd3]3?zlLٚS"}1:bwW{]5>})ZFu ܴGfݭfڛGߴ,y咫^eAnQ!tn.QBCw`FtmnDF'kJ<;w{m^ ~7/ԍ~YD+#%+!nю7],׶>xhm[afw"~O=l`ldXq)DXs#l֜~oPvu"~\2[wwMZM4{Qkk]w %qwFlҼNJ#-\i&QNCw+R_#Q/V{k߱E^ b_uv9 9K.چ̭y6PRx-'&)(k44U~Ɉpgݗ$EKԍaYD#%Mq4ۑ+Ym=z_yTJ]vD?/Q~KD8;h41Ge:]a{hW\fhwqOAS@M߭.;m4ǡ^,GIr˛&:0/zSC/Y>zf;TH(2ZP94ןR=?e89}+A9>rߡ.DHM'CGx{}IRD5OJ;RJGӹIR֣?+Nr|2:bn>;7ʻ'؉;1FKKOԏ41Gy2coդ'S}>٣'mˏ5h4Oih2*.[GM4r=4nX+)umD /}iux뜩*ߩ\LS]/IZ%n䆞&PB7m"Z5c/K{+/*p; 8>w`#`G-߉NE'xщD^t"/:NE'xщD^t"/:3.KXIENDB`stringdiff-0.3.2/doc/images/screenshot5.png000066400000000000000000000172541403233075700206520ustar00rootroot00000000000000PNG  IHDR?J+sIDATx^wW:_9sOLlyqva o6@ M$-@Bք$}zwrI*Kr|ukM^֕BDDDDDDDD%ͺht"""""""""1DDDDDDDDDc҉<ǤyI'""""""""NDDDDDDDD9&sL:t"""""""""1DDDDDDDDDc҉<Ǥy.IE59ҽWR06,o2/o|[ZF|@1K7U߈`/_ǩ,?4/z8:#ky&ƾi* ItC܍DTVߺg0m&)>PhtnU{=1lGgq<p xю=c f&{~ppds̩ u6#v!I'$ji=Mɋ/KRKm}ɷirXRɤfݸ`k_k*鄙Noh5 }vUSN$Z&5i|V'-=[DG<4ck w}&ߔe|'TwK6A4elzp#jrt Gnc}nlpלV9ϜRiha{nAل*m 8~7&FD5ipoe.A쏌-ŦD:9i\u~4}gg-_/k7%;w_xS ?8̦/O` L18<`BCIHz ~?!k[*Fe@|:řSYn料ߔQHJ]]d{VĮrtI,i¢5y&*kr&;ij}7Z ɪ>d5~!ju#2oT !4fc$2H?^Sƕb?e}I:[_#S:֪ڽ<֮S/^zD52 ,zn,2hx Eű 359~,Y֣0D'-WehxDsX7l=q3~dy=mzN1 yp+. [ƼQŞ9w*˄u]-Y|kY ӏ<[~m U nh? ۑ(cM; =b_n=2L=b?hwEη JeHB5-ye ^;řSS\cHXJ}knUw7논$gwi2{3r$zN H$!nM-_d㫉0 Uٮ tY<^}ɥV?~7ol^Zˤ&n?^(2o>yeG}0ۭ+e"i뇶퀆xعs6WE݇mhǻ܂V!~V۹H/: b 鞱~3) 4۬Nt~:ԿN A3\ VAe9/:tk 3sx;^SV7uo#ƙxG ~ApՎv =2~01{d`?M ̲ÚKL_;[ߖB^N5d7,^H2!4s%1*1i/ϐM ^_FnKvIs굵ՆfH߫L,h̘hR7ooEo|Ƕ]]G5bjFó-Pbf&S.!TkT\nrA *cgS83‹8nm2 w+5 ~Aۑ?̌Qb/a L` C9 k;H|9~1ˤ,'O0jʔB^NX)\M~Ԥ,^*4JnѤ&u2bTǜ&{R W55f-6>Zm=֪\ja7q̜hR7!ۛ*{_w0C^:6>h4llPljZ$^g9a,8uuPX` l$DaV>^氜kiSR<|m`! =ʇԯ =b?=8s*stb[XnGVS %owc*IoE~79`f. mww_:ٶ~?ߵB7]v&'N?}/^.%eU'M5zjrmͶ?ɕ/59uVSGd\ʗw5u}&sζup݁{Tv&m|0sʗN31X\*z4H378˱6GM>ik3+:#~G^#yؗn8cLV 8s*sk#v!IzG{TꋓMjlBkX#*e-υO-ض;ɶ?tS]6W*Ȳ}R8Ke_8:nI7U/lMҙwR^]>lvKSXRLIʫ&#um)hKU=jpG&Dky&Ǝ}4YNirY|B gY?xU;r+}3DnA9řSl GBΓNʣhDT7%mI9;0ɤjvѷqkMa{J:a-cu7k1mcBrSo($H~?get1Uٵj v\>oJd2U*w;L OZ 6=z8vz U5T9:KɁ#Ա>7Ue֋kNga{_44ǎ߰ lBJ6S/#MǾU37prsCױk-ϨS/z0xdl|U}9O1 :u ǷN+ Ԃ:p< Z>eڎtؗ3QPu>=֎$4ߟItH)Μu]I{o$>ɢ忱glb 9O:e i4Q׵MJiQ]I}zg4YՄdէmj&unS˘,χCBi9N( p;{ͭrM]qth:zGtU {15x]*_jdX;liYT5$d`cɱ9^'˒e=j HtrUL4:z#b2fp b`9zc*s:VM|Ic͌O7논$Ե~[ɆČ$@" qX$F"9f4aS,՚N#Gʥ|˓ wcUV몓;@IϫJ}[O^Q|L19v9axY) om;-^z4vMUyQa4Znկ-Deȟvn+,N΢mb,̃!3co&eXnv簦D^SYk{ #|[b=UPohp2fk0-^kygٗ'B ~6iGAGٗ'5|& =b?hNCk),2HHLK5.논$̏]i ǓPR#nPBeS( OVx,|ۤz;n=w .zc@,̌5#dX#BZDl;gf٤nA_] uOΛ Q13tVeύ8 Ŷv 0h`!MkYP}LxI&NY%{Pmno;_c :`jW4}~Tgٗ'B G1A_!GnQPx ~Ap(h~0>46,\x-I'0qcc[.b yI:m7PzcrI:a_r¯_X)SNkkë ͐׿WX#ј18~ o; mjxԌg/[0WYݡŴL\B96C ƳȖpf/H 鳶̂R?|rN\ߩ't05 R~CUMz^Ӕi/O%(qfƾ<bou0xxM; =2c_4L{d~IϞF=ڋ_v5f]SL:a_q_&-bqNĮtLJ6=*UL:mRW\>$T6IS jQ#^[*U/%ϵF9GBL\ 7}V9{OٵAmAg`\ef˖W?V"u? c=(V`>_GA wwkAce{1K'(vc ïd{N-^d,(r3/1U.izpZK|<~kB`z>Lp^*TTK:~KT`qT.N'5p59G$d^K dZʑteI:AgYZ uRTUN7};B/"jq쇅DZx%~>ÎZbϰ*sx~uێjg'w;ٴC< ?PyMl1Af6E911;Ytqxů'Zt!E8 d^KiF]f YžC!W2eUٺ=cF7cםB9k,m7<ÎoYjrMXK/18P'gN ~~ǣ~C̕BGN ~Gӫ_ l)I'젟kŚ+`OBz)wpX_Y7"kĚZNNEK-MDDDDDDDD0DDDDDDDDDc҉<ǤyI'""""""""NDDDDDDDD9&sL:t"""""""""1DDDDDDDDDc҉<ǤyI'""""""""NDDDDDDDD9&s`JIENDB`stringdiff-0.3.2/project/000077500000000000000000000000001403233075700153255ustar00rootroot00000000000000stringdiff-0.3.2/project/ScalaOptions.scala000066400000000000000000000016431403233075700207350ustar00rootroot00000000000000import sbt.Keys._ import sbt._ object ScalaOptions { val fixOptions = Seq( scalacOptions ~= (_.filterNot( Set( "-Wdead-code", "-Wunused:implicits", "-Wunused:explicits", "-Wunused:imports", "-Wunused:params" ) )), scalacOptions ++= (CrossVersion.partialVersion(scalaVersion.value) match { case Some((2, _)) => Seq( "-Ymacro-annotations" ) case Some((3, _)) => Seq() case _ => Seq() }), (Compile / doc / scalacOptions) ~= (_.filterNot( Set( "-scalajs", "-deprecation", "-explain-types", "-explain", "-feature", "-language:existentials,experimental.macros,higherKinds,implicitConversions", "-unchecked", "-Xfatal-warnings", "-Ykind-projector", "-from-tasty", "-encoding", "utf8" ) )) ) } stringdiff-0.3.2/project/ScalaVersions.scala000066400000000000000000000001121403233075700211000ustar00rootroot00000000000000object ScalaVersions { val v213 = "2.13.5" val v3RC2 = "3.0.0-RC2" } stringdiff-0.3.2/project/build.properties000066400000000000000000000000261403233075700205400ustar00rootroot00000000000000sbt.version=1.5.0-RC2 stringdiff-0.3.2/project/plugins.sbt000066400000000000000000000010111403233075700175110ustar00rootroot00000000000000logLevel := Level.Warn addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.5.0") addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.0.0") addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.2") addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.1.2") addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.7") addSbtPlugin("com.codecommit" % "sbt-github-actions" % "0.10.1") addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % "0.1.17") addSbtPlugin("com.geirsson" % "sbt-ci-release" % "1.5.7") stringdiff-0.3.2/stringdiff/000077500000000000000000000000001403233075700160165ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/000077500000000000000000000000001403233075700166055ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/000077500000000000000000000000001403233075700175315ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/000077500000000000000000000000001403233075700206145ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/app/000077500000000000000000000000001403233075700213745ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/000077500000000000000000000000001403233075700223725ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/000077500000000000000000000000001403233075700233025ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/DiffElement.scala000066400000000000000000000020761403233075700264760ustar00rootroot00000000000000package app.tulz.diff sealed trait DiffElement[Repr] extends Product with Serializable { def inFirstOrSecond: Boolean = false def inFirst: Boolean = false def inSecond: Boolean = false def map[B](f: Repr => B): DiffElement[B] } object DiffElement { final case class InBoth[Repr](v: Repr) extends DiffElement[Repr] { def map[B](f: Repr => B): DiffElement[B] = DiffElement.InBoth(f(v)) } final case class InFirst[Repr](v: Repr) extends DiffElement[Repr] { override def inFirstOrSecond: Boolean = true override def inFirst: Boolean = true def map[B](f: Repr => B): DiffElement[B] = DiffElement.InFirst(f(v)) } final case class InSecond[Repr](v: Repr) extends DiffElement[Repr] { override def inFirstOrSecond: Boolean = true override def inSecond: Boolean = true def map[B](f: Repr => B): DiffElement[B] = DiffElement.InSecond(f(v)) } final case class Diff[Repr](x: Repr, y: Repr) extends DiffElement[Repr] { def map[B](f: Repr => B): DiffElement[B] = DiffElement.Diff(f(x), f(y)) } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/MyersDiff.scala000066400000000000000000000061231403233075700262010ustar00rootroot00000000000000package app.tulz.diff import scala.collection.IndexedSeqView object MyersDiff { def diff[A](ss1: IndexedSeqView[A], ss2: IndexedSeqView[A]): Seq[Operation] = { def mod(a: Int, b: Int): Int = { (b + (a % b)) % b } def rec( ss1: IndexedSeqView[A], ss2: IndexedSeqView[A], i: Int, j: Int ): Seq[Operation] = { val N = ss1.size val M = ss2.size val L = N + M val Z = 2 * Math.min(N, M) + 2 if (N > 0 && M > 0) { val w = N - M val g = Array.fill(Z)(0) val p = Array.fill(Z)(0) for (h <- 0 until (L / 2 + mod(L, 2)) + 1) { for (r <- 0 until 2) { val (c, d, o, m) = if (r == 0) (g, p, 1, 1) else (p, g, 0, -1) for (k <- -(h - 2 * Math.max(0, h - M)) until h - 2 * Math.max(0, h - N) + 1 by 2) { var a = if (k == -h || k != h && c(mod(k - 1, Z)) < c(mod(k + 1, Z))) { c(mod(k + 1, Z)) } else { c(mod(k - 1, Z)) + 1 } var b = a - k val (s, t) = (a, b) while (a < N && b < M && ss1((1 - o) * N + m * a + (o - 1)) == ss2((1 - o) * M + m * b + (o - 1))) { a = a + 1 b = b + 1 } c(mod(k, Z)) = a val z = -(k - w) if (mod(L, 2) == o && z >= -(h - o) && z <= h - o && c(mod(k, Z)) + d(mod(z, Z)) >= N) { val (_D, x, y, u, v) = if (o == 1) { (2 * h - 1, s, t, a, b) } else { (2 * h, N - a, M - b, N - s, M - t) } if (_D > 1 || (x != u && y != v)) { val r1 = rec(ss1.take(x), ss2.take(y), i, j) val r2 = rec(ss1.slice(u, N), ss2.slice(v, M), i + u, j + v) return r1 ++ r2 } else if (M > N) { return rec(ss1.take(0), ss2.slice(N, M), i + N, j + N) } else if (M < N) { return rec(ss1.slice(M, N), ss2.take(0), i + M, j + M) } else { return Seq.empty } } } } } throw new RuntimeException("should never have reached here") } else if (N > 0) { if (N > 0) { (0 until N).map(n => Operation.Delete(from = i + n, count = 1)) } else { Seq.empty } } else { if (M > 0) { (0 until M).map(m => Operation.Insert(at = i, from = j + m, count = 1)).toList } else { List.empty } } } rec(ss1.toIndexedSeq.view, ss2.toIndexedSeq.view, 0, 0) } sealed trait Operation extends Product with Serializable object Operation { case object Start extends Operation final case class Insert(at: Int, from: Int, count: Int) extends Operation final case class Delete(from: Int, count: Int) extends Operation case object End extends Operation } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/MyersInterpret.scala000066400000000000000000000067231403233075700273130ustar00rootroot00000000000000package app.tulz.diff import app.tulz.diff.MyersDiff.Operation import scala.collection.mutable.ListBuffer import scala.collection.IndexedSeqView object MyersInterpret { import DiffElement._ import Operation._ def apply[A]( ops: Seq[Operation], s1: IndexedSeqView[A], s2: IndexedSeqView[A] ): List[DiffElement[IndexedSeqView[A]]] = if (ops.isEmpty) { List(DiffElement.InBoth(s1)) } else { val buffer = new ListBuffer[DiffElement[IndexedSeqView[A]]] buffer.sizeHint(ops.length) (Start +: ops).zip(ops :+ End).foreach { case (Start, Delete(deleteFrom, deleteCount)) => if (deleteFrom > 0) { buffer.addOne( InBoth( s1.take(deleteFrom) ) ) } buffer.addOne( InFirst( s1.slice(deleteFrom, deleteFrom + deleteCount) ) ) case (Start, Insert(insertAt, insertFrom, insertCount)) => if (insertAt > 0) { buffer.addOne( InBoth( s1.take(insertFrom) ) ) } buffer.addOne( InSecond( s2.slice(insertFrom, insertFrom + insertCount) ) ) case (Delete(deleteFrom, deleteCount), Insert(insertAt, insertFrom, insertCount)) => if (insertAt > deleteFrom + deleteCount) { buffer.addOne( InBoth( s1.slice(deleteFrom + deleteCount, insertAt) ) ) } buffer.addOne( InSecond( s2.slice(insertFrom, insertFrom + insertCount) ) ) case (Insert(insertAt, _, _), Delete(deleteFrom, deleteCount)) => if (deleteFrom > insertAt) { buffer.addOne( InBoth( s1.slice(insertAt, deleteFrom) ) ) } buffer.addOne( InFirst( s1.slice(deleteFrom, deleteFrom + deleteCount) ) ) case (Insert(insertAt1, _, _), Insert(insertAt2, insertFrom2, insertCount2)) => if (insertAt2 > insertAt1) { buffer.addOne( InBoth( s1.slice(insertAt1, insertAt2) ) ) } buffer.addOne( InSecond( s2.slice(insertFrom2, insertFrom2 + insertCount2) ) ) case (Delete(deleteFrom1, deleteCount1), Delete(deleteFrom2, deleteCount2)) => if (deleteFrom2 > deleteFrom1 + deleteCount1) { buffer.addOne( InBoth( s1.slice(deleteFrom1 + deleteCount1, deleteFrom2) ) ) } buffer.addOne( InFirst( s1.slice(deleteFrom2, deleteFrom2 + deleteCount2) ) ) case (Insert(insertAt, _, _), End) => if (s1.size > insertAt) { buffer.addOne( InBoth( s1.slice(insertAt, s1.size) ) ) } case (Delete(deleteFrom, deleteCount), End) => if (s1.size > deleteFrom + deleteCount) { buffer.addOne( InBoth( s1.slice(deleteFrom + deleteCount, s1.size) ) ) } case (_, End) => case (_, Start) => case (End, _) => } buffer.toList } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/SeqDiff.scala000066400000000000000000000012001403233075700256210ustar00rootroot00000000000000package app.tulz.diff import app.tulz.diff.util.DiffCollapse import scala.collection.IndexedSeqView object SeqDiff { def seq[A]( s1: IndexedSeq[A], s2: IndexedSeq[A], collapse: Boolean = true ): List[DiffElement[IndexedSeq[A]]] = apply(s1.view, s2.view, collapse).map(_.map(_.toIndexedSeq)) def apply[A]( s1: IndexedSeqView[A], s2: IndexedSeqView[A], collapse: Boolean = true ): List[DiffElement[IndexedSeqView[A]]] = { val myersDiff = MyersDiff.diff(s1, s2) val diff = MyersInterpret(myersDiff, s1, s2) if (collapse) { DiffCollapse(diff) } else { diff } } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/StringDiff.scala000066400000000000000000000017411403233075700263510ustar00rootroot00000000000000package app.tulz.diff import app.tulz.diff.format.DiffFormat import app.tulz.diff.util.DiffCollapse object StringDiff { def apply( s1: String, s2: String, collapse: Boolean = true ): String = ansi(s1, s2) def ansi( s1: String, s2: String, collapse: Boolean = true ): String = DiffFormat.ansi(diff(s1, s2, collapse)) def ansiBoth( s1: String, s2: String, collapse: Boolean = true ): (String, String) = DiffFormat.ansiBoth(diff(s1, s2, collapse)) def text( s1: String, s2: String, collapse: Boolean = true ): String = DiffFormat.text(diff(s1, s2, collapse)) def diff( s1: String, s2: String, collapse: Boolean = true ): List[DiffElement[String]] = { val myersDiff = MyersDiff.diff(s1.view, s2.view) val diff = MyersInterpret(myersDiff, s1.view, s2.view) val result = if (collapse) { DiffCollapse(diff) } else { diff } result.map(_.map(_.mkString)) } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/TokenDiff.scala000066400000000000000000000032661403233075700261670ustar00rootroot00000000000000package app.tulz.diff import app.tulz.diff.format.DiffFormat import app.tulz.diff.util.DiffCollapse import app.tulz.diff.util.DiffPrettier import app.tulz.diff.util.DiffTokenize import scala.collection.mutable.ListBuffer object TokenDiff { private val whitespace = "\\s+".r private def tokenize(s: String): IndexedSeq[String] = { val buffer = new ListBuffer[String] var pos = 0 whitespace.findAllMatchIn(s).foreach { m => if (m.start > pos) { buffer.addOne(s.substring(pos, m.start)) } buffer.addOne(s.substring(m.start, m.end)) pos = m.end } if (pos < s.length) { buffer.addOne(s.substring(pos)) } buffer.toIndexedSeq } def apply( s1: String, s2: String ): String = ansi(s1, s2) def ansi( s1: String, s2: String ): String = DiffFormat.ansi(diff(s1, s2)) def ansiBoth( s1: String, s2: String ): (String, String) = DiffFormat.ansiBoth(diff(s1, s2)) def text( s1: String, s2: String ): String = DiffFormat.ansi(diff(s1, s2)) def diff[Out]( s1: String, s2: String ): List[DiffElement[String]] = { val diff = SeqDiff( TokenDiff.tokenize(s1).view, TokenDiff.tokenize(s2).view, collapse = false ) var in = diff var transformed = diff var first = true while (first || in != transformed) { first = false in = transformed transformed = DiffTokenize.moveWhitespace(transformed) transformed = DiffTokenize.firstsGoFirst(transformed) } transformed = DiffTokenize.join(transformed) transformed = DiffCollapse(transformed) DiffPrettier(transformed.map(_.map(_.mkString))) } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/format/000077500000000000000000000000001403233075700245725ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/format/AnsiDiffFormat.scala000066400000000000000000000022271403233075700304360ustar00rootroot00000000000000package app.tulz.diff.format import app.tulz.diff.DiffElement import scala.Console._ object AnsiDiffFormat extends DiffFormat[String] { import DiffElement._ def apply(diff: List[DiffElement[String]]): String = { val sb = new StringBuilder sb.append(RESET) diff.foreach { case InBoth(both) => sb.append("[") sb.append(UNDERLINED) sb.appendAll(both) sb.append(RESET) sb.append("]") case InSecond(second) => sb.append("[∅|") sb.append(YELLOW) sb.append(UNDERLINED) sb.appendAll(second) sb.append(RESET) sb.append("]") case InFirst(first) => sb.append("[") sb.append(RED) sb.append(UNDERLINED) sb.appendAll(first) sb.append(RESET) sb.append("|∅]") case Diff(first, second) => sb.append("[") sb.append(RED) sb.append(UNDERLINED) sb.appendAll(first) sb.append(RESET) sb.append("|") sb.append(YELLOW) sb.append(UNDERLINED) sb.appendAll(second) sb.append(RESET) sb.append("]") } sb.toString() } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/format/AnsiDiffFormatBoth.scala000066400000000000000000000027661403233075700312630ustar00rootroot00000000000000package app.tulz.diff.format import app.tulz.diff.DiffElement import scala.Console._ object AnsiDiffFormatBoth extends DiffFormat[(String, String)] { import DiffElement._ def apply(diff: List[DiffElement[String]]): (String, String) = { val sb1 = new StringBuilder sb1.append(RESET) diff.foreach { case InBoth(both) => sb1.append(UNDERLINED) sb1.appendAll(both) sb1.append(RESET) case InFirst(first) => sb1.append(RED) sb1.append(UNDERLINED) sb1.appendAll(first) sb1.append(RESET) case InSecond(second) => sb1.append(YELLOW) sb1.append(UNDERLINED) sb1.appendAll(second) sb1.append(RESET) case Diff(first, _) => sb1.append(RED) sb1.append(UNDERLINED) sb1.appendAll(first) sb1.append(RESET) } val sb2 = new StringBuilder sb2.append(RESET) diff.foreach { case InBoth(both) => sb2.append(UNDERLINED) sb2.appendAll(both) sb2.append(RESET) case InFirst(first) => sb2.append(YELLOW) sb2.append(UNDERLINED) sb2.appendAll(first) sb2.append(RESET) case InSecond(second) => sb2.append(RED) sb2.append(UNDERLINED) sb2.appendAll(second) sb2.append(RESET) case Diff(_, second) => sb2.append(YELLOW) sb2.append(UNDERLINED) sb2.appendAll(second) sb2.append(RESET) } (sb1.toString(), sb2.toString()) } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/format/DiffFormat.scala000066400000000000000000000005131403233075700276170ustar00rootroot00000000000000package app.tulz.diff.format import app.tulz.diff.DiffElement trait DiffFormat[Out] { def apply(diff: List[DiffElement[String]]): Out } object DiffFormat { val ansi: DiffFormat[String] = AnsiDiffFormat val ansiBoth: DiffFormat[(String, String)] = AnsiDiffFormatBoth val text: DiffFormat[String] = TextDiffFormat } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/format/TextDiffFormat.scala000066400000000000000000000013631403233075700304700ustar00rootroot00000000000000package app.tulz.diff.format import app.tulz.diff.DiffElement object TextDiffFormat extends DiffFormat[String] { import DiffElement._ def apply(diff: List[DiffElement[String]]): String = { val sb = new StringBuilder diff.foreach { case InBoth(both) => sb.append("]") sb.appendAll(both) sb.append("]") case InSecond(second) => sb.append("[∅|") sb.appendAll(second) sb.append("]") case InFirst(first) => sb.append("[") sb.appendAll(first) sb.append("|∅]") case Diff(first, second) => sb.append("[") sb.appendAll(first) sb.append("|") sb.appendAll(second) sb.append("]") } sb.toString() } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/util/000077500000000000000000000000001403233075700242575ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/util/DiffCollapse.scala000066400000000000000000000040641403233075700276230ustar00rootroot00000000000000package app.tulz.diff.util import app.tulz.diff.DiffElement import app.tulz.diff.DiffElement.Diff import app.tulz.diff.DiffElement.InBoth import app.tulz.diff.DiffElement.InFirst import app.tulz.diff.DiffElement.InSecond import scala.collection.IndexedSeqView private[diff] object DiffCollapse { def apply[A]( diff: List[DiffElement[IndexedSeqView[A]]] ): List[DiffElement[IndexedSeqView[A]]] = ListScan(diff) { case InBoth(both) :: tail if both.isEmpty => Nil -> tail case InFirst(first) :: tail if first.isEmpty => Nil -> tail case InSecond(second) :: tail if second.isEmpty => Nil -> tail case Diff(first, second) :: tail if first.isEmpty && second.isEmpty => Nil -> tail case Diff(first, second) :: tail if second.isEmpty => (InFirst(first) :: Nil) -> tail case Diff(first, second) :: tail if first.isEmpty => (InSecond(second) :: Nil) -> tail case InBoth(both1) :: InBoth(both2) :: tail => Nil -> (InBoth(both1.concat(both2)) :: tail) case InSecond(second) :: InFirst(first) :: tail => Nil -> (Diff(first, second) :: tail) case InFirst(first) :: InSecond(second) :: tail => Nil -> (Diff(first, second) :: tail) case InFirst(first1) :: InFirst(first2) :: tail => Nil -> (InFirst(first1.concat(first2)) :: tail) case InSecond(second1) :: InSecond(second2) :: tail => Nil -> (InSecond(second1.concat(second2)) :: tail) case InFirst(first1) :: Diff(first2, second) :: tail => Nil -> (Diff(first1.concat(first2), second) :: tail) case InSecond(second1) :: Diff(first, second2) :: tail => Nil -> (Diff(first, second1.concat(second2)) :: tail) case Diff(first1, second) :: InFirst(first2) :: tail => Nil -> (Diff(first1.concat(first2), second) :: tail) case Diff(first, second1) :: InSecond(second2) :: tail => Nil -> (Diff(first, second1.concat(second2)) :: tail) case head :: tail => (head :: Nil) -> tail case Nil => Nil -> Nil } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/util/DiffLog.scala000066400000000000000000000010651403233075700266000ustar00rootroot00000000000000package app.tulz.diff.util import app.tulz.diff.DiffElement import app.tulz.diff.format.DiffFormat import scala.collection.IndexedSeqView private[diff] object DiffLog { def log(description: => String, diff: => List[DiffElement[IndexedSeqView[String]]]): Unit = { println(s"${description}:${" " * (20 - description.length)}${DiffFormat.ansi(diff.map(_.map(_.mkString)))}") } def logS(description: => String, diff: => List[DiffElement[String]]): Unit = { println(s"${description}:${" " * (20 - description.length)}${DiffFormat.ansi(diff)}") } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/util/DiffPrettier.scala000066400000000000000000000042651403233075700276620ustar00rootroot00000000000000package app.tulz.diff.util import app.tulz.diff.DiffElement import app.tulz.diff.DiffElement.Diff import app.tulz.diff.DiffElement.InBoth private[diff] object DiffPrettier { def apply( diff: List[DiffElement[String]] ): List[DiffElement[String]] = collapseInBoth( ListScan(diff) { case (d @ Diff(first, second)) :: tail => val (prefix, firstRest1, secondRest1) = sameWhitespacePrefix(first, second) val (firstRest2, secondRest2, suffix) = sameWhitespaceSuffix(firstRest1, secondRest1) if (prefix.nonEmpty && suffix.nonEmpty) { (InBoth[String](prefix) :: Diff[String](firstRest2, secondRest2) :: InBoth[String](suffix) :: Nil) -> tail } else if (prefix.nonEmpty) { (InBoth[String](prefix) :: Diff[String](firstRest2, secondRest2) :: Nil) -> tail } else if (suffix.nonEmpty) { (Diff[String](firstRest2, secondRest2) :: InBoth[String](suffix) :: Nil) -> tail } else { (d :: Nil) -> tail } case head :: tail => (head :: Nil) -> tail case Nil => Nil -> Nil } ) private def collapseInBoth( diff: List[DiffElement[String]] ): List[DiffElement[String]] = ListScan(diff) { case InBoth(first) :: InBoth(second) :: tail => Nil -> (InBoth(first + second) :: tail) case head :: tail => (head :: Nil) -> tail case Nil => Nil -> Nil } private def sameWhitespacePrefix( s1: String, s2: String ): (String, String, String) = { val samePrefixLength = s1.indices .takeWhile(i => i < s2.length && s1.charAt(i) == s2.charAt(i) && s1.charAt(i).isWhitespace) .maxOption.fold(0)(_ + 1) (s1.take(samePrefixLength), s1.drop(samePrefixLength), s2.drop(samePrefixLength)) } private def sameWhitespaceSuffix( s1: String, s2: String ): (String, String, String) = { val sameSuffixLength = s1.indices .takeWhile(i => i < s2.length && s1.charAt(s1.length - 1 - i) == s2.charAt(s2.length - 1 - i) && s1.charAt(i).isWhitespace) .maxOption.fold(0)(_ + 1) (s1.dropRight(sameSuffixLength), s2.dropRight(sameSuffixLength), s1.takeRight(sameSuffixLength)) } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/util/DiffTokenize.scala000066400000000000000000000223611403233075700276510ustar00rootroot00000000000000package app.tulz.diff.util import app.tulz.diff.DiffElement import app.tulz.diff.DiffElement.InBoth import app.tulz.diff.DiffElement.InFirst import app.tulz.diff.DiffElement.InSecond import scala.collection.mutable.ListBuffer import scala.collection.IndexedSeqView private[diff] object DiffTokenize { private def partitionFirstSecond( diff: List[DiffElement[IndexedSeqView[String]]], p: DiffElement[IndexedSeqView[String]] => Boolean, transform: (List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]]) => Seq[DiffElement[IndexedSeqView[String]]] ): List[DiffElement[IndexedSeqView[String]]] = { ListScan.withBuffer[DiffElement[IndexedSeqView[String]], DiffElement[IndexedSeqView[String]]](diff) { (list, buffer) => val (nonFirstSecond, firstSecondAndRest) = list.span(!_.inFirstOrSecond) buffer.addAll(nonFirstSecond) val (firstSecond, rest) = firstSecondAndRest.span(_.inFirstOrSecond) val (first, second) = firstSecond.partition(p) if (first.nonEmpty && second.nonEmpty) { buffer.addAll(transform(first, second)) } else { buffer.addAll(first) buffer.addAll(second) } rest } } private def samePrefix( group1: List[DiffElement[IndexedSeqView[String]]], group2: List[DiffElement[IndexedSeqView[String]]] ): Option[ ( List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]] ) ] = { group1.indices .map(_ + 1) .takeWhile(i => i <= group2.size && ((group1(i - 1), group2(i - 1)) match { case (InFirst(first), InSecond(second)) => same(first, second) case (InSecond(second), InFirst(first)) => same(first, second) case _ => false }) ).maxOption.map { samePrefixLength => val prefix = group1.take(samePrefixLength).collect { case InFirst(first) => InBoth(first) case InSecond(first) => InBoth(first) } (prefix, group1.drop(samePrefixLength), group2.drop(samePrefixLength)) } } private def sameSuffix( group1: List[DiffElement[IndexedSeqView[String]]], group2: List[DiffElement[IndexedSeqView[String]]] ): Option[ ( List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]] ) ] = { group1.indices .map(_ + 1) .takeWhile(i => i <= group2.size && ((group1(group1.length - i), group2(group2.size - i)) match { case (InFirst(first), InSecond(second)) => same(first, second) case (InSecond(second), InFirst(first)) => same(first, second) case _ => false }) ).maxOption.map { sameSuffixLength => val suffix = group1.takeRight(sameSuffixLength).collect { case InFirst(first) => InBoth(first) case InSecond(second) => InBoth(second) } (group1.dropRight(sameSuffixLength), group2.dropRight(sameSuffixLength), suffix) } } private def prefixIsSuffix( group1: List[DiffElement[IndexedSeqView[String]]], group2: List[DiffElement[IndexedSeqView[String]]] ): Option[ ( List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]] ) ] = { group1.indices .map(_ + 1) .takeWhile(i => i <= group2.size && group1.take(i).zip(group2.takeRight(i)).forall { case (InFirst(first), InSecond(second)) => same(first, second) case (InSecond(second), InFirst(first)) => same(first, second) case _ => false } ).maxOption.map { prefixSuffixLength => val prefix = group1.take(prefixSuffixLength).collect { case InFirst(first) => InBoth(first) case InSecond(first) => InBoth(first) } (prefix, group1.drop(prefixSuffixLength), group2.dropRight(prefixSuffixLength)) } } private def suffixIsPrefix( group1: List[DiffElement[IndexedSeqView[String]]], group2: List[DiffElement[IndexedSeqView[String]]] ): Option[ ( List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]], List[DiffElement[IndexedSeqView[String]]] ) ] = { group1.indices .map(_ + 1) .takeWhile(i => i <= group2.size && group1.takeRight(i).zip(group2.take(i)).forall { case (InFirst(first), InSecond(second)) => same(first, second) case (InSecond(second), InFirst(first)) => same(first, second) case _ => false } ).maxOption.map { suffixPrefixLength => val suffix = group1.takeRight(suffixPrefixLength).collect { case InFirst(first) => InBoth(first) case InSecond(first) => InBoth(first) } (group1.dropRight(suffixPrefixLength), group2.drop(suffixPrefixLength), suffix) } } private def processFirstSecondGroups( diff: List[DiffElement[IndexedSeqView[String]]], p: DiffElement[IndexedSeqView[String]] => Boolean ): List[DiffElement[IndexedSeqView[String]]] = partitionFirstSecond( diff, p, (group1, group2) => { val buffer = ListBuffer.empty[DiffElement[IndexedSeqView[String]]] val bufferSuffix = ListBuffer.empty[DiffElement[IndexedSeqView[String]]] var work1 = group1 var work2 = group2 samePrefix(work1, work2).map { case (prefix, rest1, rest2) => work1 = rest1 work2 = rest2 buffer.addAll(prefix) } sameSuffix(work1, work2).foreach { case (rest1, rest2, suffix) => work1 = rest1 work2 = rest2 bufferSuffix.prependAll(suffix) } prefixIsSuffix(work1, work2) .map { case (prefixSuffix, rest1, rest2) => buffer.addAll(rest2) buffer.addAll(prefixSuffix) buffer.addAll(rest1) buffer.addAll(bufferSuffix) () } .orElse { suffixIsPrefix(work1, work2).map { case (rest1, rest2, suffixPrefix) => buffer.addAll(rest1) buffer.addAll(suffixPrefix) buffer.addAll(rest2) buffer.addAll(bufferSuffix) () } } .getOrElse { buffer.addAll(work1) buffer.addAll(work2) buffer.addAll(bufferSuffix) () } buffer.toList } ) def firstsGoFirst( diff: List[DiffElement[IndexedSeqView[String]]] ): List[DiffElement[IndexedSeqView[String]]] = processFirstSecondGroups(diff, _.inFirst) def secondsGoFirst( diff: List[DiffElement[IndexedSeqView[String]]] ): List[DiffElement[IndexedSeqView[String]]] = processFirstSecondGroups(diff, _.inSecond) private def same(s1: IndexedSeqView[String], s2: IndexedSeqView[String]): Boolean = s1.size == s2.size && s1.indices.forall(i => s1(i) == s2(i)) def join(diff: List[DiffElement[IndexedSeqView[String]]]): List[DiffElement[IndexedSeqView[String]]] = ListScan(diff) { case InSecond(second) :: InFirst(first) :: tail if same(first, second) => Nil -> ( InBoth(first) :: tail ) case InFirst(first) :: InSecond(second) :: tail if same(first, second) => Nil -> ( InBoth(first) :: tail ) case head :: tail => (head :: Nil) -> tail case Nil => Nil -> Nil } def moveWhitespace( diff: List[DiffElement[IndexedSeqView[String]]] ): List[DiffElement[IndexedSeqView[String]]] = ListScan(diff) { case InSecond(second) :: InBoth(Whitespace(both)) :: InFirst(first) :: tail if first == second => Nil -> ( InFirst(both) :: InBoth(second) :: InSecond(both) :: tail ) case InFirst(first) :: InBoth(Whitespace(both)) :: InSecond(second) :: tail if first == second => Nil -> ( InSecond(both) :: InBoth(second) :: InFirst(both) :: tail ) case InSecond(second) :: InBoth(Whitespace(both)) :: InFirst(first) :: tail => Nil -> ( InFirst(both) :: InFirst(first) :: InSecond(second) :: InSecond(both) :: tail ) case InFirst(first) :: InBoth(Whitespace(both)) :: InSecond(second) :: tail => Nil -> ( InFirst(first) :: InFirst(both) :: InSecond(both) :: InSecond(second) :: tail ) case InFirst(first1) :: InBoth(Whitespace(both)) :: InFirst(first2) :: tail => Nil -> ( InFirst(first1) :: InFirst(both) :: InFirst(first2) :: InSecond(both) :: tail ) case InSecond(second1) :: InBoth(Whitespace(both)) :: InSecond(second2) :: tail => Nil -> ( InFirst(both) :: InSecond(second1) :: InSecond(both) :: InSecond(second2) :: tail ) case head :: tail => (head :: Nil) -> tail case Nil => Nil -> Nil } private val whitespace = "\\s+".r private object Whitespace { def unapply(s: IndexedSeqView[String]): Option[IndexedSeqView[String]] = { Some(s).filter(_.forall(whitespace.matches)) } } } stringdiff-0.3.2/stringdiff/src/main/scala/app/tulz/diff/util/ListScan.scala000066400000000000000000000010631403233075700270040ustar00rootroot00000000000000package app.tulz.diff.util import scala.collection.mutable.ListBuffer private[diff] object ListScan { def apply[A, B](list: List[A])(f: List[A] => (List[B], List[A])): List[B] = { withBuffer[A, B](list) { (list, buffer) => val (toBuffer, newWork) = f(list) buffer.addAll(toBuffer) newWork } } def withBuffer[A, B](list: List[A])(f: (List[A], ListBuffer[B]) => List[A]): List[B] = { val buffer = new ListBuffer[B] var work = list while (work.nonEmpty) { work = f(work, buffer) } buffer.toList } } stringdiff-0.3.2/stringdiff/src/test/000077500000000000000000000000001403233075700175645ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/test/scala/000077500000000000000000000000001403233075700206475ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/test/scala/app/000077500000000000000000000000001403233075700214275ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/test/scala/app/tulz/000077500000000000000000000000001403233075700224255ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/test/scala/app/tulz/diff/000077500000000000000000000000001403233075700233355ustar00rootroot00000000000000stringdiff-0.3.2/stringdiff/src/test/scala/app/tulz/diff/DiffTests.scala000066400000000000000000000220621403233075700262370ustar00rootroot00000000000000package app.tulz.diff import app.tulz.diff.format.AnsiDiffFormat import org.scalatest.funsuite.AnyFunSuite import org.scalatest.matchers.should.Matchers import scala.Console._ class DiffTests extends AnyFunSuite with Matchers { import DiffElement._ implicit class StringWithClean(s: String) { def clean: String = s.trim.replaceAll("\\s+", " ") } private def doTest( name: String, s1: String, s2: String, expectedDiff: List[DiffElement[String]] ): Unit = { val dashes = 80 test(name) { println(s"--- ${name} ${"-" * (dashes - name.length - 5)}") val result = TokenDiff.diff(s1.clean, s2.clean) if (result != expectedDiff) { println(s"| ${RED_B}${BLACK} ! failed ! ${RESET}") } println(s"| str1: ${s1.clean}") println(s"| str2: ${s2.clean}") println(s"| diff:") println(s"| ${AnsiDiffFormat(result)}") if (result != expectedDiff) { println(s"| expected") println(s"| ${AnsiDiffFormat(expectedDiff)}") } println("-" * dashes) println() result shouldBe expectedDiff } } doTest( "equal strings", "diff-1 diff-2 diff-3", "diff-1 diff-2 diff-3", List(InBoth("diff-1 diff-2 diff-3")) ) doTest( "different prefixes", "prefix-1 match-1 match-2 match-3", "prefix-2 match-1 match-2 match-3", List(Diff("prefix-1", "prefix-2"), InBoth(" match-1 match-2 match-3")) ) doTest( "different suffixes", "match-1 match-2 match-3 suffix-1", "match-1 match-2 match-3 suffix-2", List(InBoth("match-1 match-2 match-3 "), Diff("suffix-1", "suffix-2")) ) doTest( "different token in the middle", "match-1 match-2 diff-1 match-3", "match-1 match-2 diff-2 match-3", List(InBoth("match-1 match-2 "), Diff("diff-1", "diff-2"), InBoth(" match-3")) ) doTest( "different prefix and suffix and token in the middle", "prefix-1 match-1 match-2 diff-1 match-3 suffix-1", "prefix-2 match-1 match-2 diff-2 match-3 suffix-2", List( Diff("prefix-1", "prefix-2"), InBoth(" match-1 match-2 "), Diff("diff-1", "diff-2"), InBoth(" match-3 "), Diff("suffix-1", "suffix-2") ) ) doTest( "extra prefix in s1", "prefix-1 match-1 match-2 match-3", " match-1 match-2 match-3", List(InFirst("prefix-1 "), InBoth("match-1 match-2 match-3")) ) doTest( "missing prefix in s1", " match-1 match-2 match-3", "prefix-1 match-1 match-2 match-3", List(InSecond("prefix-1 "), InBoth("match-1 match-2 match-3")) ) doTest( "extra token in s1", "match-1 diff-1 match-2", "match-1 match-2", List(InBoth("match-1"), InFirst(" diff-1"), InBoth(" match-2")) ) doTest( "extra token in s2", "match-1 match-2", "match-1 diff-1 match-2", List(InBoth("match-1"), InSecond(" diff-1"), InBoth(" match-2")) ) doTest( "two extra tokens in s1", "match-1 diff-1 diff-2 match-2", "match-1 match-2", List(InBoth("match-1"), InFirst(" diff-1 diff-2"), InBoth(" match-2")) ) doTest( "two extra tokens in s2", "match-1 match-2", "match-1 diff-1 diff-2 match-2", List(InBoth("match-1"), InSecond(" diff-1 diff-2"), InBoth(" match-2")) ) doTest( "extra prefix and two extra tokens in s1", "prefix-1 match-1 diff-1 diff-2 match-2", " match-1 match-2", List(InFirst("prefix-1 "), InBoth("match-1 "), InFirst("diff-1 diff-2 "), InBoth("match-2")) ) doTest( "extra prefix in s1, two extra tokens in s2", "prefix-1 match-1 match-2", " match-1 diff-1 diff-2 match-2", List(InFirst("prefix-1 "), InBoth("match-1"), InSecond(" diff-1 diff-2"), InBoth(" match-2")) ) doTest( "extra suffix, and two extra tokens in s1", "match-1 diff-1 diff-2 match-2 suffix-1", "match-1 match-2 ", List(InBoth("match-1"), InFirst(" diff-1 diff-2"), InBoth(" match-2"), InFirst(" suffix-1")) ) doTest( "extra suffix in s1, two extra tokens in s2", "match-1 match-2 suffix-1", "match-1 diff-1 diff-2 match-2 ", List(InBoth("match-1 "), InSecond("diff-1 diff-2 "), InBoth("match-2"), InFirst(" suffix-1")) ) doTest( "extra suffix in s1", "match-1 match-2 match-3 suffix-1", "match-1 match-2 match-3 ", List(InBoth("match-1 match-2 match-3"), InFirst(" suffix-1")) ) doTest( "extra suffix in s2", "match-1 match-2 match-3 ", "match-1 match-2 match-3 suffix-1", List(InBoth("match-1 match-2 match-3"), InSecond(" suffix-1")) ) doTest( "extra prefix and suffix in s1", "prefix-1 match-1 match-2 match-3 suffix-1", " match-1 match-2 match-3 ", List(InFirst("prefix-1 "), InBoth("match-1 match-2 match-3"), InFirst(" suffix-1")) ) doTest( "extra prefix in s1, extra suffix in s2", "prefix-1 match-1 match-2 match-3 ", " match-1 match-2 match-3 suffix-1", List(InFirst("prefix-1 "), InBoth("match-1 match-2 match-3"), InSecond(" suffix-1")) ) doTest( "extra prefix and suffix in s2", " match-1 match-2 match-3 ", "prefix-1 match-1 match-2 match-3 suffix-1", List(InSecond("prefix-1 "), InBoth("match-1 match-2 match-3"), InSecond(" suffix-1")) ) doTest( "extra prefix, suffix, and token in s1", "prefix-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", " match-1 match-2 match-3 match-4 ", List(InFirst("prefix-1 "), InBoth("match-1 match-2"), InFirst(" diff-1"), InBoth(" match-3 match-4"), InFirst(" suffix-1")) ) doTest( "extra prefix, suffix and token in s2", " match-1 match-2 match-3 match-4 ", "prefix-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", List(InSecond("prefix-1 "), InBoth("match-1 match-2"), InSecond(" diff-1"), InBoth(" match-3 match-4"), InSecond(" suffix-1")) ) doTest( "extra prefix and suffix in s2, extra token in s1", " match-1 match-2 diff-1 match-3 match-4 ", "prefix-1 match-1 match-2 match-3 match-4 suffix-1", List(InSecond("prefix-1 "), InBoth("match-1 match-2"), InFirst(" diff-1"), InBoth(" match-3 match-4"), InSecond(" suffix-1")) ) doTest( "extra prefix and suffix in s1, extra token in s2", "prefix-1 match-1 match-2 match-3 match-4 suffix-1", " match-1 match-2 diff-1 match-3 match-4 ", List(InFirst("prefix-1 "), InBoth("match-1 match-2"), InSecond(" diff-1"), InBoth(" match-3 match-4"), InFirst(" suffix-1")) ) doTest( "example 1", "prefix-1 match-1 match-2 diff-1 match-3 match-4 ", " match-1 match-2 diff-2 diff-3 match-3 match-4 suffix-1", List( InFirst("prefix-1 "), InBoth("match-1 match-2 "), Diff("diff-1", "diff-2 diff-3"), InBoth(" match-3 match-4"), InSecond(" suffix-1") ) ) doTest( "example 2", " match-1 match-2 diff-1 diff-2 match-3 match-4 suffix-1", "prefix-1 match-1 match-2 diff-3 match-3 match-4 ", List( InSecond("prefix-1 "), InBoth("match-1 match-2 "), Diff("diff-1 diff-2", "diff-3"), InBoth(" match-3 match-4"), InFirst(" suffix-1") ) ) doTest( "example 3", "prefix-1 common-1 diff-1 common-2 ", " common-1 diff-2 common-2 suffix-2", List(InFirst("prefix-1 "), InBoth("common-1 "), Diff("diff-1", "diff-2"), InBoth(" common-2"), InSecond(" suffix-2")) ) doTest( "bigger one", Seq( " match-1 match-2 diff-1 diff-2 match-3 match-4 suffix-1", "prefix-1 match-1 match-2 diff-1 match-3 match-4 ", "prefix-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", " match-1 match-2 match-3 match-4 ", " match-1 match-2 diff-1 match-3 match-4 " ).mkString("", " ", " separating "), Seq( "prefix-1 match-1 match-2 diff-3 match-3 match-4 ", " match-1 match-2 diff-2 diff-3 match-3 match-4 suffix-1", " match-1 match-2 match-3 match-4 ", "prefix-1 match-1 match-2 diff-1 match-3 match-4 suffix-1", "prefix-1 match-1 match-2 match-3 match-4 suffix-1" ).mkString("", " ", " separating "), List( InSecond("prefix-1 "), InBoth("match-1 match-2 "), Diff("diff-1 diff-2", "diff-3"), InBoth(" match-3 match-4 "), InFirst("suffix-1 prefix-1 "), InBoth("match-1 match-2 "), Diff("diff-1", "diff-2 diff-3"), InBoth(" match-3 match-4 "), Diff("prefix-1", "suffix-1"), InBoth(" match-1 match-2"), InFirst(" diff-1"), InBoth(" match-3 match-4 "), Diff("suffix-1", "prefix-1"), InBoth(" match-1 match-2"), InSecond(" diff-1"), InBoth(" match-3 match-4 "), InSecond("suffix-1 prefix-1 "), InBoth("match-1 match-2 "), InFirst("diff-1 "), InBoth("match-3 match-4 "), InSecond("suffix-1 "), InBoth("separating") ) ) }