Sign upLogin

rueian/rueidis

View on GitHub
Star

Showing 507 of 651 total issues

Similar blocks of code found in 3 locations. Consider refactoring.
Open

    case "punsubscribe":
        p.psubs.Unsubscribe(values[1].string)
        if len(values) >= 3 {
            p.pshks.Load().(*pshks).hooks.OnSubscription(PubSubSubscription{Kind: values[0].string, Channel: values[1].string, Count: values[2].integer})
        }
Severity: Major
Found in pipe.go and 2 other locations - About 50 mins to fix
pipe.go on lines 668..673
pipe.go on lines 680..685

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 118.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

func (c *bloomFilter) Delete(ctx context.Context) error {
    resp := c.client.Do(
        ctx,
        c.client.B().
            Eval().
Severity: Major
Found in rueidisprob/bloomfilter.go and 2 other locations - About 50 mins to fix
rueidisprob/bloomfilter.go on lines 294..305
rueidisprob/countingbloomfilter.go on lines 333..344

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 118.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

    case "unsubscribe":
        p.nsubs.Unsubscribe(values[1].string)
        if len(values) >= 3 {
            p.pshks.Load().(*pshks).hooks.OnSubscription(PubSubSubscription{Kind: values[0].string, Channel: values[1].string, Count: values[2].integer})
        }
Severity: Major
Found in pipe.go and 2 other locations - About 50 mins to fix
pipe.go on lines 674..679
pipe.go on lines 680..685

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 118.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

    case "sunsubscribe":
        p.ssubs.Unsubscribe(values[1].string)
        if len(values) >= 3 {
            p.pshks.Load().(*pshks).hooks.OnSubscription(PubSubSubscription{Kind: values[0].string, Channel: values[1].string, Count: values[2].integer})
        }
Severity: Major
Found in pipe.go and 2 other locations - About 50 mins to fix
pipe.go on lines 668..673
pipe.go on lines 674..679

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 118.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

func (c FtCreateFieldAs) Vector(algo string, nargs int64, args ...string) FtCreateFieldFieldTypeVector {
    c.cs.s = append(c.cs.s, "VECTOR", algo, strconv.FormatInt(nargs, 10))
    c.cs.s = append(c.cs.s, args...)
    return (FtCreateFieldFieldTypeVector)(c)
}
Severity: Minor
Found in internal/cmds/gen_search.go and 1 other location - About 45 mins to fix
internal/cmds/gen_search.go on lines 1819..1823

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 114.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

func (c FtCreateFieldFieldName) Vector(algo string, nargs int64, args ...string) FtCreateFieldFieldTypeVector {
    c.cs.s = append(c.cs.s, "VECTOR", algo, strconv.FormatInt(nargs, 10))
    c.cs.s = append(c.cs.s, args...)
    return (FtCreateFieldFieldTypeVector)(c)
}
Severity: Minor
Found in internal/cmds/gen_search.go and 1 other location - About 45 mins to fix
internal/cmds/gen_search.go on lines 1786..1790

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 114.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

func (mr *ClientMockRecorder) Receive(arg0, arg1, arg2 any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Receive", reflect.TypeOf((*Client)(nil).Receive), arg0, arg1, arg2)
}
Severity: Major
Found in mock/client.go and 2 other locations - About 45 mins to fix
mock/client.go on lines 141..144
mock/client.go on lines 317..320

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 113.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

func (mr *ClientMockRecorder) DoCache(arg0, arg1, arg2 any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoCache", reflect.TypeOf((*Client)(nil).DoCache), arg0, arg1, arg2)
}
Severity: Major
Found in mock/client.go and 2 other locations - About 45 mins to fix
mock/client.go on lines 226..229
mock/client.go on lines 317..320

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 113.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

func (mr *DedicatedClientMockRecorder) Receive(arg0, arg1, arg2 any) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Receive", reflect.TypeOf((*DedicatedClient)(nil).Receive), arg0, arg1, arg2)
}
Severity: Major
Found in mock/client.go and 2 other locations - About 45 mins to fix
mock/client.go on lines 141..144
mock/client.go on lines 226..229

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 113.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c ZunionstoreKey) Weights(weight ...int64) ZunionstoreWeights {
    c.cs.s = append(c.cs.s, "WEIGHTS")
    for _, n := range weight {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_sorted_set.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c TsRangeLatest) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
    c.cs.s = append(c.cs.s, "FILTER_BY_TS")
    for _, n := range timestamp {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_timeseries.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c TsRangeTotimestamp) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
    c.cs.s = append(c.cs.s, "FILTER_BY_TS")
    for _, n := range timestamp {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_timeseries.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c TsMrangeTotimestamp) FilterByTs(timestamp ...int64) TsMrangeFilterByTs {
    c.cs.s = append(c.cs.s, "FILTER_BY_TS")
    for _, n := range timestamp {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_timeseries.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c TsRevrangeTotimestamp) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
    c.cs.s = append(c.cs.s, "FILTER_BY_TS")
    for _, n := range timestamp {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_timeseries.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c ZinterstoreKey) Weights(weight ...int64) ZinterstoreWeights {
    c.cs.s = append(c.cs.s, "WEIGHTS")
    for _, n := range weight {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_sorted_set.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

func VectorString64(v []float64) string {
    b := make([]byte, len(v)*8)
    for i, e := range v {
        i := i * 8
        binary.LittleEndian.PutUint64(b[i:i+8], math.Float64bits(e))
Severity: Minor
Found in binary.go and 1 other location - About 40 mins to fix
binary.go on lines 26..33

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c TsRevrangeLatest) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
    c.cs.s = append(c.cs.s, "FILTER_BY_TS")
    for _, n := range timestamp {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_timeseries.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

func VectorString32(v []float32) string {
    b := make([]byte, len(v)*4)
    for i, e := range v {
        i := i * 4
        binary.LittleEndian.PutUint32(b[i:i+4], math.Float32bits(e))
Severity: Minor
Found in binary.go and 1 other location - About 40 mins to fix
binary.go on lines 50..57

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c TsMrevrangeTotimestamp) FilterByTs(timestamp ...int64) TsMrevrangeFilterByTs {
    c.cs.s = append(c.cs.s, "FILTER_BY_TS")
    for _, n := range timestamp {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_timeseries.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 680..686
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 12 locations. Consider refactoring.
Open

func (c ZinterKey) Weights(weight ...int64) ZinterWeights {
    c.cs.s = append(c.cs.s, "WEIGHTS")
    for _, n := range weight {
        c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
    }
Severity: Major
Found in internal/cmds/gen_sorted_set.go and 11 other locations - About 40 mins to fix
internal/cmds/gen_sorted_set.go on lines 899..905
internal/cmds/gen_sorted_set.go on lines 2344..2350
internal/cmds/gen_sorted_set.go on lines 2499..2505
internal/cmds/gen_timeseries.go on lines 2278..2284
internal/cmds/gen_timeseries.go on lines 2473..2479
internal/cmds/gen_timeseries.go on lines 3190..3196
internal/cmds/gen_timeseries.go on lines 3385..3391
internal/cmds/gen_timeseries.go on lines 4085..4091
internal/cmds/gen_timeseries.go on lines 4185..4191
internal/cmds/gen_timeseries.go on lines 4765..4771
internal/cmds/gen_timeseries.go on lines 4865..4871

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 112.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Severity
Category
Status
Source
Language