This is a fix for: https://github.com/segmentio/golines/issues/54 I believe this is the preferred approach to ensure cross-platform compatibility. Things are working for me now in Windows but I don't have a way of verifying things in another OS.

Best described by an example: rc.Logger.WithField("FIELD", *someField).Info("Some Very Long Info Here")

could be possibly broken down to: rc.Logger. WithField("FIELD", *someField). Info("Some Very Long Info Here")

OR

rc. Logger. WithField("FIELD", *someField). Info("Some Very Long Info Here")

Formatting is not working, but essentially move the methods chain one per line.

Hi, I have a short file that causes golines to abruptly fail without indication what went wrong.

Here is the file - https://gist.github.com/hellt/bf38f4b294a567157d5edfa271349dda

Any clues on what causes it to fail?

golines just moved the last part of my if statement to another line, but other statements still on the same line (and it is still extremely long)

Attaching screenshot that I got using dry-run

golines does not yet support generic type parameters.

Adapting from the example in the official generics tutorial:

func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V, longArgument1 int, longArgument2 int, longArgument3 int) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}

shortens to:

func SumIntsOrFloats(
	m map[K]V,
	longArgument1 int,
	longArgument2 int,
	longArgument3 int,
) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}

which is missing the bracketed type parameters and thus is incorrect.

We depend on https://github.com/dave/dst to generate the ASTs that are used in the shortening process, but unfortunately that library won't be fixed to support generics for a while because the author is currently off-the-grid (see https://github.com/dave/dst/issues/63 for details). I'll follow that issue, and when it's fixed we should be able to fix golines as well.

Apologies for any inconvenience caused here.

If the file includes any struct tags possibly needing alignment (meaning there are at least 2 tags on a field), generic parameters from a function later in the file are stripped.

I have confirmed this is not an issue in the backend formatter with both gofmt and goimports.

Example

Passing

package strips_generics

type needsTagAllignemnt struct {
        Foo  *bool   `json:"foo" db:"foo"`
}


// Has its type parameters stripped
func setDefault[T any](dst **T, val T) {
        if *dst == nil {
                *dst = &val
        }
}

into golines with golines ./main.go outputs

package strips_generics

type needsTagAllignemnt struct {
        Foo *bool `json:"foo" db:"foo"`
}

// Has its type parameters stripped
func setDefault(dst **T, val T) {
        if *dst == nil {
                *dst = &val
        }
}

Code with accompanying go.mod: test.zip

Running this with latest golines:

golines --base-formatter "cat test.go" -m 120 test.go

Where test.go contains:

package main

import "fmt"

func MyLongFunction(one, two, three, four, five, six, seven, eight, nine, ten, eleven string) {
	fmt.Println("Hello world!")
}

$ golines --base-formatter "cat test.go" -m 50 test.go 
package main

import "fmt"

func MyLongFunction(one, two, three, four, five, six, seven, eight, nine, ten, eleven string) {
        fmt.Println("Hello world!")
}
$ golines -m 50 test.go 
package main

import "fmt"

func MyLongFunction(
        one, two, three, four, five, six, seven, eight, nine, ten, eleven string,
) {
        fmt.Println("Hello world!")
}

Naturally one would specify an actually useful base-formatter, but this is just to make the case.

Issue

I found a problem that if we have a long and complex expression, then golines will add a new line only before last operand. So if you have a code like this:

if getBooool1() || getBooool2() || getBooool3() || getBooool4() || getBooool5() || getBooool6() || getBooool7() {
	return "Hey"
}

it will become

if getBooool1() || getBooool2() || getBooool3() || getBooool4() || getBooool5() || getBooool6() ||
        getBooool7() {
	return "Hey"
}

Solution

My fix is pretty simple. The result will look like this

if getBooool1() || getBooool2() || getBooool3() || getBooool4() || getBooool5() ||
        getBooool6() ||
        getBooool7() {
	return "Hey"
}

It is not perfect. I would like to see something like this:

if getBooool1() || getBooool2() || getBooool3() || getBooool4() || getBooool5() ||
        getBooool6() || getBooool7() {
	return "Hey"
}

but this will require much more changes and really big refactoring I think. It is because how complex BinaryExpr are treated by dst

The below code works as expected:

package pkg

type MyStruct struct {
	Field1 string `url:"http://username:[email protected]:1234"`
}

No changes:

golines --dry-run ./pkg/foo.go
// No output

The code below does NOT work as expected if I add another tag in front of or behind the url tag:

package pkg

type MyStruct struct {
	Field1 string `param:"FOOBAR" url:"http://username:[email protected]:1234"`
}

$ golines --dry-run ./pkg/foo.go

--- ./pkg/foo.go
+++ ./pkg/foo.go.shortened
@@ -1,6 +1,6 @@
 package pkg
 type MyStruct struct {
-	Field1 string `param:"FOOBAR" url:"http://username:[email protected]:1234"`
+	Field1 string `param:"FOOBAR" url:"http://username:[email protected]:1234" http:"" username:"" bar:""`
 }

Also if the command above does align the tags, what does adding --reformat-tags do?

Here is an example: MyStruct2's tags are not aligned with other fields of MyStruct. It will be nice if tag declaration beginnings were aligned too.

package fixtures

type MyStruct struct {
	Field1    string `json:"field3" tag:"something"`
	Field2    string `              tag:"something else"`
	MyStruct2 `json:"ms2"    tag:"tada"`
}

type MyStruct2 struct {
	Field3 string `json:"field3"`
}

