Cyclomatic complexity Puns

Hello, I'm currently working on an RoR method, but it throws some rubocop warnings I've been trying to refactor for while. Do you have a better idea of how I could improve this method? Thanks

Assignment Branch Condition size for bucket_items_applies? is too high. [<9, 33, 8> 35.13/32] (convention:Metrics/AbcSize)

Cyclomatic complexity for bucket_items_applies? is too high. [8/6] (convention:Metrics/CyclomaticComplexity)

Perceived complexity for bucket_items_applies? is too high. [8/6] (convention:Metrics/PerceivedComplexity)

  def bucket_items_applies?(discount)
    @application_count = 0

    discount.bucket.bucket_items.all.each do |bucket_item|
      @cloned_items = items.map(&:clone)

      bucket_item_type_id = bucket_item.product.present? ? bucket_item.product.id : bucket_item.line.id
      line_token = bucket_item.product.present? ? bucket_item.product.line.to_gid.to_s : bucket_item.line.to_gid.to_s

      matching_line_item_product_index = line_item_product_index.select { |_, product| (bucket_item.product.present? ? product.id : product.line.id) == bucket_item_type_id }

      return false if matching_line_item_product_index.blank?

      allocate_discount(matching_line_item_product_index: matching_line_item_product_index, discount: discount, bucket_item: bucket_item)

      @line_quantities_index[line_token] -= bucket_item.minimum_quantity
      @applicable_lines << line_token
    end

    true
  end

I'm looking for a Code Review tool that checks and shows the Cyclomatic Complexity of the code during a pull request, merge request, or in a dashboard from the repository.

I'm curious because besides the SonarLint extension for VS Code I haven't seen any tool that provides this type of feature, and I think that this kind of metric it's fundamental for every team.

I have tested Sonarqube and SonarCloud, but I haven't seen Cyclomatic Complexity evaluated.

Do you know guys any type of tool that evaluates the Cyclomatic Complexity of your general code for a repository that is integrated with Gitlab, GitHub, and other Git Repositories?

Like the title indicates, I need to calculate the cyclomatic complexity of a very complex pascal-based programm. Trying to calculate it manually is pointless, so I was hoping that some tool exists.

How do people structure code for web handlers for basic Create, Read, Update, Delete operations on database records?

If you start off with separate handlers for each, you get lots of code duplication. So I broke out chunks of common functionality:

• Decode request (including authenticated ID)
• Check authorization
• Get current record
• If saving:
  • Decode form submission (including checking CSRF token)
  • Validate submitted data
  • Save new record
• Write audit log
• Output page in read or edit mode

Each operation is basically a chain of these operations in a particular order.

The problem is, there are lots of data values which need to thread through the flow to all the chunks of code. Things like whether the request is to view or edit are indicated at the very first step, decoding the request, but they have an effect on the last step, outputting the resulting page. (e.g. an edit request may result in a read-only page plus an error.)

If I put all the values explicitly as arguments to each function, some of them have half a dozen or more arguments. So for now, I've ended up with a RequestData struct that collects all the info, and that gets passed down the chain. This bothers me aesthetically, but I can't think of a better option.

So, what are you doing to keep cyclomatic complexity low in CRUD handlers? Is there some technique I'm missing? Anyone have nice clean examples?

That is all.

I'm implementing Rubocop (with Rails) and I'm wondering what kind of advice you have for using these metrics?

The default value for Cyclomatic complexity is 6 and Perceived is 7. How do these guidelines translate to your projects?

Thanks!

I'm currently studying structure complexity and I came across McCabe's measurement for a program's complexity, where he uses only D-Diagrams (one input, one output) to calculate the complexity. It seems quite outdated and I was wondering how relevant this method is. Are there any more modern approaches for analyzing the strucutre complexity?

I'm working on a project that has a number of code quality tests [yay] built into its CI pipeline. One such test is for cyclomatic complexity.

The test currently ensures the cyclomatic complexity does not exceed 20. This seems absolutely ludicrous in my mind. It suggests poor programmers have constantly bumped the threshold to the point where they no longer have to worry about it.

I would like to suggest to them that they should lower the threshold to somewhere between 10-15, but would like some reassurance that others agree with my thoughts.

So, in your experience, what's the ideal threshold for cyclomatic complexity? Also, what's the highest you've ever seen?