How to use NewWords method of diff Package

1package misspell2import (3	"bufio"4	"bytes"5	"io"6	"regexp"7	"strings"8	"text/scanner"9)10func max(x, y int) int {11	if x > y {12		return x13	}14	return y15}16func inArray(haystack []string, needle string) bool {17	for _, word := range haystack {18		if needle == word {19			return true20		}21	}22	return false23}24var wordRegexp = regexp.MustCompile(`[a-zA-Z0-9']+`)25// Diff is datastructure showing what changed in a single line26type Diff struct {27	Filename  string28	FullLine  string29	Line      int30	Column    int31	Original  string32	Corrected string33}34// Replacer is the main struct for spelling correction35type Replacer struct {36	Replacements []string37	Debug        bool38	engine       *StringReplacer39	corrected    map[string]string40}41// New creates a new default Replacer using the main rule list42func New() *Replacer {43	r := Replacer{44		Replacements: DictMain,45	}46	r.Compile()47	return &r48}49// RemoveRule deletes existings rules.50// TODO: make inplace to save memory51func (r *Replacer) RemoveRule(ignore []string) {52	newwords := make([]string, 0, len(r.Replacements))53	for i := 0; i < len(r.Replacements); i += 2 {54		if inArray(ignore, r.Replacements[i]) {55			continue56		}57		newwords = append(newwords, r.Replacements[i:i+2]...)58	}59	r.engine = nil60	r.Replacements = newwords61}62// AddRuleList appends new rules.63// Input is in the same form as Strings.Replacer: [ old1, new1, old2, new2, ....]64// Note: does not check for duplictes65func (r *Replacer) AddRuleList(additions []string) {66	r.engine = nil67	r.Replacements = append(r.Replacements, additions...)68}69// Compile compiles the rules.  Required before using the Replace functions70func (r *Replacer) Compile() {71	r.corrected = make(map[string]string, len(r.Replacements)/2)72	for i := 0; i < len(r.Replacements); i += 2 {73		r.corrected[r.Replacements[i]] = r.Replacements[i+1]74	}75	r.engine = NewStringReplacer(r.Replacements...)76}77/*78line1 and line2 are different79extract words from each line180replace word -> newword81if word == new-word82  continue83if new-word in list of replacements84  continue85new word not original, and not in list of replacements86  some substring got mixed up.  UNdo87*/88func (r *Replacer) recheckLine(s string, lineNum int, buf io.Writer, next func(Diff)) {89	first := 090	redacted := RemoveNotWords(s)91	idx := wordRegexp.FindAllStringIndex(redacted, -1)92	for _, ab := range idx {93		word := s[ab[0]:ab[1]]94		newword := r.engine.Replace(word)95		if newword == word {96			// no replacement done97			continue98		}99		// ignore camelCase words100		// https://github.com/client9/misspell/issues/113101		if CaseStyle(word) == CaseUnknown {102			continue103		}104		if StringEqualFold(r.corrected[strings.ToLower(word)], newword) {105			// word got corrected into something we know106			io.WriteString(buf, s[first:ab[0]])107			io.WriteString(buf, newword)108			first = ab[1]109			next(Diff{110				FullLine:  s,111				Line:      lineNum,112				Original:  word,113				Corrected: newword,114				Column:    ab[0],115			})116			continue117		}118		// Word got corrected into something unknown. Ignore it119	}120	io.WriteString(buf, s[first:])121}122// ReplaceGo is a specialized routine for correcting Golang source123// files.  Currently only checks comments, not identifiers for124// spelling.125func (r *Replacer) ReplaceGo(input string) (string, []Diff) {126	var s scanner.Scanner127	s.Init(strings.NewReader(input))128	s.Mode = scanner.ScanIdents | scanner.ScanFloats | scanner.ScanChars | scanner.ScanStrings | scanner.ScanRawStrings | scanner.ScanComments129	lastPos := 0130	output := ""131Loop:132	for {133		switch s.Scan() {134		case scanner.Comment:135			origComment := s.TokenText()136			newComment := r.engine.Replace(origComment)137			if origComment != newComment {138				// s.Pos().Offset is the end of the current token139				// subtract len(origComment) to get the start of the token140				offset := s.Pos().Offset141				output = output + input[lastPos:offset-len(origComment)] + newComment142				lastPos = offset143			}144		case scanner.EOF:145			break Loop146		}147	}148	if lastPos == 0 {149		// no changes, no copies150		return input, nil151	}152	if lastPos < len(input) {153		output = output + input[lastPos:]154	}155	diffs := make([]Diff, 0, 8)156	buf := bytes.NewBuffer(make([]byte, 0, max(len(input), len(output))+100))157	// faster that making a bytes.Buffer and bufio.ReadString158	outlines := strings.SplitAfter(output, "\n")159	inlines := strings.SplitAfter(input, "\n")160	for i := 0; i < len(inlines); i++ {161		if inlines[i] == outlines[i] {162			buf.WriteString(outlines[i])163			continue164		}165		r.recheckLine(inlines[i], i+1, buf, func(d Diff) {166			diffs = append(diffs, d)167		})168	}169	return buf.String(), diffs170}171// Replace is corrects misspellings in input, returning corrected version172//  along with a list of diffs.173func (r *Replacer) Replace(input string) (string, []Diff) {174	output := r.engine.Replace(input)175	if input == output {176		return input, nil177	}178	diffs := make([]Diff, 0, 8)179	buf := bytes.NewBuffer(make([]byte, 0, max(len(input), len(output))+100))180	// faster that making a bytes.Buffer and bufio.ReadString181	outlines := strings.SplitAfter(output, "\n")182	inlines := strings.SplitAfter(input, "\n")183	for i := 0; i < len(inlines); i++ {184		if inlines[i] == outlines[i] {185			buf.WriteString(outlines[i])186			continue187		}188		r.recheckLine(inlines[i], i+1, buf, func(d Diff) {189			diffs = append(diffs, d)190		})191	}192	return buf.String(), diffs193}194// ReplaceReader applies spelling corrections to a reader stream.  Diffs are195// emitted through a callback.196func (r *Replacer) ReplaceReader(raw io.Reader, w io.Writer, next func(Diff)) error {197	var (198		err     error199		line    string200		lineNum int201	)202	reader := bufio.NewReader(raw)203	for err == nil {204		lineNum++205		line, err = reader.ReadString('\n')206		// if it's EOF, then line has the last line207		// don't like the check of err here and208		// in for loop209		if err != nil && err != io.EOF {210			return err211		}212		// easily 5x faster than regexp+map213		if line == r.engine.Replace(line) {214			io.WriteString(w, line)215			continue216		}217		// but it can be inaccurate, so we need to double check218		r.recheckLine(line, lineNum, w, next)219	}220	return nil221}...

