Showing 40 of 62 total issues
File jquery-ui.js
has 1958 lines of code (exceeds 250 allowed). Consider refactoring. Open
/*! jQuery UI - v1.12.0 - 2016-08-19
* http://jqueryui.com
* Includes: widget.js, position.js, keycode.js, unique-id.js, widgets/autocomplete.js, widgets/menu.js
* Copyright jQuery Foundation and other contributors; Licensed MIT */
Function _create
has 189 lines of code (exceeds 25 allowed). Consider refactoring. Open
_create: function() {
// Some browsers only repeat keydown events, not keypress events,
// so we use the suppressKeyPress flag to determine if we've already
// handled the keydown event. #7269
Function position
has 149 lines of code (exceeds 25 allowed). Consider refactoring. Open
$.fn.position = function( options ) {
if ( !options || !options.of ) {
return _position.apply( this, arguments );
}
Method subscribe_all
has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring. Open
def self.subscribe_all
lista_segmentos = segment_list
cidades = City.joins("inner join candidates on (candidates.city_id = cities.id) group by cities.id having count(*) > 1")
usuarios = User.where("id not in (select id from candidates) and city_id is not null")
- 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 widget
has 77 lines of code (exceeds 25 allowed). Consider refactoring. Open
$.widget = function( name, base, prototype ) {
var existingConstructor, constructor, basePrototype;
// ProxiedPrototype allows the provided prototype to remain unmodified
// so that it can be used as a mixin for multiple widgets (#8876)
Function _create
has 75 lines of code (exceeds 25 allowed). Consider refactoring. Open
_create: function() {
this.activeMenu = this.element;
// Flag used to prevent firing of the click handler
// as the event bubbles up through nested menus
Function _keydown
has 68 lines of code (exceeds 25 allowed). Consider refactoring. Open
_keydown: function( event ) {
var match, prev, character, skip,
preventDefault = true;
switch ( event.keyCode ) {
Method subscribe_all
has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring. Open
def self.subscribe_all
lista_segmentos = segment_list
cands = Candidate.where("nickname is not null and party_id is not null and city_id is not null").
each{ |c|
alvo = ''
- 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 index
has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring. Open
def index
if session[:candidate_id]
candidate_id = session[:candidate_id]
if not Candidate.exists? candidate_id
reset_session
- 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 keydown
has 53 lines of code (exceeds 25 allowed). Consider refactoring. Open
keydown: function( event ) {
if ( this.element.prop( "readOnly" ) ) {
suppressKeyPress = true;
suppressInput = true;
suppressKeyPressRepeat = true;
Method subscribe_all
has 53 lines of code (exceeds 25 allowed). Consider refactoring. Open
def self.subscribe_all
lista_segmentos = segment_list
cidades = City.joins("inner join candidates on (candidates.city_id = cities.id) group by cities.id having count(*) > 1")
usuarios = User.where("id not in (select id from candidates) and city_id is not null")
Method create
has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring. Open
def create
# Now we can identify if login is from an user or from an candidate
# type = "user" ou "candidate"
type = request.env['omniauth.params']["type"]
auth = request.env['omniauth.auth']
- 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 bridge
has 48 lines of code (exceeds 25 allowed). Consider refactoring. Open
$.widget.bridge = function( name, object ) {
var fullName = object.prototype.widgetFullName || name;
$.fn[ name ] = function( options ) {
var isMethodCall = typeof options === "string";
var args = widgetSlice.call( arguments, 1 );
Method matchup
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
def matchup
@user = nil
@user = User.find params[:user_id] if User.exists? params[:user_id]
if @user == nil
flash[:error] = 'Usuário inexistente'
- 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 ligaCidades
has 46 lines of code (exceeds 25 allowed). Consider refactoring. Open
var ligaCidades = function(componenteBusca, selecionaValores) {
cBusca = $( componenteBusca );
cBusca.autocomplete({
source: function( request, response ) {
$.ajax({
Function name
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
$.fn[ name ] = function( options ) {
var isMethodCall = typeof options === "string";
var args = widgetSlice.call( arguments, 1 );
var returnValue = this;
Function refresh
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
refresh: function() {
var menus, items, newSubmenus, newItems, newWrappers,
that = this,
icon = this.options.icons.submenu,
submenus = this.element.find( this.options.menus );
Method matches
has 44 lines of code (exceeds 25 allowed). Consider refactoring. Open
def matches
ors = answers.select{|a| a.weight > 0}.map{|a| "ca.question_id = #{a.question_id}"}.join(" or ")
ors = "1=1" if (ors == '')
match_data = Candidate.
select(
Function _on
has 38 lines of code (exceeds 25 allowed). Consider refactoring. Open
_on: function( suppressDisabledCheck, element, handlers ) {
var delegateElement;
var instance = this;
// No suppressDisabledCheck flag, shuffle arguments
Method matches
has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring. Open
def matches
ors = answers.select{|a| a.weight > 0}.map{|a| "ca.question_id = #{a.question_id}"}.join(" or ")
ors = "1=1" if (ors == '')
match_data = Candidate.
select(
- 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"