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

Open

        final void tryAwaitLock(Node[] tab, int i) {
            if (tab != null && i >= 0 && i < tab.length) { // sanity check
                int r = ThreadLocalRandom.current().nextInt(); // randomize spins
                int spins = MAX_SPINS, h;
                while (tabAt(tab, i) == this && ((h = hash) & LOCKED) != 0) {

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

Open

        final void tryAwaitLock(AtomicReferenceArray<Node> tab, int i) {
            if (tab != null && i >= 0 && i < tab.length()) { // sanity check
                int r = ThreadLocalRandom.current().nextInt(); // randomize spins
                int spins = MAX_SPINS, h;
                while (tabAt(tab, i) == this && ((h = hash) & LOCKED) != 0) {

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

Open

        @SuppressWarnings("unchecked") final TreeNode getTreeNode
        (int h, RubyObject k, TreeNode p) {
            RubyClass c = k.getMetaClass(); boolean kNotComparable = !k.respondsTo("<=>");
            while (p != null) {
                int dir, ph;  RubyObject pk; RubyClass pc;

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

Open

        @SuppressWarnings("unchecked") final TreeNode getTreeNode
        (int h, RubyObject k, TreeNode p) {
            RubyClass c = k.getMetaClass(); boolean kNotComparable = !k.respondsTo("<=>");
            while (p != null) {
                int dir, ph;  RubyObject pk; RubyClass pc;

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

Open

      def self.define_struct_class(parent, base, name, members, &block)
        clazz = Class.new(base || Object) do
          include parent
          self.const_set(:MEMBERS, members.collect{|member| member.to_s.to_sym}.freeze)
          def ns_initialize(*values)

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

Open

    def acquire_write_lock
      if (held = @HeldCount.value) >= WRITE_LOCK_HELD
        # if we already have a write (exclusive) lock, there's no need to wait
        @HeldCount.value = held + WRITE_LOCK_HELD
        return true

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

Open

def new_tree(n, size = 10)
  values = [*1..size].collect{|i| i * n }.sample(size)
  root = Tree.new(values.shift)

  inserter = ->(current, new) do

• Read up
  Read up

Method wait! has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

      def wait!(timeout = nil, resolve_on_timeout = nil)
        super(timeout) or if resolve_on_timeout
                            if resolve(*resolve_on_timeout, false)
                              false
                            else

• Read up
  Read up

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

Open

      def exception(*args)
        raise Concurrent::Error, 'it is not rejected' unless rejected?
        raise ArgumentError unless args.size <= 1
        reason = Array(internal_state.reason).flatten.compact
        if reason.size > 1

• Read up
  Read up

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

Open

      def perform
        loop do
          ivar, method, args, block = synchronize { @queue.first }
          break unless ivar # queue is empty

• Read up
  Read up

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

Open

        def on_envelope(envelope)
          result = pass envelope
          if result != MESSAGE_PROCESSED && !envelope.future.nil?
            envelope.future.fulfill result
            log(DEBUG) { "finished processing of #{envelope.message.inspect}"}

• Read up
  Read up

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

Open

def get_top_stock(symbols, year, timeout = 10)
  api_key = ENV['ALPHAVANTAGE_KEY']
  abort(error_message) unless api_key

  stock_prices = symbols.collect{|symbol| Concurrent::dataflow{ get_year_end_closing(symbol, year, api_key) }}

• Read up
  Read up

Method single_test has 7 arguments (exceeds 4 allowed). Consider refactoring.

Open

def single_test(lock, n_readers, n_writers, reader_iterations=50, writer_iterations=50, reader_sleep=0.001, writer_sleep=0.001)

Method defineClass has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

            Ruby runtime,
            RubyModule namespace,
            String parentName,
            String name,
            Class javaImplementation,

Avoid deeply nested control flow statements.

Open

                            if ((pr = p.right) != null && h >= pr.hash && (r = getTreeNode(h, k, pr)) != null)
                                return r;
                            // try to continue iterating on the left side
                            else if ((pl = p.left) != null && h <= pl.hash)
                                dir = -1;

Avoid deeply nested control flow statements.

Open

                                    if ((p.val = v) == null) {
                                        deleted = true;
                                        t.deleteTreeNode(p);
                                    }

Avoid deeply nested control flow statements.

Open

                                    if ((e.val = v) == null) {
                                        deleted = true;
                                        Node en = e.next;
                                        if (pred != null)
                                            pred.next = en;

Avoid deeply nested control flow statements.

Open

                            if (!collide && q != null && q.hash == p.hash)
                                collide = true;

Avoid deeply nested control flow statements.

Open

                                        if (count >= TREE_THRESHOLD)
                                            replaceWithTreeBin(tab, i, k);

Avoid deeply nested control flow statements.

Open

                        for (Node e = tabAt(tab, i); e != null; e = e.next) {
                            if (++c > TREE_THRESHOLD &&
                                    (e.key instanceof Comparable)) {
                                replaceWithTreeBin(tab, i, e.key);
                                break;