It's unclear to me why `(@user.submitted_at || session[:confirm_membership].present?)` determine if `@user` is saved with full validations or not. Regardless, it could be written less confusingly:

```ruby
def should_save_with_validations?(user)
  @user.submitted_at || session[:confirm_membership].present?
end

def update_maybe_with_validations
  method = should_save_with_validations?(@user) ? :update_with_full_validation : :update_attributes
  @user.send(method, params[:user]
end

if update_maybe_with_validations
  ...
else
  ...
end
```

I'd argue this snippet is better for a few reasons:
* `should_save_with_validations?` now holds the only unexplainable/surprising parts of the code. And `update_maybe_with_validations` is completely clean.
* `update_maybe_with_validations` is a simple function and every code path is exercised every time it's called. When it can be done simply, I prefer this way to a more verbose:

```ruby
def update_maybe_with_validations
  if should_save_with_validations?(@user)
    @user.update_with_full_validation(params[:user])
  else
    @user.update_attributes(params[:user])
  end
end
```

* .. because this has duplicated code, and that's always an opportunity for an inconsistency to be introduced.

You might be tempted to use a ternary:
```ruby
def update_maybe_with_validations
  should_save_with_validations?(@user) ?
    @user.update_with_full_validation(params[:user]) :
    @user.update_attributes(params[:user])
end
```

but remember that standard convention says a ternary should be for selecting values and not calling functions with side effects.