function recursiveMenuSideBar($id_cha)
{
    $categories = DB::table('categories')->where('parent_id', '=', $id_cha)->get();
    $word = array();
    foreach ($categories as $category) {
        $numOfWord = str_word_count($category->name);
        $word = explode(' ', $category->name);
        $link = '';
        if ($numOfWord > 1) {
            for ($i = 0; $i < $numOfWord; $i++) {
                $link .= $word[$i];
            }
        } else {
            $link = $category->name;
        }
        echo "<option><a href='http://localhost/HungNH/public/{$link}'>";
        $name = '';
        for ($i = 0; $i < $category->level; $i++) {
            $name .= '&nbsp&nbsp';
        }
        $name .= '' . $category->name;
        echo $name;
        echo "</option>";
        $haveChild = haveChild($category->id);
        if ($haveChild > 0) {
            recursiveMenuSideBar($category->id);
        }
    }
}

function umwords_build($p, $o)
{
    $ratio = 50;
    $min = $p * $ratio;
    $limit = $min . ', ' . ($min + $ratio);
    $r = sql_inner('pub_art.id,msg', 'qda', 'qdm', 'id', 'kv', 'where nod="ummo" limit ' . $limit);
    if ($r) {
        foreach ($r as $k => $v) {
            $v = str_replace("'", ' ', $v);
            //$v=str_replace('-',' ',$v);
            $rb = str_word_count($v, 2);
            if ($rb) {
                foreach ($rb as $ka => $va) {
                    if ($va == strtoupper($va) && !umwords_dicos($va) && strlen($va) > 1) {
                        $rd[] = array($k, $va, $ka, soundex($va));
                        //idart,voc,pos,sound
                        $rc[$va] = array($k, $va, $ka, soundex($va));
                    }
                }
            }
        }
    }
    //if(auth(6))umwords_sav($rc);
    return $rd;
    $ret = count($rc);
    $ret .= make_table($rc);
    return $ret;
}

function contentSearch($url)
{
    $dom = new DOMDocument();
    @$dom->loadHTMLFile($url);
    //$dom->loadHTML( '<?xml encoding="UTF-8">' . $content );
    $output = array();
    $csv_file = $_POST['csv_file'];
    $xpath = new DOMXPath($dom);
    $textNodes = $xpath->query('//text()');
    foreach ($textNodes as $textNode) {
        $parent = $textNode;
        while ($parent) {
            if (!empty($parent->tagName) && in_array(strtolower($parent->tagName), array('pre', 'code', 'a')) && str_word_count($parent->nodeValue) > 6) {
                continue 2;
            }
            if (str_word_count($parent->nodeValue) < 6 && !empty($parent->tagName)) {
                $job_title_file = fopen("{$csv_file}" . ".csv", 'r');
                while ($row = fgetcsv($job_title_file)) {
                    $nv = strip_tags($parent->nodeValue);
                    if (preg_match("/\\b" . $row[0] . "\\b/i", $nv)) {
                        //job title found
                        //echo $parent->tagName . '===' . $parent->nodeValue . '===' .  $row[0] . '<br />';
                        $output[] = array($nv, '');
                        fclose($job_title_file);
                        break;
                    }
                }
            }
            $parent = $parent->parentNode;
        }
        //end while parent
    }
    //end  for
    return $output;
}

/**
 * findWord
 *
 * Compute the word that contains the highest number of repeated charaters
 * from the supplied text file
 *
 * @param  string $filePath The search text
 * @return string       The word with the highest number of charaters
 */
