Sign upLogin

SpeciesFileGroup/taxonworks

View on GitHub
Star

Showing 928 of 12,577 total issues

Method has too many lines. [56/25]
Open

  def self.gpx_to_csv(gpx_file, csv_options = {col_sep: "\t", headers: true, encoding: 'UTF-8', write_headers: true})
    gpx_headers = %w(name geojson start_date end_date minimum_elevation maximum_elevation)

    csv_string = CSV.generate(**csv_options) do |csv|
      csv << gpx_headers
Severity: Minor
Found in lib/vendor/gpx_to_csv.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Class Autocomplete has 39 methods (exceeds 20 allowed). Consider refactoring.
Open

  class Query::Autocomplete < Queries::Query

    include Arel::Nodes

    include Queries::Concerns::Identifiers
Severity: Minor
Found in lib/queries/query/autocomplete.rb - About 5 hrs to fix

    Class Result has 39 methods (exceeds 20 allowed). Consider refactoring.
    Open

        class Result
      # query string
      attr_accessor :name

      # how to match
    Severity: Minor
    Found in lib/vendor/biodiversity.rb - About 5 hrs to fix

      Method has too many lines. [55/25]
      Open

        def self.generate(otus, project_members, reference_csv = nil )
    ::CSV.generate(col_sep: "\t") do |csv|

      csv << %w{
        ID
      Severity: Minor
      Found in lib/export/coldp/files/type_material.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Method using_iccn_class has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
      Open

        def using_iccn_class
    unless identifier.nil?
      lccn = identifier

      # '200112345', '2010549727', '2003064850', '|a  2003064850', '88156495', '68-004897', '2001-459440'
      Severity: Minor
      Found in app/models/identifier/global/lccn.rb - About 5 hrs 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 handleEvents has 127 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      FilterHub.prototype.handleEvents = function (that) {
  const elements = [...document.querySelectorAll('#task_carrousel')]

  that.arrayTasks = elements.map(
    (element) =>
      Severity: Major
      Found in app/assets/javascripts/views/hub/filterHub.js - About 5 hrs to fix

        Method has too many lines. [54/25]
        Open

            def build_sequence_relationships
      @total_data_lines = 0
      i = 0
      gene_descriptors = {}
      gene_attributes = {}
        Severity: Minor
        Found in lib/batch_load/import/sequence_relationships/primers_interpreter.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Method has too many lines. [54/25]
        Open

            def self.significant_digits(number_string)
      # is there a decimal point?
      intg = ''
      decimal_point_zeros = ''
      mantissa = ''
        Severity: Minor
        Found in lib/utilities/geo.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Method has too many lines. [53/25]
        Open

          def perform_staging
    records, headers = get_records(source.path)

    update!(metadata:
      metadata.merge({
        Severity: Minor
        Found in app/models/import_dataset/darwin_core/occurrences.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        File dwc_extensions.rb has 371 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        module FieldOccurrence::DwcExtensions

  extend ActiveSupport::Concern

  # include FieldOccurrence::DwcExtensions::TaxonworksExtensions
        Severity: Minor
        Found in app/models/field_occurrence/dwc_extensions.rb - About 4 hrs to fix

          Method has too many lines. [52/25]
          Open

            def get_diffs version_new, version_old
    added_strings = []
    added_strings_indices = []
    deleted_strings = []
    deleted_strings_indices = []
          Severity: Minor
          Found in app/helpers/plugins/papertrail_helper.rb by rubocop

          This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

          Function makeInitialState has 120 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          function makeInitialState() {
  return {
    loadState: {
      assertedDistribution: false,
      biologicalAssociations: true,
          Severity: Major
          Found in app/javascript/vue/tasks/otu/browse/store/store.js - About 4 hrs to fix

            Function init has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
            Open

              init: function () {
    let softValidations

    function fillSoftValidation() {
      if (!softValidations) {
            Severity: Minor
            Found in app/assets/javascripts/views/tasks/nomenclature/browse.js - About 4 hrs 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 add_original_combination has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
            Open

              def self.add_original_combination(t, csv, origin_citation, name_remarks_vocab_id, project_members)
    e = t.original_combination_elements

    infraspecific_element = t.original_combination_infraspecific_element(e, remove_sic: true)
            Severity: Minor
            Found in lib/export/coldp/files/name.rb - About 4 hrs 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 has too many lines. [51/25]
            Open

                def build
      v = object.valid_taxon_name
      base_names = v.historical_taxon_names

      base_names.each do |t|
            Severity: Minor
            Found in lib/catalog/nomenclature/entry.rb by rubocop

            This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

            Method has too many lines. [50/25]
            Open

              def row_hash_initiate
    h = {}
    rows = nil # Of either Otu or ObservationMatrixRow of type Otu !! TODO:
    if observation_matrix_id.to_i == 0 && !otu_filter.blank?
            Severity: Minor
            Found in lib/tools/image_matrix.rb by rubocop

            This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

            Class Data has 35 methods (exceeds 20 allowed). Consider refactoring.
            Open

              class Data

    attr_accessor :data

    attr_accessor :eml
            Severity: Minor
            Found in lib/export/dwca/data.rb - About 4 hrs to fix

              Method sv_species_gender_agreement has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
              Open

                  def sv_species_gender_agreement
      if is_species_rank?
        s = part_of_speech_name
        if !s.nil? && is_available?
          if %w{adjective participle}.include?(s)
              Severity: Minor
              Found in app/models/protonym/soft_validation_extensions.rb - About 4 hrs 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

              Class TaxonNameClassification has 34 methods (exceeds 20 allowed). Consider refactoring.
              Open

              class TaxonNameClassification < ApplicationRecord
  include Housekeeping
  include Shared::Citations
  include Shared::Notes
  include Shared::IsData
              Severity: Minor
              Found in app/models/taxon_name_classification.rb - About 4 hrs to fix

                Class Filter has 34 methods (exceeds 20 allowed). Consider refactoring.
                Open

                  class Query::Filter < Queries::Query

    include Queries::Concerns::Users
    # include Queries::Concerns::Identifiers # Presently in Queries for other use in autocompletes
                Severity: Minor
                Found in lib/queries/query/filter.rb - About 4 hrs to fix
                  Severity
                  Category
                  Status
                  Source
                  Language