Ldaph - Code Metrics - comodojo/ldaph - Measure and Improve Code Quality continuously with Scrutinizer

Ldaph C
last analyzed 2018-01-29 22:54 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	550
Duplicated Lines	8.55 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

53.74%

Importance

Changes	4
Bugs	3	Features	0

Metric	Value
wmc	61
c	4
b	3
f	0
lcom	1
cbo	1
dl	47
loc	550
ccs	79
cts	147
cp	0.5374
rs	6.018

16 Methods

Rating	Name	Duplication	Size	Complexity
A	base()	11	11	2
A	dn()	0	9	2
A	version()	0	13	2
A	ssl()	13	13	2
A	tls()	13	13	2
A	sso()	0	19	3
A	account()	10	10	3
A	searchbase()	0	11	2
A	fields()	0	11	3
B	auth()	0	27	5
B	search()	0	29	3
C	setupConnection()	0	39	12
A	unsetConnection()	0	5	1
B	searchHelper()	0	17	5
C	searchCleaner()	0	59	11
A	__construct()	0	18	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Ldaph often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Ldaph, and based on these observations, apply Extract Interface, too.

<?php namespace Comodojo\Ldaph;

use \Comodojo\Exception\LdaphException;
use \Exception;

/**
 * ldaph: poor man's php ldap class
 *
 * @package     Comodojo Spare Parts
 * @author      Marco Giovinazzi <[email protected]>
 * @license     MIT
 *
 * LICENSE:
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

class Ldaph {

    /**
     * Ldap handler
     *
     * @var resource
     */
    private $ldaph = false;

    /**
     * Ldap version
     *
     * @var int
     */
    private $version = 3;

    /**
     * ldaps support
     *
     * @var bool
     */
    private $ssl = false;

    /**
     * Use tls
     *
     * @var bool
     */
    private $tls = false;

    /**
     * SSO support
     *
     * @var bool
     */
    private $sso = false;

    /**
     * DC(s)
     *
     * @var string
     */
    private $dc = '';

    /**
     * DN
     *
     * @var string
     */
    private $dn = 'USER_NAME';

    /**
     * The base to search in
     *
     * @var string
     */
    private $searchbase = null;

    /**
     * Ldap username
     *
     * @var string
     */
    private $user = null;

    /**
     * Ldap user password
     *
     * @var string
     */
    private $pass = null;

    /**
     * Ldap server port
     *
     * @var int
     */
    private $port = 389;

    /**
     * Ldap server
     *
     * @var string
     */
    private $server = null;

    /**
     * Fields to return
     *
     * @var array
     */
    private $fields = array();

    /**
     * Constructor method
     *
     * Prepare environment for connection (bind)
     *
     * @param   string  $server ldap server (ip or FQDN)
     * @param   int     $port   port to connect to
     *
     * @throws  LdaphException
     */
    public function __construct($server, $port = 389) {

        if ( empty($server) ) throw new LdaphException("Invalid LDAP parameters", 1401);

        if ( !function_exists("ldap_connect") ) throw new LdaphException("PHP ldap extension not available", 1407);

        $this->server = $server;

        $this->port = filter_var($port, FILTER_VALIDATE_INT, array(
            "options" => array(
                "min_range" => 1,
                "max_range" => 65535,
                "default" => 389
                )
            )
        );

    }

    /**
     * Set ldap base
     *
     * @param   string  $dcs    ldap base, comma separated, not spaced
     *
     * @return  Ldaph
     *
     * @throws  LdaphException
     */
    final public function base($dcs) {


        if ( empty($dcs) ) throw new LdaphException($dcs, 1410);

        $pDc = preg_replace('/\s*,\s*/', ',', $dcs);

        $this->dc = $pDc;

        return $this;

    }

    /**
     * Set ldap distinguished name (used in ldap bind)
     *
     * Before bind, special word USERNAME will be substituted by real username
     *
     * @param   string  $dn    ldap DN, comma separated, not spaced
     *
     * @return  Ldaph
     *
     * @throws  LdaphException
     */
    final public function dn($dn) {

        if ( empty($dn) ) throw new LdaphException($dn, 1411);

        $this->dn = preg_replace('/\s*,\s*/', ',', $dn);

        return $this;

    }

    /**
     * Set ldap version: 2 or 3 (default)
     *
     * @param   int $mode   ldap protocol version
     *
     * @return  Ldaph
     */
    final public function version($mode = 3) {

        $mode = filter_var($mode, FILTER_VALIDATE_INT);

        if ( $mode === 2 ) {
            $this->version = 2;
        } else {
            $this->version = 3;
        }

        return $this;

    }

    /**
     * Enable/disable ssl for connection
     *
     * @param   bool    $mode
     *
     * @return  Ldaph
     */
    final public function ssl($mode = true) {


        $mode = filter_var($mode, FILTER_VALIDATE_BOOLEAN);

        if ( $mode === true ) {
            $this->ssl = true;
        } else {
            $this->ssl = false;
        }

        return $this;

    }

    /**
     * Enable/disable tls for connection
     *
     * @param   bool    $mode
     *
     * @return  Ldaph
     */
    final public function tls($mode = true) {


        $mode = filter_var($mode, FILTER_VALIDATE_BOOLEAN);

        if ( $mode === true ) {
            $this->tls = true;
        } else {
            $this->tls = false;
        }

        return $this;

    }

    /**
     * Enable/disable single sign on
     *
     * @param   bool    $mode
     *
     * @return  Ldaph
     *
     * @throws  LdaphException
     */
    final public function sso($mode = true) {

        $mode = filter_var($mode, FILTER_VALIDATE_BOOLEAN);

        if ( $mode === true ) {

            if ( !function_exists('ldap_sasl_bind') ) throw new LdaphException("No LDAP SSO support", 1408);

            $this->sso = true;

        } else {

            $this->sso = false;

        }

        return $this;

    }

    /**
     * Set user/pass for bind and search
     *
     * @param   string  $user
     * @param   string  $pass
     *
     * @return  Ldaph
     *
     * @throws  LdaphException
     */
    final public function account($user, $pass) {


        if ( empty($user) OR empty($pass) ) throw new LdaphException("Invalid LDAP user/pass", 1402);
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

        $this->user = $user;
        $this->pass = $pass;

        return $this;

    }

    /**
     * Set ldap search base
     *
     * During search, special word PATTERN will be sbstituted by provided pattern
     *
     * @param   string  $s
     *
     * @return  Ldaph
     */
    final public function searchbase($s) {

        if ( empty($s) ) {
            $this->searchbase = null;
        } else {
            $this->searchbase = preg_replace('/\s*,\s*/', ',', $s);
        }

        return $this;

    }

    /**
     * Set fields to query ldap for
     *
     * @param   mixed    $f
     *
     * @return  Ldaph
     */
    final public function fields($f) {

        if ( empty($f) ) $this->fields = array();

        elseif ( is_array($f) ) $this->fields = $f;

        else $this->fields = array($f);

        return $this;

    }

    /**
     * Authenticate an user via LDAP
     *
     * @param   string  $userName   The user to auth
     * @param   string  $userPass   The password for user
     *
     * @return  bool
     *
     * @throws  LdaphException
     * @throws  Exception
     */
    public function auth($userName, $userPass) {

        if ( empty($userName) OR empty($userPass) ) throw new LdaphException("Invalid LDAP user/pass", 1402);
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

        try {

            $auth = $this->setupConnection($userName, $userPass);

        } catch (LdaphException $le) {

            $this->unsetConnection();

            throw $le;

        } catch (Exception $e) {

            $this->unsetConnection();

            throw $e;

        }

        $this->unsetConnection();

        return $auth;

    }

    /**
     * Search ldap directory for $what
     *
     * @param   string  $what   The pattern to search for (will replace the searcbase PATTERN special word)
     * @param   bool    $clean  If true, raw ldap_get_entries result will be normalized as plain array
     *
     * @return  array
     *
     * @throws  LdaphException
     * @throws  Exception
     */
    public function search($what = "*", $clean = false) {

        try {

            $this->setupConnection($this->user, $this->pass);

            ldap_set_option($this->ldaph, LDAP_OPT_SIZELIMIT, 0);

            $result = $this->searchHelper($what, filter_var($clean, FILTER_VALIDATE_BOOLEAN));

        } catch (LdaphException $le) {

            $this->unsetConnection();

            throw $le;

        } catch (Exception $e) {

            $this->unsetConnection();

            throw $e;

        }

        $this->unsetConnection();

        return $result;

    }

    /**
     * Setup LDAP connection
     *
     * @param string $user
     * @param string $pass
     *
     * @return  bool
     *
     * @throws  LdaphException
     */
    private function setupConnection($user = null, $pass = null) {
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}

        $this->ldaph = $this->ssl ? ldap_connect("ldaps://".$this->server, $this->port) : ldap_connect($this->server, $this->port);

        if ( !$this->ldaph ) throw new LdaphException(ldap_error($this->ldaph), 1403);

        ldap_set_option($this->ldaph, LDAP_OPT_PROTOCOL_VERSION, $this->version);
        ldap_set_option($this->ldaph, LDAP_OPT_REFERRALS, 0);

        if ( $this->tls ) {

            $tls = @ldap_start_tls($this->ldaph);

            if ( $tls === false ) throw new LdaphException(ldap_error($this->ldaph), 1403);

        }

        if ( $this->sso AND $_SERVER['REMOTE_USER'] AND $_SERVER["REMOTE_USER"] == $user AND $_SERVER["KRB5CCNAME"] ) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

            putenv("KRB5CCNAME=".$_SERVER["KRB5CCNAME"]);

            $bind = @ldap_sasl_bind($this->ldaph, null, null, "GSSAPI");

        } elseif ( is_null($user) OR is_null($pass) ) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

            $bind = @ldap_bind($this->ldaph);

        } else {

            $user_dn = str_replace('USERNAME', $user, $this->dn);
            $bind = @ldap_bind($this->ldaph, $user_dn, $pass);

        }

        if ( !$bind ) throw new LdaphException(ldap_error($this->ldaph), 1402);

        return true;

    }

    /**
     * Unset a previously opened ldap connection
     */
    private function unsetConnection() {

        @ldap_unbind($this->ldaph);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}

    }

    /**
     * Helper for $this->search()
     *
     * @param string $what
     * @param bool   $clean
     *
     * @return  array
     *
     * @throws  LdaphException
     */
    private function searchHelper($what, $clean) {

        $base = $this->dc;

        $search = str_replace('PATTERN', $what, $this->searchbase);

        $result = empty($this->fields) ? ldap_search($this->ldaph, $base, $search) : ldap_search($this->ldaph, $base, $search, $this->fields);

        if ( !$result ) throw new LdaphException(ldap_error($this->ldaph), 1404);

        $to_return = ldap_get_entries($this->ldaph, $result);

        if ( $to_return === false ) throw new LdaphException(ldap_error($this->ldaph), 1412);

        return $clean ? $this->searchCleaner($to_return) : $to_return;

    }

    /**
     * Normalize ldap search result into plain array
     *
     * @return array
     */
    private function searchCleaner($results) {

        $entry = array();

        unset($results['count']);

        foreach ( $results as $key => $result ) {

            unset($result["count"]);

            $valid = true;

            foreach ( $this->fields as $field ) {

                if ( !array_key_exists(strtolower($field), $result) ) $valid = false;

            }

            if ( !$valid ) {

                unset($result[$key]);
                continue;

            } else {

                $entry[$key] = array();

            }

            foreach ( $result as $subkey => $value ) {

                if ( is_int($subkey) OR $subkey == "count" ) continue;
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

                else {

                    if ( is_scalar($value) ) {
                        $entry[$key][$subkey] = $value;
                    }

                    if ( is_array($value) ) {

                        if ( $value["count"] == 1 ) {
                            $entry[$key][$subkey] = $value[0];
                        } else {
                            unset($value["count"]);
                            $entry[$key][$subkey] = $value;
                        }

                    }

                }

            }

        }

        return $entry;

    }

}


Ldaph C
last analyzed 2018-01-29 22:54 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

comodojo / ldaph

Ldaph C last analyzed 2018-01-29 22:54 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

16 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

Ldaph C
last analyzed 2018-01-29 22:54 UTC