How to use addInlineTableRow method of parser Package

...416			result = ParseResult{Ok: true}417		} else if isInState(*state, stepScope) {418			latestScenario := spec.LatestScenario()419			latestStep := latestScenario.LatestStep()420			result = addInlineTableRow(latestStep, token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName)421		} else if isInState(*state, contextScope) {422			latestContext := spec.LatestContext()423			result = addInlineTableRow(latestContext, token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName)424		} else if isInState(*state, tearDownScope) {425			if len(spec.TearDownSteps) > 0 {426				latestTeardown := spec.LatestTeardown()427				result = addInlineTableRow(latestTeardown, token, new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table), spec.FileName)428			} else {429				spec.AddComment(&gauge.Comment{token.LineText, token.LineNo})430			}431		} else {432			//todo validate datatable rows also433			spec.DataTable.Table.AddRowValues(token.Args)434			result = ParseResult{Ok: true}435		}436		retainStates(state, specScope, scenarioScope, stepScope, contextScope, tearDownScope, tableScope, tableSeparatorScope)437		return result438	})439	tagConverter := converterFn(func(token *Token, state *int) bool {440		return (token.Kind == gauge.TagKind)441	}, func(token *Token, spec *gauge.Specification, state *int) ParseResult {442		tags := &gauge.Tags{Values: token.Args}443		if isInState(*state, scenarioScope) {444			if spec.LatestScenario().NTags() != 0 {445				return ParseResult{Ok: false, ParseErrors: []ParseError{ParseError{FileName: spec.FileName, LineNo: token.LineNo, Message: "Tags can be defined only once per scenario", LineText: token.LineText}}}446			}447			spec.LatestScenario().AddTags(tags)448		} else {449			if spec.NTags() != 0 {450				return ParseResult{Ok: false, ParseErrors: []ParseError{ParseError{FileName: spec.FileName, LineNo: token.LineNo, Message: "Tags can be defined only once per specification", LineText: token.LineText}}}451			}452			spec.AddTags(tags)453		}454		return ParseResult{Ok: true}455	})456	converter := []func(*Token, *int, *gauge.Specification) ParseResult{457		specConverter, scenarioConverter, stepConverter, contextConverter, commentConverter, tableHeaderConverter, tableRowConverter, tagConverter, keywordConverter, tearDownConverter, tearDownStepConverter,458	}459	return converter460}461func (parser *SpecParser) validateSpec(specification *gauge.Specification) error {462	if len(specification.Items) == 0 {463		return ParseError{FileName: specification.FileName, LineNo: 1, Message: "Spec does not have any elements"}464	}465	if specification.Heading == nil {466		return ParseError{FileName: specification.FileName, LineNo: 1, Message: "Spec heading not found"}467	}468	if len(strings.TrimSpace(specification.Heading.Value)) < 1 {469		return ParseError{FileName: specification.FileName, LineNo: specification.Heading.LineNo, Message: "Spec heading should have at least one character"}470	}471	dataTable := specification.DataTable.Table472	if dataTable.IsInitialized() && dataTable.GetRowCount() == 0 {473		return ParseError{FileName: specification.FileName, LineNo: dataTable.LineNo, Message: "Data table should have at least 1 data row"}474	}475	if len(specification.Scenarios) == 0 {476		return ParseError{FileName: specification.FileName, LineNo: specification.Heading.LineNo, Message: "Spec should have atleast one scenario"}477	}478	for _, sce := range specification.Scenarios {479		if len(sce.Steps) == 0 {480			return ParseError{FileName: specification.FileName, LineNo: sce.Heading.LineNo, Message: "Scenario should have atleast one step"}481		}482	}483	return nil484}485func CreateStepFromStepRequest(stepReq *gauge_messages.ExecuteStepRequest) *gauge.Step {486	args := createStepArgsFromProtoArguments(stepReq.GetParameters())487	step := &gauge.Step{Value: stepReq.GetParsedStepText(),488		LineText: stepReq.GetActualStepText()}489	step.AddArgs(args...)490	return step491}492func createStepArgsFromProtoArguments(parameters []*gauge_messages.Parameter) []*gauge.StepArg {493	stepArgs := make([]*gauge.StepArg, 0)494	for _, parameter := range parameters {495		var arg *gauge.StepArg496		switch parameter.GetParameterType() {497		case gauge_messages.Parameter_Static:498			arg = &gauge.StepArg{ArgType: gauge.Static, Value: parameter.GetValue(), Name: parameter.GetName()}499			break500		case gauge_messages.Parameter_Dynamic:501			arg = &gauge.StepArg{ArgType: gauge.Dynamic, Value: parameter.GetValue(), Name: parameter.GetName()}502			break503		case gauge_messages.Parameter_Special_String:504			arg = &gauge.StepArg{ArgType: gauge.SpecialString, Value: parameter.GetValue(), Name: parameter.GetName()}505			break506		case gauge_messages.Parameter_Table:507			arg = &gauge.StepArg{ArgType: gauge.TableArg, Table: *(TableFrom(parameter.GetTable())), Name: parameter.GetName()}508			break509		case gauge_messages.Parameter_Special_Table:510			arg = &gauge.StepArg{ArgType: gauge.SpecialTable, Table: *(TableFrom(parameter.GetTable())), Name: parameter.GetName()}511			break512		}513		stepArgs = append(stepArgs, arg)514	}515	return stepArgs516}517func converterFn(predicate func(token *Token, state *int) bool, apply func(token *Token, spec *gauge.Specification, state *int) ParseResult) func(*Token, *int, *gauge.Specification) ParseResult {518	return func(token *Token, state *int, spec *gauge.Specification) ParseResult {519		if !predicate(token, state) {520			return ParseResult{Ok: true}521		}522		return apply(token, spec, state)523	}524}525func createStep(spec *gauge.Specification, stepToken *Token) (*gauge.Step, *ParseResult) {526	dataTableLookup := new(gauge.ArgLookup).FromDataTable(&spec.DataTable.Table)527	stepToAdd, parseDetails := CreateStepUsingLookup(stepToken, dataTableLookup, spec.FileName)528	if parseDetails != nil && len(parseDetails.ParseErrors) > 0 {529		return nil, parseDetails530	}531	stepToAdd.Suffix = stepToken.Suffix532	return stepToAdd, parseDetails533}534func CreateStepUsingLookup(stepToken *Token, lookup *gauge.ArgLookup, specFileName string) (*gauge.Step, *ParseResult) {535	stepValue, argsType := extractStepValueAndParameterTypes(stepToken.Value)536	if argsType != nil && len(argsType) != len(stepToken.Args) {537		return nil, &ParseResult{ParseErrors: []ParseError{ParseError{specFileName, stepToken.LineNo, "Step text should not have '{static}' or '{dynamic}' or '{special}'", stepToken.LineText}}, Warnings: nil}538	}539	step := &gauge.Step{LineNo: stepToken.LineNo, Value: stepValue, LineText: strings.TrimSpace(stepToken.LineText)}540	arguments := make([]*gauge.StepArg, 0)541	var warnings []*Warning542	for i, argType := range argsType {543		argument, parseDetails := createStepArg(stepToken.Args[i], argType, stepToken, lookup, specFileName)544		if parseDetails != nil && len(parseDetails.ParseErrors) > 0 {545			return nil, parseDetails546		}547		arguments = append(arguments, argument)548		if parseDetails != nil && parseDetails.Warnings != nil {549			for _, warn := range parseDetails.Warnings {550				warnings = append(warnings, warn)551			}552		}553	}554	step.AddArgs(arguments...)555	return step, &ParseResult{Warnings: warnings}556}557func createConceptStep(spec *gauge.Specification, concept *gauge.Step, originalStep *gauge.Step) {558	stepCopy := concept.GetCopy()559	originalArgs := originalStep.Args560	originalStep.CopyFrom(stepCopy)561	originalStep.Args = originalArgs562	// set parent of all concept steps to be the current concept (referred as originalStep here)563	// this is used to fetch from parent's lookup when nested564	for _, conceptStep := range originalStep.ConceptSteps {565		conceptStep.Parent = originalStep566	}567	spec.PopulateConceptLookup(&originalStep.Lookup, concept.Args, originalStep.Args)568}569func extractStepValueAndParameterTypes(stepTokenValue string) (string, []string) {570	argsType := make([]string, 0)571	r := regexp.MustCompile("{(dynamic|static|special)}")572	/*573		enter {dynamic} and {static}574		returns575		[576		["{dynamic}","dynamic"]577		["{static}","static"]578		]579	*/580	args := r.FindAllStringSubmatch(stepTokenValue, -1)581	if args == nil {582		return stepTokenValue, nil583	}584	for _, arg := range args {585		//arg[1] extracts the first group586		argsType = append(argsType, arg[1])587	}588	return r.ReplaceAllString(stepTokenValue, gauge.ParameterPlaceholder), argsType589}590func createStepArg(argValue string, typeOfArg string, token *Token, lookup *gauge.ArgLookup, fileName string) (*gauge.StepArg, *ParseResult) {591	if typeOfArg == "special" {592		resolvedArgValue, err := newSpecialTypeResolver().resolve(argValue)593		if err != nil {594			switch err.(type) {595			case invalidSpecialParamError:596				return treatArgAsDynamic(argValue, token, lookup, fileName)597			default:598				return nil, &ParseResult{ParseErrors: []ParseError{ParseError{FileName: fileName, LineNo: token.LineNo, Message: fmt.Sprintf("Dynamic parameter <%s> could not be resolved", argValue), LineText: token.LineText}}}599			}600		}601		return resolvedArgValue, nil602	} else if typeOfArg == "static" {603		return &gauge.StepArg{ArgType: gauge.Static, Value: argValue}, nil604	} else {605		return validateDynamicArg(argValue, token, lookup, fileName)606	}607}608func treatArgAsDynamic(argValue string, token *Token, lookup *gauge.ArgLookup, fileName string) (*gauge.StepArg, *ParseResult) {609	parseRes := &ParseResult{Warnings: []*Warning{&Warning{FileName: fileName, LineNo: token.LineNo, Message: fmt.Sprintf("Could not resolve special param type <%s>. Treating it as dynamic param.", argValue)}}}610	stepArg, result := validateDynamicArg(argValue, token, lookup, fileName)611	if result != nil {612		if len(result.ParseErrors) > 0 {613			parseRes.ParseErrors = result.ParseErrors614		}615		if result.Warnings != nil {616			for _, warn := range result.Warnings {617				parseRes.Warnings = append(parseRes.Warnings, warn)618			}619		}620	}621	return stepArg, parseRes622}623func validateDynamicArg(argValue string, token *Token, lookup *gauge.ArgLookup, fileName string) (*gauge.StepArg, *ParseResult) {624	if !isConceptHeader(lookup) && !lookup.ContainsArg(argValue) {625		return nil, &ParseResult{ParseErrors: []ParseError{ParseError{FileName: fileName, LineNo: token.LineNo, Message: fmt.Sprintf("Dynamic parameter <%s> could not be resolved", argValue), LineText: token.LineText}}}626	}627	stepArgument := &gauge.StepArg{ArgType: gauge.Dynamic, Value: argValue, Name: argValue}628	return stepArgument, nil629}630//Step value is modified when inline table is found to account for the new parameter by appending {}631//todo validate headers for dynamic632func addInlineTableHeader(step *gauge.Step, token *Token) {633	step.Value = fmt.Sprintf("%s %s", step.Value, gauge.ParameterPlaceholder)634	step.HasInlineTable = true635	step.AddInlineTableHeaders(token.Args)636}637func addInlineTableRow(step *gauge.Step, token *Token, argLookup *gauge.ArgLookup, fileName string) ParseResult {638	dynamicArgMatcher := regexp.MustCompile("^<(.*)>$")639	tableValues := make([]gauge.TableCell, 0)640	warnings := make([]*Warning, 0)641	for _, tableValue := range token.Args {642		if dynamicArgMatcher.MatchString(tableValue) {643			match := dynamicArgMatcher.FindAllStringSubmatch(tableValue, -1)644			param := match[0][1]645			if !argLookup.ContainsArg(param) {646				tableValues = append(tableValues, gauge.TableCell{Value: tableValue, CellType: gauge.Static})647				warnings = append(warnings, &Warning{FileName: fileName, LineNo: token.LineNo, Message: fmt.Sprintf("Dynamic param <%s> could not be resolved, Treating it as static param", param)})648			} else {649				tableValues = append(tableValues, gauge.TableCell{Value: param, CellType: gauge.Dynamic})650			}651		} else {...

...210			if latestScenario.DataTable.IsInitialized() {211				tables = append(tables, &latestScenario.DataTable.Table)212			}213			latestStep := latestScenario.LatestStep()214			result = addInlineTableRow(latestStep, token, new(gauge.ArgLookup).FromDataTables(tables...), spec.FileName)215		} else if isInState(*state, contextScope) {216			latestContext := spec.LatestContext()217			result = addInlineTableRow(latestContext, token, new(gauge.ArgLookup).FromDataTables(&spec.DataTable.Table), spec.FileName)218		} else if isInState(*state, tearDownScope) {219			if len(spec.TearDownSteps) > 0 {220				latestTeardown := spec.LatestTeardown()221				result = addInlineTableRow(latestTeardown, token, new(gauge.ArgLookup).FromDataTables(&spec.DataTable.Table), spec.FileName)222			} else {223				spec.AddComment(&gauge.Comment{Value: token.LineText, LineNo: token.LineNo})224			}225		} else {226			t := spec.DataTable227			if isInState(*state, scenarioScope) && env.AllowScenarioDatatable() {228				t = spec.LatestScenario().DataTable229			}230			tableValues, warnings, err := validateTableRows(token, new(gauge.ArgLookup).FromDataTables(&t.Table), spec.FileName)231			if len(err) > 0 {232				result = ParseResult{Ok: false, Warnings: warnings, ParseErrors: err}233			} else {234				t.Table.AddRowValues(tableValues)235				result = ParseResult{Ok: true, Warnings: warnings}236			}237		}238		retainStates(state, specScope, scenarioScope, stepScope, contextScope, tearDownScope, tableScope, tableSeparatorScope)239		return result240	})241	tagConverter := converterFn(func(token *Token, state *int) bool {242		return (token.Kind == gauge.TagKind)243	}, func(token *Token, spec *gauge.Specification, state *int) ParseResult {244		tags := &gauge.Tags{RawValues: [][]string{token.Args}}245		if isInState(*state, scenarioScope) {246			if isInState(*state, tagsScope) {247				spec.LatestScenario().Tags.Add(tags.RawValues[0])248			} else {249				if spec.LatestScenario().NTags() != 0 {250					return ParseResult{Ok: false, ParseErrors: []ParseError{ParseError{FileName: spec.FileName, LineNo: token.LineNo, Message: "Tags can be defined only once per scenario", LineText: token.LineText}}}251				}252				spec.LatestScenario().AddTags(tags)253			}254		} else {255			if isInState(*state, tagsScope) {256				spec.Tags.Add(tags.RawValues[0])257			} else {258				if spec.NTags() != 0 {259					return ParseResult{Ok: false, ParseErrors: []ParseError{ParseError{FileName: spec.FileName, LineNo: token.LineNo, Message: "Tags can be defined only once per specification", LineText: token.LineText}}}260				}261				spec.AddTags(tags)262			}263		}264		addStates(state, tagsScope)265		return ParseResult{Ok: true}266	})267	converter := []func(*Token, *int, *gauge.Specification) ParseResult{268		specConverter, scenarioConverter, stepConverter, contextConverter, commentConverter, tableHeaderConverter, tableRowConverter, tagConverter, keywordConverter, tearDownConverter, tearDownStepConverter,269	}270	return converter271}272func converterFn(predicate func(token *Token, state *int) bool, apply func(token *Token, spec *gauge.Specification, state *int) ParseResult) func(*Token, *int, *gauge.Specification) ParseResult {273	return func(token *Token, state *int, spec *gauge.Specification) ParseResult {274		if !predicate(token, state) {275			return ParseResult{Ok: true}276		}277		return apply(token, spec, state)278	}279}280//Step value is modified when inline table is found to account for the new parameter by appending {}281//todo validate headers for dynamic282func addInlineTableHeader(step *gauge.Step, token *Token) {283	step.Value = fmt.Sprintf("%s %s", step.Value, gauge.ParameterPlaceholder)284	step.HasInlineTable = true285	step.AddInlineTableHeaders(token.Args)286}287func addInlineTableRow(step *gauge.Step, token *Token, argLookup *gauge.ArgLookup, fileName string) ParseResult {288	tableValues, warnings, err := validateTableRows(token, argLookup, fileName)289	if len(err) > 0 {290		return ParseResult{Ok: false, Warnings: warnings, ParseErrors: err}291	}292	step.AddInlineTableRow(tableValues)293	return ParseResult{Ok: true, Warnings: warnings}294}295func validateTableRows(token *Token, argLookup *gauge.ArgLookup, fileName string) ([]gauge.TableCell, []*Warning, []ParseError) {296	dynamicArgMatcher := regexp.MustCompile("^<(.*)>$")297	specialArgMatcher := regexp.MustCompile("^<(file:.*)>$")298	tableValues := make([]gauge.TableCell, 0)299	warnings := make([]*Warning, 0)300	error := make([]ParseError, 0)301	for _, tableValue := range token.Args {...

