meurio/verdade-ou-consequencia

View on GitHub

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 */

Severity: Major
Found in app/assets/javascripts/jquery-ui.js - About 5 days to fix

    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
    Severity: Major
    Found in app/assets/javascripts/jquery-ui.js - About 7 hrs to fix

      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 );
          }
      
      
      Severity: Major
      Found in app/assets/javascripts/jquery-ui.js - About 5 hrs to fix

        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")
        Severity: Minor
        Found in app/models/user.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 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)
        Severity: Major
        Found in app/assets/javascripts/jquery-ui.js - About 3 hrs to fix

          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
          Severity: Major
          Found in app/assets/javascripts/jquery-ui.js - About 3 hrs to fix

            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 ) {
            Severity: Major
            Found in app/assets/javascripts/jquery-ui.js - About 2 hrs to fix

              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 = ''
              Severity: Minor
              Found in app/models/candidate.rb - About 2 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 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
              Severity: Minor
              Found in app/controllers/main_controller.rb - About 2 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 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;
              Severity: Major
              Found in app/assets/javascripts/jquery-ui.js - About 2 hrs to fix

                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")
                Severity: Major
                Found in app/models/user.rb - About 2 hrs to fix

                  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']
                  Severity: Minor
                  Found in app/controllers/sessions_controller.rb - About 2 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 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 );
                  Severity: Minor
                  Found in app/assets/javascripts/jquery-ui.js - About 1 hr to fix

                    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'
                    Severity: Minor
                    Found in app/controllers/users_controller.rb - 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

                    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({
                    Severity: Minor
                    Found in app/assets/stylesheets/cidades.js - About 1 hr to fix

                      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;
                      
                      
                      Severity: Minor
                      Found in app/assets/javascripts/jquery-ui.js - About 1 hr to fix

                        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 );
                        Severity: Minor
                        Found in app/assets/javascripts/jquery-ui.js - About 1 hr to fix

                          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(
                          Severity: Minor
                          Found in app/models/user.rb - About 1 hr to fix

                            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
                            Severity: Minor
                            Found in app/assets/javascripts/jquery-ui.js - About 1 hr to fix

                              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(
                              Severity: Minor
                              Found in app/models/user.rb - 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

                              Severity
                              Category
                              Status
                              Source
                              Language