Showing 740 of 12,584 total issues
Method included_annotator_facets
has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring. Open
def self.included_annotator_facets
f = [
::Queries::Concerns::Users
]
- Read upRead up
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 build_collecting_events
has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring. Open
def build_collecting_events
# DRMFieldNumbers DRMFN
namespace_drm_field_numbers = Namespace.find_by(name: 'DRMFieldNumbers')
@total_data_lines = 0
- Read upRead up
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
Consider simplifying this complex logical expression. Open
if (name =~ /^[a-zA-Z]*$/) || # !! should reference NOT_LATIN
(nomenclatural_code == :iczn && name =~ /^[a-zA-Z]-[a-zA-Z]*$/) ||
(nomenclatural_code == :icnp && name =~ /^[a-zA-Z]-[a-zA-Z]*$/) ||
(nomenclatural_code == :icn && name =~ /^[a-zA-Z]*-[a-zA-Z]*$/) ||
(nomenclatural_code == :icn && name =~ /^[a-zA-Z]*\s×\s[a-zA-Z]*$/) ||
Method gpx_to_csv
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. 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
- Read upRead up
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 hunt_lat_long
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. Open
def self.hunt_lat_long(label, how = ' ')
if how.nil?
pieces = [label]
else
pieces = label.split(how)
- Read upRead up
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 extract_dates
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. Open
def self.extract_dates(trial, match_data)
end_date_year, end_date_month, end_date_day = 0, 0, 0
case trial[:method].downcase.to_sym
when :month_dd_yyyy_2
start_date_year = 3
- Read upRead up
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
File image_matrix.rb
has 302 lines of code (exceeds 250 allowed). Consider refactoring. Open
class Tools::ImageMatrix
##### FILTER PARAMETERS #####
# @!observation_matrix_id
Function makeInitialState
has 80 lines of code (exceeds 25 allowed). Consider refactoring. Open
function makeInitialState() {
return reactive({
settings: {
increment: false,
isLocked: false,
Method create_quick_verbatim
has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring. Open
def self.create_quick_verbatim(options = {})
# We could refactor this to use nested attributes, but it's not that much cleaner
opts = {
'collection_objects' => {},
'note' => nil,
- Read upRead up
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 initializeGoogleMap
has 77 lines of code (exceeds 25 allowed). Consider refactoring. Open
initializeGoogleMap: function (map_canvas, fcdata, map_center) {
// does this need to be set? would it alter fcdata if not set?
var mapData = fcdata;
//
Function initializeDrawingManager
has 77 lines of code (exceeds 25 allowed). Consider refactoring. Open
initializeDrawingManager: function (map, mapDrawingModes) {
var drawingMode = undefined; // "active: circle, polygon, circle" results in hand, polygon, circle(selected)
var drawingModes = []; // "polygon, circle" results in hand(active), polygon, circle in draw mode menu
var i; // loop counter
var j = 0; // offset for start of i-loop when ACTIVE:mode has explicit position
File task-filter.js
has 294 lines of code (exceeds 250 allowed). Consider refactoring. Open
var CarrouselTask = function (sec, rows, columns) {
// sec = Name of data section, this is for identify div.
// rows = This is for the number of rows that will be displayed, if this number is less than the number of items, it will activate the navigation controls
this.children = []
Method eml
has 76 lines of code (exceeds 25 allowed). Consider refactoring. Open
def eml
return @eml if @eml
@eml = Tempfile.new('eml.xml')
# This may need to be logged somewhere
Class LeadsController
has 26 methods (exceeds 20 allowed). Consider refactoring. Open
class LeadsController < ApplicationController
include DataControllerConfiguration::ProjectDataControllerConfiguration
before_action :set_lead, only: %i[
edit create_for_edit update destroy show show_all show_all_print all_texts
destroy_couplet insert_couplet delete_couplet duplicate update_meta otus]
Class Autocomplete
has 26 methods (exceeds 20 allowed). Consider refactoring. Open
class Autocomplete < Query::Autocomplete
# Either match against all Sources (default) or just those with ProjectSource
# @return [Boolean]
# @param limit_to_project [String] `true` or `false`
Method build_collecting_events
has 74 lines of code (exceeds 25 allowed). Consider refactoring. Open
def build_collecting_events
# DRMFieldNumbers DRMFN
namespace_drm_field_numbers = Namespace.find_by(name: 'DRMFieldNumbers')
@total_data_lines = 0
File pinboard.js
has 289 lines of code (exceeds 250 allowed). Consider refactoring. Open
var TW = TW || {}
TW.workbench = TW.workbench || {}
TW.workbench.pinboard = TW.workbench.pinboard || {}
Object.assign(TW.workbench.pinboard, {
Method set_cached_names_for_taxon_names
has 73 lines of code (exceeds 25 allowed). Consider refactoring. Open
def set_cached_names_for_taxon_names
begin
TaxonName.transaction_with_retry do
t = taxon_name
Method sv_potential_family_homonyms
has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring. Open
def sv_potential_family_homonyms
if persisted? && is_family_rank? && is_available?
if TaxonNameRelationship.where_subject_is_taxon_name(self).homonym_or_suppressed.empty?
if self.id == self.lowest_rank_coordinated_taxon.id
name2 = self.cached_primary_homonym_alternative_spelling ? self.cached_primary_homonym_alternative_spelling : nil
- Read upRead up
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 descriptors_hash_initiate
has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring. Open
def descriptors_hash_initiate
h = {}
# Depictions is depictions with other attributes added
depictions = nil
- Read upRead up
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"