Sign upLogin

kete/kete

View on GitHub
Star
app/controllers/account_controller.rb

Summary

Maintainability
F
3 days
Test Coverage

Unprotected mass assignment
Open

    @user = User.new(params[:user])
Severity: Critical
Found in app/controllers/account_controller.rb by brakeman

Mass assignment is a feature of Rails which allows an application to create a record from the values of a hash.

Example:

User.new(params[:user])

Unfortunately, if there is a user field called admin which controls administrator access, now any user can make themselves an administrator.

attr_accessible and attr_protected can be used to limit mass assignment. However, Brakeman will warn unless attr_accessible is used, or mass assignment is completely disabled.

There are two different mass assignment warnings which can arise. The first is when mass assignment actually occurs, such as the example above. This results in a warning like

Unprotected mass assignment near line 61: User.new(params[:user])

The other warning is raised whenever a model is found which does not use attr_accessible. This produces generic warnings like

Mass assignment is not restricted using attr_accessible

with a list of affected models.

In Rails 3.1 and newer, mass assignment can easily be disabled:

config.active_record.whitelist_attributes = true

Unfortunately, it can also easily be bypassed:

User.new(params[:user], :without_protection => true)

Brakeman will warn on uses of without_protection.

Unprotected mass assignment
Open

    if @user.update_attributes(params[:user])
Severity: Critical
Found in app/controllers/account_controller.rb by brakeman

Mass assignment is a feature of Rails which allows an application to create a record from the values of a hash.

Example:

User.new(params[:user])

Unfortunately, if there is a user field called admin which controls administrator access, now any user can make themselves an administrator.

attr_accessible and attr_protected can be used to limit mass assignment. However, Brakeman will warn unless attr_accessible is used, or mass assignment is completely disabled.

There are two different mass assignment warnings which can arise. The first is when mass assignment actually occurs, such as the example above. This results in a warning like

Unprotected mass assignment near line 61: User.new(params[:user])

The other warning is raised whenever a model is found which does not use attr_accessible. This produces generic warnings like

Mass assignment is not restricted using attr_accessible

with a list of affected models.

In Rails 3.1 and newer, mass assignment can easily be disabled:

config.active_record.whitelist_attributes = true

Unfortunately, it can also easily be bypassed:

User.new(params[:user], :without_protection => true)

Brakeman will warn on uses of without_protection.

Class has too many lines. [369/100]
Open

class AccountController < ApplicationController
  #####################################################################
  #####################################################################
  ### CONFIGURATION
  #####################################################################
Severity: Minor
Found in app/controllers/account_controller.rb by rubocop

This cop checks if the length a class exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Assignment Branch Condition size for login is too high. [90.36/15]
Open

  def login
    if request.post?

      # check for login/password
      # else anonymous user
Severity: Minor
Found in app/controllers/account_controller.rb by rubocop

This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

Method has too many lines. [52/10]
Open

  def login
    if request.post?

      # check for login/password
      # else anonymous user
Severity: Minor
Found in app/controllers/account_controller.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Method login has a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
Open

  def login
    if request.post?

      # check for login/password
      # else anonymous user
Severity: Minor
Found in app/controllers/account_controller.rb - About 5 hrs 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

File account_controller.rb has 370 lines of code (exceeds 250 allowed). Consider refactoring.
Open

class AccountController < ApplicationController
  #####################################################################
  #####################################################################
  ### CONFIGURATION
  #####################################################################
Severity: Minor
Found in app/controllers/account_controller.rb - About 4 hrs to fix

    Assignment Branch Condition size for reset_password is too high. [39.27/15]
    Open

      def reset_password
    @user = User.find_by_password_reset_code(params[:id]) if params[:id]
    raise if @user.nil?
    # form should have user hash after it's been submitted
    return if @user unless params[:user]
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

    Assignment Branch Condition size for forgot_password is too high. [39.77/15]
    Open

      def forgot_password
    return unless request.post?
    @users =
      !params[:user][:login].blank? ? User.find_all_by_email_and_login(params[:user][:email], params[:user][:login]) :
                                                  User.find_all_by_email(params[:user][:email])
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

    Method has too many lines. [30/10]
    Open

      def signup
    # this loads @content_type
    load_content_type

    @user = User.new
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

    Perceived complexity for login is too high. [24/7]
    Open

      def login
    if request.post?

      # check for login/password
      # else anonymous user
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop tries to produce a complexity score that's a measure of the complexity the reader experiences when looking at a method. For that reason it considers when nodes as something that doesn't add as much complexity as an if or a &&. Except if it's one of those special case/when constructs where there's no expression after case. Then the cop treats it as an if/elsif/elsif... and lets all the when nodes count. In contrast to the CyclomaticComplexity cop, this cop considers else nodes as adding complexity.

    Example:

    def my_method                   # 1
  if cond                       # 1
    case var                    # 2 (0.8 + 4 * 0.2, rounded)
    when 1 then func_one
    when 2 then func_two
    when 3 then func_three
    when 4..10 then func_other
    end
  else                          # 1
    do_something until a && b   # 2
  end                           # ===
