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

Open

        def define_has_many_getter(association)
          klass = association[:class]

          define_method association[:name] do |*args|
            instance_opts = args.last.is_a?(Hash) ? args.pop : {}

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

Open

    def save!(options = {})
      return false if respond_to?(:destroyed?) && destroyed?

      if new_record? && !options[:force_update]
        method = :post

• Read up
  Read up

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

Open

  def get_klass(statement)
    statement.traverse do |node|
      if node.type == :assoc && node.jump(:kw).source == "class"
        node.traverse do |value|
          if value.type == :const_path_ref || value.type == :var_ref

• Read up
  Read up

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

Open

        def traverse_hash(hash)
          hash.keys.each do |key|
            if hash[key].is_a?(File)
              set_file(hash, key, false)
            elsif hash[key].is_a?(Hash)

• Read up
  Read up

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

Open

        def call(environment)
          return @app.call(environment) unless [:get, :head].include?(environment[:method])

          # send known etag
          cached = @cache.read(cache_key(environment))

• Read up
  Read up

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

Open

      def clear_changes
        each do |k, v|
          if v.respond_to?(:clear_changes)
            v.clear_changes
          elsif v.is_a?(Array)

• Read up
  Read up

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

Open

    def set_token_auth
      return if config.password || config.token.nil?

      if config.username.nil?
        raise ArgumentError, "you need to provide a username when using API token auth"

• Read up
  Read up

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

Open

      def _save(method = :save)
        return self unless @resources

        @client.connection.post(path) do |req|
          req.body = { :tags => @resources.reject(&:destroyed?).map(&:id) }

• Read up
  Read up

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

Open

    def initialize(client, attributes = {})
      raise "Expected a Hash for attributes, got #{attributes.inspect}" unless attributes.is_a?(Hash)

      @association = attributes.delete(:association) || Association.new(:class => self.class)
      @global_params = attributes.delete(:global) || {}

• Read up
  Read up

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

Open

    def extract_id(instance, options, original_options)
      if options[:with_id] && !@options[:class].ancestors.include?(SingularResource)
        if instance && instance.id
          instance.id
        elsif options[:id]

• Read up
  Read up

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

Open

    def update_many!(client, ids_or_attributes, attributes = {})
      association = attributes.delete(:association) || Association.new(:class => self)

      response = client.connection.put("#{association.generate_path}/update_many") do |req|
        if attributes == {}

• Read up
  Read up

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

Open

    def get_response(path)
      @error = nil
      @client.connection.send(@verb || "get", path) do |req|
        opts = @options.delete_if { |_, v| v.nil? }

• Read up
  Read up

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

Open

    def _side_load(name, klass, resources)
      associations = klass.associated_with(name)

      associations.each do |association|
        association.side_load(resources, @included[name])

• Read up
  Read up

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

Open

        def define_has_many_setter(association)
          define_method "#{association[:name]}=" do |resources|
            if resources.is_a?(Array)
              wrapped = resources.map { |attr| wrap_resource(attr, association) }
              send(association[:name]).replace(wrapped)

• Read up
  Read up

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

Open

      def changes
        (@changes ||= self.class.superclass.new).tap do |changes|
          each do |k, v|
            if v.respond_to?(:changed?) && v.changed?
              changes[k] = v.changes

• Read up
  Read up

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

Open

    def _save(method = :save)
      return self unless @resources

      result = true

• Read up
  Read up

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

Open

    def ==(other)
      return false unless other

      return true if other.object_id == object_id

• Read up
  Read up

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

Open

        def initialize(app, options = {})
          super(app)
          @logger = options[:logger]
          @error_codes = options.key?(:retry_codes) && options[:retry_codes] ? options[:retry_codes] : DEFAULT_ERROR_CODES
          @retry_on_exception = options.key?(:retry_on_exception) && options[:retry_on_exception] ? options[:retry_on_exception] : false

• Read up
  Read up

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

Open

      def regular_writer(key, value)
        if has_key?(key) && self[key] == value
          value
        else
          changes[key] = value

• Read up
  Read up

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

Open

      def find!(client, options = {})
        @client = client # so we can use client.logger in rescue

        raise ArgumentError, "No :id given" unless options[:id] || options["id"] || ancestors.include?(SingularResource)
        association = options.delete(:association) || Association.new(:class => self)

• Read up
  Read up