Sign upLogin

3scale/porta

View on GitHub
Star

Showing 5,269 of 5,606 total issues

ProviderInvitationMailer#invitation calls 'invitation.account' 2 times
Open

    @account = invitation.account
    @url = provider_invitee_signup_url(invitation_token: invitation.token,
                                       host: @account.external_admin_domain,
                                       protocol: 'https')
Severity: Minor
Found in app/mailers/provider_invitation_mailer.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

TablesForBeast#self.up calls 't.integer "forum_id"' 3 times
Open

    t.integer  "forum_id"
    t.integer  "user_id"
    t.datetime "created_at"
    t.datetime "updated_at"
  end
Severity: Minor
Found in db/migrate/20081112151449_tables_for_beast.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Pdf::Finance::InvoiceReportData#total_invoice_label calls '@invoice.exact_cost_without_vat' 2 times
Open

      total = ['Total cost', '', @invoice.exact_cost_without_vat, @invoice.charge_cost]
      [total]
    else
      vat_rate_label = @invoice.buyer_account.field_label('vat_rate')
Severity: Minor
Found in app/lib/pdf/finance/invoice_report_data.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Pdf::Report#header_text calls '1.day.ago.to_date' 2 times
Open

        [{ text: 1.day.ago.to_date.to_s }.merge!(format)]
      else
        [
          { text: 1.week.ago.to_date.to_s }.merge!(format),
          { text: " - " },
Severity: Minor
Found in app/lib/pdf/report.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Base#extract_metric calls 'options[:metric_name]' 3 times
Open

      unless options[:metric] || options[:metric_name] || options[:response_code]
        raise InvalidParameterError, "Missing key(s): metric_name"
      end

      metric = if options[:metric]
Severity: Minor
Found in app/lib/stats/base.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Deprecated#self.extract_timezone calls 'options[:timezone]' 2 times
Open

      raise InvalidParameterError, 'missing :timezone option' unless options[:timezone]
      ActiveSupport::TimeZone.new(options[:timezone])
Severity: Minor
Found in app/lib/stats/deprecated.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::KeyHelpers#key_for calls 'object.map' 2 times
Open

          object.map { |key, value| encode_pair(key, value) }.join('/')
        when Array
          object.map { |part| key_for(part) }.join('/')
Severity: Minor
Found in app/lib/stats/key_helpers.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Views::UsageHack::StorageFake#mget calls 'key.to_s' 2 times
Open

        @cached_keys << key.to_s unless @cached_keys.include?(key.to_s)
Severity: Minor
Found in app/lib/stats/views/usage_hack.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

ThreeScale::Address#initialize calls 'args.shift' 2 times
Open

        value = args.shift

        if value.is_a?(Integer)
          self.country_id = value
        else
Severity: Minor
Found in app/lib/three_scale/address.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

ThreeScale::Analytics::Salesforce#update_invoice_status calls '@provider.id' 2 times
Open

            account_id: @provider.id,
            self_domain: @provider.internal_admin_domain,

            plan: bought_plan.name,
            plan_id: bought_plan.id,
Severity: Minor
Found in app/lib/three_scale/analytics/salesforce.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

ThreeScale::PrivateModule#PrivateModule calls 'mod.public_instance_methods' 2 times
Open

            public_methods = mod.public_instance_methods
            mod.send(:include, m)
            added = mod.public_instance_methods - public_methods
Severity: Minor
Found in app/lib/three_scale/private_module.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

ThreeScale::Search::Helpers#per_page calls 'params[:per_page]' 3 times
Open

      if params[:per_page].present? && params[:per_page].to_i <= MAX_PER_PAGE
        params[:per_page]
Severity: Minor
Found in app/lib/three_scale/search.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Base#extract_metric calls 'options[:metric]' 3 times
Open

      unless options[:metric] || options[:metric_name] || options[:response_code]
        raise InvalidParameterError, "Missing key(s): metric_name"
      end

      metric = if options[:metric]
Severity: Minor
Found in app/lib/stats/base.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Deprecated#self.usage calls 'options[:month]' 3 times
Open

        range_since = zone.local(options[:year], options[:month], options[:day])
        range_until = range_since.end_of_day

        granularity = :hour
      elsif options[:week]
Severity: Minor
Found in app/lib/stats/deprecated.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Service#top_clients calls 'cinstance.user_account' 3 times
Open

        if cinstance && cinstance.user_account
          {
            :name     => cinstance.name,
            :id       => cinstance.id,
            :value    => value,
Severity: Minor
Found in app/lib/stats/service.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Storage#compute_timeshift_deltas calls 'range.begin' 2 times
Open

        beginning_of_range = range.begin.beginning_of_month
        if shift > 0
          granularity_for_iteration = :end_of_month
        else # negative time zones
          granularity_for_iteration = :month
Severity: Minor
Found in app/lib/stats/storage.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Views::ActiveClients#active_clients_progress calls 'options[:granularity]' 2 times
Open

        options[:granularity] ||= :day

        range = extract_range(options)
        cinstances = source.last.cinstances
Severity: Minor
Found in app/lib/stats/views/active_clients.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Views::Csv::TopApplications#generate calls 'app[:plan]' 2 times
Open

              csv << [app[:name], app[:id], app[:plan][:name], app[:plan][:id], app[:account][:name], app[:account][:id], app[:value]]
Severity: Minor
Found in app/lib/stats/views/csv/top_applications.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Stats::Views::Usage#extract_range_and_granularity calls 'options[:range]' 2 times
Open

          elsif options[:range].present?
            sanitize_range_and_granularity(options[:range], options[:granularity])
Severity: Minor
Found in app/lib/stats/views/usage.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

ThreeScale::Swagger::Validator#validate calls 'record.errors' 2 times
Open

        record.errors.add :body, :invalid_swagger
      rescue JSON::ParserError => error
        record.errors.add :body, :invalid_json
Severity: Minor
Found in app/lib/three_scale/swagger/validator.rb by reek

Duplication occurs when two fragments of code look nearly identical, or when two fragments of code have nearly identical effects at some conceptual level.

Reek implements a check for Duplicate Method Call.

Example

Here's a very much simplified and contrived example. The following method will report a warning:

def double_thing()
  @other.thing + @other.thing
end

One quick approach to silence Reek would be to refactor the code thus:

def double_thing()
  thing = @other.thing
  thing + thing
end

A slightly different approach would be to replace all calls of double_thing by calls to @other.double_thing:

class Other
  def double_thing()
    thing + thing
  end
end

The approach you take will depend on balancing other factors in your code.

Severity
Category
Status
Source
Language