function findWord($filePath)
{
    if (!is_readable($filePath)) {
        throw new \RuntimeException(sprintf('The file path \'%s\' is not readable.', $filePath));
    }
    $text = file_get_contents($filePath);
    if (false === $text) {
        throw new \RuntimeException(sprintf('An error occured while trying to read the contents of \'%s\'', $filePath));
    }
    if (empty($text)) {
        throw new \DomainException(sprintf('The text file \'%s\' contains no text!', $filePath));
    }
    $winningWord = null;
    $charCount = 0;
    foreach (str_word_count(strtolower($text), 1) as $word) {
        $counts = count_chars($word, 1);
        if (!empty($counts)) {
            rsort($counts);
            $count = current($counts);
            if ($charCount == 0 || $count > $charCount) {
                $winningWord = $word;
                $charCount = $count;
            }
        }
    }
    return $winningWord;
}

 /**
  * Checks if the given value matches the specified maximum words.
  *
  * @param mixed $value The value that should be validated
  * @return void
  */
 public function isValid($value)
 {
     $maximumWords = $this->options['maximumWords'];
     if (str_word_count($value) > $maximumWords) {
         $this->addError('Verringern Sie die Anzahl der Worte - es sind maximal ' . $maximumWords . ' erlaubt!', 1383400016);
     }
 }

 /**
  * Return a truncated string by the number of words
  */
 public static function truncateWords($str, $words)
 {
     if (str_word_count($str) > $words) {
         $str = trim(preg_replace('/((\\w+\\W*){' . $words . '}(\\w+))(.*)/', '${1}', $str)) . '…';
     }
     return $str;
 }

 /**
  * Get a single keyword from a string or array of sanitized words.
  *
  * @access private
  *
  * @param string|array $words Array or string of sanitized words
  * 
  * @return string A single keyword
  */
 private function get_keyword($words)
 {
     // Make a string from array if array is provided
     if (is_array($words)) {
         $words = implode(' ', $words);
     }
     // Get an array of all words contained in the string
     $words = str_word_count($words, 1);
     // Get the count of all words
     $total_words = count($words);
     // Count all the values in the array and sort by values
     $word_count = array_count_values($words);
     arsort($word_count);
     // Holder for parsed words
     $new_words = array();
     // Loop through the words and score each into a percentage of word density
     foreach ($word_count as $key => $value) {
         $new_words[$key] = number_format($value / $total_words * 100);
     }
     // Pop the first word off the array
     reset($new_words);
     $first_key = key($new_words);
     // And return it
     return $first_key;
 }

