SugarMin

Complexity

Total Complexity

4

Size/Duplication

Total Lines	46
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

84.62%

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	minify()	0	11	2
A	jsParser()	0	4	1

<?php

class SugarMin {

Since you have declared the constructor as private, maybe you should also declare the class as final.

    /**
     * jsParser will take javascript source code and minify it.
     *
     * Note: There is a lot of redundant code since both passes
     * operate similarly but with slight differences. It will probably
     * be a good idea to refactor the code at a later point when it is stable.
     *
     * JSParser will perform 3 passes on the code. Pass 1 takes care of single
     * line and mult-line comments. Pass 2 performs some sanitation on each of the lines
     * and pass 3 works on stripping out unnecessary spaces.
     *
     * @param string $js

There is no parameter named $js. Was it maybe removed?

     * @param string $currentOptions

There is no parameter named $currentOptions. Was it maybe removed?

     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    private function __construct($text, $compression) {
        $this->text = trim($text)."\n";
        $this->compression = $compression;
    }

    /**
     * Entry point function to minify javascript.
     *
     * @param string $js Javascript source code as a string.
     * @param string $compression Compression option. {light, deep}.
     * @return string $output Output javascript code as a string.
     */
    static public function minify($js, $compression = 'light') {

As per PSR2, the static declaration should come after the visibility declaration.

        try {
            $me = new SugarMin($js, $compression);
            $output = $me->jsParser();

            return $output;
        } catch (Exception $e) {
            // Exception handling is left up to the implementer.
            throw $e;
        }
    }

    protected function jsParser() {
        require_once('jssource/Minifier.php');
        return Minifier::minify($this->text);
	}
}