Sign upLogin

openSUSE/open-build-service

View on GitHub
Star

Showing 391 of 425 total issues

Method start has 30 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    def self.start(options = {})
      return unless Rails.env.test?
      return if @backend
      return if ENV['BACKEND_STARTED']
Severity: Minor
Found in src/api/app/lib/backend/test.rb - About 1 hr to fix

    Method rdiff has 30 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      def rdiff
    @last_rev = @package.dir_hash['rev']
    @linkinfo = @package.linkinfo
    if params[:oproject]
      @oproject = ::Project.find_by_name(params[:oproject])
    Severity: Minor
    Found in src/api/app/controllers/webui/package_controller.rb - About 1 hr to fix

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

        def gather_exception_defaults(opt)
    if opt[:message]
      @summary = opt[:message].to_s
    elsif @exception
      @summary = @exception.message
      Severity: Minor
      Found in src/api/app/controllers/application_controller.rb - About 1 hr to fix

        Method parse_single_bugzilla_issue has 28 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def parse_single_bugzilla_issue(bugzilla_response)
    issue = Issue.find_by_name_and_tracker(bugzilla_response['id'].to_s, name)
    return unless issue

    issue.state = if bugzilla_response['is_open']
        Severity: Minor
        Found in src/api/app/models/issue_tracker.rb - About 1 hr to fix

          Method cleanup_before_destroy has 28 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            def cleanup_before_destroy
    # change all linking repository pathes
    linking_repositories.each do |lrep|
      lrep.path_elements.includes(:link, :repository).find_each do |pe|
        next unless pe.link == self # this is not pointing to our repo
          Severity: Minor
          Found in src/api/app/models/repository.rb - About 1 hr to fix

            Method search has 28 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              def search
    # If there is nothing to search for, just return
    return unless params[:search_text]

    # If the search is too short, return too
            Severity: Minor
            Found in src/api/app/controllers/webui/search_controller.rb - About 1 hr to fix

              Method internal_register has 28 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                def internal_register
    if ::Configuration.ldap_enabled?
      render_error(
        status: 403,
        errorcode: 'permission_denied',
              Severity: Minor
              Found in src/api/app/controllers/person_controller.rb - About 1 hr to fix

                Method show has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  def show
    # TODO: Remove this `if` condition, and the `else` clause once request_show_redesign is rolled out
    if Flipper.enabled?(:request_show_redesign, User.session)
      @history_elements = @bs_request.history_elements.includes(:user)
      @active_tab = 'conversation'
                Severity: Minor
                Found in src/api/app/controllers/webui/request_controller.rb - About 1 hr to fix

                  Method put_or_post has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      def self.put_or_post(method, path, data, in_headers)
      start_time = Time.now
      Rails.logger.debug { "[backend] #{method}: #{path}" }
      timeout = in_headers.delete('Timeout')
      backend_request = if method == 'PUT'
                  Severity: Minor
                  Found in src/api/app/lib/backend/connection.rb - About 1 hr to fix

                    Method check_maintenance_release_accept has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def check_maintenance_release_accept(action)
    if action.source_rev
      # FIXME2.4 we have a directory model
      c = Backend::Api::Sources::Package.files(action.source_project, action.source_package, expand: 1)
      data = REXML::Document.new(c)
                    Severity: Minor
                    Found in src/api/app/models/bs_request_permission_check.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 check_action_target has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def check_action_target(action)
    return unless action.action_type.in?(%i[submit change_devel maintenance_release maintenance_incident])

    raise PostRequestNoPermission, "Target package is missing in request #{action.bs_request.number} (type #{action.action_type})" if action.action_type == :change_devel && !action.target_package
                    Severity: Minor
                    Found in src/api/app/models/bs_request_permission_check.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 add_channel_repos_to_project has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def add_channel_repos_to_project(target_package, mode = nil)
    if channel_targets.empty?
      # not defined in channel, so take all from project
      target_package.project.branch_to_repositories_from(package.project, package, extend_names: true)
      return
                    Severity: Minor
                    Found in src/api/app/models/channel.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 all has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                          def all
        return [bs_request_action.source_package] if bs_request_action.bs_request_action_accept_info # the old package can be gone

        if bs_request_action.source_package
          bs_request_action.source_access_check! unless skip_access_check?
                    Severity: Minor
                    Found in src/api/app/models/bs_request_action/differ/source_package_finder.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 monitor_set_filter has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def monitor_set_filter(defaults)
    @avail_status_values = Buildresult.avail_status_values
    @status_filter = []
    excluded_status = %w[disabled excluded unknown]
    @avail_status_values.each do |s|
                    Severity: Minor
                    Found in src/api/app/controllers/concerns/webui/project_build_result_parsing.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 update_flags has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def update_flags(xmlhash, flagtype, position)
    # translate the flag types as used in the xml to model name + s
    validate_type flagtype

    # we need to catch duplicates - and prefer the last
                    Severity: Minor
                    Found in src/api/app/helpers/flag_helper.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 validate_target_for_package_command_exists! has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def validate_target_for_package_command_exists!
    @project = nil
    @package = nil

    follow_project_links = SOURCE_UNTOUCHED_COMMANDS.include?(@command)
                    Severity: Minor
                    Found in src/api/app/controllers/source_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 resolve_devel_package has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def resolve_devel_package
    pkg = self
    prj_name = pkg.project.name
    processed = {}
                    Severity: Minor
                    Found in src/api/app/models/package.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 search has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def search
    # If there is nothing to search for, just return
    return unless params[:search_text]

    # If the search is too short, return too
                    Severity: Minor
                    Found in src/api/app/controllers/webui/search_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 destroy has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def destroy
    @comment = Comment.find(params[:id])
    authorize @comment, :destroy?
    @commentable = @comment.commentable
                    Severity: Minor
                    Found in src/api/app/controllers/webui/comments_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 find has a Cognitive Complexity of 13 (exceeds 8 allowed). Consider refactoring.
                    Open

                      def find(xpath)
    # logger.debug "---------------------- parsing xpath: #{xpath} -----------------------"

    begin
      @stack = @lexer.parse xpath
                    Severity: Minor
                    Found in src/api/lib/xpath_engine.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