Method valid? has a Cognitive Complexity of 69 (exceeds 5 allowed). Consider refactoring.

Open

    def valid?
      @errors = Hash.new {|h,k| h[k] = []}
      self.class._validations.each do |validation|
        value = self.send(validation[:field_name])
        validation[:options].each do |type, options|

• Read up
  Read up

File request.rb has 512 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require "cgi"
require "multi_json"
require 'crack'
require 'crack/xml'

Method do_request has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

    def do_request(etag)
      http_headers = {}
      http_headers["If-None-Match"] = etag if etag
      http_headers["Accept"] = "application/hal+json, application/json;q=0.5"
      headers.each do |key,value|

• Read up
  Read up

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

Open

    def call(explicit_parameters=nil)
      @instrumentation_name = "#{class_name}##{@method[:name]}"
      result = nil
      cached = nil
      ActiveSupport::Notifications.instrument("request_call.active_rest_client", :name => @instrumentation_name) do

• Read up
  Read up

Class Request has 31 methods (exceeds 20 allowed). Consider refactoring.

Open

  class Request
    attr_accessor :post_params, :get_params, :url, :path, :headers, :method, :object, :body, :forced_url, :original_url

    def initialize(method, object, params = {})
      @method                     = method

Method handle_response has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.

Open

    def handle_response(response, cached = nil)
      @response = response
      status = @response.status || 200

      if cached && response.status == 304

• Read up
  Read up

Method new_object has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.

Open

    def new_object(attributes, name = nil)
      @method[:options][:has_many] ||= {}
      name = name.to_sym rescue nil
      if @method[:options][:has_many][name]
        overridden_name = name

• Read up
  Read up

Method generate_new_object has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def generate_new_object(options={})
      if @response.body.is_a?(Array) || @response.body.is_a?(Hash)
        body = @response.body
      elsif is_json_response?
        body = @response.body.blank? ? {} : MultiJson.load(@response.body)

• Read up
  Read up

Method call has 67 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def call(explicit_parameters=nil)
      @instrumentation_name = "#{class_name}##{@method[:name]}"
      result = nil
      cached = nil
      ActiveSupport::Notifications.instrument("request_call.active_rest_client", :name => @instrumentation_name) do

Method do_request has 65 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def do_request(etag)
      http_headers = {}
      http_headers["If-None-Match"] = etag if etag
      http_headers["Accept"] = "application/hal+json, application/json;q=0.5"
      headers.each do |key,value|

Method write_cached_response has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

      def write_cached_response(request, response, result)
        return if result.is_a? Symbol
        return unless perform_caching
        return unless !result.respond_to?(:_status) || [200, 304].include?(result._status)
        headers = response.response_headers

• Read up
  Read up

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

Open

    def method_missing(name, *args)
      if name.to_s[-1,1] == "="
        name = name.to_s.chop.to_sym
        @attributes[name] = args.first
        @dirty_attributes << name

• Read up
  Read up

Method handle_hal_links_embedded has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def handle_hal_links_embedded(object, attributes)
      attributes["_links"] = attributes[:_links] if attributes[:_links]
      attributes["_embedded"] = attributes[:_embedded] if attributes[:_embedded]
      if attributes["_links"]
        attributes["_links"].each do |key, value|

• Read up
  Read up

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

Open

    def initialize(name, value, request, options = {})
      @name = name
      class_to_map = request.method[:options][:lazy][name] rescue nil
      @request = class_to_map.nil? ? request : ActiveRestClient::Request.new(class_to_map._mapped_method(:find), class_to_map.new, options)
      @object = nil

• Read up
  Read up

Method handle_response has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def handle_response(response, cached = nil)
      @response = response
      status = @response.status || 200

      if cached && response.status == 304

Method new_object has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def new_object(attributes, name = nil)
      @method[:options][:has_many] ||= {}
      name = name.to_sym rescue nil
      if @method[:options][:has_many][name]
        overridden_name = name

Method hal_response? has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def hal_response?
      _, content_type = @response.response_headers.detect{|k,v| k.downcase == "content-type"}
      faked_response = @response.response_headers.detect{|k,v| k.downcase == "x-arc-faked-response"}
      if content_type && content_type.respond_to?(:each)
        content_type.each do |ct|

• Read up
  Read up

Method valid? has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def valid?
      @errors = Hash.new {|h,k| h[k] = []}
      self.class._validations.each do |validation|
        value = self.send(validation[:field_name])
        validation[:options].each do |type, options|

Method generate_new_object has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def generate_new_object(options={})
      if @response.body.is_a?(Array) || @response.body.is_a?(Hash)
        body = @response.body
      elsif is_json_response?
        body = @response.body.blank? ? {} : MultiJson.load(@response.body)

Method inspect has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def inspect
      inspection = if @attributes.any?
                     @attributes.collect { |key, value|
                       "#{key}: #{value_for_inspect(value)}"
                     }.compact.join(", ")

• Read up
  Read up