Sign upLogin

3scale/porta

View on GitHub
Star
app/lib/logic/plan_changes.rb

Summary

Maintainability
A
3 hrs
Test Coverage

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

      def can_change_plan?(issuer = self.plan.issuer)
        return false unless issuer
        # get type from passed plan or from reflection if plan is not available
        type = plan ? plan.class : self.class.reflect_on_association(:plan).class_name
Severity: Minor
Found in app/lib/logic/plan_changes.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

Logic::PlanChanges::Contract#buyer_changes_plan! has approx 9 statements
Open

      def buyer_changes_plan!(plan)
Severity: Minor
Found in app/lib/logic/plan_changes.rb by reek

A method with Too Many Statements is any method that has a large number of lines.

Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

So the following method would score +6 in Reek's statement-counting algorithm:

def parse(arg, argv, &error)
  if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
    return nil, block, nil                                         # +1
  end
  opt = (val = parse_arg(val, &error))[1]                          # +2
  val = conv_arg(*val)                                             # +3
  if opt and !arg
    argv.shift                                                     # +4
  else
    val[0] = nil                                                   # +5
  end
  val                                                              # +6
end

(You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

Logic::PlanChanges::Contract#plan_change_permission_warning has approx 9 statements
Open

      def plan_change_permission_warning
Severity: Minor
Found in app/lib/logic/plan_changes.rb by reek

A method with Too Many Statements is any method that has a large number of lines.

Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

So the following method would score +6 in Reek's statement-counting algorithm:

def parse(arg, argv, &error)
  if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
    return nil, block, nil                                         # +1
  end
  opt = (val = parse_arg(val, &error))[1]                          # +2
  val = conv_arg(*val)                                             # +3
  if opt and !arg
    argv.shift                                                     # +4
  else
    val[0] = nil                                                   # +5
  end
  val                                                              # +6
end

(You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

Logic::PlanChanges::Contract#can_change_plan? has approx 10 statements
Open

      def can_change_plan?(issuer = self.plan.issuer)
Severity: Minor
Found in app/lib/logic/plan_changes.rb by reek

A method with Too Many Statements is any method that has a large number of lines.

Too Many Statements warns about any method that has more than 5 statements. Reek's smell detector for Too Many Statements counts +1 for every simple statement in a method and +1 for every statement within a control structure (if, else, case, when, for, while, until, begin, rescue) but it doesn't count the control structure itself.

So the following method would score +6 in Reek's statement-counting algorithm:

def parse(arg, argv, &error)
  if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
    return nil, block, nil                                         # +1
  end
  opt = (val = parse_arg(val, &error))[1]                          # +2
  val = conv_arg(*val)                                             # +3
  if opt and !arg
    argv.shift                                                     # +4
  else
    val[0] = nil                                                   # +5
  end
  val                                                              # +6
end

(You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)

Method plan_change_permission has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
Open

      def plan_change_permission(type, opts = { :new_contract => false })
        if opts[:new_contract]
          if type == ApplicationPlan && !self.buyer_can_select_plan?
            :none
          else
Severity: Minor
Found in app/lib/logic/plan_changes.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 buyer_changes_plan! has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
Open

      def buyer_changes_plan!(plan)
        issuer = self.plan.issuer
        permission = issuer.plan_change_permission(self.plan.class)

        case permission
Severity: Minor
Found in app/lib/logic/plan_changes.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 plan_change_permission_warning has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
Open

      def plan_change_permission_warning
        permission = self.plan.issuer.plan_change_permission(self.plan.class)
        direct = 'Are you sure you want to change your plan?'
        request = 'Are you sure you want to request a plan change?'
Severity: Minor
Found in app/lib/logic/plan_changes.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

Logic::PlanChanges::Contract#buyer_changes_plan! calls 'self.user_account' 2 times
Open

          if self.user_account.credit_card_stored?
            direct_plan_change_actions(plan)
          else
            request_plan_change_actions(plan)
          end
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#account_plan_change_action calls 'self.user_account' 2 times
Open

        AccountMessenger.plan_change_request(self.user_account, plan).deliver
        event = Accounts::AccountPlanChangeRequestedEvent.create(self.user_account, User.current, plan)
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#buyer_changes_plan! calls 'self.plan' 2 times
Open

        issuer = self.plan.issuer
        permission = issuer.plan_change_permission(self.plan.class)
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Provider#set_change_account_plan_permission! calls 'self.settings' 2 times
Open

        self.settings.change_account_plan_permission = mode
        self.settings.save!
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Provider#set_change_service_plan_permission! calls 'self.settings' 2 times
Open

        self.settings.change_service_plan_permission = mode
        self.settings.save!
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#buyer_changes_plan! calls 'self.user_account.credit_card_stored?' 2 times
Open

          if self.user_account.credit_card_stored?
            direct_plan_change_actions(plan)
          else
            request_plan_change_actions(plan)
          end
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#plan_change_permission_name calls 'self.plan' 2 times
Open

        permission = self.plan.issuer.plan_change_permission(self.plan.class)
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#plan_change_permission_warning calls 'self.user_account' 2 times
Open

        when :credit_card then self.user_account.credit_card_stored? ? direct : request
        when :request_credit_card then self.user_account.credit_card_stored? ? direct : request
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#plan_change_permission_warning calls 'self.plan' 2 times
Open

        permission = self.plan.issuer.plan_change_permission(self.plan.class)
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#buyer_changes_plan! calls 'request_plan_change_actions(plan)' 2 times
Open

          request_plan_change_actions(plan)
        when :credit_card
          if self.user_account.credit_card_stored?
            direct_plan_change_actions(plan)
          else
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#plan_change_permission_warning calls 'self.user_account.credit_card_stored?' 2 times
Open

        when :credit_card then self.user_account.credit_card_stored? ? direct : request
        when :request_credit_card then self.user_account.credit_card_stored? ? direct : request
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#provider_changes_plan! calls 'self.plan' 2 times
Open

        issuer = self.plan.issuer
        permission = issuer.plan_change_permission(self.plan.class)
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Service#plan_change_permission calls 'type == ApplicationPlan' 2 times
Open

          if type == ApplicationPlan && !self.buyer_can_select_plan?
            :none
          else
            :direct
          end
Severity: Minor
Found in app/lib/logic/plan_changes.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.

Logic::PlanChanges::Contract#buyer_changes_plan! calls 'direct_plan_change_actions(plan)' 3 times
Open

          direct_plan_change_actions(plan)
        when :request
          request_plan_change_actions(plan)
        when :credit_card
          if self.user_account.credit_card_stored?
Severity: Minor
Found in app/lib/logic/plan_changes.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.

There are no issues that match your filters.

Category
Status