Sign upLogin

3scale/porta

View on GitHub
Star

Showing 5,269 of 5,606 total issues

Backend::UsageAccumulator#validate_limits! calls 'usage_limit.metric_id' 2 times
Open

        value = values_in_period && values_in_period[usage_limit.metric_id]
        value = value.to_i + additional_usage[usage_limit.metric_id].to_i
Severity: Minor
Found in app/models/backend/usage_accumulator.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.

CMS::Section#dirty? calls 'p.dirty?' 2 times
Open

      self.pages.any? { |p| p.dirty? } ||
      self.builtins.any? { |p| p.dirty? }
Severity: Minor
Found in app/models/cms/section.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.

Contract#intersect_with_unpaid_period calls 'period.end' 2 times
Open

      period = period.begin..(period.end - 1.second)
    end

    from = [ period.begin.to_date, paid_end ].max.to_date
    to = [ period.end.to_date, from ].max.to_date
Severity: Minor
Found in app/models/contract.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.

Finance::BillingStrategy#charge_invoices calls 'log_prefix(buyer)' 2 times
Open

        Rails.logger.info("#{log_prefix(buyer)} trying to charge invoice #{invoice.id}")
        invoice.charge!

      end
    else
Severity: Minor
Found in app/models/finance/billing_strategy.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.

HyperMegaProfiler#count_objects calls 'ObjectSpace.memsize_of(o)' 2 times
Open

        val[:size] += ObjectSpace.memsize_of(o)
        val[:names] += ", #{o.org_name}" if o.respond_to?(:org_name)
      else
        new[key] = {
          count: 1,
Severity: Minor
Found in script/hyper_mega_profiler.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.

APIHitting::Client#method_missing calls 'params.to_query' 3 times
Open

      print "ERROR for #{method.to_s.upcase} #{url} with #{params.to_query} in #{Time.now - start} seconds\n"
    rescue HTTPClient::ReceiveTimeoutError
      print "TIMEOUT for #{method.to_s.upcase} #{url} with #{params.to_query} in #{Time.now - start} seconds\n"
    rescue OpenSSL::SSL::SSLError
      print "SSL ERROR #{method.to_s.upcase} #{url} with #{params.to_query} in #{Time.now - start} seconds\n"
Severity: Minor
Found in script/stress-test/api_hitting.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.

ProviderClicking#log_in! calls '@agent.submit(form)' 2 times
Open

      page = @agent.submit(form)
    end

    form = page.form_with(:action => '/p/sessions')
    form.username = @username
Severity: Minor
Found in script/stress-test/provider_clicking.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.

Backend::UsageAccumulator#calculate_total_cost calls 'options[:additional_usage]' 2 times
Open

      total_values += options[:additional_usage] if options[:additional_usage]
Severity: Minor
Found in app/models/backend/usage_accumulator.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.

CMS::Portlet#inputs calls 'self.class' 2 times
Open

    inputs = self.class._inputs
    Hash[ self.class.attributes.map{ |attr| [attr, { :as => inputs[attr] } ] } ]
Severity: Minor
Found in app/models/cms/portlet.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.

FeaturesPlan#feature_scope_matches_plan_class? calls 'self.plan' 2 times
Open

    if self.plan && self.feature && self.feature.scope != self.plan.class.to_s
Severity: Minor
Found in app/models/features_plan.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.

Invoice#charge! calls 'Rails.application' 2 times
Open

        Rails.application.config.event_store.publish_event(event)
      else
        logger.info("Marking invoice #{id} (buyer #{buyer_account_id}) as failed (too many retries)")
        fail!
        # TODO: Decouple the notification to observer and delete the IF
Severity: Minor
Found in app/models/invoice.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.

Backend::Status#to_xml calls 'record.period_as_range' 2 times
Open

            xml.period_start(record.period_as_range.begin.to_s(:db)) unless record.period == :eternity
            xml.period_end(record.period_as_range.end.to_s(:db)) unless record.period == :eternity
Severity: Minor
Found in app/models/backend/status.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.

CMS::Portlet::Base#default_template manually dispatches method call
Open

      self.class.respond_to?(:default_template) and self.class.default_template
Severity: Minor
Found in app/models/cms/portlet.rb by reek

Reek reports a Manual Dispatch smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of Simulated Polymorphism which leads to code that is harder to reason about, debug, and refactor.

Example

class MyManualDispatcher
  attr_reader :foo

  def initialize(foo)
    @foo = foo
  end

  def call
    foo.bar if foo.respond_to?(:bar)
  end
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)

Configuration#save! manually dispatches method call
Open

      @configurable.configuration_changed if @configurable.respond_to?(:configuration_changed)
Severity: Minor
Found in app/models/configuration.rb by reek

Reek reports a Manual Dispatch smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of Simulated Polymorphism which leads to code that is harder to reason about, debug, and refactor.

Example

class MyManualDispatcher
  attr_reader :foo

  def initialize(foo)
    @foo = foo
  end

  def call
    foo.bar if foo.respond_to?(:bar)
  end
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)

Finance::BillingStrategy::Results#success calls '@providers[billing_strategy.provider.id]' 2 times
Open

    @providers[billing_strategy.provider.id][:success] = true
    @providers[billing_strategy.provider.id][:errors] = billing_strategy.failed_buyers
Severity: Minor
Found in app/models/finance/billing_strategy/results.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.

Finance::BillingStrategy#add_plan_cost calls 'action == :refund' 2 times
Open

      sign = action == :refund ? -1 : 1
      reason = action == :refund ? 'Refund' : 'Fixed fee'
Severity: Minor
Found in app/models/finance/billing_strategy.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.

Invoice#charge! calls 'Rails.application.config' 2 times
Open

        Rails.application.config.event_store.publish_event(event)
      else
        logger.info("Marking invoice #{id} (buyer #{buyer_account_id}) as failed (too many retries)")
        fail!
        # TODO: Decouple the notification to observer and delete the IF
Severity: Minor
Found in app/models/invoice.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.

PaymentGatewaySetting#symbolized_settings manually dispatches method call
Open

    settings = settings.permit(keys).to_h unless settings.respond_to? :symbolize_keys
Severity: Minor
Found in app/models/payment_gateway_setting.rb by reek

Reek reports a Manual Dispatch smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of Simulated Polymorphism which leads to code that is harder to reason about, debug, and refactor.

Example

class MyManualDispatcher
  attr_reader :foo

  def initialize(foo)
    @foo = foo
  end

  def call
    foo.bar if foo.respond_to?(:bar)
  end
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)

PaymentTransaction#process! calls 'exception.message' 2 times
Open

      logger.info("Processing of PaymentTransaction threw an exception: #{exception.message}")
      self.success = false
      self.message = exception.message
Severity: Minor
Found in app/models/payment_transaction.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.

Backend::Status#initialize manually dispatches method call
Open

        metric_name = if constant_data[:metric_ids].respond_to?(:index) # this works for arrays and 1.8 hashes
Severity: Minor
Found in app/models/backend/status.rb by reek

Reek reports a Manual Dispatch smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of Simulated Polymorphism which leads to code that is harder to reason about, debug, and refactor.

Example

class MyManualDispatcher
  attr_reader :foo

  def initialize(foo)
    @foo = foo
  end

  def call
    foo.bar if foo.respond_to?(:bar)
  end
end

Reek would emit the following warning:

test.rb -- 1 warning:
  [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)
Severity
Category
Status
Source
Language