Seems like the github.com/dave/[email protected] module isn't compiling properly. Strangely, I only see this error in Github Actions, but not on my Mac. I'm wondering if it's a Linux issue?

Update: I cannot reproduce in a Docker container on my Mac, so probably not a Linux issue. Am I doing something stupid?

$ go install github.com/segmentio/[email protected]
go: downloading github.com/segmentio/golines v0.10.0
go: downloading github.com/dave/dst v0.27.0
go: downloading github.com/fatih/structtag v1.2.0
go: downloading github.com/pmezard/go-difflib v1.0.0
go: downloading github.com/sirupsen/logrus v1.4.2
go: downloading github.com/x-cray/logrus-prefixed-formatter v0.5.2
go: downloading golang.org/x/crypto v0.0.0-20220517005047-85d78b3ac167
go: downloading gopkg.in/alecthomas/kingpin.v2 v2.2.6
go: downloading golang.org/x/tools v0.1.10
go: downloading github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b
go: downloading golang.org/x/sys v0.0.0-20220318055525-2edf467146b5
go: downloading github.com/alecthomas/template v0.0.0-201907180[12](https://github.com/weberc2/mono/runs/6804449321?check_suite_focus=true#step:5:13)654-fb15b899a751
go: downloading github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d
go: downloading golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1
go: downloading github.com/mattn/go-colorable v0.1.4
go: downloading github.com/mattn/go-isatty v0.0.10
go: downloading golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
go: downloading golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3
# github.com/dave/dst/decorator
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:620:12: n.Type.TypeParams undefined (type *ast.FuncType has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:621:29: n.Type.TypeParams undefined (type *ast.FuncType has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:625:12: n.Type.TypeParams undefined (type *ast.FuncType has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:692:7: n.TypeParams undefined (type *ast.FuncType has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:693:24: n.TypeParams undefined (type *ast.FuncType has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:697:7: n.TypeParams undefined (type *ast.FuncType has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:9[13](https://github.com/weberc2/mono/runs/6804449321?check_suite_focus=true#step:5:14):8: undefined: ast.IndexListExpr
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:[14](https://github.com/weberc2/mono/runs/6804449321?check_suite_focus=true#step:5:15)40:7: n.TypeParams undefined (type *ast.TypeSpec has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:1441:24: n.TypeParams undefined (type *ast.TypeSpec has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:1445:7: n.TypeParams undefined (type *ast.TypeSpec has no field or method TypeParams)
Error: /go/pkg/mod/github.com/dave/[email protected]/decorator/decorator-fragment-generated.go:1445:7: too many errors
note: module requires Go 1.[18](https://github.com/weberc2/mono/runs/6804449321?check_suite_focus=true#step:5:19)
Error: Process completed with exit code 2.

I have the following struct tag: jsonschema:"title=Title,minLength=1,maxLength=40,pattern=^[^\\-<>%{}\\[\\]&#\\\\\\\"]+$", and upon running golines ${file} -w -m 120 using the Run on Save extension in VSCode, the tag is changed into jsonschema:"title=title=Title,maxLength=40,pattern=^[^\-<>%{}\[\]&#\\\"]+$", turning it into an invalid struct tag.

Currently there are two flags for ignoring files: --ignore-generated and --ignored-dirs.

--ignore-generated is very strict about what it considers a generated file, causing a lot of generated files to be considered not generated in many code bases.

--ignored-dirs only checks the last part of a path which can mean it will match a much larger set that intended if the ignored directory has a generic name. Additionally it is rather combersome to specify multile directories as the flag needs to be repeated and it is quite long (granted not a major concern).

Ideally I would like to see ignores specified as regular expressions on the whole path, similar to how golangci-lint handles its skip-dirs configuration

If a line exceeds 80 characters, we move all the parameters to each line on their own. Instead we could try to fit them in as lesser lines as possible. This would help avoid scrolling, improves readability. It is fine, even if this takes time.

In the screenshot below, the 3rd segment is more readable than the 2nd segment.

Description

Refactor codebase to add a shorten package. This allows other projects to use this library and closes #34.

Some notes:

• Sometimes a dir called pkg is preferred for things that should be public. I could easily move to pkg/shorten. I opted to keep the imports shorter, but let me know if you have a different preference!
• Most of the funcs in the shorten package could be moved to their own packages in internal. Again, I don't mind doing the refactoring if you'd prefer that.
• To simplify usage in other projects, I have added shorten.DefaultConfig() which returns a shorten.Config struct that matches the default flag values. I have also changed shorten.New() so that config is an optional parameter. If not passed, the default config is used.
• I renamed most funcs and vars to make them private. Only shorten.New(), shorten.DefaultConfig(), and Shortener.Shorten() are exposed.
• All tests are passing.

Unfortunately, this PR required some major refactoring and will create merge conflicts with any other open PRs.

Let me know if you have any suggestions!

Example: Usage in another project

package main

import (
	"fmt"
	"github.com/segmentio/golines/shorten"
)

var code = `package main

var myMap = map[string]string{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4", "key5", "value5"}
`


func main() {
	shortener := shorten.New()

	out, err := shortener.Shorten([]byte(code))
	if err != nil {
		panic(err)
	}

	fmt.Print(string(out))
}

Todo

• Add a quick section to the readme that shows usage from other packages.

One of the files that gqlgen generates has the comment:

// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.

so figured I'd add it to generatedTerms to avoid issues between gqlgeng and golines.