end                             # 7 complexity points

    Assignment Branch Condition size for change_password is too high. [32.94/15]
    Open

      def change_password
    return unless request.post?
    if User.authenticate(current_user.login, params[:old_password])
      if params[:password] == params[:password_confirmation]
        current_user.password_confirmation = params[:password_confirmation]
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

    Cyclomatic complexity for login is too high. [21/6]
    Open

      def login
    if request.post?

      # check for login/password
      # else anonymous user
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.

    An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one.

    Assignment Branch Condition size for signup is too high. [30.77/15]
    Open

      def signup
    # this loads @content_type
    load_content_type

    @user = User.new
    Severity: Minor
    Found in app/controllers/account_controller.rb by rubocop

    This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

    Class AccountController has 27 methods (exceeds 20 allowed). Consider refactoring.
    Open

    class AccountController < ApplicationController
  #####################################################################
  #####################################################################
  ### CONFIGURATION
  #####################################################################
    Severity: Minor
    Found in app/controllers/account_controller.rb - About 3 hrs to fix

      Assignment Branch Condition size for update_portraits is too high. [27/15]
      Open

        def update_portraits
    begin
      portrait_ids = params[:portraits].delete('&').split('portrait_images[]=')
      # portrait_ids will now contain two blank spaces at the front, then the order of other portraits
      # we could strip these, but they actually work well here. One of then aligns positions with array indexs
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

      Method has too many lines. [21/10]
      Open

        def change_password
    return unless request.post?
    if User.authenticate(current_user.login, params[:old_password])
      if params[:password] == params[:password_confirmation]
        current_user.password_confirmation = params[:password_confirmation]
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Assignment Branch Condition size for activate is too high. [26.19/15]
      Open

        def activate
    flash.clear
    return if params[:id].nil? && params[:activation_code].nil?
    activator = params[:id] || params[:activation_code]
    @user = User.find_by_activation_code(activator)
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

      Method has too many lines. [19/10]
      Open

        def activate
    flash.clear
    return if params[:id].nil? && params[:activation_code].nil?
    activator = params[:id] || params[:activation_code]
    @user = User.find_by_activation_code(activator)
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Method has too many lines. [19/10]
      Open

        def update_portraits
    begin
      portrait_ids = params[:portraits].delete('&').split('portrait_images[]=')
      # portrait_ids will now contain two blank spaces at the front, then the order of other portraits
      # we could strip these, but they actually work well here. One of then aligns positions with array indexs
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Method has too many lines. [17/10]
      Open

        def reset_password
    @user = User.find_by_password_reset_code(params[:id]) if params[:id]
    raise if @user.nil?
    # form should have user hash after it's been submitted
    return if @user unless params[:user]
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Method has too many lines. [17/10]
      Open

        def forgot_password
    return unless request.post?
    @users =
      !params[:user][:login].blank? ? User.find_all_by_email_and_login(params[:user][:email], params[:user][:login]) :
                                                  User.find_all_by_email(params[:user][:email])
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Method has too many lines. [15/10]
      Open

        def update
    @user = User.find(current_user.id)

    original_user_name = @user.user_name
    if @user.update_attributes(params[:user])
      Severity: Minor
      Found in app/controllers/account_controller.rb by rubocop

      This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

      Method login has 52 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        def login
    if request.post?

      # check for login/password
      # else anonymous user
      Severity: Major
      Found in app/controllers/account_controller.rb - About 2 hrs to fix

        Assignment Branch Condition size for move_portrait_higher is too high. [18.71/15]
        Open

          def move_portrait_higher
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.move_portrait_higher_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.move_portrait_higher.moved_higher', portrait_title: @still_image.title)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

        Assignment Branch Condition size for move_portrait_lower is too high. [18.71/15]
        Open

          def move_portrait_lower
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.move_portrait_lower_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.move_portrait_lower.moved_lower', portrait_title: @still_image.title)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

        Assignment Branch Condition size for remove_portrait is too high. [18.71/15]
        Open

          def remove_portrait
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.remove_portrait_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.remove_portrait.removed_portrait', portrait_title: @still_image.title)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

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

          def reset_password
    @user = User.find_by_password_reset_code(params[:id]) if params[:id]
    raise if @user.nil?
    # form should have user hash after it's been submitted
    return if @user unless params[:user]
        Severity: Minor
        Found in app/controllers/account_controller.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 change_password has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
        Open

          def change_password
    return unless request.post?
    if User.authenticate(current_user.login, params[:old_password])
      if params[:password] == params[:password_confirmation]
        current_user.password_confirmation = params[:password_confirmation]
        Severity: Minor
        Found in app/controllers/account_controller.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

        Cyclomatic complexity for reset_password is too high. [8/6]
        Open

          def reset_password
    @user = User.find_by_password_reset_code(params[:id]) if params[:id]
    raise if @user.nil?
    # form should have user hash after it's been submitted
    return if @user unless params[:user]
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.

        An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one.

        Method has too many lines. [12/10]
        Open

          def remove_portrait
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.remove_portrait_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.remove_portrait.removed_portrait', portrait_title: @still_image.title)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Assignment Branch Condition size for show is too high. [17.03/15]
        Open

          def show
    if logged_in?
      if params[:id]
        @user = User.find(params[:id])
      else
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

        Method has too many lines. [12/10]
        Open

          def fetch_gravatar
    respond_to do |format|
      format.js do
        render :update do |page|
          page.replace_html params[:avatar_id],
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Method has too many lines. [12/10]
        Open

          def move_portrait_lower
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.move_portrait_lower_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.move_portrait_lower.moved_lower', portrait_title: @still_image.title)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Method has too many lines. [12/10]
        Open

          def show
    if logged_in?
      if params[:id]
        @user = User.find(params[:id])
      else
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Method has too many lines. [12/10]
        Open

          def move_portrait_higher
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.move_portrait_higher_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.move_portrait_higher.moved_higher', portrait_title: @still_image.title)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

        Assignment Branch Condition size for update is too high. [17.29/15]
        Open

          def update
    @user = User.find(current_user.id)

    original_user_name = @user.user_name
    if @user.update_attributes(params[:user])
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

        Perceived complexity for change_password is too high. [9/7]
        Open

          def change_password
    return unless request.post?
    if User.authenticate(current_user.login, params[:old_password])
      if params[:password] == params[:password_confirmation]
        current_user.password_confirmation = params[:password_confirmation]
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop tries to produce a complexity score that's a measure of the complexity the reader experiences when looking at a method. For that reason it considers when nodes as something that doesn't add as much complexity as an if or a &&. Except if it's one of those special case/when constructs where there's no expression after case. Then the cop treats it as an if/elsif/elsif... and lets all the when nodes count. In contrast to the CyclomaticComplexity cop, this cop considers else nodes as adding complexity.

        Example:

        def my_method                   # 1
  if cond                       # 1
    case var                    # 2 (0.8 + 4 * 0.2, rounded)
    when 1 then func_one
    when 2 then func_two
    when 3 then func_three
    when 4..10 then func_other
    end
  else                          # 1
    do_something until a && b   # 2
  end                           # ===
