PHP PKPString::regexp_match方法代码示例

 /**
  * @copydoc Filter::process()
  * @param $citationString string
  * @return MetadataDescription
  */
 function &process(&$input)
 {
     $nullVar = null;
     $queryParams = array('demo' => '3', 'textlines' => $input);
     // Parscit web form - the result is (mal-formed) HTML
     if (is_null($result = $this->callWebService(PARSCIT_WEBSERVICE, $queryParams, XSL_TRANSFORMER_DOCTYPE_STRING, 'POST'))) {
         return $nullVar;
     }
     $result = html_entity_decode($result);
     // Detect errors.
     if (!PKPString::regexp_match('/.*<algorithm[^>]+>.*<\\/algorithm>.*/s', $result)) {
         $translationParams = array('filterName' => $this->getDisplayName());
         $this->addError(__('submission.citations.filter.webserviceResultTransformationError', $translationParams));
         return $nullVar;
     }
     // Screen-scrape the tagged portion and turn it into XML.
     $xmlResult = PKPString::regexp_replace('/.*<algorithm[^>]+>(.*)<\\/algorithm>.*/s', '\\1', $result);
     $xmlResult = PKPString::regexp_replace('/&/', '&amp;', $xmlResult);
     // Transform the result into an array of meta-data.
     if (is_null($metadata = $this->transformWebServiceResults($xmlResult, dirname(__FILE__) . DIRECTORY_SEPARATOR . 'parscit.xsl'))) {
         return $nullVar;
     }
     // Extract a publisher from the place string if possible.
     $metadata =& $this->fixPublisherNameAndLocation($metadata);
     return $this->getNlm30CitationDescriptionFromMetadataArray($metadata);
 }

 /**
  * @see TypeDescription::parseTypeName()
  */
 function parseTypeName($typeName)
 {
     // Standard validators are based on string input.
     parent::parseTypeName('string');
     // Split the type name into validator name and arguments.
     $typeNameParts = explode('(', $typeName, 2);
     switch (count($typeNameParts)) {
         case 1:
             // no argument
             $this->_validatorArgs = '';
             break;
         case 2:
             // parse arguments (no UTF8-treatment necessary)
             if (substr($typeNameParts[1], -1) != ')') {
                 return false;
             }
             // FIXME: Escape for PHP code inclusion?
             $this->_validatorArgs = substr($typeNameParts[1], 0, -1);
             break;
     }
     // Validator name must start with a lower case letter
     // and may contain only alphanumeric letters.
     if (!PKPString::regexp_match('/^[a-z][a-zA-Z0-9]+$/', $typeNameParts[0])) {
         return false;
     }
     // Translate the validator name into a validator class name.
     $this->_validatorClassName = 'Validator' . PKPString::ucfirst($typeNameParts[0]);
     return true;
 }

 /**
  * Retrieve the export as an XML string.
  * @param $pluginUrl string the url to be requested for export.
  * @param $postParams array additional post parameters
  * @return string
  */
 protected function getXmlOnExport($pluginUrl, $postParams = array())
 {
     // Prepare HTTP session.
     $curlCh = curl_init();
     curl_setopt($curlCh, CURLOPT_POST, true);
     // Create a cookie file (required for log-in).
     $cookies = tempnam(sys_get_temp_dir(), 'curlcookies');
     // Log in.
     $loginUrl = $this->baseUrl . '/index.php/test/login/signIn';
     // Bug #8518 safety work-around
     if ($this->password[0] == '@') {
         die('CURL parameters may not begin with @.');
     }
     $loginParams = array('username' => 'admin', 'password' => $this->password);
     curl_setopt($curlCh, CURLOPT_URL, $loginUrl);
     curl_setopt($curlCh, CURLOPT_POSTFIELDS, $loginParams);
     curl_setopt($curlCh, CURLOPT_COOKIEJAR, $cookies);
     self::assertTrue(curl_exec($curlCh));
     // Request export document.
     $exportUrl = $this->baseUrl . '/index.php/test/manager/importexport/plugin/' . $pluginUrl;
     curl_setopt($curlCh, CURLOPT_URL, $exportUrl);
     // Bug #8518 safety work-around
     foreach ($postParams as $paramValue) {
         if ($paramValue[0] == '@') {
             die('CURL parameters may not begin with @.');
         }
     }
     curl_setopt($curlCh, CURLOPT_POSTFIELDS, $postParams);
     curl_setopt($curlCh, CURLOPT_HTTPHEADER, array('Accept: application/xml, application/x-gtar, */*'));
     curl_setopt($curlCh, CURLOPT_RETURNTRANSFER, true);
     curl_setopt($curlCh, CURLOPT_HEADER, true);
     $response = curl_exec($curlCh);
     do {
         list($header, $response) = explode("\r\n\r\n", $response, 2);
     } while (PKPString::regexp_match('#HTTP/.*100#', $header));
     // Check whether we got a tar file.
     if (PKPString::regexp_match('#Content-Type: application/x-gtar#', $header)) {
         // Save the data to a temporary file.
         $tempfile = tempnam(sys_get_temp_dir(), 'tst');
         file_put_contents($tempfile, $response);
         // Recursively extract tar file.
         $result = $this->extractTarFile($tempfile);
         unlink($tempfile);
     } else {
         $matches = null;
         PKPString::regexp_match_get('#filename="([^"]+)"#', $header, $matches);
         self::assertTrue(isset($matches[1]));
         $result = array($matches[1] => $response);
     }
     // Destroy HTTP session.
     curl_close($curlCh);
     unlink($cookies);
     return $result;
 }

 /**
  * @verbatim
  * Helper method that configures and optionally
  * installs a filter based on the given XML node
  * which represents a <filter> element.
  * @endverbatim
  * @param $filterNode XMLNode
  * @param $persist boolean whether to install the filter
  * @return PersistableFilter the installed filter.
  */
 function &configureFilter($filterNode, $persist = true)
 {
     // Install filters.
     $filterDao = DAORegistry::getDAO('FilterDAO');
     /* @var $filterDao FilterDAO */
     $filterGroupSymbolic = $filterNode->getAttribute('inGroup');
     $filterClassName = $filterNode->getAttribute('class');
     $isTemplate = $filterNode->getAttribute('isTemplate');
     // We have to include the filter class before going on
     // so that all required constants are defined before they
     // might be used in settings.
     if (PKPString::regexp_match('/^[a-zA-Z0-9.]+$/', $filterClassName)) {
         import($filterClassName);
     }
     // Go through the filter sub-nodes. This can be nested
     // filters or filter settings.
     $subNodes = $filterNode->getChildren();
     $settings = array();
     $subFilters = array();
     foreach ($subNodes as $subNode) {
         /* @var $subNode XMLNode */
         switch ($subNode->getName()) {
             case 'setting':
                 // Get the filter setting.
                 list($name, $value) = $this->getFilterSetting($subNode);
                 $settings[$name] = $value;
                 unset($name, $value);
                 break;
             case 'filter':
                 // Recursively configure sub-filters.
                 $subFilter =& $this->configureFilter($subNode, false);
                 $subFilters[] =& $subFilter;
                 unset($subFilter);
                 break;
         }
     }
     // We ensure idempotence of plug-in installation by checking
     // for existing identical filters.
     $similarFilterFactory =& $filterDao->getObjectsByGroupAndClass($filterGroupSymbolic, $filterClassName, 0, $isTemplate);
     if ($similarFilterFactory->getCount() > 0) {
         // 1) Find similar filters.
         $similarFilters =& $similarFilterFactory->toArray();
         // 2) Go through similar filters and eliminate them
         //    if they don't have the exact same settings.
         foreach ($similarFilters as $index => $similarFilter) {
             /* @var $similarFilter PersistableFilter */
             if (!$this->compareFilters($similarFilter, $settings, $subFilters)) {
                 unset($similarFilters[$index]);
             }
         }
         // There can be a maximum of exactly one identical transformation
         // in the database otherwise we've somehow installed a duplicate filter.
         $identicalFilters = count($similarFilters);
         assert($identicalFilters <= 1);
         // 3) If the filter has been installed before then return the existing filter.
         if ($identicalFilters) {
             $existingFilter = array_pop($similarFilters);
             return $existingFilter;
         }
     }
     // Configure (and optionally install) the filter.
     $installedFilter = $filterDao->configureObject($filterClassName, $filterGroupSymbolic, $settings, $isTemplate, 0, $subFilters, $persist);
     assert(is_a($installedFilter, 'PersistableFilter'));
     return $installedFilter;
 }

 /**
  * Do the actual web service request.
  * @param $action string
  * @param $arg string
  * @param $attachment array
  * @return boolean|string True for success, an error message otherwise.
  */
 function _doRequest($action, $arg, $attachment = null)
 {
     // Build the multipart SOAP message from scratch.
     $soapMessage = '<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" ' . 'xmlns:med="http://www.medra.org">' . '<SOAP-ENV:Header/>' . '<SOAP-ENV:Body>' . "<med:{$action}>{$arg}</med:{$action}>" . '</SOAP-ENV:Body>' . '</SOAP-ENV:Envelope>';
     $soapMessageId = $this->_getContentId($action);
     if ($attachment) {
         assert(count($attachment) == 1);
         $request = "--MIME_boundary\r\n" . $this->_getMimePart($soapMessageId, $soapMessage) . "--MIME_boundary\r\n" . $this->_getMimePart(key($attachment), current($attachment)) . "--MIME_boundary--\r\n";
         $contentType = 'multipart/related; type="text/xml"; boundary="MIME_boundary"';
     } else {
         $request = $soapMessage;
         $contentType = 'text/xml';
     }
     // Prepare HTTP session.
     $curlCh = curl_init();
     curl_setopt($curlCh, CURLOPT_RETURNTRANSFER, true);
     curl_setopt($curlCh, CURLOPT_POST, true);
     // Set up basic authentication.
     curl_setopt($curlCh, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
     curl_setopt($curlCh, CURLOPT_USERPWD, $this->_auth);
     // Set up SSL.
     curl_setopt($curlCh, CURLOPT_SSL_VERIFYPEER, false);
     // Make SOAP request.
     curl_setopt($curlCh, CURLOPT_URL, $this->_endpoint);
     $extraHeaders = array('SOAPAction: "' . $action . '"', 'Content-Type: ' . $contentType, 'UserAgent: OJS-mEDRA');
     curl_setopt($curlCh, CURLOPT_HTTPHEADER, $extraHeaders);
     curl_setopt($curlCh, CURLOPT_POSTFIELDS, $request);
     $result = true;
     $response = curl_exec($curlCh);
     // We do not localize our error messages as they are all
     // fatal errors anyway and must be analyzed by technical staff.
     if ($response === false) {
         $result = 'OJS-mEDRA: Expected string response.';
     }
     if ($result === true && ($status = curl_getinfo($curlCh, CURLINFO_HTTP_CODE)) != MEDRA_WS_RESPONSE_OK) {
         $result = 'OJS-mEDRA: Expected ' . MEDRA_WS_RESPONSE_OK . ' response code, got ' . $status . ' instead.';
     }
     curl_close($curlCh);
     // Check SOAP response by simple string manipulation rather
     // than instantiating a DOM.
     if (is_string($response)) {
         $matches = array();
         PKPString::regexp_match_get('#<faultstring>([^<]*)</faultstring>#', $response, $matches);
         if (empty($matches)) {
             if ($attachment) {
                 assert(PKPString::regexp_match('#<returnCode>success</returnCode>#', $response));
             } else {
                 $parts = explode("\r\n\r\n", $response);
                 $result = array_pop($parts);
                 $result = PKPString::regexp_replace('/>[^>]*$/', '>', $result);
             }
         } else {
             $result = 'mEDRA: ' . $status . ' - ' . $matches[1];
         }
     } else {
         $result = 'OJS-mEDRA: Expected string response.';
     }
     return $result;
 }

 /**
  * Converts a string with multiple persons
  * to an array of NLM name descriptions.
  *
  * @param $personsString string
  * @param $title boolean true to parse for title
  * @param $degrees boolean true to parse for degrees
  * @return array an array of NLM name descriptions or null
  *  if the string could not be converted plus optionally a
  *  single 'et-al' string.
  */
 function &_parsePersonsString($personsString, $title, $degrees)
 {
     // Check for 'et al'.
     $personsStringBeforeEtal = PKPString::strlen($personsString);
     $personsString = PKPString::regexp_replace('/et ?al$/', '', $personsString);
     $etAl = $personsStringBeforeEtal == PKPString::strlen($personsString) ? false : true;
     // Remove punctuation.
     $personsString = trim($personsString, ':;, ');
     // Cut the authors string into pieces.
     $personStrings = PKPString::iterativeExplode(array(':', ';'), $personsString);
     // If we did not have success with simple patterns then try more complex
     // patterns to tokenize multiple-person strings.
     if (count($personStrings) == 1) {
         // The first pattern must match the whole string, the second is used
         // to extract names.
         $complexPersonsPatterns = array(array('/^((([^ \\t\\n\\r\\f\\v,.&]{2,}\\s*)+,\\s*([A-Z]\\.\\s*)+),\\s*)+(\\&|\\.\\s\\.\\s\\.)\\s*([^ \\t\\n\\r\\f\\v,.&]{2,}\\s*,\\s*([A-Z]\\.\\s*)+)$/i', '/(?:[^ \\t\\n\\r\\f\\v,.&]{2,}\\s*)+,\\s*(?:[A-Z]\\.\\s*)+/i'), array('/^((([^ \\t\\n\\r\\f\\v,&]+\\s+)+[^ \\t\\n\\r\\f\\v,&]+\\s*)[,&]\\s*)+(([^ \\t\\n\\r\\f\\v,&]+\\s+)+[^ \\t\\n\\r\\f\\v,&]+)/i', '/(?:(?:[^ \\t\\n\\r\\f\\v,&.]+|[^ \\t\\n\\r\\f\\v,&]{2,})\\s+)+(?:[^ \\t\\n\\r\\f\\v,&.]+|[^ \\t\\n\\r\\f\\v,&]{2,})/i'));
         $matched = false;
         foreach ($complexPersonsPatterns as $complexPersonsPattern) {
             // Break at the first pattern that matches.
             if ($matched = PKPString::regexp_match($complexPersonsPattern[0], $personsString)) {
                 // Retrieve names.
                 $success = PKPString::regexp_match_all($complexPersonsPattern[1], $personsString, $personStrings);
                 assert($success && count($personStrings) == 1);
                 $personStrings = $personStrings[0];
                 break;
             }
         }
         if (!$matched) {
             // If nothing matches then try to parse as a single person.
             $personStrings = array($personsString);
         }
     }
     // Parse persons.
     $persons = array();
     foreach ($personStrings as $personString) {
         $persons[] =& $this->_parsePersonString($personString, $title, $degrees);
     }
     // Add et-al string.
     if ($etAl) {
         $persons[] = PERSON_STRING_FILTER_ETAL;
     }
     return $persons;
 }

 /**
  * Encode a display name for proper inclusion with an email address.
  * @param $displayName string
  * @param $send boolean True to encode the results for sending
  * @return string
  */
 function encodeDisplayName($displayName, $send = false)
 {
     if (PKPString::regexp_match('!^[-A-Za-z0-9\\!#\\$%&\'\\*\\+\\/=\\?\\^_\\`\\{\\|\\}~]+$!', $displayName)) {
         return $displayName;
     }
     return '"' . ($send ? PKPString::encode_mime_header(str_replace(array('"', '\\'), '', $displayName)) : str_replace(array('"', '\\'), '', $displayName)) . '"';
 }

 /**
  * Insert an entry into metrics table.
  *
  * @param $record array
  * @param $errorMsg string
  */
 function insertRecord($record)
 {
     $recordToStore = array();
     // Required dimensions.
     $requiredDimensions = array('load_id', 'assoc_type', 'assoc_id', 'metric_type');
     foreach ($requiredDimensions as $requiredDimension) {
         if (!isset($record[$requiredDimension])) {
             throw new Exception('Cannot load record: missing dimension "' . $requiredDimension . '".');
         }
         $recordToStore[$requiredDimension] = $record[$requiredDimension];
     }
     $assocType = $recordToStore['assoc_type'] = (int) $recordToStore['assoc_type'];
     $assocId = $recordToStore['assoc_id'] = (int) $recordToStore['assoc_id'];
     list($contextId, $pkpSectionId, $assocObjType, $assocObjId, $submissionId, $representationId) = $this->foreignKeyLookup($assocType, $assocId);
     $recordToStore['context_id'] = $contextId;
     $recordToStore['pkp_section_id'] = $pkpSectionId;
     $recordToStore['assoc_object_type'] = $assocObjType;
     $recordToStore['assoc_object_id'] = $assocObjId;
     $recordToStore['submission_id'] = $submissionId;
     $recordToStore['representation_id'] = $representationId;
     // File type is optional.
     if (isset($record['file_type']) && $record['file_type']) {
         $recordToStore['file_type'] = (int) $record['file_type'];
     }
     // We require either month or day in the time dimension.
     if (isset($record['day'])) {
         if (!PKPString::regexp_match('/[0-9]{8}/', $record['day'])) {
             throw new Exception('Cannot load record: invalid date.');
         }
         $recordToStore['day'] = $record['day'];
         $recordToStore['month'] = substr($record['day'], 0, 6);
         if (isset($record['month']) && $recordToStore['month'] != $record['month']) {
             throw new Exception('Cannot load record: invalid month.');
         }
     } elseif (isset($record['month'])) {
         if (!PKPString::regexp_match('/[0-9]{6}/', $record['month'])) {
             throw new Exception('Cannot load record: invalid month.');
         }
         $recordToStore['month'] = $record['month'];
     } else {
         throw new Exception('Cannot load record: Missing time dimension.');
     }
     // Geolocation is optional.
     if (isset($record['country_id'])) {
         $recordToStore['country_id'] = (string) $record['country_id'];
     }
     if (isset($record['region'])) {
         $recordToStore['region'] = (string) $record['region'];
     }
     if (isset($record['city'])) {
         $recordToStore['city'] = (string) $record['city'];
     }
     // The metric must be set. If it is 0 we ignore the record.
     if (!isset($record['metric'])) {
         throw new Exception('Cannot load record: metric is missing.');
     }
     if (!is_numeric($record['metric'])) {
         throw new Exception('Cannot load record: invalid metric.');
     }
     $recordToStore['metric'] = (int) $record['metric'];
     // Save the record to the database.
     $fields = implode(', ', array_keys($recordToStore));
     $placeholders = implode(', ', array_pad(array(), count($recordToStore), '?'));
     $params = array_values($recordToStore);
     return $this->update("INSERT INTO metrics ({$fields}) VALUES ({$placeholders})", $params);
 }

 /**
  * Check the passed user agent for a bot.
  * @param $userAgent string
  * @param $botRegexpsFile string An alternative file with regular
  * expressions to find bots inside user agent strings.
  * @return boolean
  */
 static function isUserAgentBot($userAgent, $botRegexpsFile = USER_AGENTS_FILE)
 {
     static $botRegexps;
     Registry::set('currentUserAgentsFile', $botRegexpsFile);
     if (!isset($botRegexps[$botRegexpsFile])) {
         $botFileCacheId = md5($botRegexpsFile);
         $cacheManager = CacheManager::getManager();
         $cache = $cacheManager->getCache('core', $botFileCacheId, array('Core', '_botFileListCacheMiss'), CACHE_TYPE_FILE);
         $botRegexps[$botRegexpsFile] = $cache->getContents();
     }
     foreach ($botRegexps[$botRegexpsFile] as $regexp) {
         if (PKPString::regexp_match($regexp, $userAgent)) {
             return true;
         }
     }
     return false;
 }

 /**
  * This method pre-validates the service endpoint parts before
  * we try to convert them to a file/method name. This also
  * converts all parts to lower case.
  * @param $rpcServiceEndpointParts array
  * @return array the validated service endpoint parts or null if validation
  *  does not succeed.
  */
 function _validateServiceEndpointParts($rpcServiceEndpointParts)
 {
     // Do we have data at all?
     if (is_null($rpcServiceEndpointParts) || empty($rpcServiceEndpointParts) || !is_array($rpcServiceEndpointParts)) {
         return null;
     }
     // We require at least three parts: component directory, handler
     // and method name.
     if (count($rpcServiceEndpointParts) < 3) {
         return null;
     }
     // Check that the array dimensions remain within sane limits.
     if (count($rpcServiceEndpointParts) > COMPONENT_ROUTER_PARTS_MAXDEPTH) {
         return null;
     }
     // Validate the individual endpoint parts.
     foreach ($rpcServiceEndpointParts as $key => $rpcServiceEndpointPart) {
         // Make sure that none of the elements exceeds the length limit.
         $partLen = strlen($rpcServiceEndpointPart);
         if ($partLen > COMPONENT_ROUTER_PARTS_MAXLENGTH || $partLen < COMPONENT_ROUTER_PARTS_MINLENGTH) {
             return null;
         }
         // Service endpoint URLs are case insensitive.
         $rpcServiceEndpointParts[$key] = strtolower_codesafe($rpcServiceEndpointPart);
         // We only allow letters, numbers and the hyphen.
         if (!PKPString::regexp_match('/^[a-z0-9-]*$/', $rpcServiceEndpointPart)) {
             return null;
         }
     }
     return $rpcServiceEndpointParts;
 }

 /**
  * Checks whether the given version file exists and whether it
  * contains valid data. Returns a Version object if everything
  * is ok, otherwise null. If $returnErroMsg is true, returns the
  * error message.
  *
  * @param $versionFile string
  * @param $returnErrorMesg boolean
  * @return Version or null/string if invalid or missing version file
  */
 function getValidPluginVersionInfo($versionFile, $returnErrorMsg = false)
 {
     $errorMsg = null;
     $fileManager = new FileManager();
     if ($fileManager->fileExists($versionFile)) {
         $versionInfo = VersionCheck::parseVersionXML($versionFile);
     } else {
         $errorMsg = 'manager.plugins.versionFileNotFound';
     }
     // Validate plugin name and type to avoid abuse
     if (is_null($errorMsg)) {
         $productType = explode(".", $versionInfo['type']);
         if (count($productType) != 2 || $productType[0] != 'plugins') {
             $errorMsg = 'manager.plugins.versionFileInvalid';
         }
     }
     if (is_null($errorMsg)) {
         $pluginVersion = $versionInfo['version'];
         $namesToValidate = array($pluginVersion->getProduct(), $productType[1]);
         foreach ($namesToValidate as $nameToValidate) {
             if (!PKPString::regexp_match('/[a-z][a-zA-Z0-9]+/', $nameToValidate)) {
                 $errorMsg = 'manager.plugins.versionFileInvalid';
                 break;
             }
         }
     }
     if ($errorMsg) {
         if ($returnErrorMsg) {
             return $errorMsg;
         } else {
             $templateMgr = TemplateManager::getManager();
             $templateMgr->assign('message', $errorMsg);
             return null;
         }
     } else {
         return $pluginVersion;
     }
 }