/** * @param string[] $items * @return bool */ public function writeArray(array $items) { $content = $this->generateFileContentForArray($items); $file = $this->fileInfo->openFile('w'); $file->fwrite($content); return $file->fflush(); }
/** * Create a file if is not already exists. * @return self */ protected function _createFeedLockFile() { if (!$this->_isFeedLockFileExist()) { $this->_stream->openFile(static::FILE_OPEN_MODE); } return $this; }
/** * @return \SplFileObject */ protected function getFile() { if (!$this->file instanceof \SplFileObject) { $this->file = $this->fileInfo->openFile(); $this->file->setFlags(\SplFileObject::READ_CSV | \SplFileObject::READ_AHEAD | \SplFileObject::DROP_NEW_LINE); $this->file->setCsvControl($this->delimiter, $this->enclosure, $this->escape); if ($this->firstLineIsHeader && !$this->header) { $this->header = $this->file->fgetcsv(); } } return $this->file; }
protected function execute(InputInterface $input, OutputInterface $output) { $fileInfo = new \SplFileInfo($this->getContainer()->getParameter('kernel.root_dir') . '/../web/sitemap.xml'); if ($fileInfo->isFile() && $fileInfo->isReadable()) { $output->write('Reading sitemap.xml...'); $file = $fileInfo->openFile(); $xml = ''; while (!$file->eof()) { $xml .= $file->fgets(); } $output->writeln(' done.'); $output->write('Updating sitemap.xml...'); $sitemap = new \SimpleXMLIterator($xml); $sitemap->rewind(); $lastmodDate = new \DateTime(); $lastmodDate->sub(new \DateInterval('P1D')); $lastmodDateFormatted = $lastmodDate->format('Y-m-d'); while ($sitemap->valid()) { $sitemap->current()->lastmod = $lastmodDateFormatted; $sitemap->next(); } $file = $file->openFile('w'); $file->fwrite($sitemap->asXML()); $output->writeln(' done.'); } else { $output->writeln('Error: Cannot open file web/sitemap.xml'); } }
public function importSingleMovie(\SplFileInfo $source) { if (!$source->isReadable()) { return $this->output->writelnError(sprintf("File %s not readable", $source->getFilename())); } $this->output->writelnInfo(sprintf("Importing %s ...", $source->getRealPath())); $file = $source->openFile(); /** @var Movies $movie */ $movie = $this->getMovie($file->fread($file->getSize()), $file->getBasename('.html')); if (!$movie) { return $this->output->writelnError(sprintf("Not found dmm id", $source->getFilename())); } $this->currentDmmId = $movie->banngo; if (Movies::findFirstById($movie->id)) { return $this->output->writelnWarning(sprintf("Movie %s already exists, insert skipped", $movie->banngo)); } /** @var Mysql $db */ $db = $this->getDI()->get('dbMaster'); $db->begin(); if (false === $movie->save()) { $db->rollback(); return $this->output->writelnError(sprintf("Movie saving failed by %s", implode(',', $movie->getMessages()))); } $db->commit(); $this->output->writelnSuccess(sprintf("Movie %s saving success as %s, detail: %s", $movie->banngo, $movie->id, '')); }
protected function getInput() { $input = new \SplFileInfo(FILESYSTEM1 . self::KEY); $fileObj = $input->openFile('a'); $fileObj->fwrite(self::CONTENT); return $input; }
/** * Main check method * * @param string $pathToFile * @throws \RuntimeException if file not found * @return bool */ public function validate($pathToFile) { $this->clearErrors(); $path = new \SplFileInfo($pathToFile); if (!$path->isFile() || !$path->isReadable()) { throw new \RuntimeException(sprintf('File "%s" not found', $pathToFile)); } $file = $path->openFile('r'); $currentLineNumber = 1; while (!$file->eof()) { $line = $file->fgets(); if ($line == '' && $file->eof()) { break; } // Validate line structure $this->validateEOL($currentLineNumber, $line); $nodes = array_filter(preg_split('/\\s+/', $line)); // Validate label $label = array_shift($nodes); $this->validateLabel($currentLineNumber, $label); // Validate features format $this->validateFeatures($currentLineNumber, $nodes); // Increate the line number $currentLineNumber++; } return $this->isValid(); }
public function it_throws_if_the_data_read_back_from_the_file_system_is_not_an_array() { $fs = new FileSystem(); $fileInfo = new \SplFileInfo($fs->path('/r.php')); $file = $fileInfo->openFile('w'); $file->fwrite("<?php\nreturn 'foo';"); $this->beConstructedWith($fileInfo); $this->shouldThrow(UnexpectedValueException::class)->duringReadArray(); }
public function importXmlFile(\SplFileInfo $source) { if (!$source->isReadable()) { return $this->output->writelnError(sprintf("File %s not readable", $source->getFilename())); } $this->output->writelnInfo(sprintf("Importing %s ...", $source->getRealPath())); $file = $source->openFile(); $xml = simplexml_load_string($file->fread($file->getSize())); return $this->saveDmmList($xml); }
/** * @see EbayEnterprise_Catalog_Model_Error_IConfirmations::append() */ public function append($content = '') { if (is_null($this->fileStream)) { throw new EbayEnterprise_Catalog_Model_Error_Exception(sprintf('[ %s ] Error Confirmations file stream is not instantiated', __CLASS__)); } $oldMask = umask(self::ERROR_FILE_PERMISSIONS_MASK); $this->fileStream->openFile('a')->fwrite("{$content}\n"); umask($oldMask); return $this; }
/** * Builds a UnitOfWork instance from the given \SplFileInfo * * @param \SplFileInfo $fileInfo The fileInfo to build from * * @throws \InvalidArgumentException * * @return UnitOfWork The instantiated migration */ public static function buildFromSplFileInfo(\SplFileInfo $fileInfo) { $uniqueId = $fileInfo->getBasename(); $file = $fileInfo->openFile(); $query = ''; while (!$file->eof()) { $query .= $file->fgets(); } return new UnitOfWork(new Uid($uniqueId), new Workload($query), new \DateTime()); }
public static function write_file($path, $data, $mode = 'w') { try { $file = new SplFileInfo($path); $data_obj = $file->openFile($mode); $data_obj->fwrite($data, strlen($data)); $data_obj->fflush(); } catch (Exception $e) { throw new keke_exception($e->getMessage()); } unset($file, $data_obj, $data); return TRUE; }
/** * Abre um arquivo especificado pelo parâmetro $filePath para leitura. * Retorna o objeto que representa o arquivo em caso de sucesso, ou o * boolean false caso contrário. * * @param string $filePath caminho do arquivo * @return mixed SplFileObject em caso de sucesso | bool false caso contrário */ static function openFile($filePath) { if (is_string($filePath)) { try { $fileInfo = new SplFileInfo($filePath); if ($fileInfo->isFile()) { $file = $fileInfo->openFile(); return $file; } else { return false; } } catch (Exception $e) { trigger_error("Arquivo não pode ser importado\n" . $e->getMessage(), E_USER_WARNING); return false; } } }
/** * Fetch a file from remote host and write to local filesystem. * * Set overwrite to true to force overwrite of existing files. * * @param string $remotePathName - e.g. replicant/files * @param string $localPathName - e.g. assets/replicant/files * @param bool $overwrite * @param string $contentType * @return int|bool number of bytes written or false if failed * @throws Exception */ public function fetchFile($remotePathName, $localPathName, $overwrite = false, $contentType = '') { // most paths lead to null or error return $written = null; $fileInfo = new SplFileInfo($localPathName); $exists = $fileInfo->isFile(); if ($exists && !$overwrite) { return false; } $url = $this->buildURL($remotePathName); $fileObject = $fileInfo->openFile("w"); if ($fileObject) { // readFile will throw an exception on error so we'll not try and write a bad file $written = $fileObject->fwrite($this->readFile($url, $contentType)); } return $written > 0 ? $written : false; }
/** * Overwritten I do not want to throw an exception...just ignore it! return default and delete. * Retrieve a cached value entry by id. * * // Retrieve cache entry from file group * $data = Cache::instance('file')->get('foo'); * * // Retrieve cache entry from file group and return 'bar' if miss * $data = Cache::instance('file')->get('foo', 'bar'); * * @param string $id id of cache to entry * @param string $default default value to return if cache miss * @return mixed * @throws Cache_Exception */ public function get($id, $default = NULL) { $filename = Cache_File::filename($this->_sanitize_id($id)); $directory = $this->_resolve_directory($filename); // Wrap operations in try/catch to return default try { // Open file $file = new SplFileInfo($directory . $filename); // If file does not exist if (!$file->isFile()) { // Return default value return $default; } else { // Open the file and parse data $created = $file->getMTime(); $data = $file->openFile(); $lifetime = $data->fgets(); // If we're at the EOF at this point, corrupted! if ($data->eof()) { $this->_delete_file($file, NULL, TRUE); return $default; } $cache = ''; while ($data->eof() === FALSE) { $cache .= $data->fgets(); } // Test the expiry if ($created + (int) $lifetime < time()) { // Delete the file $this->_delete_file($file, NULL, TRUE); return $default; } else { return unserialize($cache); } } } catch (ErrorException $e) { $this->_delete_file($file, NULL, TRUE); return $default; } }
public static function install() { $dirs = array('resources/cache', 'resources/log', 'tmp'); foreach ($dirs as $dir) { if (!file_exists($dir)) { mkdir($dir, 0755, true); } else { chmod($dir, 0755); } } $console = 'console'; $code = <<<HEREDOC #!/usr/bin/env php <?php require_once __DIR__.'/vendor/autoload.php'; \$app = new Silex\\Application(); \$app['environment'] = 'dev'; require __DIR__.'/src/app.php'; \$app->boot(); \$console = require __DIR__.'/src/console.php'; \$console->run(); HEREDOC; if (!file_exists($console)) { $fileinfo = new \SplFileInfo($console); $f = $fileinfo->openFile('w'); $f->fwrite($code); $fileinfo = null; $f = null; } if (file_exists($console)) { chmod($console, 0500); } }
/** * Sets the current cache key this class is managing, and creates a writable SplFileObject * for the cache file the key is referring to. * * @param string $key The key * @param boolean $createKey Whether the key should be created if it doesn't exists, or not * @return boolean true if the cache key could be set, false otherwise */ protected function _setKey($key, $createKey = false) { $groups = null; if (!empty($this->_groupPrefix)) { $groups = vsprintf($this->_groupPrefix, $this->groups()); } $dir = $this->settings['path'] . $groups; if (!is_dir($dir)) { mkdir($dir, 0775, true); } $path = new SplFileInfo($dir . $key); if (!$createKey && !$path->isFile()) { return false; } if (empty($this->_File) || $this->_File->getBaseName() !== $key) { $exists = file_exists($path->getPathname()); try { $this->_File = $path->openFile('c+'); } catch (Exception $e) { trigger_error($e->getMessage(), E_USER_WARNING); return false; } unset($path); if (!$exists && !chmod($this->_File->getPathname(), (int) $this->settings['mask'])) { trigger_error(__d('cake_dev', 'Could not apply permission mask "%s" on cache file "%s"', array($this->_File->getPathname(), $this->settings['mask'])), E_USER_WARNING); } } return true; }
protected function getDataFromFile(\SplFileInfo $fileinfo) { $file = $fileinfo->openFile('r'); $file->setFlags(\SplFileObject::SKIP_EMPTY | \SplFileObject::DROP_NEW_LINE); $lines = []; foreach ($file as $line) { if ($line !== false) { $lines[] = $line; } } $content = implode('', $lines); $data = json_decode($content, true); if ($data === null) { throw new \Exception("File [" . $fileinfo->getPathname() . "] contains incorrect JSON (error code " . json_last_error() . ")"); } return $data; }
/** * Deletes files recursively and returns FALSE on any errors * * // Delete a file or folder whilst retaining parent directory and ignore all errors * $this->_delete_file($folder, TRUE, TRUE); * * @param SplFileInfo file * @param boolean retain the parent directory * @param boolean ignore_errors to prevent all exceptions interrupting exec * @param boolean only expired files * @return boolean * @throws Kohana_Cache_Exception */ protected function _delete_file(SplFileInfo $file, $retain_parent_directory = FALSE, $ignore_errors = FALSE, $only_expired = FALSE) { // Allow graceful error handling try { // If is file if ($file->isFile()) { try { // If only expired is not set if ($only_expired === FALSE) { // We want to delete the file $delete = TRUE; } else { // Assess the file expiry to flag it for deletion $json = $file->openFile('r')->current(); $data = json_decode($json); $delete = $data->expiry < time(); } // If the delete flag is set if ($delete === TRUE) { // Try to delete unlink($file->getRealPath()); } } catch (ErrorException $e) { // Catch any delete file warnings if ($e->getCode() === E_WARNING) { throw new Kohana_Cache_Exception(__METHOD__ . ' failed to delete file : :file', array(':file' => $file->getRealPath())); } } } else { if ($file->isDir()) { // Create new DirectoryIterator $files = new DirectoryIterator($file->getPathname()); // Iterate over each entry while ($files->valid()) { // Extract the entry name $name = $files->getFilename(); // If the name is not a dot if ($name != '.' and $name != '..') { // Create new file resource $fp = new SplFileInfo($files->getRealPath()); // Delete the file $this->_delete_file($fp); } // Move the file pointer on $files->next(); } // If set to retain parent directory, return now if ($retain_parent_directory) { return TRUE; } try { // Remove the files iterator // (fixes Windows PHP which has permission issues with open iterators) unset($files); // Try to remove the parent directory return rmdir($file->getRealPath()); } catch (ErrorException $e) { // Catch any delete directory warnings if ($e->getCode() === E_WARNING) { throw new Kohana_Cache_Exception(__METHOD__ . ' failed to delete directory : :directory', array(':directory' => $file->getRealPath())); } } } } } catch (Exception $e) { // If ignore_errors is on if ($ignore_errors === TRUE) { // Return return FALSE; } // Throw exception throw $e; } }
public function testDecoratedMethods() { $decorated = $this->getMockBuilder('hanneskod\\classtools\\Tests\\MockSplFileInfo')->setConstructorArgs([''])->getMock(); $decorated->expects($this->once())->method('getRelativePath'); $decorated->expects($this->once())->method('getRelativePathname'); $decorated->expects($this->once())->method('getContents'); $decorated->expects($this->once())->method('getATime'); $decorated->expects($this->once())->method('getBasename'); $decorated->expects($this->once())->method('getCTime'); $decorated->expects($this->once())->method('getExtension'); $decorated->expects($this->once())->method('getFileInfo'); $decorated->expects($this->once())->method('getFilename'); $decorated->expects($this->once())->method('getGroup'); $decorated->expects($this->once())->method('getInode'); $decorated->expects($this->once())->method('getLinkTarget'); $decorated->expects($this->once())->method('getMTime'); $decorated->expects($this->once())->method('getOwner'); $decorated->expects($this->once())->method('getPath'); $decorated->expects($this->once())->method('getPathInfo'); $decorated->expects($this->once())->method('getPathname'); $decorated->expects($this->once())->method('getPerms'); $decorated->expects($this->once())->method('getRealPath'); $decorated->expects($this->once())->method('getSize'); $decorated->expects($this->once())->method('getType'); $decorated->expects($this->once())->method('isDir'); $decorated->expects($this->once())->method('isExecutable'); $decorated->expects($this->once())->method('isFile'); $decorated->expects($this->once())->method('isLink'); $decorated->expects($this->once())->method('isReadable'); $decorated->expects($this->once())->method('isWritable'); $decorated->expects($this->once())->method('openFile'); $decorated->expects($this->once())->method('setFileClass'); $decorated->expects($this->once())->method('setInfoClass'); $decorated->expects($this->once())->method('__toString')->will($this->returnValue('')); $fileInfo = new SplFileInfo($decorated); $fileInfo->getRelativePath(); $fileInfo->getRelativePathname(); $fileInfo->getContents(); $fileInfo->getATime(); $fileInfo->getBasename(); $fileInfo->getCTime(); $fileInfo->getExtension(); $fileInfo->getFileInfo(); $fileInfo->getFilename(); $fileInfo->getGroup(); $fileInfo->getInode(); $fileInfo->getLinkTarget(); $fileInfo->getMTime(); $fileInfo->getOwner(); $fileInfo->getPath(); $fileInfo->getPathInfo(); $fileInfo->getPathname(); $fileInfo->getPerms(); $fileInfo->getRealPath(); $fileInfo->getSize(); $fileInfo->getType(); $fileInfo->isDir(); $fileInfo->isExecutable(); $fileInfo->isFile(); $fileInfo->isLink(); $fileInfo->isReadable(); $fileInfo->isWritable(); $fileInfo->openFile(); $fileInfo->setFileClass(); $fileInfo->setInfoClass(); (string) $fileInfo; }
/** * Test if the `remove` return true if the resource was removed. */ public function testRemoveReturnTrueIfTheResourceWasRemoved() { $this->fileInfo->openFile('w+'); $resource = new XMLResource($this->fileInfo); $this->assertTrue($resource->remove()); }
/** * Parse the CREDITS file to populate the package developers, roles and email. * */ function parseCREDITS() { if (file_exists($this->path . DIRECTORY_SEPARATOR . 'CREDITS')) { $a = new \SplFileInfo($this->path . DIRECTORY_SEPARATOR . 'CREDITS'); foreach ($a->openFile('r') as $line) { if ($line && $line[0] === ';') { continue; } if (preg_match('/^(.+) \\[(.+)\\] \\<(.+)\\> \\((.+?)(\\/inactive)?\\)/', $line, $match)) { $this->pxml->maintainer[$match[2]]->role($match[4])->name($match[1])->email($match[3])->active(isset($match[5]) ? 'no' : 'yes'); if ($this->doCompatible) { $this->pxml_compatible->maintainer[$match[2]]->role($match[4])->name($match[1])->email($match[3])->active(isset($match[5]) ? 'no' : 'yes'); } } } } }
/** * @param $indexFileName */ public function addHtaccessRule($indexFileName) { $file = $this->getHtaccessFile(); if ($file instanceof SplFileInfo) { $fileObj = $file->openFile('a+'); } else { $filePath = $this->getRootDir() . DIRECTORY_SEPARATOR . '.htaccess'; $file = new SplFileInfo($filePath); $fileObj = $file->openFile('w+'); } $content = ' RewriteEngine On RewriteCond %{REQUEST_FILENAME} -s [OR] RewriteCond %{REQUEST_FILENAME} -l [OR] RewriteCond %{REQUEST_FILENAME} -d RewriteRule ^.*$ - [NC,L] RewriteRule ^.*$ ' . $indexFileName . ' [NC,L] DirectoryIndex ' . $indexFileName . ' '; $fileObj->fwrite($content); }
/** * Set a value to cache with id and lifetime * * $data = 'bar'; * * // Set 'bar' to 'foo' in file group, using default expiry * Cache::instance('file')->set('foo', $data); * * // Set 'bar' to 'foo' in file group for 30 seconds * Cache::instance('file')->set('foo', $data, 30); * * @param string id of cache entry * @param string data to set to cache * @param integer lifetime in seconds * @return boolean */ public function set($id, $data, $lifetime = NULL) { $filename = Cache_File::filename($this->_sanitize_id($id)); $directory = $this->_resolve_directory($filename); // If lifetime is NULL if ($lifetime === NULL) { // Set to the default expiry $lifetime = Arr::get($this->_config, 'default_expire', Cache::DEFAULT_EXPIRE); } // Open directory $dir = new SplFileInfo($directory); // If the directory path is not a directory if (!$dir->isDir()) { // Create the directory if (!mkdir($directory, 0777, TRUE)) { throw new Kohana_Cache_Exception(__METHOD__ . ' unable to create directory : :directory', array(':directory' => $directory)); } // chmod to solve potential umask issues chmod($directory, 0777); } // Open file to inspect $resouce = new SplFileInfo($directory . $filename); $file = $resouce->openFile('w'); try { $type = gettype($data); // Serialize the data $data = json_encode((object) array('payload' => $type === 'string' ? $data : serialize($data), 'expiry' => time() + $lifetime, 'type' => $type)); $size = strlen($data); } catch (ErrorException $e) { // If serialize through an error exception if ($e->getCode() === E_NOTICE) { // Throw a caching error throw new Kohana_Cache_Exception(__METHOD__ . ' failed to serialize data for caching with message : ' . $e->getMessage()); } // Else rethrow the error exception throw $e; } try { $file->fwrite($data, $size); return (bool) $file->fflush(); } catch (Exception $e) { throw $e; } }
/** * Creates the SSL file passed as parameter or nothing if the file already exists. * * @param \SplFileInfo $certificate The file info about the SSL file to generate * * @return void */ public function createSslCertificate(\SplFileInfo $certificate) { // first we've to check if OpenSSL is available if (!extension_loaded('openssl')) { return; } // do nothing if the file is already available if ($certificate->isFile()) { return; } // prepare the certificate data from our configuration $dn = array("countryName" => "DE", "stateOrProvinceName" => "Bavaria", "localityName" => "Kolbermoor", "organizationName" => "appserver.io", "organizationalUnitName" => "Development", "commonName" => gethostname(), "emailAddress" => "*****@*****.**"); // check the operating system switch (strtoupper(PHP_OS)) { case 'DARWIN': // on Mac OS X use the system default configuration $configargs = array('config' => '/System/Library/OpenSSL/openssl.cnf'); break; case 'WINNT': // on Windows use the system configuration we deliver $configargs = array('config' => $this->getBaseDirectory('/php/extras/ssl/openssl.cnf')); break; default: // on all other use a standard configuration $configargs = array('digest_alg' => 'md5', 'x509_extensions' => 'v3_ca', 'req_extensions' => 'v3_req', 'private_key_bits' => 2048, 'private_key_type' => OPENSSL_KEYTYPE_RSA, 'encrypt_key' => false); } // generate a new private (and public) key pair $privkey = openssl_pkey_new($configargs); // Generate a certificate signing request $csr = openssl_csr_new($dn, $privkey, $configargs); // create a self-signed cert that is valid for 365 days $sscert = openssl_csr_sign($csr, null, $privkey, 365, $configargs); // export the cert + pk files $certout = ''; $pkeyout = ''; openssl_x509_export($sscert, $certout); openssl_pkey_export($privkey, $pkeyout, null, $configargs); // write the SSL certificate data to the target $file = $certificate->openFile('w'); if (($written = $file->fwrite($certout . $pkeyout)) === false) { throw new \Exception(sprintf('Can\'t create SSL certificate %s', $certificate->getPathname())); } // log a message that the file has been written successfully $this->getInitialContext()->getSystemLogger()->info(sprintf('Successfully created %s with %d bytes', $certificate->getPathname(), $written)); // log any errors that occurred here while (($e = openssl_error_string()) !== false) { $this->getInitialContext()->getSystemLogger()->debug($e); } }
<?php $info = new SplFileInfo('SplFileInfo.php'); printf("Extension: %s\n", $info->getExtension()); printf("Filename: %s\n", $info->getFilename()); printf("Path: %s\n", $info->getPathname()); printf("RealPath: %s\n", $info->getRealPath()); printf("Type: %s\n", $info->getType()); printf("Size: %s\n", $info->getSize()); printf("Dir: %b, Exec: %b, File: %b, Link: %b, R: %b, W: %b\n", $info->isDir(), $info->isExecutable(), $info->isFile(), $info->isLink(), $info->isReadable(), $info->isWritable()); $file = $info->openFile('r'); foreach ($file as $line) { printf("%s", $line); }
<?php class test extends SplFileObject { public function example() { return "From class test"; } } $info = new SplFileInfo(__FILE__); $info->setFileClass('test'); var_dump($info->openFile()->example()); try { $info->setFileClass('stdclass'); } catch (UnexpectedValueException $e) { echo $e->getMessage(), PHP_EOL; }
final function parseFile(\SplFileInfo $file) { $this->file = $file->openFile('rb'); if (version_compare(PHP_VERSION, '5.5.11', '<')) { $this->file->setMaxLineLen(4096); } $this->init(); while ($data = version_compare(PHP_VERSION, '5.5.11', '<') ? $this->file->fgets() : $this->file->fread(4096)) { $this->parse($data, false); } $this->parse(NULL, true); $this->destroy(); return true; }
<?php class Foo extends SplFileObject { public $bam = array(); } $fileInfo = new SplFileInfo('php://temp'); $fileInfo->setFileClass('Foo'); $file = $fileInfo->openFile('r'); print var_dump($file->bam); // is null or UNKNOWN:0 ?> ===DONE===
<?php class CustomFO extends SplFileObject { private $i = 1; public function current() { return $this->i++ . ": " . htmlspecialchars($this->getCurrentLine()) . ""; } } $SFI = new SplFileInfo("splFileInfo.php"); $SFI->setFileClass("CustomFO"); $file = $SFI->openFile(); echo "<pre>"; foreach ($file as $line) { echo $line; } echo "</pre>"; ?> <?php /* foreach( get_class_methods(SplFileInfo) as $methodName){ echo $methodName.'<br />'; } */