Method execute_accept has a Cognitive Complexity of 27 (exceeds 8 allowed). Consider refactoring.

Open

  def execute_accept(opts)
    # create package unless it exists already
    target_project = Project.get_by_name(self.target_project)

    # FIXME: when this code is moved to conditional assigment, it causes ambiguity between target_package and self.target_package.

• Read up
  Read up

Method find_changed_issues has a Cognitive Complexity of 27 (exceeds 8 allowed). Consider refactoring.

Open

  def find_changed_issues
    # no expand=1, so only branches are tracked
    query = { cmd: :diff, orev: 0, onlyissues: 1, linkrev: :base, view: :xml }
    issue_change = parse_issues_xml(query, 'kept')
    # issues introduced by local changes

• Read up
  Read up

Class SCMWebhook has 28 methods (exceeds 20 allowed). Consider refactoring.

Confirmed

class SCMWebhook
  include ActiveModel::Model
  include SCMWebhookInstrumentation # for run_callbacks

  attr_accessor :payload

Method store_from_xml has a Cognitive Complexity of 26 (exceeds 8 allowed). Consider refactoring.

Open

  def store_from_xml(hash)
    source = hash.delete('source')
    if source
      self.source_package = source.delete('package')
      self.source_project = source.delete('project')

• Read up
  Read up

Method create has a Cognitive Complexity of 26 (exceeds 8 allowed). Consider refactoring.

Open

      def create
        # FIXME: We should use strong parameters instead of this custom implementation
        params.fetch(:linked_project) { raise ArgumentError, 'Linked Project parameter missing' }
        params.fetch(:linked_package) { raise ArgumentError, 'Linked Package parameter missing' }

• Read up
  Read up

Method action_details has 80 lines of code (exceeds 25 allowed). Consider refactoring.

Confirmed

  def action_details(opts = {}, xml:)
    with_diff = opts.delete(:diffs)
    action = { type: xml.action_type }
    action[:id] = xml.id
    action[:number] = xml.bs_request.number

Method cleanup_before_destroy has a Cognitive Complexity of 25 (exceeds 8 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

• Read up
  Read up

Method evaluate_expr has a Cognitive Complexity of 25 (exceeds 8 allowed). Consider refactoring.

Open

  def evaluate_expr(expr, root, escape: false)
    table = @base_table
    a = []
    until expr.empty?
      token = expr.shift

• Read up
  Read up

Class Repository has 26 methods (exceeds 20 allowed). Consider refactoring.

Open

class Repository < ApplicationRecord
  include StatusCheckable

  belongs_to :project, foreign_key: :db_project_id, inverse_of: :repositories

Class WebuiController has 26 methods (exceeds 20 allowed). Consider refactoring.

Open

class Webui::WebuiController < ActionController::Base
  layout 'webui/webui'

  Rails.cache.set_domain if Rails.cache.respond_to?(:set_domain)

Method _merge_pkg_into_maintenance_incident has 73 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def _merge_pkg_into_maintenance_incident(incident_project)
    # recreate package based on link target and throw everything away, except source changes
    # silently as maintenance teams requests ...
    new_pkg = nil

Method update_from_xml has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def update_from_xml(xml)
    transaction do
      xml.elements('productdefinition') do |pd|
        # we are either an operating system or an application for CPE
        sw_class = 'o'

• Read up
  Read up

Method render_xml has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def render_xml(opts = {})
    builder = Nokogiri::XML::Builder.new
    builder.request(id: number, creator: creator) do |r|
      bs_request_actions.includes([:bs_request_action_accept_info]).find_each do |action|
        action.render_xml(r)

• Read up
  Read up

Method is_reviewer? has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def is_reviewer?(user)
    return false if reviews.blank?

    reviews.each do |r|
      if r.by_user

• Read up
  Read up

Method apply_default_reviewers has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def apply_default_reviewers
    reviewers = collect_default_reviewers!
    # apply reviewers
    reviewers.each do |r|
      if r.instance_of?(User)

• Read up
  Read up

Method verify_release_targets! has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def verify_release_targets!(pro)
    repo_matches = nil
    repo_bad_type = nil

    pro.repositories.each do |repo|

• Read up
  Read up

Method update has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def update
    params[:user] = User.session!.login
    begin
      project = Project.get_by_name(@request_data['name'])
    rescue Project::UnknownObjectError

• Read up
  Read up

Method check_action_permission_target! has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def check_action_permission_target!
    return unless target_project

    tprj = Project.get_by_name(target_project)
    if tprj.is_a?(Project)

• Read up
  Read up

Method sync_hash_with_model has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def sync_hash_with_model(entry_class, dblist, inhasharray)
    keys = entry_class._sync_keys
    entries = {}

    dblist.each do |e|

• Read up
  Read up

Method parse_predicate has a Cognitive Complexity of 24 (exceeds 8 allowed). Consider refactoring.

Open

  def parse_predicate(root, stack)
    # logger.debug "------------------ predicate ---------------"
    # logger.debug "-- pred_array: #{stack.inspect} --"

    raise IllegalXpathError, 'invalid predicate' if stack.nil?

• Read up
  Read up