function bind_listdomains()
{
    $array_listado = array();
    $lines = file(_CFG_BIND_CFG_FILE);
    $i = 0;
    foreach ($lines as $line_num => $line) {
        if (substr($line, 0, 2) != "//") {
            $cadena = str_word_count($line, 1);
            if ($cadena[0] == "zone") {
                $linea_zona = trim($line);
                $pos_ini = strpos($linea_zona, '"');
                $pos_fin = strpos($linea_zona, '"', $pos_ini + 1);
                $zona = substr($linea_zona, $pos_ini + 1, $pos_fin - strlen($linea_zona));
                if (!word_exist($zona, _CFG_BIND_IGNORE_FILE)) {
                    $array_listado[$i] = trim($zona);
                    $i++;
                }
            }
            if ($cadena[0] == "file") {
                $linea_fichero = trim($line);
                $pos = strpos($linea_fichero, '"');
                $fichero = trim(substr($linea_fichero, $pos + 1, -2));
            }
        }
    }
    sort($array_listado);
    return $array_listado;
}

 /**
  * @param string $name
  *
  * @throws ElementNotFoundException
  *
  * @return NodeElement
  */
 public function findField($name)
 {
     $currency = null;
     if (1 === preg_match('/in (.{1,3})$/', $name)) {
         // Price in EUR
         list($name, $currency) = explode(' in ', $name);
         return $this->findPriceField($name, $currency);
     } elseif (1 < str_word_count($name)) {
         // mobile Description
         $words = explode(' ', $name);
         $scope = array_shift($words);
         $name = implode(' ', $words);
         // Check that it is really a scoped field, not a field with a two word label
         if (strtolower($scope) === $scope) {
             return $this->findScopedField($name, $scope);
         }
     }
     $label = $this->find('css', sprintf('label:contains("%s")', $name));
     if (!$label) {
         throw new ElementNotFoundException($this->getSession(), 'form label ', 'value', $name);
     }
     $field = $label->getParent()->find('css', 'input,textarea');
     if (!$field) {
         throw new ElementNotFoundException($this->getSession(), 'form field ', 'id|name|label|value', $name);
     }
     return $field;
 }

 /**
  * Add method
  *
  * @return void Redirects on successful add, renders view otherwise.
  */
 public function add()
 {
     $accumulatedPoints = array();
     $point = $this->Points->newEntity();
     if ($this->request->is('post')) {
         $point = $this->Points->patchEntity($point, $this->request->data);
         if ($this->Points->save($point)) {
             $this->Flash->success(__('The point has been saved.'));
             return $this->redirect(['action' => 'index']);
         } else {
             $this->Flash->error(__('The point could not be saved. Please, try again.'));
         }
     }
     $username = $this->Points->Users->find('list', ['keyField' => 'id', 'valueField' => 'name'], ['limit' => 200])->toArray();
     $users = $this->Points->Users->find('all', ['contain' => ['Diarys', 'Historys', 'Points', 'Words', 'CompletedWords']]);
     //make array of most recent accumulated points
     foreach ($users as $user) {
         $sum = 0;
         foreach ($user->diarys as $diary) {
             $sum = $sum + str_word_count($diary['body']) % $this->maxWord * $this->rateJournalWord;
         }
         $numWords = 0;
         foreach ($user->words as $word) {
             if ($word->meaning != null) {
                 $numWords++;
             }
         }
         $accumulatedPoints[$user->id] = $numWords * $this->rateAddWord + count($user->completed_words) * $this->rateFinishWord + count($user->diarys) * $this->rateJournal + count($user->historys) * $this->rateHistory + $sum;
     }
     //make array of most recent remained points
     $remainedPoints = $this->Points->find('list', ['keyField' => 'user_id', 'valueField' => 'remained_points'], ['limit' => 200])->order(['id' => 'ASC'])->toArray();
     $this->set(compact('point', 'accumulatedPoints', 'remainedPoints', 'username'));
 }

 public function test($target)
 {
     $DOM = $target;
     $page = $DOM->saveHTML();
     $body_elements = $DOM->getElementsByTagName('body');
     $tags = $body_elements->item(0)->childNodes;
     foreach ($tags as $tag) {
         if ($tag->nodeName == "script" || $tag->nodeName == "noscript" || $tag->nodeName == "style") {
             continue;
         }
         if ($tag->nodeName == "p") {
             $this->p_content .= ' ' . $tag->textContent;
         }
         $this->text_content .= $tag->textContent;
     }
     $all_text = $this->text_content;
     $ratio = number_format(strlen($all_text) * 100 / strlen($page), 2);
     $num_words = str_word_count($this->p_content);
     if ($ratio >= 25) {
         $this->result .= '<p><span class="result ok">OK</span>Text / HTML ratio in your website is above 25%.</p><pre>' . $ratio . '% ratio</pre><code>' . $this->text_content . '</code>' . "\n";
         $this->score += 1;
     } else {
         $this->result .= '<p><span class="result warn">WARN</span>Text / HTML ratio in your website is below 25%.</p><pre>' . $ratio . '% ratio</pre><code>' . $this->text_content . '</code>' . "\n";
     }
     if ($num_words >= 300) {
         $this->result .= '<p><span class="result ok">OK</span>Number of words in your text is above 300 words.</p><pre>' . $num_words . ' words</pre><code>' . $this->p_content . '</code>' . "\n";
         $this->score += 1;
     } else {
         $this->result .= '<p><span class="result warn">WARN</span>Number of words in your text is below 300 words.</p><pre>' . $num_words . ' words</pre><code>' . $this->p_content . '</code>' . "\n";
     }
     return array("name" => "textratio", "score" => $this->score, "total_score" => self::TOTAL_SCORE, "result" => $this->result);
 }

/**
 * Reduce the length of custom excerpt (if specified manually) for widgets.
 *
 * @param string $excerpt Current excerpt
 *
 * @since 1.0.0
 *
 * @return string
 */
function appica_widget_trim_excerpt($excerpt)
{
    if (false === strpos($excerpt, '...') && str_word_count($excerpt) > 9) {
        $excerpt = wp_trim_words($excerpt, 9, ' ...');
    }
    return $excerpt;
}

