Sign upLogin

lstejskal/adapi

View on GitHub
Star

Showing 36 of 55 total issues

Method mutate has 31 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    def mutate(operation)      
      operation = [operation] unless operation.is_a?(Array)
      
      # fix to save space during specifyng operations
      operation = operation.map do |op|
Severity: Minor
Found in lib/adapi/api.rb - About 1 hr to fix

    Method find has 31 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        def self.find(amount = :all, params = {})
      # find single campaign by id
      if params.empty? and not amount.is_a?(Symbol)
        params[:id] = amount.to_i
        amount = :first
    Severity: Minor
    Found in lib/adapi/campaign.rb - About 1 hr to fix

      Method update has 29 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          def update(params = {})
      # REFACTOR for the moment, we use separate campaign object just to prepare and execute 
      # campaign update request. This is kinda ugly and should be eventually refactored (if
      # only because of weird transfer of potential errors later when dealing with response). 
      #
      Severity: Minor
      Found in lib/adapi/campaign.rb - About 1 hr to fix

        Method find has 28 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            def self.find(amount = :all, params = {})
      params.symbolize_keys!
      first_only = (amount.to_sym == :first)
      # by default, exclude ad_groups with status DELETED
      params[:status] ||= %w{ ENABLED PAUSED }
        Severity: Minor
        Found in lib/adapi/ad_group.rb - About 1 hr to fix

          Method find has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
          Open

              def self.find(amount = :all, params = {})
      params.symbolize_keys!
      first_only = (amount.to_sym == :first)

      # for ActiveRecord compatibility, we don't use anything besides conditions
          Severity: Minor
          Found in lib/adapi/ad/text_ad.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 check_for_errors has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
          Open

              def check_for_errors(adapi_instance, options = {})
      options.merge!( store_errors: true, raise_errors: false )

      # don't store errors in this case, because errors are already there
      # and loop in store_errors method would cause application to hang
          Severity: Minor
          Found in lib/adapi/api.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 create has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              def create
      @ads = [ self.attributes ] unless @ads 

      operations = []
          Severity: Minor
          Found in lib/adapi/ad/text_ad.rb - About 1 hr to fix

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

                def create
      return false unless self.valid?
      
      operand = Hash[
        [:campaign_id, :name, :status, :bids].map do |k|
            Severity: Minor
            Found in lib/adapi/ad_group.rb - About 1 hr to fix

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

                  def create
      operations = @keywords.map do |keyword|
        {
          :operator => 'ADD', 
          :operand => {
              Severity: Minor
              Found in lib/adapi/keyword.rb - About 1 hr to fix

                Method find has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                Open

                    def self.find(amount = :first, params = {})
      # find single campaign by id
      if params.empty? and not amount.is_a?(Symbol)
        params[:customer_id] = amount.to_i
        amount = :first
                Severity: Minor
                Found in lib/adapi/managed_customer.rb - About 55 mins 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 find has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                Open

                    def self.find(params = {})
      params.symbolize_keys!

      predicates = [ :ad_group_id, :criterion_id ].map do |param_name|
        if params[param_name]
                Severity: Minor
                Found in lib/adapi/ad_param.rb - About 55 mins 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 find has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                    def self.find(amount = :all, params = {})
      params[:format] ||= :google # default, don't do anything with the data from google
      
      params.symbolize_keys!
      # this has no effect, it's here just to have the same interface everywhere
                Severity: Minor
                Found in lib/adapi/keyword.rb - About 45 mins 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 bids= has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                    def bids=(params = {})
      @bids = params

      if @bids
        unless @bids.is_a?(Hash)
                Severity: Minor
                Found in lib/adapi/ad_group.rb - About 45 mins 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 find has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                    def self.find(params = {})
      params.symbolize_keys!
      
      if params[:conditions]
        params[:campaign_id] = params[:campaign_id] || params[:conditions][:campaign_id]
                Severity: Minor
                Found in lib/adapi/campaign_target.rb - About 35 mins 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 update has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                    def update(params = {})
      # REFACTOR for the moment, we use separate campaign object just to prepare and execute 
      # campaign update request. This is kinda ugly and should be eventually refactored (if
      # only because of weird transfer of potential errors later when dealing with response). 
      #
                Severity: Minor
                Found in lib/adapi/campaign.rb - About 35 mins 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 store_errors has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                Open

                    def store_errors(failed_instance, error_prefix = nil)
      raise "#{failed_instance.xsi_type}#store_errors: Invalid object instance" unless failed_instance.respond_to?(:errors)

      error_prefix ||= failed_instance.respond_to?(:xsi_type) ? failed_instance.xsi_type : nil
                Severity: Minor
                Found in lib/adapi/api.rb - About 25 mins 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