Avoid deeply nested control flow statements.

Open

                  :id => (method.is_a?(Array) && method.first == "new") ? [nil] : [@ar_object.id],

Method method_missing has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def method_missing(name, *args, &block)
      if name =~ /\!$/
        name = name.gsub(/\!$/,"")
        force_update = true
      end

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

              if value.nil?
                attributes[attribute].attributes[inverse_of].delete(@ar_instance) unless attributes[attribute].nil?
              elsif value.attributes[inverse_of]
                value.attributes[inverse_of] << @ar_instance
              else

Avoid deeply nested control flow statements.

Open

              if false and parent.new?
                parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]] if parent.new?
                #puts "updated"
              else
                #puts "skipped"

Avoid deeply nested control flow statements.

Open

            elsif aggregation = record.model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
              add_new_association.call record, attribute, value.backing_record unless value.nil?
            elsif aggregation
              new_value = aggregation.serialize(value)
              output_attributes[attribute] = new_value if record.changed?(attribute) or new_value != aggregation.serialize(record.synced_attributes[attribute])

Method save_records has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def self.save_records(models, associations, acting_user, validate, save)

Method try has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

        def try(*args, &b)
          if args.empty? && block_given?
            yield self
          else
            send(*args, &b)

• Read up
  Read up

Method sync_scopes has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def sync_scopes
      self.class.sync_blocks[self.model].each do |watching_class, scopes|
        scopes.each do |scope_name, blocks|
          blocks.each do |block|
            if block.arity > 0

• Read up
  Read up

Method inverse_of has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def inverse_of
        unless @options[:through] or @inverse_of
          inverse_association = klass.reflect_on_all_associations.detect do | association |
            association.association_foreign_key == @association_foreign_key and association.klass == @owner_class and association.attribute != attribute and klass == association.owner_class
          end

• Read up
  Read up

Method [] has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def [](index)
      observed
      if (@collection || all).length <= index and @dummy_collection
        (@collection.length..index).each do |i|
          new_dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*#{i}")

• Read up
  Read up

Method aggregation? has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

          def aggregation?(method)
            if method.is_a?(String) && value.class.respond_to?(:reflect_on_aggregation)
              aggregation = value.class.reflect_on_aggregation(method.to_sym)
              if aggregation && !(aggregation.klass < ActiveRecord::Base) && value.send(method)
                aggregation

• Read up
  Read up

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

Open

    def load(*attributes, &block)
      first_time = true
      ReactiveRecord.load do
        results = attributes.collect { |attr| @backing_record.reactive_get!(attr, first_time) }
        results = yield *results if block

• Read up
  Read up

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

Open

  def self.load(&block)
    promise = Promise.new
    @load_stack ||= []
    @load_stack << @loads_pending
    @loads_pending = nil

• Read up
  Read up

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

Open

    def all
      observed
      @dummy_collection.notify if @dummy_collection
      unless @collection
        @collection = []

• Read up
  Read up

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

Open

      def self.destroy_record(model, id, vector, acting_user)
        model = Object.const_get(model)
        record = if id
          model.find(id)
        else

• Read up
  Read up

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

Open

    def ==(other_collection)
      observed
      return !@collection unless other_collection.is_a? Collection
      other_collection.observed
      my_collection = (@collection || []).select { |target| target != @dummy_record }

• Read up
  Read up