function obtainData($objDb, $id)
{
    $aRes = $objDb->GetDetails($id);
    $sText = $objDb->GetRawText($id);
    if ($aRes === FALSE || $sText === FALSE) {
        // No such record!
        return FALSE;
    }
    // Clean up list of words
    $aWords = array_filter(array_unique(str_word_count($sText, 1)), "filter_words");
    // Split words into likely and unlikely (based on spelling)
    $aLikely = array();
    $aUnlikely = array();
    $hSpell = pspell_new("en");
    if ($hSpell !== FALSE) {
        foreach ($aWords as $sWord) {
            // Make a spellcheck on it
            if (pspell_check($hSpell, $sWord)) {
                array_push($aLikely, $sWord);
            } else {
                array_push($aUnlikely, $sWord);
            }
        }
    } else {
        $aLikely = $aWords;
    }
    return array("likely" => $aLikely, "unlikely" => $aUnlikely);
}

 public function test($target)
 {
     $title = self::extractTitle($target);
     $metatitle = self::extractMetaTitle($target);
     if (strlen($metatitle) >= 1) {
         $this->result .= '<p><span class="result ok">OK</span>The meta title is present: <pre>' . $metatitle . '</pre></p>' . "\n";
         $this->score += 1;
         $metatitle_length = str_word_count($metatitle);
         if ($metatitle_length == 9) {
             $this->result .= '<p><span class="result ok">OK</span>Meta title length is good: <pre>9 words</pre></p>' . "\n";
             $this->score += 1;
         } else {
             $this->result .= '<p><span class="result warn">WARN</span>Meta title length should be 9 words, detected: <pre>' . $metatitle_length . ' words</pre></p>' . "\n";
         }
         $metatitle_length = strlen($metatitle);
         if ($metatitle_length >= 60 && $metatitle_length <= 70) {
             $this->result .= '<p><span class="result ok">OK</span>Meta title length is good: <pre>65 characters</pre></p>' . "\n";
             $this->score += 1;
         } else {
             $this->result .= '<p><span class="result warn">WARN</span>Meta title length should between 60 and 70 characters aprox. (included spaces), detected: <pre>' . $metatitle_length . ' characters</pre></p>' . "\n";
         }
         // title == metatitle
         if (strcmp($title, $metatitle) == 0) {
             $this->result .= '<p><span class="result ok">OK</span>Meta title is equal to page title</p>' . "\n";
             $this->score += 1;
         } else {
             $this->result .= '<p><span class="result error">Error</span>Meta title is different to page title: <pre>' . $title . "\n" . $metatitle . '</pre></p>' . "\n";
         }
     } else {
         $this->result .= '<p><span class="result error">ERROR</span>No meta title detected!</p>' . "\n";
         $this->result .= '<p><span class="result error">ERROR</span>Meta title length should be 9 words and 60 - 70 characters, none is detected.</p>' . "\n";
     }
     return array("name" => "metatitle", "score" => $this->score, "total_score" => self::TOTAL_SCORE, "result" => $this->result);
 }

 public function testTruncatesLongTextToGivenNumberOfWords()
 {
     $nwords = str_word_count(strip_tags(Truncator::truncate($this->long_text, 10, '')));
     $this->assertEquals(10, $nwords);
     $nwords = str_word_count(strip_tags(Truncator::truncate($this->long_text, 11, '')));
     $this->assertEquals(11, $nwords);
 }

 function build()
 {
     $this->db = new db();
     $this->db->connect('localhost', 'bot', 'dyton', 'bot');
     $this->aliasbuild();
     $this->zerocounts();
     $res = $this->db->query("SELECT * FROM `system`");
     while ($row = mysql_fetch_array($res)) {
         $this->system[$row['field']] = $row['value'];
     }
     $res = $this->db->query("SELECT * FROM `log`");
     while ($row = mysql_fetch_array($res)) {
         $nick = $this->getnick($row['nick']);
         if ($nick != "NORECORD") {
             $hour = date("G", $row['time']);
             $this->gs['total'] += 1;
             $this->gs[$hour] += 1;
             $this->counts[$nick]['lines'] += 1;
             $words = str_word_count($row['s']);
             $this->counts[$nick]['words'] += $words;
             $chars = strlen($row['s']);
             $this->counts[$nick]['chars'] += $chars;
             foreach ($this->regex as $key => $string) {
                 if (preg_match($string, $row['s']) == 1) {
                     $this->counts[$nick][$key] += 1;
                 }
             }
         }
     }
 }

 public function test($target)
 {
     $title = self::extractTitle($target);
     if ($title) {
         $this->result .= '<p><span class="result ok">OK</span>The title is present: <pre>' . $title . '</pre></p>' . "\n";
         $this->score += 1;
         $title_length = str_word_count($title);
         if ($title_length == 9) {
             $this->result .= '<p><span class="result ok">OK</span>Title length is good: <pre>' . $title_length . ' words</pre></p>' . "\n";
             $this->score += 1;
         } else {
             $this->result .= '<p><span class="result warn">WARN</span>Title length should be 9 words, detected: <pre>' . $title_length . ' words</pre></p>' . "\n";
         }
         $title_length = strlen($title);
         if ($title_length >= 60 && $title_length <= 70) {
             $this->result .= '<p><span class="result ok">OK</span>Title length is good: <pre>' . $title_length . ' characters</pre></p>' . "\n";
             $this->score += 1;
         } else {
             $this->result .= '<p><span class="result warn">WARN</span>Title length should between 60 and 70 characters aprox. (included spaces), detected: <pre>' . $title_length . ' characters</pre></p>' . "\n";
         }
     } else {
         $this->result .= '<p><span class="result error">ERROR</span>No title detected!</p>' . "\n";
         $this->result .= '<p><span class="result error">ERROR</span>Title length should be 9 words and 60 - 70 characters (spaces included), none is detected.</p>' . "\n";
     }
     return array("name" => "title", "score" => $this->score, "total_score" => self::TOTAL_SCORE, "result" => $this->result);
 }

 public function ajaxCountWords()
 {
     $param = $this->input->post('param');
     if (!empty($param['amount'])) {
         echo str_word_count($param['amount']);
     }
 }

 /**
  * Returns the current payment method
  * @return string
  */
 public function getPaymentMethodProperty()
 {
     $element = Helper::findElements($this, ['currentMethod']);
     $currentMethod = $element['currentMethod']->getText();
     $currentMethod = str_word_count($currentMethod, 1);
     return $currentMethod[0];
 }

 protected function pruneUserComments(Issue $issue, DoBrowser $browser, $comment_words, InputInterface $input, OutputInterface $output)
 {
     $deleted_comments = 0;
     /** @var \DOMElement $comment */
     foreach ($issue->getCrawler()->filter('section.comments div.comment') as $comment) {
         $words = 0;
         $crawler = new Crawler($comment);
         if ($crawler->filter('.nodechanges-file-changes')->count() > 0) {
             // Has a file attached ignore.
             continue;
         }
         $comment_body = $crawler->filter('.field-name-comment-body div.field-item');
         if ($comment_body->count()) {
             $text = $comment_body->text();
             $words = str_word_count(trim($text));
         }
         // Zero word comments are often issue summary updates extra - ignore them
         // for now.
         if ($words <= $comment_words) {
             $changes = $crawler->filter('.field-name-field-issue-changes div.field-item');
             if ($changes->count()) {
                 $output->writeln("Comment issue changes: " . trim($changes->text()));
             }
             $output->writeln("Comment text: " . trim($text));
             if ($this->askConfirmation($input, $output, 'Delete this comment (yes/NO)? ')) {
                 $delete_link = $crawler->filter('li.comment-delete a, div.system-message.queued-retesting li.comment-delete a')->extract(array('href'));
                 $delete_link = $delete_link[0];
                 $this->deleteComment($delete_link, $browser, $output);
                 $deleted_comments++;
             }
             $output->writeln('');
         }
     }
     $output->writeln("Deleted {$deleted_comments} user comments.");
 }