end                             # 7 complexity points

        Perceived complexity for activate is too high. [9/7]
        Open

          def activate
    flash.clear
    return if params[:id].nil? && params[:activation_code].nil?
    activator = params[:id] || params[:activation_code]
    @user = User.find_by_activation_code(activator)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop tries to produce a complexity score that's a measure of the complexity the reader experiences when looking at a method. For that reason it considers when nodes as something that doesn't add as much complexity as an if or a &&. Except if it's one of those special case/when constructs where there's no expression after case. Then the cop treats it as an if/elsif/elsif... and lets all the when nodes count. In contrast to the CyclomaticComplexity cop, this cop considers else nodes as adding complexity.

        Example:

        def my_method                   # 1
  if cond                       # 1
    case var                    # 2 (0.8 + 4 * 0.2, rounded)
    when 1 then func_one
    when 2 then func_two
    when 3 then func_three
    when 4..10 then func_other
    end
  else                          # 1
    do_something until a && b   # 2
  end                           # ===
end                             # 7 complexity points

        Perceived complexity for reset_password is too high. [9/7]
        Open

          def reset_password
    @user = User.find_by_password_reset_code(params[:id]) if params[:id]
    raise if @user.nil?
    # form should have user hash after it's been submitted
    return if @user unless params[:user]
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop tries to produce a complexity score that's a measure of the complexity the reader experiences when looking at a method. For that reason it considers when nodes as something that doesn't add as much complexity as an if or a &&. Except if it's one of those special case/when constructs where there's no expression after case. Then the cop treats it as an if/elsif/elsif... and lets all the when nodes count. In contrast to the CyclomaticComplexity cop, this cop considers else nodes as adding complexity.

        Example:

        def my_method                   # 1
  if cond                       # 1
    case var                    # 2 (0.8 + 4 * 0.2, rounded)
    when 1 then func_one
    when 2 then func_two
    when 3 then func_three
    when 4..10 then func_other
    end
  else                          # 1
    do_something until a && b   # 2
  end                           # ===