...10)11func TestReduce(t *testing.T) {12	eq := func(x, y string, e string) {13		t.Helper()14		out := diff.NewWords(diff.Split(x)).Reduce(diff.NewWords(diff.Split(y))).String()15		if out != e {16			t.Error(out, "!=", e)17		}18	}19	eq("", "", "")20	eq("", "a", "")21	eq("a", "", "")22	eq("abc", "abc", "abc")23	eq("abc", "acb", "abc")24	eq("abc", "acbc", "abc")25	eq("abc", "xxx", "")26	eq("ac", "bc", "c")27}28func TestCommon(t *testing.T) {29	eq := func(x, y string, el, er int) {30		t.Helper()31		l, r := diff.NewWords(diff.Split(x)).Common(diff.NewWords(diff.Split(y)))32		if l != el || r != er {33			t.Error(l, r, "!=", el, er)34		}35	}36	eq("", "", 0, 0)37	eq("", "a", 0, 0)38	eq("a", "", 0, 0)39	eq("abc", "abc", 3, 0)40	eq("abc", "acb", 1, 0)41	eq("abc", "acbc", 1, 2)42	eq("abc", "xxx", 0, 0)43	eq("ac", "bc", 0, 1)44}45func TestLCSString(t *testing.T) {46	eq := func(x, y, expected string) {47		t.Helper()48		ctx, cancel := context.WithTimeout(context.Background(), time.Second)49		defer cancel()50		lcs := diff.NewWords(split(x)).LCS(ctx, diff.NewWords(split(y)))51		out := lcs.String()52		if out != expected {53			t.Error(out, "!=", expected)54		}55	}56	eq("", "", "")57	eq("abc", "acb", "ac")58	eq("abc", "acbc", "abc")59	eq("abc", "xxx", "")60	eq("ac", "bc", "c")61	eq("gac", "agcat", "gc")62	eq("agcat", "gac", "ga")63	x := bytes.Repeat([]byte("x"), 100000)64	y := bytes.Repeat([]byte("y"), 100000)65	eq(string(x), string(y), "")66	x[len(x)/2] = byte('a')67	y[len(y)/2] = byte('a')68	eq(string(x), string(y), "a")69	x[len(x)/2] = byte('y')70	y[len(y)/2] = byte('x')71	eq(string(x), string(y), "yx")72}73func TestLCSRandomString(t *testing.T) {74	g := got.T(t)75	x := g.ReadFile("fixtures/rand_x.txt").String()76	y := g.ReadFile("fixtures/rand_y.txt").String()77	res := diff.NewWords(split(x)).LCS(g.Context(), diff.NewWords(split(y)))78	g.Eq(79		res.String(),80		g.ReadFile("fixtures/rand_lcs.txt").String(),81	)82}83func TestText(t *testing.T) {84	g := setup(t)85	g.Len(diff.NewLines("a"), 1)86	g.Len(diff.NewLines("a\n"), 2)87	g.Len(diff.NewLines("a\n\n"), 3)88	g.Len(diff.NewLines("\na"), 2)89}90func TestLCSText(t *testing.T) {91	g := setup(t)92	eq := func(x, y, expected string) {93		t.Helper()94		x = strings.Join(strings.Split(x, ""), "\n")95		y = strings.Join(strings.Split(y, ""), "\n")96		expected = strings.Join(strings.Split(expected, ""), "\n")97		lcs := diff.NewLines(x).LCS(context.Background(), diff.NewLines(y))98		g.Eq(lcs.String(), expected)99	}100	eq("", "", "")101	eq("abc", "acb", "ac")102	eq("abc", "acbc", "abc")103	eq("abc", "xxx", "")104}105func TestIsIn(t *testing.T) {106	g := got.T(t)107	y := diff.NewWords(split("abc"))108	g.True(diff.NewWords(split("ab")).IsSubsequenceOf(y))109	g.True(diff.NewWords(split("ac")).IsSubsequenceOf(y))110	g.True(diff.NewWords(split("bc")).IsSubsequenceOf(y))111	g.False(diff.NewWords(split("cb")).IsSubsequenceOf(y))112	g.False(diff.NewWords(split("ba")).IsSubsequenceOf(y))113	g.False(diff.NewWords(split("ca")).IsSubsequenceOf(y))114}115func TestBTreeFindGreater(t *testing.T) {116	g := got.T(t)117	check := func(x int, ey int, ef bool) {118		g.Helper()119		y, f := diff.BTreeFindGreater([]int{1, 3, 5, 7, 9, 11}, x)120		g.Eq(y, ey)121		g.Eq(f, ef)122	}123	check(4, 5, true)124	check(5, 7, true)125	check(1, 3, true)126	check(8, 9, true)127	check(11, 0, false)...

1import (2func main() {3    dmp := diffmatchpatch.New()4    d := dmp.DiffMain("Hello World!", "Hello Go World!", false)5    fmt.Println(dmp.DiffPrettyText(d))6}

1import (2func main() {3	fmt.Println("Enter two strings:")4	fmt.Scan(&str1, &str2)5	diff := NewWords(str1, str2)6	fmt.Println("Words in first string but not in second string are:")7	fmt.Println(diff)8}9import (10func main() {11	fmt.Println("Enter two strings:")12	fmt.Scan(&str1, &str2)13	diff := Words(str1, str2)14	fmt.Println("Words in first string but not in second string are:")15	fmt.Println(diff)16}17import (18func main() {19	fmt.Println("Enter two strings:")20	fmt.Scan(&str1, &str2)21	diff := Words(str1, str2)22	fmt.Println("Words in first string but not in second string are:")23	fmt.Println(diff)24}25import (26func main() {27	fmt.Println("Enter two strings:")28	fmt.Scan(&str1, &str2)29	diff := Words(str1, str2)30	fmt.Println("Words in first string but not in second string are:")31	fmt.Println(diff)32}33import (34func main() {35	fmt.Println("Enter two strings:")36	fmt.Scan(&str1, &str2)37	diff := Words(str1, str2)38	fmt.Println("Words in first string but not in second string are:")39	fmt.Println(diff)40}41import (42func main() {43	fmt.Println("Enter two strings:")44	fmt.Scan(&str1, &str2)45	diff := Words(str1, str2)46	fmt.Println("Words in first string but not in second string are:")47	fmt.Println(diff

1import (2func main() {3	diff := NewWords(str1, str2)4	fmt.Println(diff)5}6type Diff struct {7}8func NewWords(str1, str2 string) *Diff {9	return &Diff{str1, str2}10}11type Diff struct {12}13func NewWords(str1, str2 string) *Diff {14    return &Diff{str1, str2}15}

1func main() {2    words := diff.NewWords()3    words.Add("hello")4    words.Add("world")5    words.Add("goodbye")6    words.Add("world")7    fmt.Println(words)8}9func main() {10    words := diff.NewWords()11    words.Add("hello")12    words.Add("world")13    words.Add("goodbye")14    words.Add("world")15    fmt.Println(words)16}17func main() {18    words := diff.NewWords()19    words.Add("hello")20    words.Add("world")21    words.Add("goodbye")22    words.Add("world")23    fmt.Println(words)24}25func main() {26    words := diff.NewWords()27    words.Add("hello")28    words.Add("world")29    words.Add("goodbye")30    words.Add("world")31    fmt.Println(words)32}33func main() {34    words := diff.NewWords()35    words.Add("hello")36    words.Add("world")37    words.Add("goodbye")38    words.Add("world")39    fmt.Println(words)40}41func main() {42    words := diff.NewWords()43    words.Add("hello")44    words.Add("world")45    words.Add("goodbye")46    words.Add("world")47    fmt.Println(words)48}49func main() {50    words := diff.NewWords()51    words.Add("hello")52    words.Add("world")53    words.Add("goodbye")54    words.Add("world")55    fmt.Println(words)56}57func main() {58    words := diff.NewWords()59    words.Add("hello")60    words.Add("world

1import "fmt"2func main() {3    diff := diff{words:make([]string,0)}4    diff.NewWords("hello")5    diff.NewWords("world")6    fmt.Println(diff.words)7}8import "fmt"9func main() {10    diff := diff{words:make([]string,0)}11    diff.NewWords("hello")12    diff.NewWords("world")13    fmt.Println(diff.words)14}15import "fmt"16func main() {17    diff := diff{words:make([]string,0)}18    diff.NewWords("hello")19    diff.NewWords("world")20    fmt.Println(diff.words)21}22import "fmt"23func main() {24    diff := diff{words:make([]string,0)}25    diff.NewWords("hello")26    diff.NewWords("world")27    fmt.Println(diff.words)28}29import "fmt"30func main() {31    diff := diff{words:make([]string,0)}32    diff.NewWords("hello")33    diff.NewWords("world")34    fmt.Println(diff.words)35}36import "fmt"37func main() {38    diff := diff{words:make([]string,0)}39    diff.NewWords("hello")40    diff.NewWords("world")41    fmt.Println(diff.words)42}43import "fmt"44func main() {45    diff := diff{words:make([]string,0)}46    diff.NewWords("hello")47    diff.NewWords("world")48    fmt.Println(diff.words)49}50import "fmt"51func main() {52    diff := diff{words:make([]string,0)}53    diff.NewWords("hello")54    diff.NewWords("world")55    fmt.Println(diff.words)56}

1import (2func main() {3	d.NewWords("hello world")4	fmt.Println(d.words)5}6import (7func main() {8	d.NewWords("hello world")9	fmt.Println(d.words)10}11import (12func main() {13	d.NewWords("hello world")14	fmt.Println(d.words)15}16import (17func main() {18	d.NewWords("hello world")19	fmt.Println(d.words)20}21import (22func main() {23	d.NewWords("hello world")24	fmt.Println(d.words)25}26import (27func main() {28	d.NewWords("hello world")29	fmt.Println(d.words)30}31import (32func main() {

1func main() {2    d := diff.NewWords("Hello world", "Hello world!")3    fmt.Printf("%v4    fmt.Printf("%v5", d.Diff())6    fmt.Printf("%v7", d.Hunks())8}9func main() {10    d := diff.NewWords("Hello world", "Hello world!")11    fmt.Printf("%v12    fmt.Printf("%v13", d.Diff())14    fmt.Printf("%v15", d.Hunks())16}17func main() {18    d := diff.NewWords("Hello world", "Hello world!")19    fmt.Printf("%v20    fmt.Printf("%v21", d.Diff())22    fmt.Printf("%v23", d.Hunks())24}25func main() {26    d := diff.NewWords("Hello world", "Hello world!")27    fmt.Printf("%v28    fmt.Printf("%v29", d.Diff())30    fmt.Printf("%v31", d.Hunks())32}33func main() {34    d := diff.NewWords("Hello world", "Hello world!")35    fmt.Printf("%v

1import (2func main() {3    fmt.Printf("%s4", pretty.Sprint(diff.NewWords("Hello World!")))5}6import (7func main() {8    fmt.Printf("%s9", pretty.Sprint(diff.NewWords("Hello World!")))10}11import (12func main() {13    fmt.Printf("%s14", pretty.Sprint(diff.NewWords("Hello World!")))15}16import (17func main() {18    fmt.Printf("%s19", pretty.Sprint(diff.NewWords("Hello World!")))20}21import (22func main() {23    fmt.Printf("%s24", pretty.Sprint(diff.NewWords("Hello World!")))25}26import (27func main() {28    fmt.Printf("%s29", pretty.Sprint(diff.NewWords("Hello World!")))30}31import (32func main() {33    fmt.Printf("%s34", pretty.Sprint(diff.NewWords("Hello World!")))35}36import (37func main() {38    fmt.Printf("%s39", pretty.Sprint(diff.NewWords("Hello World!")))40}41import (

1func main(){2    fmt.Println(diff.NewWords())3}4func main(){5    fmt.Println(diff.NewWords())6}7func main(){8    fmt.Println(diff.NewWords())9}10func main(){11    fmt.Println(diff2.NewWords())12}13func main(){14    fmt.Println(diff.NewWords())15}16func main(){17    fmt.Println(diff.NewWords())18}19func main(){20    fmt.Println(diff.NewWords())21}22func main(){23    fmt.Println(diff.NewWords())24}