Hello,

Interesting tool. Would it be possible to have an alternate output format that is more easily integrated with editors/IDEs?

Instead of:

found 3 clones:
  loc 1: main.go, line 139-139,
  loc 2: main.go, line 140-140,
  loc 3: main.go, line 150-150,

Something like:

main.go:139-139: duplicate of main.go:140-140, main.go:150-150
main.go:140-140: duplicate of main.go:139-139, main.go:150-150
main.go:150-150: duplicate of main.go:139-139, main.go:140-140

Consider this go code:

switch raw.VersionField {
// v1.Version and v2.Version are just strings aliases.
case v1.Version:
    dec := json.NewDecoder(bytes.NewReader(b))
    dec.UseNumber()
    var m v1.QueueMessage
    // some more code
case v2.Version:
    dec := json.NewDecoder(bytes.NewReader(b))
    dec.UseNumber()
    var m v2.QueueMessage
    // some more code, similar to the previous clause.
}

Running dupl on this returns:

duplicate of ./api.go:119-150 (dupl) // Lines belong to the second clase
duplicate of ./api.go:87-118 (dupl)  // Lines belong to the first clause

There are two issues here:

1. These two cases aren't the same, and differ by the var m v1.QueueMessage line.
2. Presuming that they are the same, they're linking each other in the error message. I guess the link should be one way, from the duplicate (the second clause, the with v2) to the first.

There are two places have serious memory leak：

• 1.https://github.com/mibk/dupl/blob/master/suffixtree/dupl.go#L34
• 2.https://github.com/mibk/dupl/blob/master/main.go#L166

Since you use for range that go 1.4 supported.

If you use go 1.3, you will get:

Installing dupl -> go get -u github.com/mibk/dupl
# github.com/mibk/dupl/suffixtree
../../mibk/dupl/suffixtree/suffixtree.go:44: syntax error: unexpected range, expecting {
../../mibk/dupl/suffixtree/suffixtree.go:49: syntax error: unexpected }
gometalinter: error: failed to install dupl: exit status 2: exit status 2

Running dupl will find duplicates across files. Running dupl *.go will only find duplicates inside each file. Given the feedback of https://github.com/mibk/dupl/issues/6 is it possible for multiple files specified on the command line to work the same as dupl on a directory?

Currently, dupl searches for clones in the current directory. There is an option to search in another directory that can be specified using the first argument.

This CL enables using other arguments as well. If the argument is a directory it searches recursively all *.go files in that directory. If it is a file it uses it regardless of the file extension.

The following commands are now equivalent:

    > dupl
    > dupl .
    > dupl $(find -name '*.go')
    > find -name '*.go' |dupl -files

Also, update README and help texts.

An example of the plumbing output as suggested in #2:

$ dupl -t 30 -plumbing
syntax/golang/golang.go:97-105: duplicate of syntax/golang/golang.go:133-140
syntax/golang/golang.go:133-140: duplicate of syntax/golang/golang.go:97-105
syntax/golang/golang.go:146-153: duplicate of syntax/golang/golang.go:155-162
syntax/golang/golang.go:155-162: duplicate of syntax/golang/golang.go:146-153
syntax/golang/golang.go:221-229: duplicate of syntax/golang/golang.go:255-263
syntax/golang/golang.go:255-263: duplicate of syntax/golang/golang.go:221-229
syntax/golang/golang.go:235-240: duplicate of syntax/golang/golang.go:352-357
syntax/golang/golang.go:352-357: duplicate of syntax/golang/golang.go:235-240
output/output_test.go:15-20: duplicate of output/output_test.go:33-38
output/output_test.go:33-38: duplicate of output/output_test.go:15-20

Note that groups are not dividied. Should it be divided (for example by a blank line)?

I've found that running dupl on the same codebase multiple times produces different results. I'm not sure why this would be the case, any ideas?

Heres some examples to demonstrate what I mean:

>for i in $(seq 1 100);do dupl ~/go/src/github.com/spf13/cobra/ |grep Found;done  |sort |uniq -c
      6 Found total 82 clone groups.
     27 Found total 83 clone groups.
     52 Found total 84 clone groups.
     13 Found total 85 clone groups.
      2 Found total 86 clone groups.
> for i in $(seq 1 100);do dupl ~/go/src/golang.org/x/net/webdav |grep Found;done  |sort |uniq -c
      2 Found total 228 clone groups.
     30 Found total 229 clone groups.
     30 Found total 230 clone groups.
     23 Found total 231 clone groups.
     12 Found total 232 clone groups.
      3 Found total 233 clone groups.

I don't see a way to check the version of dupl I have installed, but I just updated to the latest commit as of the time of me posting this ticket (415e882)

It would be nice to clean up the code a little bit and therefore remove these flags as well as the code that uses it. It is all related to using some instance of dupl as server and some other instances of dupl as clients to speed up the search.

Because there is no such repository that the speed of the search was the issue, and because sadly it is not faster, but rather much much slower instead, I propose to remove it. I also think that nobody is using it anyway. More likely people are confused what is it doing there.

I'm pretty sure nobody is using it. But in any case, I'm filing this issue. If nobody argues against it, I'm going to remove it in a week or so. Thank you.

Even though one can figure out the import path from the url, it's still helpful to display it in readme. Especially because many packages have vanity import paths, so it's not always immediately obvious.

For some historical reason golanci/golangci-lint uses for of mibk/dupl. I am in the process of moving golangci-lint away from forks towards upstream versions of all used linters. To achieve this we must be able to use dupl as a library and this PR introduces such an ability.

Great tool by the way! It has enabled me to write better code by pointing places where things can be dry'd up.

It would be nice to disable output for certain places in code where I know there is duplication, but I've chosen to keep the duplication in place. Sometimes there are reasons for this.

I'm thinking something akin to a linting comment to disable duplication checking:

// dupl-disable
            Context("when specifying parameter set 1", func() {
                BeforeEach(func() {
                    request, _ = http.NewRequest("GET", "/?paramA=20&paramB=40", nil)
                })
                It("should reflect the desired parameters", func() {
                    server.GET("/", func(c *gin.Context) {
                        paramSet1, _ := getParamSet1(c)
                        Expect(paramSet1.A).To(Equal(20))
                        Expect(paramSet1.B).To(Equal(40))
                    })
                    server.ServeHTTP(recorder, request)
                })
            })
// dupl-enable

...

// dupl-disable
                Context("when specifying parameter set 2", func() {
                    BeforeEach(func() {
                        request, _ = http.NewRequest("GET", "/?paramX=5000&paramY=10000", nil)
                    })
                    It("will reflect the desired parameters", func() {
                        server.GET("/", func(c *gin.Context) {
                            paramSet2, _ := getParamSet2(c)
                            Expect(paramSet2.X).To(Equal(5000))
                            Expect(paramSet2.Y).To(Equal(10000))
                        })
                        server.ServeHTTP(recorder, request)
                    })
                })
// dupl-enable