end                             # 7 complexity points

        Perceived complexity for signup is too high. [8/7]
        Open

          def signup
    # this loads @content_type
    load_content_type

    @user = User.new
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop tries to produce a complexity score that's a measure of the complexity the reader experiences when looking at a method. For that reason it considers when nodes as something that doesn't add as much complexity as an if or a &&. Except if it's one of those special case/when constructs where there's no expression after case. Then the cop treats it as an if/elsif/elsif... and lets all the when nodes count. In contrast to the CyclomaticComplexity cop, this cop considers else nodes as adding complexity.

        Example:

        def my_method                   # 1
  if cond                       # 1
    case var                    # 2 (0.8 + 4 * 0.2, rounded)
    when 1 then func_one
    when 2 then func_two
    when 3 then func_three
    when 4..10 then func_other
    end
  else                          # 1
    do_something until a && b   # 2
  end                           # ===
end                             # 7 complexity points

        Cyclomatic complexity for activate is too high. [7/6]
        Open

          def activate
    flash.clear
    return if params[:id].nil? && params[:activation_code].nil?
    activator = params[:id] || params[:activation_code]
    @user = User.find_by_activation_code(activator)
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the cyclomatic complexity of methods is not higher than the configured maximum. The cyclomatic complexity is the number of linearly independent paths through a method. The algorithm counts decision points and adds one.

        An if statement (or unless or ?:) increases the complexity by one. An else branch does not, since it doesn't add a decision point. The && operator (or keyword and) can be converted to a nested if statement, and ||/or is shorthand for a sequence of ifs, so they also add one. Loops can be said to have an exit condition, so they add one.

        Assignment Branch Condition size for simple_or_application is too high. [15.56/15]
        Open

          def simple_or_application
    return 'application' if session[:return_to].blank?

    simple_return_tos_regexp = Regexp.new(simple_return_tos.join('|'))
        Severity: Minor
        Found in app/controllers/account_controller.rb by rubocop

        This cop checks that the ABC size of methods is not higher than the configured maximum. The ABC size is based on assignments, branches (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric

        Method signup has 30 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          def signup
    # this loads @content_type
    load_content_type

    @user = User.new
        Severity: Minor
        Found in app/controllers/account_controller.rb - About 1 hr to fix

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

            def signup
    # this loads @content_type
    load_content_type

    @user = User.new
          Severity: Minor
          Found in app/controllers/account_controller.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 activate has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
          Open

            def activate
    flash.clear
    return if params[:id].nil? && params[:activation_code].nil?
    activator = params[:id] || params[:activation_code]
    @user = User.find_by_activation_code(activator)
          Severity: Minor
          Found in app/controllers/account_controller.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 forgot_password has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

            def forgot_password
    return unless request.post?
    @users =
      !params[:user][:login].blank? ? User.find_all_by_email_and_login(params[:user][:email], params[:user][:login]) :
                                                  User.find_all_by_email(params[:user][:email])
          Severity: Minor
          Found in app/controllers/account_controller.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 show has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

            def show
    if logged_in?
      if params[:id]
        @user = User.find(params[:id])
      else
          Severity: Minor
          Found in app/controllers/account_controller.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

          Avoid more than 3 levels of block nesting.
          Open

                    website = 'http://' + website unless website.include?('http')
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for excessive nesting of conditional and looping constructs.

          You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

          The maximum level of nesting allowed is configurable.

          Avoid more than 3 levels of block nesting.
          Open

                    if @security_code != @security_code_confirmation || @security_code.blank?
            error_msgs << t('account_controller.login.failed_security_answer')
          end
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for excessive nesting of conditional and looping constructs.

          You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

          The maximum level of nesting allowed is configurable.

          Avoid more than 3 levels of block nesting.
          Open

                    anonymous_name = params[:name].blank? ? @anonymous_user.user_name : params[:name]
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for excessive nesting of conditional and looping constructs.

          You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

          The maximum level of nesting allowed is configurable.

          Avoid more than 3 levels of block nesting.
          Open

                    session[:anonymous_user][:website] = website if temp_weblink.valid?
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for excessive nesting of conditional and looping constructs.

          You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

          The maximum level of nesting allowed is configurable.

          Avoid more than 3 levels of block nesting.
          Open

                    if params[:email].blank? || !params[:email].include?('@')
            error_msgs << t('account_controller.login.invalid_email')
          end
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for excessive nesting of conditional and looping constructs.

          You can configure if blocks are considered using the CountBlocks option. When set to false (the default) blocks are not counted towards the nesting level. Set to true to count blocks as well.

          The maximum level of nesting allowed is configurable.

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

            def move_portrait_lower
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.move_portrait_lower_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.move_portrait_lower.moved_lower', portrait_title: @still_image.title)
          Severity: Major
          Found in app/controllers/account_controller.rb and 2 other locations - About 1 hr to fix
          app/controllers/account_controller.rb on lines 336..347
          app/controllers/account_controller.rb on lines 361..372

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 56.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

            def move_portrait_higher
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.move_portrait_higher_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.move_portrait_higher.moved_higher', portrait_title: @still_image.title)
          Severity: Major
          Found in app/controllers/account_controller.rb and 2 other locations - About 1 hr to fix
          app/controllers/account_controller.rb on lines 336..347
          app/controllers/account_controller.rb on lines 376..387

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 56.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

            def remove_portrait
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.remove_portrait_for(current_user, @still_image)
      @successful = true
      flash[:notice] = t('account_controller.remove_portrait.removed_portrait', portrait_title: @still_image.title)
          Severity: Major
          Found in app/controllers/account_controller.rb and 2 other locations - About 1 hr to fix
          app/controllers/account_controller.rb on lines 361..372
          app/controllers/account_controller.rb on lines 376..387

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 56.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

            def add_portrait
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.new_portrait_for(current_user, @still_image)
      flash[:notice] = t('account_controller.add_portrait.added_portrait', portrait_title: @still_image.title)
    else
          Severity: Minor
          Found in app/controllers/account_controller.rb and 1 other location - About 30 mins to fix
          app/controllers/account_controller.rb on lines 351..358

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 32.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Similar blocks of code found in 2 locations. Consider refactoring.
          Open

            def make_selected_portrait
    @still_image = StillImage.find(params[:id])
    if UserPortraitRelation.make_portrait_selected_for(current_user, @still_image)
      flash[:notice] = t('account_controller.make_selected_portrait.made_selected', portrait_title: @still_image.title)
    else
          Severity: Minor
          Found in app/controllers/account_controller.rb and 1 other location - About 30 mins to fix
          app/controllers/account_controller.rb on lines 326..333

          Duplicated Code

          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

          Tuning

          This issue has a mass of 32.

          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

          Refactorings

          Further Reading

          Useless assignment to variable - original_user_name.
          Open

              original_user_name = @user.user_name
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for every useless assignment to local variable in every scope. The basic idea for this cop was from the warning of ruby -cw:

          assigned but unused variable - foo

          Currently this cop has advanced logic that detects unreferenced reassignments and properly handles varied cases such as branch, loop, rescue, ensure, etc.

          Example:

          # bad

def some_method
  some_var = 1
  do_something
end

          Example:

          # good

def some_method
  some_var = 1
  do_something(some_var)
end

          Favor modifier if usage when having a single-line body. Another good alternative is the usage of control flow &&/||.
          Open

              if agreed_terms?
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          Checks for if and unless statements that would fit on one line if written as a modifier if/unless. The maximum line length is configured in the Metrics/LineLength cop.

          Example:

          # bad
if condition
  do_stuff(bar)
end

unless qux.empty?
  Foo.do_something
end

# good
do_stuff(bar) if condition
Foo.do_something unless qux.empty?

          Avoid multi-line ternary operators, use if or unless instead.
          Open

                !params[:user][:login].blank? ? User.find_all_by_email_and_login(params[:user][:email], params[:user][:login]) :
                                                  User.find_all_by_email(params[:user][:email])
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for multi-line ternary op expressions.

          Example:

          # bad
a = cond ?
  b : c
a = cond ? b :
    c
a = cond ?
    b :
    c

# good
a = cond ? b : c
a =
  if cond
    b
  else
    c
  end

          Avoid rescuing without specifying an error class.
          Open

              rescue
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for rescuing StandardError. There are two supported styles implicit and explicit. This cop will not register an offense if any error other than StandardError is specified.

          Example: EnforcedStyle: implicit

          # `implicit` will enforce using `rescue` instead of
# `rescue StandardError`.

# bad
begin
  foo
rescue StandardError
  bar
end

# good
begin
  foo
rescue
  bar
end

# good
begin
  foo
rescue OtherError
  bar
end

# good
begin
  foo
rescue StandardError, SecurityError
  bar
end

          Example: EnforcedStyle: explicit (default)

          # `explicit` will enforce using `rescue StandardError`
# instead of `rescue`.

# bad
begin
  foo
rescue
  bar
end

# good
begin
  foo
rescue StandardError
  bar
end

# good
begin
  foo
rescue OtherError
  bar
end

# good
begin
  foo
rescue StandardError, SecurityError
  bar
end

          Convert if nested inside else to elsif.
          Open

                  if anonymous_ok_for?(session[:return_to]) &&
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          If the else branch of a conditional consists solely of an if node, it can be combined with the else to become an elsif. This helps to keep the nesting level from getting too deep.

          Example:

          # bad
if condition_a
  action_a
else
  if condition_b
    action_b
  else
    action_c
  end
end

# good
if condition_a
  action_a
elsif condition_b
  action_b
else
  action_c
end

          Redundant curly braces around a hash parameter.
          Open

              redirect_back_or_default({
                               locale: params[:user][:locale],
                               urlified_name: @site_basket.urlified_name,
                               controller: 'account',
                               action: 'index'
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for braces around the last parameter in a method call if the last parameter is a hash. It supports braces, no_braces and context_dependent styles.

          Example: EnforcedStyle: braces

          # The `braces` style enforces braces around all method
# parameters that are hashes.

# bad
some_method(x, y, a: 1, b: 2)

# good
some_method(x, y, {a: 1, b: 2})

          Example: EnforcedStyle: no_braces (default)

          # The `no_braces` style checks that the last parameter doesn't
# have braces around it.

# bad
some_method(x, y, {a: 1, b: 2})

# good
some_method(x, y, a: 1, b: 2)

          Example: EnforcedStyle: context_dependent

          # The `context_dependent` style checks that the last parameter
# doesn't have braces around it, but requires braces if the
# second to last parameter is also a hash literal.

# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)

# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})

          Use the return of the conditional for variable assignment and comparison.
          Open

                if params[:id]
        @user = User.find(params[:id])
      else
        @user = current_user
      end
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          Redundant curly braces around a hash parameter.
          Open

                redirect_to({
                    locale: params[:user][:locale],
                    urlified_name: @site_basket.urlified_name,
                    controller: 'account',
                    action: 'show',
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for braces around the last parameter in a method call if the last parameter is a hash. It supports braces, no_braces and context_dependent styles.

          Example: EnforcedStyle: braces

          # The `braces` style enforces braces around all method
# parameters that are hashes.

# bad
some_method(x, y, a: 1, b: 2)

# good
some_method(x, y, {a: 1, b: 2})

          Example: EnforcedStyle: no_braces (default)

          # The `no_braces` style checks that the last parameter doesn't
# have braces around it.

# bad
some_method(x, y, {a: 1, b: 2})

# good
some_method(x, y, a: 1, b: 2)

          Example: EnforcedStyle: context_dependent

          # The `context_dependent` style checks that the last parameter
# doesn't have braces around it, but requires braces if the
# second to last parameter is also a hash literal.

# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)

# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})

          Use a guard clause instead of wrapping the code inside a conditional expression.
          Open

              unless SystemSetting.enable_user_portraits?
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          Use a guard clause instead of wrapping the code inside a conditional expression

          Example:

          # bad
def test
  if something
    work
  end
end

# good
def test
  return unless something
  work
end

# also good
def test
  work if something
end

# bad
if something
  raise 'exception'
else
  ok
end

# good
raise 'exception' if something
ok

          Redundant curly braces around a hash parameter.
          Open

                                        { width: 30, height: 30, alt: t('account_controller.fetch_gravatar.your_gravatar') }
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for braces around the last parameter in a method call if the last parameter is a hash. It supports braces, no_braces and context_dependent styles.

          Example: EnforcedStyle: braces

          # The `braces` style enforces braces around all method
# parameters that are hashes.

# bad
some_method(x, y, a: 1, b: 2)

# good
some_method(x, y, {a: 1, b: 2})

          Example: EnforcedStyle: no_braces (default)

          # The `no_braces` style checks that the last parameter doesn't
# have braces around it.

# bad
some_method(x, y, {a: 1, b: 2})

# good
some_method(x, y, a: 1, b: 2)

          Example: EnforcedStyle: context_dependent

          # The `context_dependent` style checks that the last parameter
# doesn't have braces around it, but requires braces if the
# second to last parameter is also a hash literal.

# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)

# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})

          Convert if nested inside else to elsif.
          Open

                  if params[:login].present? && params[:password].present?
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          If the else branch of a conditional consists solely of an if node, it can be combined with the else to become an elsif. This helps to keep the nesting level from getting too deep.

          Example:

          # bad
if condition_a
  action_a
else
  if condition_b
    action_b
  else
    action_c
  end
end

# good
if condition_a
  action_a
elsif condition_b
  action_b
else
  action_c
end

          Avoid multi-line ternary operators, use if or unless instead.
          Open

                    current_user.save ?
                 t('account_controller.change_password.password_changed') :
                   t('account_controller.change_password.password_not_changed')
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for multi-line ternary op expressions.

          Example:

          # bad
a = cond ?
  b : c
a = cond ? b :
    c
a = cond ?
    b :
    c

# good
a = cond ? b : c
a =
  if cond
    b
  else
    c
  end

          Use a guard clause instead of wrapping the code inside a conditional expression.
          Open

              if request.post?
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          Use a guard clause instead of wrapping the code inside a conditional expression

          Example:

          # bad
def test
  if something
    work
  end
end

# good
def test
  return unless something
  work
end

# also good
def test
  work if something
end

# bad
if something
  raise 'exception'
else
  ok
end

# good
raise 'exception' if something
ok

          Avoid using nested modifiers.
          Open

              return if @user unless params[:user]
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for nested use of if, unless, while and until in their modifier form.

          Example:

          # bad
something if a if b

# good
something if b && a

          Avoid rescuing without specifying an error class.
          Open

            rescue
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for rescuing StandardError. There are two supported styles implicit and explicit. This cop will not register an offense if any error other than StandardError is specified.

          Example: EnforcedStyle: implicit

          # `implicit` will enforce using `rescue` instead of
# `rescue StandardError`.

# bad
begin
  foo
rescue StandardError
  bar
end

# good
begin
  foo
rescue
  bar
end

# good
begin
  foo
rescue OtherError
  bar
end

# good
begin
  foo
rescue StandardError, SecurityError
  bar
end

          Example: EnforcedStyle: explicit (default)

          # `explicit` will enforce using `rescue StandardError`
# instead of `rescue`.

# bad
begin
  foo
rescue
  bar
end

# good
begin
  foo
rescue StandardError
  bar
end

# good
begin
  foo
rescue OtherError
  bar
end

# good
begin
  foo
rescue StandardError, SecurityError
  bar
end

          Redundant curly braces around a hash parameter.
          Open

                                        User.new({ email: params[:email] || '' }),
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for braces around the last parameter in a method call if the last parameter is a hash. It supports braces, no_braces and context_dependent styles.

          Example: EnforcedStyle: braces

          # The `braces` style enforces braces around all method
# parameters that are hashes.

# bad
some_method(x, y, a: 1, b: 2)

# good
some_method(x, y, {a: 1, b: 2})

          Example: EnforcedStyle: no_braces (default)

          # The `no_braces` style checks that the last parameter doesn't
# have braces around it.

# bad
some_method(x, y, {a: 1, b: 2})

# good
some_method(x, y, a: 1, b: 2)

          Example: EnforcedStyle: context_dependent

          # The `context_dependent` style checks that the last parameter
# doesn't have braces around it, but requires braces if the
# second to last parameter is also a hash literal.

# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)

# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})

          Use User.count.positive? instead of User.count > 0.
          Open

              if logged_in? || User.count > 0
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for usage of comparison operators (==, >, <) to test numbers as zero, positive, or negative. These can be replaced by their respective predicate methods. The cop can also be configured to do the reverse.

          The cop disregards #nonzero? as it its value is truthy or falsey, but not true and false, and thus not always interchangeable with != 0.

          The cop ignores comparisons to global variables, since they are often populated with objects which can be compared with integers, but are not themselves Interger polymorphic.

          Example: EnforcedStyle: predicate (default)

          # bad

foo == 0
0 > foo
bar.baz > 0

# good

foo.zero?
foo.negative?
bar.baz.positive?

          Example: EnforcedStyle: comparison

          # bad

foo.zero?
foo.negative?
bar.baz.positive?

# good

foo == 0
0 > foo
bar.baz > 0

          Use safe navigation (&.) instead of checking if an object exists before calling the method.
          Open

              if @user && @user.activate
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop transforms usages of a method call safeguarded by a non nil check for the variable whose method is being called to safe navigation (&.).

          Configuration option: ConvertCodeThatCanStartToReturnNil The default for this is false. When configured to true, this will check for code in the format !foo.nil? && foo.bar. As it is written, the return of this code is limited to false and whatever the return of the method is. If this is converted to safe navigation, foo&.bar can start returning nil as well as what the method returns.

          Example:

          # bad
foo.bar if foo
foo.bar(param1, param2) if foo
foo.bar { |e| e.something } if foo
foo.bar(param) { |e| e.something } if foo

foo.bar if !foo.nil?
foo.bar unless !foo
foo.bar unless foo.nil?

foo && foo.bar
foo && foo.bar(param1, param2)
foo && foo.bar { |e| e.something }
foo && foo.bar(param) { |e| e.something }

# good
foo&.bar
foo&.bar(param1, param2)
foo&.bar { |e| e.something }
foo&.bar(param) { |e| e.something }

foo.nil? || foo.bar
!foo || foo.bar

# Methods that `nil` will `respond_to?` should not be converted to
# use safe navigation
foo.to_i if foo

          Use the return of the conditional for variable assignment and comparison.
          Open

                if SystemSetting.administrator_activates?
        flash[:notice] = t('account_controller.signup.signed_up_admin_will_review')
      else
        flash[:notice] = t('account_controller.signup.signed_up_with_email')
      end
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          Redundant curly braces around a hash parameter.
          Open

                UserPortraitRelation.update_all({ position: 1 }, { user_id: current_user })
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          This cop checks for braces around the last parameter in a method call if the last parameter is a hash. It supports braces, no_braces and context_dependent styles.

          Example: EnforcedStyle: braces

          # The `braces` style enforces braces around all method
# parameters that are hashes.

# bad
some_method(x, y, a: 1, b: 2)

# good
some_method(x, y, {a: 1, b: 2})

          Example: EnforcedStyle: no_braces (default)

          # The `no_braces` style checks that the last parameter doesn't
# have braces around it.

# bad
some_method(x, y, {a: 1, b: 2})

# good
some_method(x, y, a: 1, b: 2)

          Example: EnforcedStyle: context_dependent

          # The `context_dependent` style checks that the last parameter
# doesn't have braces around it, but requires braces if the
# second to last parameter is also a hash literal.

# bad
some_method(x, y, {a: 1, b: 2})
some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)

# good
some_method(x, y, a: 1, b: 2)
some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})

          Convert if nested inside else to elsif.
          Open

                if SystemSetting.administrator_activates?
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          If the else branch of a conditional consists solely of an if node, it can be combined with the else to become an elsif. This helps to keep the nesting level from getting too deep.

          Example:

          # bad
if condition_a
  action_a
else
  if condition_b
    action_b
  else
    action_c
  end
end

# good
if condition_a
  action_a
elsif condition_b
  action_b
else
  action_c
end

          Avoid modifier unless after another conditional.
          Open

              return if @user unless params[:user]
          Severity: Minor
          Found in app/controllers/account_controller.rb by rubocop

          Checks for if and unless statements used as modifiers of other if or unless statements.

          Example:

          # bad tired? ? 'stop' : 'go faster' if running?

          # bad if tired? "please stop" else "keep going" end if running?

          # good if running? tired? ? 'stop' : 'go faster' end

          There are no issues that match your filters.

          Category
          Status