discourse/discourse

View on GitHub

Showing 1,411 of 1,710 total issues

Class Post has 75 methods (exceeds 20 allowed). Consider refactoring.
Open

class Post < ActiveRecord::Base
  # TODO: Remove this after 19th Dec 2018
  self.ignored_columns = %w{vote_count}

  include RateLimiter::OnCreateRecord
Severity: Major
Found in app/models/post.rb - About 1 day to fix

    Method destroy has a Cognitive Complexity of 70 (exceeds 5 allowed). Consider refactoring.
    Open

      def destroy(user, opts = {})
        raise Discourse::InvalidParameters.new('user is nil') unless user && user.is_a?(User)
        raise PostsExistError if !opts[:delete_posts] && user.posts.count != 0
        @guardian.ensure_can_delete_user!(user)
    
    
    Severity: Minor
    Found in app/services/user_destroyer.rb - About 1 day 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 send_notification_email has a Cognitive Complexity of 69 (exceeds 5 allowed). Consider refactoring.
    Open

      def send_notification_email(opts)
        post = opts[:post]
        title = opts[:title]
    
        allow_reply_by_email = opts[:allow_reply_by_email]
    Severity: Minor
    Found in app/mailers/user_notifications.rb - About 1 day 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

    File posts_controller.rb has 598 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    require_dependency 'new_post_manager'
    require_dependency 'post_creator'
    require_dependency 'post_destroyer'
    require_dependency 'post_merger'
    require_dependency 'distributed_memoizer'
    Severity: Major
    Found in app/controllers/posts_controller.rb - About 1 day to fix

      Class Instance has 70 methods (exceeds 20 allowed). Consider refactoring.
      Open

      class Plugin::Instance
      
        attr_accessor :path, :metadata
        attr_reader :admin_route
      
      
      Severity: Major
      Found in lib/plugin/instance.rb - About 1 day to fix

        Method post_process_oneboxes has a Cognitive Complexity of 65 (exceeds 5 allowed). Consider refactoring.
        Open

          def post_process_oneboxes
            limit = SiteSetting.max_oneboxes_per_post
            oneboxes = {}
            inlineOneboxes = {}
        
        
        Severity: Minor
        Found in lib/cooked_post_processor.rb - About 1 day 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

        File group.rb has 591 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        require_dependency 'enum'
        
        class Group < ActiveRecord::Base
          include HasCustomFields
          include AnonCacheInvalidator
        Severity: Major
        Found in app/models/group.rb - About 1 day to fix

          Method password_reset has a Cognitive Complexity of 63 (exceeds 5 allowed). Consider refactoring.
          Open

            def password_reset
              expires_now
          
              token = params[:token]
          
          
          Severity: Minor
          Found in app/controllers/users_controller.rb - About 1 day 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

          File application_controller.rb has 579 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          require 'current_user'
          require_dependency 'canonical_url'
          require_dependency 'discourse'
          require_dependency 'custom_renderer'
          require_dependency 'archetype'
          Severity: Major
          Found in app/controllers/application_controller.rb - About 1 day to fix

            File track_selector_spec.rb has 571 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            require 'rails_helper'
            
            describe DiscourseNarrativeBot::TrackSelector do
              let(:user) { Fabricate(:user) }
              let(:discobot_user) { User.find(-2) }

              Method show has a Cognitive Complexity of 60 (exceeds 5 allowed). Consider refactoring.
              Open

                def show
                  if request.referer
                    flash["referer"] ||= request.referer[0..255]
                  end
              
              
              Severity: Minor
              Found in app/controllers/topics_controller.rb - About 1 day 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

              File user_notifications.rb has 558 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              require_dependency 'markdown_linker'
              require_dependency 'email/message_builder'
              require_dependency 'age_words'
              require_dependency 'rtl'
              require_dependency 'discourse_ip_info'
              Severity: Major
              Found in app/mailers/user_notifications.rb - About 1 day to fix

                Class TopicView has 64 methods (exceeds 20 allowed). Consider refactoring.
                Open

                class TopicView
                  MEGA_TOPIC_POSTS_COUNT = 10000
                
                  attr_reader :topic, :posts, :guardian, :filtered_posts, :chunk_size, :print, :message_bus_last_id
                  attr_accessor :draft, :draft_key, :draft_sequence, :user_custom_fields, :post_custom_fields, :post_number
                Severity: Major
                Found in lib/topic_view.rb - About 1 day to fix

                  Class PostSerializer has 63 methods (exceeds 20 allowed). Consider refactoring.
                  Open

                  class PostSerializer < BasicPostSerializer
                  
                    # To pass in additional information we might need
                    INSTANCE_VARS ||= [
                      :topic_view,
                  Severity: Major
                  Found in app/serializers/post_serializer.rb - About 1 day to fix

                    Class ApplicationController has 61 methods (exceeds 20 allowed). Consider refactoring.
                    Open

                    class ApplicationController < ActionController::Base
                      include CurrentUser
                      include CanonicalURL::ControllerExtensions
                      include JsonError
                      include GlobalPath
                    Severity: Major
                    Found in app/controllers/application_controller.rb - About 1 day to fix

                      Method send has a Cognitive Complexity of 56 (exceeds 5 allowed). Consider refactoring.
                      Open

                          def send
                            return if SiteSetting.disable_emails == "yes" && @email_type.to_s != "admin_login"
                      
                            return if ActionMailer::Base::NullMail === @message
                            return if ActionMailer::Base::NullMail === (@message.message rescue nil)
                      Severity: Minor
                      Found in lib/email/sender.rb - About 1 day 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 TopicsController has 60 methods (exceeds 20 allowed). Consider refactoring.
                      Open

                      class TopicsController < ApplicationController
                        requires_login only: [
                          :timings,
                          :destroy_timings,
                          :update,
                      Severity: Major
                      Found in app/controllers/topics_controller.rb - About 1 day to fix

                        Method resolve has a Cognitive Complexity of 54 (exceeds 5 allowed). Consider refactoring.
                        Open

                          def resolve
                            if @uri && @uri.port == 80 && FinalDestination.is_https_domain?(@uri.hostname)
                              @uri.scheme = "https"
                              @uri = URI(@uri.to_s)
                            end
                        Severity: Minor
                        Found in lib/final_destination.rb - About 1 day 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

                        File advanced_user_narrative_spec.rb has 516 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        require 'rails_helper'
                        
                        RSpec.describe DiscourseNarrativeBot::AdvancedUserNarrative do
                          let(:discobot_user) { User.find(-2) }
                          let(:first_post) { Fabricate(:post, user: discobot_user) }

                          File post_action.rb has 516 lines of code (exceeds 250 allowed). Consider refactoring.
                          Open

                          require_dependency 'rate_limiter'
                          require_dependency 'system_message'
                          
                          class PostAction < ActiveRecord::Base
                            class AlreadyActed < StandardError; end
                          Severity: Major
                          Found in app/models/post_action.rb - About 1 day to fix
                            Severity
                            Category
                            Status
                            Source
                            Language