1import (2func main() {3	f := excelize.NewFile()4	index := f.NewSheet("Sheet2")5	f.SetCellValue("Sheet1", "A2", "Hello world.")6	f.SetCellValue("Sheet1", "B2", 100)7	f.SetActiveSheet(index)8	if err := f.SaveAs("Book1.xlsx"); err != nil {9		fmt.Println(err)10	}11}12import (13func main() {14	f, err := excelize.OpenFile("Book1.xlsx")15	if err != nil {16		fmt.Println(err)17	}18	rows, err := f.GetRows("Sheet1")19	for _, row := range rows {20		for _, colCell := range row {21			fmt.Print(colCell, "\t")22		}23		fmt.Println()24	}25}26import (27func main() {28	f, err := excelize.OpenFile("Book1.xlsx")29	if err != nil {30		fmt.Println(err)31	}32	cell, err := f.GetCellValue("Sheet1", "B2")33	if err != nil {34		fmt.Println(err)35	}36	fmt.Println(cell)37	index := f.GetSheetIndex("Sheet2")38	fmt.Println(index)39	rows, err := f.GetRows("Sheet1")40	for _, row := range rows {41		for _, colCell := range row {42			fmt.Print(colCell, "\t")43		}44		fmt.Println()45	}46	rows, err = f.GetRows("Sheet2")47	for _, row := range rows {

1import (2func main() {3	customMapping := bleve.NewIndexMapping()4	customAnalyzer := custom.Analyzer{5		TokenFilters: []string{6		},7	}8	customFieldMapping := bleve.NewTextFieldMapping()9	customDocumentMapping := bleve.NewDocumentMapping()10	customDocumentMapping.AddFieldMappingsAt("name", customFieldMapping)11	customMapping.AddDocumentMapping("custom", customDocumentMapping)12	index, err := bleve.New("example.bleve", customMapping)13	if err != nil {14		panic(err)15	}16	index.Index("1", map[string]interface{}{17	})18	query := bleve.NewMatchQuery("John")19	search := bleve.NewSearchRequest(query)20	searchResults, err := index.Search(search)21	if err != nil {22		panic(err)23	}24	fmt.Println(searchResults)25}26import (

1import "fmt"2func main() {3    fmt.Println("Hello, world.")4}5import "fmt"6func main() {7    fmt.Println("Hello, world.")8}9import "fmt"10func main() {11    fmt.Println("Hello, world.")12}13func main() {14    for i := 1; i < 4; i++ {15        copyFile(strconv.Itoa(i) + ".go", strconv.Itoa(i+1) + ".go")16    }17}18func copyFile(src, dst string) (err error) {19    in, err := os.Open(src)20    if err != nil {21    }22    defer in.Close()23    out, err := os.Create(dst)24    if err != nil {25    }26    defer func() {27        cerr := out.Close()28        if err == nil {29        }30    }()31    if _, err = io.Copy(out, in); err != nil {32    }33    err = out.Sync()34}35main.copyFile(0x7fff5fbff8e0, 0x5, 0x7fff5fbff8f4, 0x5, 0x0, 0x0)36main.main()

1import (2func main() {3	input, err := os.Open("input.html")4	if err != nil {5		log.Fatal(err)6	}7	defer input.Close()8	output, err := os.Open("output.html")9	if err != nil {10		log.Fatal(err)11	}12	defer output.Close()13	inputData, err := ioutil.ReadAll(input)14	if err != nil {15		log.Fatal(err)16	}17	outputData, err := ioutil.ReadAll(output)18	if err != nil {19		log.Fatal(err)20	}21	m := minify.New()22	m.AddFunc("text/html", html.Minify)23	minifiedInput, err := m.Bytes("text/html", inputData)24	if err != nil {25		log.Fatal(err)26	}27	minifiedOutput, err := m.Bytes("text/html", outputData)28	if err != nil {29		log.Fatal(err)30	}31	fmt.Println(string(minifiedInput))32	fmt.Println(string(minifiedOutput))33	inputParser := parser{minifiedInput}34	outputParser := parser{minifiedOutput}35	inputInlineTableRow := inputParser.findInlineTableRow()36	outputInlineTableRow := outputParser.findInlineTableRow()37	fmt.Println(string(inputInlineTableRow))38	fmt.Println(string(outputInlineTableRow))39	outputParser.addInlineTableRow(inputInlineTableRow)40	fmt.Println(string(outputParser.minifiedFile))41}42import (

1import (2func main() {3	f, err := os.Open("input.html")4	if err != nil {5		log.Fatal(err)6	}7	defer f.Close()8	b := parse.NewInputBuf(f)9	p := html.NewParser(b)10	for {11		tt, data := p.Next()12		if tt == html.ErrorToken {13		} else if tt == html.StartTagToken {14			if bytes.Equal(data, []byte("table")) {15			}16		}17	}18	for {19		tt, data := p.Next()20		if tt == html.ErrorToken {21		} else if tt == html.StartTagToken {22			if bytes.Equal(data, []byte("tr")) {23			}24		}25	}26	p.AddInlineTableRow([]byte("<tr><td>4</td><td>5</td><td>6</td></tr>"))27	for {28		tt, data := p.Next()29		if tt == html.ErrorToken {30		} else if tt == html.TextToken {31			fmt.Print(string(data))32		} else if tt == html.StartTagToken {33			fmt.Print("<", string(data), ">")34		} else if tt == html.EndTagToken {35			fmt.Print("</", string(data), ">")36		}37	}38}39import (40func main() {41	f, err := os.Open("input.html")42	if err != nil {43		log.Fatal(err)44	}45	defer f.Close()46	b := parse.NewInputBuf(f)47	p := html.NewParser(b)

1import (2func main() {3    md := blackfriday.MarkdownCommon([]byte("Hello World!"))4    fmt.Println(string(md))5}6import (7func main() {8    md := blackfriday.MarkdownCommon([]byte("Hello World!"))9    fmt.Println(string(md))10}11import (12func main() {13    md := blackfriday.MarkdownCommon([]byte("Hello World!"))14    fmt.Println(string(md))15}16import (17func main() {18    md := blackfriday.MarkdownCommon([]byte("Hello World!"))19    fmt.Println(string(md))20}21import (22func main() {23    md := blackfriday.MarkdownCommon([]byte("Hello World!"))24    fmt.Println(string(md))25}26import (27func main() {28    md := blackfriday.MarkdownCommon([]byte("Hello World!"))29    fmt.Println(string(md))30}31import (

1import "github.com/tdewolff/parse/v2"2import "github.com/tdewolff/parse/v2/html"3func main() {4    p := html.NewParser(strings.NewReader(`5    for {6        tok, data := p.Next()7        switch tok {8            name, hasAttr := p.TagName()9            if hasAttr {10                fmt.Println("StartTagToken:", name)11                for {12                    key, val, more := p.TagAttr()13                    if !more {14                    }15                    fmt.Println("  Attr:", string(key), string(val))16                }17            }18            fmt.Println("TextToken:", string(data))19            name, _ := p.TagName()20            fmt.Println("EndTagToken:", name)21        }22    }23}24import "github.com/tdewolff/parse/v2"25import "github.com/tdewolff/parse/v2/html"26func main() {27    p := html.NewParser(strings.NewReader(`