example_custom_test.go

package diff_test

import (
	"fmt"
	"strings"

	"mibk.dev/diff"
)

// columns presents two grids of ASCII characters to Diff
// as their sequences of columns.
// A column is not a slice of its own,
// which is what the Data interface is for:
// it describes a sequence by index,
// leaving it to exist however it already does.
type columns struct {
	a, b []string // rows, equally long within a grid
}

func (c columns) Lens() (n, m int) { return len(c.a[0]), len(c.b[0]) }

func (c columns) Equal(i, j int) bool {
	for r := range c.a {
		if c.a[r][i] != c.b[r][j] {
			return false
		}
	}
	return true
}

func Example_customType() {
	a := []string{
		"abcd",
		"1234",
	}
	b := []string{
		"abxd",
		"12y4",
	}

	for _, ed := range diff.Diff(columns{a, b}) {
		switch ed.Op {
		case diff.Delete:
			fmt.Println("-", column(a, ed.Index))
		case diff.Insert:
			fmt.Println("+", column(b, ed.Bindex))
		}
	}

	// output:
	// - c3
	// + xy
}

func column(rows []string, i int) string {
	col := make([]byte, len(rows))
	for r, row := range rows {
		col[r] = row[i]
	}
	return string(col)
}

// missingIgnoreCase returns elements that are moved or deleted from a
// compared to b.
func missingIgnoreCase(a, b []string) []string {
	eds := diff.SlicesFunc(a, b, strings.EqualFold)

	var miss []string
	for _, ed := range eds {
		if ed.Op == diff.Insert {
			miss = append(miss, b[ed.Bindex])
		}
	}
	return miss
}

func Example_ignoreCase() {
	a := []string{"black", "#31ad1d", "#8923dd", "#baddad", "yellow"}
	b := []string{"#31AD1D", "#8924dd", "#BadDad", "black", "YELLOW"}

	for _, m := range missingIgnoreCase(a, b) {
		fmt.Println("-", m)
	}

	// output:
	// - #8924dd
	// - black
}