similar_text::is_ascii() - Code Metrics - Inspection of "upload main files" - manuwhat/similar-text - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( adeed7...b5464f )

by Akpé Aurelle Emmanuel Moïse
created 2019-04-20 07:15 UTC
similar_text::is_ascii() A

↳ Parent: similar_text
Complexity

Conditions	2
Paths	2
Size

Total Lines	7
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	3
dl	0
loc	7
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1
<?php
/**
*
* @Name : similar-text
* @Programmer : Akpé Aurelle Emmanuel Moïse Zinsou
* @Date : 2019-04-01
* @Released under : https://github.com/manuwhat/similar-text/blob/master/LICENSE
* @Repository : https://github.com/manuwhat/similar
*
**/
namespace{
    function SimilarText(
        $firstString,
        $secondString,
        $round=2,
        $insensitive=true,
        &$stats=false,
        $getParts=false
                        ) {
        return EZAMA\similar_text::similarText(
            $firstString,
            $secondString,
            $round,
            $insensitive,
            $stats,
            $getParts
                                        );
    }
    
    function areAnagrams($a, $b)
    {
        return EZAMA\similar_text::areAnagrams($a, $b);
    }
    
    function similarButNotEqual($a, $b)
    {
        return   EZAMA\similar_text::similarButNotEqual($a, $b);
    }
}

namespace EZAMA{
        
    class similar_text
    {
        private function __construct()
        {
        }
        public static function similarText($a, $b, $round=2, $insensitive=true, &$stats=false, $getParts=false)
        {
            if (!is_string($a)||!is_string($b)) {
                return false;
            }
            if ($insensitive) {
                $a=self::strtolower($a);
                $b=self::strtolower($b);
            }
            /* prevent bad types and useless memory usage due to for example array instead of simple boolean */
            unset($insensitive);
            $getParts=(bool)$getParts;
            /*  ******************************************************************************************** */
            $a=self::split($a);
            $b=self::split($b);
            $ca=count($a);
            $ca=count(/** @scrutinizer ignore-type */ $a);
            $cb=count($b);
            if ($ca<$cb) {
                $stats=self::getStats($cb, $a, self::_check($a, $b, $getParts, $round), $getParts, $round);
            } else {
                $stats=self::getStats($ca, $b, self::_check($b, $a, $getParts, $round), $getParts, $round);
            }
            return $stats['similar'];
        }
        
        protected static function _check($a, $b, $getParts, $round)
        {
            if ($getParts) {
                $diff[]=array_diff($a, $b);

                $diff[]=array_diff($b, $a);
            }
            $diff[]=array_intersect($a, $b);
            $diff[]=round(count(array_intersect(self::getParts($a, $c), self::getParts($b)))/$c*100, $round);
            $diff[]=$a===$b;
            return $diff;
        }
        
        protected static function getStats($ca, $b, $diff, $getParts, $round)
        {
            if ($getParts) {
                $stats['similar']=round(count($diff[2])*100/$ca, $round);

                $stats['substr']=$diff[3];
                $stats['contain']=($diff[2]===$b)?true:false;
                $stats['equal']=$diff[4];
                $stats['a-b']=$diff[0];
                $stats['b-a']=$diff[1];
                $stats['a&b']=$diff[2];
            } else {
                $stats['similar']=round(count($diff[0])*100/$ca, $round);
                $stats['substr']=$diff[1];
                $stats['contain']=($diff[0]===$b)?true:false;
                $stats['equal']=$diff[2];
            }
            return $stats;
        }

        protected static function getParts($b, &$c=0)
        {
            $tmp='';
            $c=0;
            foreach ($b as $k=>$v) {
                $tmp.=$v;
                if (ctype_space($v)) {
                    $parts[]=$tmp;
                    $parts[]=$v;
                    $c+=2;
                    $tmp='';
                }
            }
            if (!empty($tmp)) {
                $parts[]=$tmp;
                $c++;
            }
            return $parts;

        }
        
        
        
        protected static function is_ascii($str)
        {
            if ('' === $str) {
                return true;
            }

            return !preg_match('/[^\x09\x10\x13\x0A\x0D\x20-\x7E]/', $str);
        }
        
        protected static function strtolower($str)
        {
            return join(
            return /** @scrutinizer ignore-call */ join(
                array_map(
                /** @scrutinizer ignore-type */ array_map(
                    function ($val) {
                        if (self::is_ascii($val)) {
                            return strtolower($val);
                        }
                        return $val;
                    },
                    self::split($str)
                    /** @scrutinizer ignore-type */ self::split($str)
            )
                        )
                       ;
        }
        
        protected static function split($str)
        {
            if (!is_string($str)) {
                return false;
            }
            static $split=[];
            static $old='';
            if ($old===$str) {
                return $split;
            } else {
                $old=$str;
                $split=preg_split('//u', $str, -1, PREG_SPLIT_NO_EMPTY);
                return $split;
            }
        }
        
        public static function areAnagrams($a, $b)
        {
            return  self::similarText($a, $b, 2, true, $check)?$check['similar'] === 100.0&&$check['contain']===true:false;
        }
        
        public static function similarButNotEqual($a, $b)
        {
            return   self::similarText($a, $b, 2, true, $check)&&is_array($check)&&$check['equal']===true?false:true;
        }
    }
}

manuwhat / similar-text

Push — master ( adeed7...b5464f )

similar_text::is_ascii() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
