bblimke/webmock

View on GitHub

Showing 70 of 70 total issues

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

      def fill_accumulator_for_subscript(accumulator, key, value)
        current_node = accumulator
        subkeys = key.split(/(?=\[[^\[\]]+)/)
        subkeys[0..-2].each do |subkey|
          node = subkey =~ /\[\]\z/ ? [] : {}
Severity: Minor
Found in lib/webmock/util/query_mapper.rb - About 4 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Method parse_header_string has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
Open

        def self.parse_header_string(header_string)
          status, headers = nil, {}

          header_string.split(/\r\n/).each do |header|
            if header =~ %r|^HTTP/1.[01] \d\d\d (.*)|
Severity: Minor
Found in lib/webmock/http_lib_adapters/curb_adapter.rb - About 4 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

File request_pattern.rb has 325 lines of code (exceeds 250 allowed). Consider refactoring.
Open

module WebMock

  module RSpecMatcherDetector
    def rSpecHashIncludingMatcher?(matcher)
      matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashIncludingMatcher/
Severity: Minor
Found in lib/webmock/request_pattern.rb - About 3 hrs to fix

    Method build_curb_response has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

          def build_curb_response(webmock_response)
            raise Curl::Err::TimeoutError if webmock_response.should_timeout
            webmock_response.raise_error_if_any
    
            @body_str = webmock_response.body
    Severity: Minor
    Found in lib/webmock/http_lib_adapters/curb_adapter.rb - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method invoke_curb_callbacks has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

          def invoke_curb_callbacks
            @on_progress.call(0.0,1.0,0.0,1.0) if defined?( @on_progress )
            self.header_str.lines.each { |header_line| @on_header.call header_line } if defined?( @on_header )
            if defined?( @on_body )
              if chunked_response?
    Severity: Minor
    Found in lib/webmock/http_lib_adapters/curb_adapter.rb - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Method make_raw_response has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

          def make_raw_response(response)
            response.raise_error_if_any
    
            status, headers, body = response.status, response.headers, response.body
            headers ||= {}
    Severity: Minor
    Found in lib/webmock/http_lib_adapters/em_http_request_adapter.rb - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Class WebMockCurlEasy has 26 methods (exceeds 20 allowed). Consider refactoring.
    Open

        class WebMockCurlEasy < Curl::Easy
          def curb_or_webmock
            request_signature = build_request_signature
            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
    
    
    Severity: Minor
    Found in lib/webmock/http_lib_adapters/curb_adapter.rb - About 3 hrs to fix

      File curb_adapter.rb has 290 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      begin
        require 'curb'
      rescue LoadError
        # curb not found
      end
      Severity: Minor
      Found in lib/webmock/http_lib_adapters/curb_adapter.rb - About 2 hrs to fix

        Method do_get has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.
        Open

            def do_get(req, proxy, conn, stream = false, &block)
              clear_thread_variables unless conn.async_thread
        
              request_signature = build_request_signature(req, :reuse_existing)
        
        
        Severity: Minor
        Found in lib/webmock/http_lib_adapters/httpclient_adapter.rb - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

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

              def values_to_query(new_query_values, options = {})
                options[:notation] ||= :subscript
                return if new_query_values.nil?
        
                unless new_query_values.is_a?(Array)
        Severity: Minor
        Found in lib/webmock/util/query_mapper.rb - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

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

              def self.convert_json_to_yaml(json) #:nodoc:
                scanner, quoting, marks, times = StringScanner.new(json), false, [], []
                while scanner.scan_until(/(\\['"]|['":,\\]|\\.)/)
                  case char = scanner[1]
                  when '"', "'"
        Severity: Minor
        Found in lib/webmock/util/json.rb - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method stringify_keys! has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
        Open

              def self.stringify_keys!(arg, options = {})
                case arg
                when Array
                  arg.map { |elem|
                    options[:deep] ? stringify_keys!(elem, options) : elem
        Severity: Minor
        Found in lib/webmock/util/hash_keys_stringifier.rb - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method request has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

                def request(request, body = nil, &block)
                  request_signature = WebMock::NetHTTPUtility.request_signature_from_request(self, request, body)
        
                  WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
        
        
        Severity: Minor
        Found in lib/webmock/http_lib_adapters/net_http.rb - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method to_return_json has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

            def to_return_json(*response_hashes)
              raise ArgumentError, '#to_return_json does not support passing a block' if block_given?
        
              json_response_hashes = [*response_hashes].flatten.map do |resp_h|
                headers, body = resp_h.values_at(:headers, :body)
        Severity: Minor
        Found in lib/webmock/request_stub.rb - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Method fill_accumulator_for_subscript has 45 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

              def fill_accumulator_for_subscript(accumulator, key, value)
                current_node = accumulator
                subkeys = key.split(/(?=\[[^\[\]]+)/)
                subkeys[0..-2].each do |subkey|
                  node = subkey =~ /\[\]\z/ ? [] : {}
        Severity: Minor
        Found in lib/webmock/util/query_mapper.rb - About 1 hr to fix

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

                  def self.build_request_signature(req)
                    uri = WebMock::Util::URI.heuristic_parse(req.url)
                    uri.path = uri.normalized_path.gsub("[^:]//","/")
          
                    if [:put, :post, :patch].include?(req.action)
          Severity: Minor
          Found in lib/webmock/http_lib_adapters/patron_adapter.rb - About 1 hr to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

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

              def do_get(req, proxy, conn, stream = false, &block)
                clear_thread_variables unless conn.async_thread
          
                request_signature = build_request_signature(req, :reuse_existing)
          
          
          Severity: Minor
          Found in lib/webmock/http_lib_adapters/httpclient_adapter.rb - About 1 hr to fix

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

                    def call(request)
                      request.scheme ||= self.scheme
                      request.authority ||= self.authority
            
                      request_signature = build_request_signature(request)
            Severity: Minor
            Found in lib/webmock/http_lib_adapters/async_http_client_adapter.rb - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Method build_request_signature has 39 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                  def build_request_signature
                    method = @webmock_method.to_s.downcase.to_sym
            
                    uri = WebMock::Util::URI.heuristic_parse(self.url)
                    uri.path = uri.normalized_path.gsub("[^:]//","/")
            Severity: Minor
            Found in lib/webmock/http_lib_adapters/curb_adapter.rb - About 1 hr to fix

              Method to_s has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
              Open

                  def to_s(with_response = true)
                    request_pattern = @request_stub.request_pattern
                    string = "stub_request(:#{request_pattern.method_pattern.to_s},".dup
                    string << " \"#{request_pattern.uri_pattern.to_s}\")"
              
              
              Severity: Minor
              Found in lib/webmock/stub_request_snippet.rb - About 1 hr to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Severity
              Category
              Status
              Source
              Language