openSUSE/open-build-service

View on GitHub
src/api/app/controllers/webui/project_controller.rb

Summary

Maintainability
F
6 days
Test Coverage

File project_controller.rb has 785 lines of code (exceeds 250 allowed). Consider refactoring.
Open

class Webui::ProjectController < Webui::WebuiController
  require_dependency 'opensuse/validator'
  include Webui::RequestHelper
  include Webui::ProjectHelper
  include Webui::ManageRelationships
Severity: Major
Found in src/api/app/controllers/webui/project_controller.rb - About 1 day to fix

    Class ProjectController has 67 methods (exceeds 20 allowed). Consider refactoring.
    Open

    class Webui::ProjectController < Webui::WebuiController
      require_dependency 'opensuse/validator'
      include Webui::RequestHelper
      include Webui::ProjectHelper
      include Webui::ManageRelationships
    Severity: Major
    Found in src/api/app/controllers/webui/project_controller.rb - About 1 day to fix

      Method status_filter_packages has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
      Open

        def status_filter_packages
          filter_for_user = User.find_by_login!(@filter_for_user) if @filter_for_user.present?
          current_develproject = @filter || @all_projects
          @develprojects = {}
          packages_to_filter_for = nil
      Severity: Minor
      Found in src/api/app/controllers/webui/project_controller.rb - About 3 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 status_check_package has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

        def status_check_package(p)
          currentpack = {}
          pname = p.name
      
          currentpack['requests_from'] = []
      Severity: Minor
      Found in src/api/app/controllers/webui/project_controller.rb - About 3 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 check_devel_package_status has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
      Open

        def check_devel_package_status(currentpack, p)
          dp = p.develpack
          return unless dp
          dproject = dp.project
          currentpack['develproject'] = dproject
      Severity: Minor
      Found in src/api/app/controllers/webui/project_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

      Method monitor_parse_result has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
      Open

        def monitor_parse_result(result)
          repo = result['repository']
          arch = result['arch']
      
          return unless @repo_filter.nil? || @repo_filter.include?(repo)
      Severity: Minor
      Found in src/api/app/controllers/webui/project_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

      Method monitor_set_filter has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
      Open

        def monitor_set_filter(defaults)
          @avail_status_values = Buildresult.avail_status_values
          @status_filter = []
          @avail_status_values.each do |s|
            id = s.delete(' ')
      Severity: Minor
      Found in src/api/app/controllers/webui/project_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

      Method status_check_package has 38 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        def status_check_package(p)
          currentpack = {}
          pname = p.name
      
          currentpack['requests_from'] = []
      Severity: Minor
      Found in src/api/app/controllers/webui/project_controller.rb - About 1 hr to fix

        Method filter_matches? has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
        Open

          def filter_matches?(input, filter_string)
            result = false
            filter_string.gsub!(/\s*/, '')
            filter_string.split(',').each do |filter|
              no_invert = filter.match(/(^!?)(.+)/)
        Severity: Minor
        Found in src/api/app/controllers/webui/project_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

        Method new_release_request has 31 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def new_release_request
            if params[:skiprequest]
              # FIXME2.3: do it directly here, api function missing
            else
              begin
        Severity: Minor
        Found in src/api/app/controllers/webui/project_controller.rb - About 1 hr to fix

          Method status has 29 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            def status
              all_packages = 'All Packages'
              no_project = 'No Project'
              @no_project = '_none_'
              @all_projects = '_all_'
          Severity: Minor
          Found in src/api/app/controllers/webui/project_controller.rb - About 1 hr to fix

            Method status_filter_packages has 27 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              def status_filter_packages
                filter_for_user = User.find_by_login!(@filter_for_user) if @filter_for_user.present?
                current_develproject = @filter || @all_projects
                @develprojects = {}
                packages_to_filter_for = nil
            Severity: Minor
            Found in src/api/app/controllers/webui/project_controller.rb - About 1 hr to fix

              Method create has 26 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                def create
                  # ns means namespace / parent project
                  params[:project][:name] = "#{params[:ns]}:#{params[:project][:name]}" if params[:ns]
              
                  @project = Project.new(project_params)
              Severity: Minor
              Found in src/api/app/controllers/webui/project_controller.rb - About 1 hr to fix

                Method check_devel_package_status has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  def check_devel_package_status(currentpack, p)
                    dp = p.develpack
                    return unless dp
                    dproject = dp.project
                    currentpack['develproject'] = dproject
                Severity: Minor
                Found in src/api/app/controllers/webui/project_controller.rb - About 1 hr to fix

                  Method monitor_buildresult has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                  Open

                    def monitor_buildresult
                      @legend = Buildresult::STATUS_DESCRIPTION
                  
                      @name_filter = params[:pkgname]
                      @lastbuild_switch = params[:lastbuild]
                  Severity: Minor
                  Found in src/api/app/controllers/webui/project_controller.rb - About 55 mins 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 status_gather_requests has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                  Open

                    def status_gather_requests
                      # we do not filter requests for project because we need devel projects too later on and as long as the
                      # number of open requests is limited this is the easiest solution
                      raw_requests = BsRequest.order(:number).where(state: [:new, :review, :declined]).joins(:bs_request_actions).
                                     where(bs_request_actions: { type: 'submit' }).pluck('bs_requests.number', 'bs_requests.state',
                  Severity: Minor
                  Found in src/api/app/controllers/webui/project_controller.rb - About 55 mins 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 create has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                  Open

                    def create
                      # ns means namespace / parent project
                      params[:project][:name] = "#{params[:ns]}:#{params[:project][:name]}" if params[:ns]
                  
                      @project = Project.new(project_params)
                  Severity: Minor
                  Found in src/api/app/controllers/webui/project_controller.rb - About 55 mins 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

                  Consider simplifying this complex logical expression.
                  Open

                      return unless currentpack['firstfail'] || currentpack['failedcomment'] || currentpack['upstream_version'] ||
                                    !currentpack['problems'].empty? || !currentpack['requests_from'].empty? || !currentpack['requests_to'].empty?
                  Severity: Major
                  Found in src/api/app/controllers/webui/project_controller.rb - About 40 mins to fix

                    Method project_status_set_version has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                    Open

                      def project_status_set_version(p)
                        ret = {}
                        ret['version'] = p.version
                        if p.upstream_version
                          begin
                    Severity: Minor
                    Found in src/api/app/controllers/webui/project_controller.rb - About 25 mins 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

                    There are no issues that match your filters.

                    Category
                    Status