Showing 248 of 460 total issues

Method build_load_balancer_service has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
Open

          def build_load_balancer_service(xml)
            lb_config = @configuration[:LoadBalancerService]
            return unless lb_config

            xml.LoadBalancerService {

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 available? has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
Open

      def available?
        availability = true
        for service in services
          begin
            service = self.class_for(service)
Severity: Minor
Found in lib/fog/bin.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 get_edge_gateway has 47 lines of code (exceeds 25 allowed). Consider refactoring.
Open

        def get_edge_gateway(id)
          unless edge_gateway = data[:edge_gateways][id]
            raise Fog::Compute::VcloudDirector::Forbidden.new(
              "No access to entity \"(com.vmware.vcloud.entity.gateway:#{id})\""
            )
Severity: Minor
Found in lib/fog/vcloud_director/requests/compute/get_edge_gateway.rb - About 1 hr to fix

    Method get_vms_in_lease_from_query has 44 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

            def get_vms_in_lease_from_query(options={})
    
              if options.key?(:filter) && options[:filter] =~ /^href==([^;,]+)$/
                href = $1
                id = href.split('/').last

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

          def available?
            begin
              availability=true unless Gem::Specification::find_by_name("opennebula").nil?
            rescue Gem::LoadError
              availability=false
      Severity: Minor
      Found in lib/fog/bin/opennebula.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 expand_commands has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

              def expand_commands(commands, params, args)
                # For all params unless the ctid
                # pass it to the command
                params.keys.each do |k|
                  if (params[k]) && (k.to_s != 'ctid')
      Severity: Minor
      Found in lib/fog/openvz/compute.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 generate_configure_vm_request has 42 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

              def generate_configure_vm_request(vm_data)
                xmlns = 'http://schemas.dmtf.org/ovf/envelope/1'
                xmlns_vcloud = 'http://www.vmware.com/vcloud/v1'
                xmlns_rasd = 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData'
                xmlns_vssd = 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData'
      Severity: Minor
      Found in lib/fog/vcloud/requests/compute/configure_vm.rb - About 1 hr to fix

        Method [] has 42 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            def [](service)
              @@connections ||= Hash.new do |hash, key|
                hash[key] = case key
                when :auto_scale
                  Fog::Rackspace::AutoScale.new
        Severity: Minor
        Found in lib/fog/bin/rackspace.rb - About 1 hr to fix

          Method get_org_vdc_gateways has 42 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  def get_org_vdc_gateways(vdc_id)
                    unless data[:vdcs][vdc_id]
                      raise Fog::Compute::VcloudDirector::Forbidden.new(
                        "No access to entity \"(com.vmware.vcloud.entity.vdc:#{vdc_id})\"."
                      )
          Severity: Minor
          Found in lib/fog/vcloud_director/requests/compute/get_org_vdc_gateways.rb - About 1 hr to fix

            Method vm_allocate has 42 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    def vm_allocate(attr={ })
            
                      if(attr[:flavor].nil?)
                        raise(ArgumentError.new("Attribute flavor is nil! #{attr.inspect}"))
                      end
            Severity: Minor
            Found in lib/fog/opennebula/requests/compute/vm_allocate.rb - About 1 hr to fix

              Method get_network_complete has 41 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                      def get_network_complete(id)
                        unless network = data[:networks][id]
                          raise Fog::Compute::VcloudDirector::Forbidden.new(
                            'This operation is denied.'
                          )
              Severity: Minor
              Found in lib/fog/vcloud_director/requests/compute/get_network_complete.rb - About 1 hr to fix

                Method post_upload_disk has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                        def post_upload_disk(id, name, size, options={})
                          unless size.to_s =~ /^\d+$/
                            raise Fog::Compute::VcloudDirector::BadRequest.new(
                              "validation error on field 'diskSpec.sizeBytes': must be greater than or equal to 0"
                            )
                Severity: Minor
                Found in lib/fog/vcloud_director/requests/compute/post_upload_disk.rb - About 1 hr to fix

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

                          def get_groups_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]
                  Severity: Minor
                  Found in lib/fog/vcloud_director/requests/compute/get_groups_from_query.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 get_users_from_query has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def get_users_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]
                  Severity: Minor
                  Found in lib/fog/vcloud_director/requests/compute/get_users_from_query.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 get_disks_from_query has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def get_disks_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]
                  Severity: Minor
                  Found in lib/fog/vcloud_director/requests/compute/get_disks_from_query.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 get_organizations_from_query has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def get_organizations_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]

                  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 get_catalogs_from_query has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def get_catalogs_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]
                  Severity: Minor
                  Found in lib/fog/vcloud_director/requests/compute/get_catalogs_from_query.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 list_addresses has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def list_addresses
                            # Loop through addresses and update states and values if they aren't set
                            self.data[:addresses].values.each do |address|
                              address['state']    = 2 if address['state'] == 0
                              address['ip']       = Fog::IBM::Mock.ip_address if address['ip'].empty?
                  Severity: Minor
                  Found in lib/fog/ibm/requests/compute/list_addresses.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 get_medias_from_query has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def get_medias_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]
                  Severity: Minor
                  Found in lib/fog/vcloud_director/requests/compute/get_medias_from_query.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 get_vdcs_from_query has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                  Open

                          def get_vdcs_from_query(options={})
                            query = []
                            query << "sortAsc=#{options[:sortAsc]}" if options[:sortAsc]
                            query << "sortDesc=#{options[:sortDesc]}" if options[:sortDesc]
                            query << "page=#{options[:page]}" if options[:page]
                  Severity: Minor
                  Found in lib/fog/vcloud_director/requests/compute/get_vdcs_from_query.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