$('#username').keyup(function() {
    if ($('#username').val() != '') {
        $('#submit').removeAttr('disabled');
    } else {
        $('#submit').attr('disabled', 'disabled');
    }
});

It ensures that the submit button is only enabled if the “username” input field is not empty (you can see such a behavior on twitter for example).

However, the snippet from above can be rewritten in a shorter and more elegant way:

$('#username').keyup(function() {
    $('#submit').attr('disabled', !$('#username').val()); 
});

Maybe this is helpful for someone out there ;-)

class BooleanValidatorTest extends CakeTestCase {
    private $validator = null;
	
    public function setUp() {
        $this->validator = new BooleanValidator();
    }
	
    public function testValidate() {
        $this->assertIdentical(true, $this->validator->validate(true));
        $this->assertIdentical(true, $this->validator->validate(false));
        $this->assertTrue(is_string($this->validator->validate(0)));
        $this->assertTrue(is_string($this->validator->validate(1)));
    }
}

The code is quite trivial, though it is not that easy to see what I try to express with this code. And so we have to improve its readability.

For this purpose we will write two custom asserts. Custom asserts are nothing special, they are normal methods. But for some reason it seems like people think they always have to use the assert methods provided by the testing framework.

Let’s have a look at the test method above. What is verified in the first two lines with assertIdentical()? It is simple: it is verified the validation process recognizes the provided data as valid. So, we have the first custom assert method: assertValid().

Now you might think the second custom assert method will be assertInvalid(). This would be a good name if the validation process would return false if a value doesn’t validate. Though, in this specific case a validation error is returned, and so a better name for the second assert method is: assertValidationError().

With this, we can refactor the example from above to:

class BooleanValidatorTest extends CakeTestCase {
    private $validator = null;
	
    public function setUp() {
        $this->validator = new BooleanValidator();
    }
	
    public function testValidate() {
        $this->assertValid($this->validator->validate(true));
        $this->assertValid($this->validator->validate(false));
        $this->assertValidationError($this->validator->validate(0));
        $this->assertValidationError($this->validator->validate(1));
    }

    private function assertValid($validationResult) {
        $this->assertIdentical(true, $validationResult);
    }
	
    private function assertValidationError($validationResult) {
        $this->assertTrue(is_string($validationResult));
    }
}

The result is now much easier to read (at least in my opinion), and as a nice side effect of this refactoring we also have eliminated some duplicate code.

public function doSomething() {
    $aVariable = '';

    if (X) {
        $aVariable = 'x';
    } else {
        $aVariable = 'y';
    }

    if ($this->isSomething()) {
        // ...
    } else {
        $anotherVariable = $aVariable . 'z';
        // ...
    }
}

In this example the variable $aVariable is defined at the top of the method, but it is only used in the “else” case of the second “if” statement. So this means the definition of $aVariable happens too early, at a time when it is not clear whether $aVariable is even needed. To fix it, we can move the first “if” block to the “else” case of the second “if”:

public function doSomething() {
    if ($this->isSomething()) {
        // ...
    } else {
        $aVariable = '';

        if (X) {
            $aVariable = 'x';
        } else {
            $aVariable = 'y';
        }

        $anotherVariable = $aVariable . 'z';
        // ...
    }
}

That’s better. But we are not finished yet. If you look at the code, the definition of $aVariable is very dominant, and can distract the reader of the code from the method’s purpose. To improve it, we could use the ternary operator:

$aVariable = X ? 'x' : 'y';

Using the ternary operator is sometimes seen as bad practice (see for example the coding standard for CakePHP). So it is better to apply the Extract Method refactoring:

public function doSomething() {
    if ($this->isSomething()) {
        // ...
    } else {
        $anotherVariable = $this->getAVariable() . 'z';
        // ...
    }
}

private function getAVariable() {
   $aVariable = '';

    if (X) {
        $aVariable = 'x';
    } else {
        $aVariable = 'y';
    }

    return $aVariable;
}

With that, the “doSomething” method has become easier to read and understand.

Happy refactoring :)