nexxtway/react-rainbow

View on GitHub
src/components/Table/__test__/table.spec.js

Summary

Maintainability
F
3 wks
Test Coverage

File table.spec.js has 1625 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import React from 'react';
import { mount } from 'enzyme';
import Table from '../index';
import Column from '../../Column';
import { ESCAPE_KEY, ENTER_KEY } from '../../../libs/constants';
Severity: Major
Found in src/components/Table/__test__/table.spec.js - About 4 days to fix

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

        it('should render the right amount of body cells with the right props when showRowNumberColumn is passed', () => {
            const component = mount(
                <Table data={data} keyField="id" showRowNumberColumn>
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 days to fix
    src/components/Table/__test__/table.spec.js on lines 1363..1403

    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 385.

    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

        it('should render the right amount of body cells with the right props when showCheckboxColumn is passed', () => {
            const component = mount(
                <Table data={data} keyField="id" showCheckboxColumn>
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 days to fix
    src/components/Table/__test__/table.spec.js on lines 1404..1444

    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 385.

    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

        it('should render the right amount of columns headers with the right props when showCheckboxColumn is passed', () => {
            const component = mount(
                <Table data={data} keyField="id" showCheckboxColumn>
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 day to fix
    src/components/Table/__test__/table.spec.js on lines 1271..1299

    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 277.

    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

        it('should render the right amount of columns headers with the right props when showRowNumberColumn is passed', () => {
            const component = mount(
                <Table data={data} keyField="id" showRowNumberColumn>
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 day to fix
    src/components/Table/__test__/table.spec.js on lines 1242..1270

    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 277.

    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

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

            const component = mount(
                <Table data={data} keyField="id" showCheckboxColumn showRowNumberColumn>
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
                    <Column field="id" header="User Id" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1446..1452

    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 94.

    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

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

            const component = mount(
                <Table data={data} keyField="id" showCheckboxColumn showRowNumberColumn>
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
                    <Column field="id" header="User Id" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1301..1307

    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 94.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'radio',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: true,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'radio',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 729..748
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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 15 locations. Consider refactoring.
    Open

            expect(component.state().rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: true,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 14 other locations - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 386..405
    src/components/Table/__test__/table.spec.js on lines 419..438
    src/components/Table/__test__/table.spec.js on lines 446..465
    src/components/Table/__test__/table.spec.js on lines 508..527
    src/components/Table/__test__/table.spec.js on lines 532..551
    src/components/Table/__test__/table.spec.js on lines 560..579
    src/components/Table/__test__/table.spec.js on lines 584..603
    src/components/Table/__test__/table.spec.js on lines 647..666
    src/components/Table/__test__/table.spec.js on lines 671..690
    src/components/Table/__test__/table.spec.js on lines 705..724
    src/components/Table/__test__/table.spec.js on lines 785..804
    src/components/Table/__test__/table.spec.js on lines 843..862
    src/components/Table/__test__/table.spec.js on lines 899..918
    src/components/Table/__test__/table.spec.js on lines 945..964

    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 93.

    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

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

            const component = mount(
                <Table data={data} keyField="id">
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
                    <Column field="id" header="User Id" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1330..1336

    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 88.

    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

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

            const component = mount(
                <Table data={data} keyField="id">
                    <Column field="name" header="Name" />
                    <Column field="email" header="Email" />
                    <Column field="id" header="User Id" />
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1223..1229

    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 88.

    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

            expect(state.rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 999..1018

    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 86.

    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

            expect(state.rows).toEqual([
                {
                    inputType: 'checkbox',
                    isDisabled: false,
                    isSelected: false,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1031..1050

    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 86.

    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

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

            const component = mount(
                <Table
                    data={tableData}
                    showCheckboxColumn
                    onRowSelection={onRowSelectionMockFn}
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1116..1126

    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 80.

    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

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

            const component = mount(
                <Table data={data} keyField="name" onSort={onSortMock}>
                    <Column field="name" header="Name" sortable />
                    <Column field="number" header="Number" />,
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 332..337

    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 80.

    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

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

            const component = mount(
                <Table
                    data={tableData}
                    showCheckboxColumn
                    onRowSelection={onRowSelectionMockFn}
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 1159..1169

    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 80.

    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

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

            const component = mount(
                <Table data={data} keyField="name" onSort={onSortMock}>
                    <Column field="name" header="Name" sortable />
                    <Column field="number" header="Number" />,
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 2 hrs to fix
    src/components/Table/__test__/table.spec.js on lines 344..349

    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 80.

    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

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

            const component = mount(
                <Table data={tableData} showCheckboxColumn keyField="id">
                    <Column field="name" header="Name" />
                    <Column field="id" header="ID" />
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1080..1085

    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 73.

    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

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

            const component = mount(
                <Table data={tableData} showCheckboxColumn keyField="id">
                    <Column field="name" header="Name" />
                    <Column field="id" header="ID" />
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1054..1059

    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 73.

    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

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

            const component = mount(
                <Table
                    data={tableData}
                    showCheckboxColumn
                    selectedRows={['1234qwerty']}
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 769..779

    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 71.

    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

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

            const component = mount(
                <Table
                    data={tableData}
                    showCheckboxColumn
                    selectedRows={['1234qwerty']}
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 636..646

    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 71.

    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 5 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                    <Column field="number" header="Number" />
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 4 other locations - About 1 hr to fix
    src/components/MultiSelect/__test__/multiSelect.a11y.spec.js on lines 20..25
    src/components/MultiSelect/__test__/multiSelect.spec.js on lines 58..63
    src/components/Table/__test__/table.spec.js on lines 249..254
    src/components/Table/__test__/table.spec.js on lines 311..316

    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 70.

    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 5 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                    <Column field="number" header="Number" />
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 4 other locations - About 1 hr to fix
    src/components/MultiSelect/__test__/multiSelect.a11y.spec.js on lines 20..25
    src/components/MultiSelect/__test__/multiSelect.spec.js on lines 58..63
    src/components/Table/__test__/table.spec.js on lines 234..239
    src/components/Table/__test__/table.spec.js on lines 249..254

    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 70.

    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 5 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                    <Column field="number" header="Number" />
                </Table>,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 4 other locations - About 1 hr to fix
    src/components/MultiSelect/__test__/multiSelect.a11y.spec.js on lines 20..25
    src/components/MultiSelect/__test__/multiSelect.spec.js on lines 58..63
    src/components/Table/__test__/table.spec.js on lines 234..239
    src/components/Table/__test__/table.spec.js on lines 311..316

    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 70.

    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

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

            expect(onRowSelectionMockFn).toHaveBeenCalledWith([
                {
                    name: 'Pepe',
                    email: 'pepe@gmail.com',
                    id: '1234qwerty',
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 749..765

    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 67.

    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

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

            expect(onRowSelectionMockFn).toHaveBeenCalledWith([
                {
                    name: 'Pepe',
                    email: 'pepe@gmail.com',
                    id: '1234qwerty',
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 863..879

    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 67.

    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

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

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable onChange={onChangeMockFn} />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1588..1592
    src/components/Table/__test__/table.spec.js on lines 1608..1612

    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 62.

    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

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

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable onChange={onChangeMockFn} />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1553..1557
    src/components/Table/__test__/table.spec.js on lines 1608..1612

    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 62.

    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

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

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable onChange={onChangeMockFn} />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1553..1557
    src/components/Table/__test__/table.spec.js on lines 1588..1592

    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 62.

    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

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

            const component = mount(
                <Table
                    data={tableData}
                    showCheckboxColumn
                    onRowSelection={onRowSelectionMockFn}
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 820..829

    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 62.

    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

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

            const component = mount(
                <Table
                    data={tableData}
                    showCheckboxColumn
                    onRowSelection={onRowSelectionMockFn}
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 695..704

    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 62.

    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

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

            expect(component.state().columns).toEqual([
                {
                    field: 'name',
                    header: 'Name',
                    headerAlignment: undefined,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 206..218

    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 57.

    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

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

            const columnsState = [
                {
                    field: 'name',
                    header: 'Name',
                    headerAlignment: undefined,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 104..116

    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 57.

    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

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

            const component = mount(
                <Table data={[]} showCheckboxColumn keyField="id">
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 990..994

    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 56.

    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

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

            const component = mount(
                <Table data={[]} showCheckboxColumn keyField="id">
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 975..979

    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 56.

    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

    Identical blocks of code found in 6 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 5 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1488..1492
    src/components/Table/__test__/table.spec.js on lines 1497..1501
    src/components/Table/__test__/table.spec.js on lines 1508..1512
    src/components/Table/__test__/table.spec.js on lines 1534..1538
    src/components/Table/__test__/table.spec.js on lines 1570..1574

    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 55.

    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

    Identical blocks of code found in 6 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 5 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1488..1492
    src/components/Table/__test__/table.spec.js on lines 1497..1501
    src/components/Table/__test__/table.spec.js on lines 1508..1512
    src/components/Table/__test__/table.spec.js on lines 1521..1525
    src/components/Table/__test__/table.spec.js on lines 1570..1574

    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 55.

    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

    Identical blocks of code found in 6 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 5 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1497..1501
    src/components/Table/__test__/table.spec.js on lines 1508..1512
    src/components/Table/__test__/table.spec.js on lines 1521..1525
    src/components/Table/__test__/table.spec.js on lines 1534..1538
    src/components/Table/__test__/table.spec.js on lines 1570..1574

    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 55.

    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

    Identical blocks of code found in 6 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 5 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1488..1492
    src/components/Table/__test__/table.spec.js on lines 1508..1512
    src/components/Table/__test__/table.spec.js on lines 1521..1525
    src/components/Table/__test__/table.spec.js on lines 1534..1538
    src/components/Table/__test__/table.spec.js on lines 1570..1574

    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 55.

    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

    Identical blocks of code found in 6 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 5 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1488..1492
    src/components/Table/__test__/table.spec.js on lines 1497..1501
    src/components/Table/__test__/table.spec.js on lines 1521..1525
    src/components/Table/__test__/table.spec.js on lines 1534..1538
    src/components/Table/__test__/table.spec.js on lines 1570..1574

    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 55.

    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

    Identical blocks of code found in 6 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" isEditable />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 5 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 1488..1492
    src/components/Table/__test__/table.spec.js on lines 1497..1501
    src/components/Table/__test__/table.spec.js on lines 1508..1512
    src/components/Table/__test__/table.spec.js on lines 1521..1525
    src/components/Table/__test__/table.spec.js on lines 1534..1538

    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 55.

    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

                {
                    field: 'number',
                    header: 'Number',
                    headerAlignment: undefined,
                    computedWidth: 50,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 257..267
    src/components/Table/__test__/table.spec.js on lines 268..278

    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 55.

    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

            const component = mount(
                <Table data={data} keyField="name" showCheckboxColumn>
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 84..88
    src/components/Table/__test__/table.spec.js on lines 381..385

    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 55.

    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

                {
                    field: 'name',
                    header: 'Name',
                    headerAlignment: undefined,
                    computedWidth: 50,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 268..278
    src/components/Table/__test__/table.spec.js on lines 297..307

    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 55.

    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

                {
                    field: 'number',
                    header: 'Number',
                    headerAlignment: undefined,
                    computedWidth: 50,
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 257..267
    src/components/Table/__test__/table.spec.js on lines 297..307

    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 55.

    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

            const component = mount(
                <Table data={tableData} keyField="id" showCheckboxColumn>
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 84..88
    src/components/Table/__test__/table.spec.js on lines 146..150

    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 55.

    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

            const component = mount(
                <Table data={data} keyField="name" showCheckboxColumn>
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 2 other locations - About 1 hr to fix
    src/components/Table/__test__/table.spec.js on lines 146..150
    src/components/Table/__test__/table.spec.js on lines 381..385

    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 55.

    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

    Identical blocks of code found in 4 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 3 other locations - About 50 mins to fix
    src/components/Table/__test__/table.spec.js on lines 66..70
    src/components/Table/__test__/table.spec.js on lines 99..103
    src/components/Table/__test__/table.spec.js on lines 219..223

    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 52.

    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

    Identical blocks of code found in 4 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 3 other locations - About 50 mins to fix
    src/components/Table/__test__/table.spec.js on lines 53..57
    src/components/Table/__test__/table.spec.js on lines 66..70
    src/components/Table/__test__/table.spec.js on lines 219..223

    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 52.

    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

    Identical blocks of code found in 4 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 3 other locations - About 50 mins to fix
    src/components/Table/__test__/table.spec.js on lines 53..57
    src/components/Table/__test__/table.spec.js on lines 99..103
    src/components/Table/__test__/table.spec.js on lines 219..223

    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 52.

    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

    Identical blocks of code found in 4 locations. Consider refactoring.
    Open

            const component = mount(
                <Table data={data} keyField="name">
                    <Column field="name" header="Name" />
                </Table>,
            );
    Severity: Major
    Found in src/components/Table/__test__/table.spec.js and 3 other locations - About 50 mins to fix
    src/components/Table/__test__/table.spec.js on lines 53..57
    src/components/Table/__test__/table.spec.js on lines 66..70
    src/components/Table/__test__/table.spec.js on lines 99..103

    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 52.

    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

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

                {
                    field: 'number',
                    sortable: true,
                    computedWidth: 50,
                    type: 'text',
    Severity: Minor
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 45 mins to fix
    src/components/Table/__test__/table.spec.js on lines 193..202

    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 50.

    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

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

                {
                    field: 'number',
                    sortable: true,
                    computedWidth: 50,
                    type: 'text',
    Severity: Minor
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 45 mins to fix
    src/components/Table/__test__/table.spec.js on lines 133..142

    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 50.

    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

            expect(onRowSelectionMockFn).toHaveBeenCalledWith([
                {
                    name: 'Pepe',
                    email: 'pepe@gmail.com',
                    id: '1234qwerty',
    Severity: Minor
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 45 mins to fix
    src/components/Table/__test__/table.spec.js on lines 629..632

    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 50.

    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

            expect(onRowSelectionMockFn).toHaveBeenCalledWith([
                { id: '1234qwerty', name: 'Pepe', email: 'pepe@gmail.com' },
                { id: '9012zxcvbn', name: 'Josep', email: 'josep@gmail.com' },
            ]);
    Severity: Minor
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 45 mins to fix
    src/components/Table/__test__/table.spec.js on lines 805..816

    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 50.

    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

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

            component.setProps({
                children: [<Column field="name" header="Name" />, <Column field="number" />],
            });
    Severity: Minor
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 35 mins to fix
    src/components/Table/__test__/table.spec.js on lines 74..76

    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 47.

    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

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

            component.setProps({
                children: [<Column field="name" header="Name" />, <Column field="number" />],
            });
    Severity: Minor
    Found in src/components/Table/__test__/table.spec.js and 1 other location - About 35 mins to fix
    src/components/Table/__test__/table.spec.js on lines 91..93

    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 47.

    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

    There are no issues that match your filters.

    Category
    Status