Sign upLogin

elliotchance/gedcom

View on GitHub
Star

Showing 640 of 640 total issues

Method IndividualListPage.WriteHTMLTo has 65 lines of code (exceeds 50 allowed). Consider refactoring.
Open

func (c *IndividualListPage) WriteHTMLTo(w io.Writer) (int64, error) {
    table := []core.Component{
        core.NewTableHead("Name", "Birth", "Death"),
    }
Severity: Minor
Found in html/individual_list_page.go - About 1 hr to fix

    Method Publisher.Places has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.
    Open

    func (publisher *Publisher) Places() map[string]*place {
    if publisher.placesMap == nil {
        publisher.placesMap = map[string]*place{}

        // Get all of the unique place names.
    Severity: Minor
    Found in html/publish.go - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method Number.UpperRoman has 59 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func (n Number) UpperRoman() (string, error) {
    // Catch edge cases first.
    switch {
    case n == 0:
        return "N", nil
    Severity: Minor
    Found in number.go - About 1 hr to fix

      Method IndividualEvents.WriteHTMLTo has 57 lines of code (exceeds 50 allowed). Consider refactoring.
      Open

      func (c *IndividualEvents) WriteHTMLTo(w io.Writer) (int64, error) {
    var events []core.Component

    for _, event := range c.individual.AllEvents() {
        date, place := gedcom.DateAndPlace(event)
      Severity: Minor
      Found in html/individual_events.go - About 1 hr to fix

        Method DiffPage.WriteHTMLTo has 55 lines of code (exceeds 50 allowed). Consider refactoring.
        Open

        func (c *DiffPage) WriteHTMLTo(w io.Writer) (int64, error) {
    if c.progress != nil {
        c.progress <- gedcom.Progress{
            Total: int64(len(c.comparisons)),
        }
        Severity: Minor
        Found in html/diff_page.go - About 1 hr to fix

          Your code does not pass gofmt in 14 places. Go fmt your code!
          Open

          // Package q is the "gedcom query" parser and engine.
          Severity: Minor
          Found in q/doc.go by gofmt

          Method IndividualNode.incorrectEventOrderWarnings has 54 lines of code (exceeds 50 allowed). Consider refactoring.
          Open

          func (node *IndividualNode) incorrectEventOrderWarnings() (warnings Warnings) {
    // Event order describes the boundaries of groups of events. That is to say
    // that any baptism or LDS baptism events must be after a birth event but
    // also much be before the any death event.
    eventOrder := []*struct {
          Severity: Minor
          Found in individual_node.go - About 1 hr to fix

            Method FamilyNode.siblingsBornTooCloseWarnings has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.
            Open

            func (node *FamilyNode) siblingsBornTooCloseWarnings() (warnings Warnings) {
    pairs := IndividualNodePairs{}
    nineMonths := time.Duration(274 * 24 * time.Hour)
    twoDays := time.Duration(2 * 24 * time.Hour)
            Severity: Minor
            Found in family_node.go - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method PartnersAndChildren.WriteHTMLTo has 51 lines of code (exceeds 50 allowed). Consider refactoring.
            Open

            func (c *PartnersAndChildren) WriteHTMLTo(w io.Writer) (int64, error) {
    heading := core.NewHeading(2, "", core.NewText("Spouses & Children"))
    column := core.NewColumn(core.EntireRow, heading)

    rows := []core.Component{
            Severity: Minor
            Found in html/partners_and_children.go - About 1 hr to fix

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

              func (node *FamilyNode) Husband() (husband *HusbandNode) {
    if node == nil {
        return nil
    }
              Severity: Major
              Found in family_node.go and 1 other location - About 1 hr to fix
              family_node.go on lines 48..69

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

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

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

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

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

              Refactorings

              Further Reading

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

              func (node *FamilyNode) Wife() (wife *WifeNode) {
    if node == nil {
        return nil
    }
              Severity: Major
              Found in family_node.go and 1 other location - About 1 hr to fix
              family_node.go on lines 24..45

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

              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

                  if death, _ := node.Death(); death != nil && death.DateRange().IsValid() {
        dateParts = append(dateParts, fmt.Sprintf("d. %s", death.String()))
    } else if burial, _ := node.Burial(); burial != nil && burial.DateRange().IsValid() {
        dateParts = append(dateParts, fmt.Sprintf("bur. %s", burial.String()))
    }
              Severity: Minor
              Found in individual_node.go and 1 other location - About 1 hr to fix
              individual_node.go on lines 804..808

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

              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

                  if birth, _ := node.Birth(); birth != nil && birth.DateRange().IsValid() {
        dateParts = append(dateParts, fmt.Sprintf("b. %s", birth.String()))
    } else if baptism, _ := node.Baptism(); baptism != nil && baptism.DateRange().IsValid() {
        dateParts = append(dateParts, fmt.Sprintf("bap. %s", baptism.String()))
    }
              Severity: Minor
              Found in individual_node.go and 1 other location - About 1 hr to fix
              individual_node.go on lines 810..814

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

              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

              Method IndividualNodesCompareOptions.calculateWinners has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
              Open

              func (o *IndividualNodesCompareOptions) calculateWinners(a, b IndividualNodes, similarityResults chan *IndividualComparison, options SimilarityOptions) chan *IndividualComparison {
    // See description in createJobs().
    winners := make(chan *IndividualComparison, 1000)

    go func() {
              Severity: Minor
              Found in individual_nodes.go - About 55 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function NewDiffPage has 7 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              func NewDiffPage(comparisons gedcom.IndividualComparisons, filterFlags *gedcom.FilterFlags, googleAnalyticsID string, show, sort string, progress chan gedcom.Progress, compareOptions *gedcom.IndividualNodesCompareOptions, visibility LivingVisibility) *DiffPage {
              Severity: Major
              Found in html/diff_page.go - About 50 mins to fix

                Function runDiffCommand has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.
                Open

                func runDiffCommand() {
    var optionLeftGedcomFile string
    var optionRightGedcomFile string
    var optionOutputFile string
    var optionShow string // see optionShow constants.
                Severity: Minor
                Found in cmd/gedcom/diff.go - About 45 mins to fix

                Cognitive Complexity

                Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                A method's cognitive complexity is based on a few simple rules:

                • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                • Code is considered more complex for each "break in the linear flow of the code"
                • Code is considered more complex when "flow breaking structures are nested"

                Further reading

                Method LastExpr.Evaluate has 7 return statements (exceeds 4 allowed).
                Open

                func (e *LastExpr) Evaluate(engine *Engine, input interface{}, args []*Statement) (interface{}, error) {
    in := reflect.ValueOf(input)

    if len(args) != 1 {
        return nil, errors.New("function Last() must take a single argument")
                Severity: Major
                Found in q/last_expr.go - About 45 mins to fix

                  Function NewPublishHeader has 6 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                  func NewPublishHeader(document *gedcom.Document, extraTab string, selectedTab string, options *PublishShowOptions, indexLetters []rune, placesMap map[string]*place) *PublishHeader {
                  Severity: Minor
                  Found in html/publish_header.go - About 45 mins to fix

                    Function NewIndividualListPage has 6 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                    func NewIndividualListPage(document *gedcom.Document, selectedLetter rune, googleAnalyticsID string, options *PublishShowOptions, indexLetters []rune, placesMap map[string]*place) *IndividualListPage {
                    Severity: Minor
                    Found in html/individual_list_page.go - About 45 mins to fix

                      Function NewPlacePage has 6 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                      func NewPlacePage(document *gedcom.Document, placeKey string, googleAnalyticsID string, options *PublishShowOptions, indexLetters []rune, placesMap map[string]*place) *PlacePage {
                      Severity: Minor
                      Found in html/place_page.go - About 45 mins to fix
                        Severity
                        Category
                        Status
                        Source
                        Language