PHP PackageInterface::isDev方法代码示例

 /**
  * Try to determine the build number from a composer package
  *
  * @param \Composer\Package\PackageInterface $package
  *
  * @return string
  */
 public static function determineBuildNumberFromPackage(PackageInterface $package)
 {
     if ($package->isDev()) {
         $buildNumber = self::determineBuildNumberFromBrowscapBuildFile();
         if (is_null($buildNumber)) {
             $buildNumber = substr($package->getSourceReference(), 0, 8);
         }
     } else {
         $installedVersion = $package->getPrettyVersion();
         // SemVer supports build numbers, but fall back to just using
         // version number if not available; at time of writing, composer
         // did not support SemVer 2.0.0 build numbers fully:
         // @see https://github.com/composer/composer/issues/2422
         $plusPos = strpos($installedVersion, '+');
         if ($plusPos !== false) {
             $buildNumber = substr($installedVersion, $plusPos + 1);
         } else {
             $buildNumber = self::determineBuildNumberFromBrowscapBuildFile();
             if (is_null($buildNumber)) {
                 $buildNumber = $installedVersion;
             }
         }
     }
     return $buildNumber;
 }

 public static function formatVersion(PackageInterface $package, $truncate = true)
 {
     if (!$package->isDev() || !in_array($package->getSourceType(), array('hg', 'git'))) {
         return $package->getPrettyVersion();
     }
     return $package->getPrettyVersion() . ' ' . ($truncate ? substr($package->getSourceReference(), 0, 6) : $package->getSourceReference());
 }

 public static function formatVersion(PackageInterface $package, $truncate = true)
 {
     if (!$package->isDev() || !in_array($package->getSourceType(), array('hg', 'git'))) {
         return $package->getPrettyVersion();
     }
     // if source reference is a sha1 hash -- truncate
     if ($truncate && strlen($package->getSourceReference()) === 40) {
         return $package->getPrettyVersion() . ' ' . substr($package->getSourceReference(), 0, 7);
     }
     return $package->getPrettyVersion() . ' ' . $package->getSourceReference();
 }

 /**
  * Given a concrete version, this returns a ~ constraint (when possible)
  * that should be used, for example, in composer.json.
  *
  * For example:
  *  * 1.2.1         -> ~1.2
  *  * 1.2           -> ~1.2
  *  * v3.2.1        -> ~3.2
  *  * 2.0-beta.1    -> ~2.0@beta
  *  * dev-master    -> ~2.1@dev      (dev version with alias)
  *  * dev-master    -> dev-master    (dev versions are untouched)
  *
  * @param PackageInterface $package
  * @return string
  */
 public function findRecommendedRequireVersion(PackageInterface $package)
 {
     $version = $package->getVersion();
     if (!$package->isDev()) {
         return $this->transformVersion($version, $package->getPrettyVersion(), $package->getStability());
     }
     $loader = new ArrayLoader($this->getParser());
     $dumper = new ArrayDumper();
     $extra = $loader->getBranchAlias($dumper->dump($package));
     if ($extra) {
         $extra = preg_replace('{^(\\d+\\.\\d+\\.\\d+)(\\.9999999)-dev$}', '$1.0', $extra, -1, $count);
         if ($count) {
             $extra = str_replace('.9999999', '.0', $extra);
             return $this->transformVersion($extra, $extra, 'dev');
         }
     }
     return $package->getPrettyVersion();
 }

 /**
  * Tells if a package has to be dumped or not.
  *
  * @param PackageInterface $package The package to be dumped
  *
  * @return bool false if the package has to be dumped.
  */
 public function isSkippable(PackageInterface $package)
 {
     if ('metapackage' === $package->getType()) {
         return true;
     }
     $name = $package->getPrettyString();
     if (true === $this->archiveConfig['skip-dev'] && true === $package->isDev()) {
         $this->output->writeln(sprintf("<info>Skipping '%s' (is dev)</info>", $name));
         return true;
     }
     $names = $package->getNames();
     if ($this->archiveConfig['whitelist'] && !array_intersect($this->archiveConfig['whitelist'], $names)) {
         $this->output->writeln(sprintf("<info>Skipping '%s' (is not in whitelist)</info>", $name));
         return true;
     }
     if ($this->archiveConfig['blacklist'] && array_intersect($this->archiveConfig['blacklist'], $names)) {
         $this->output->writeln(sprintf("<info>Skipping '%s' (is in blacklist)</info>", $name));
         return true;
     }
     return false;
 }

 /**
  * @param PackageInterface $package
  * @return bool
  */
 protected function isSharedInstallEnabled(PackageInterface $package)
 {
     // @todo disabled when prefer source
     if ($package->isDev()) {
         return false;
     }
     $this->initializePattern();
     $name = $package->getName();
     foreach ($this->excludePatterns as $pattern) {
         if (fnmatch($pattern, $name)) {
             return false;
         }
     }
     if (count($this->includePatterns) === 0) {
         return true;
     }
     foreach ($this->includePatterns as $pattern) {
         if (fnmatch($pattern, $name)) {
             return true;
         }
     }
     return false;
 }

 /**
  * Updates package from initial to target version.
  *
  * @param PackageInterface $initial   initial package version
  * @param PackageInterface $target    target package version
  * @param string           $targetDir target dir
  *
  * @throws InvalidArgumentException if initial package is not installed
  */
 public function update(PackageInterface $initial, PackageInterface $target, $targetDir)
 {
     $downloader = $this->getDownloaderForInstalledPackage($initial);
     $installationSource = $initial->getInstallationSource();
     if ('dist' === $installationSource) {
         $initialType = $initial->getDistType();
         $targetType = $target->getDistType();
     } else {
         $initialType = $initial->getSourceType();
         $targetType = $target->getSourceType();
     }
     // upgrading from a dist stable package to a dev package, force source reinstall
     if ($target->isDev() && 'dist' === $installationSource) {
         $downloader->remove($initial, $targetDir);
         $this->download($target, $targetDir);
         return;
     }
     if ($initialType === $targetType) {
         $target->setInstallationSource($installationSource);
         $downloader->update($initial, $target, $targetDir);
     } else {
         $downloader->remove($initial, $targetDir);
         $this->download($target, $targetDir, 'source' === $installationSource);
     }
 }

 /**
  * @param InstalledRepositoryInterface $repo
  * @param PackageInterface             $package
  *
  * @throws FilesystemException
  */
 public function uninstall(InstalledRepositoryInterface $repo, PackageInterface $package)
 {
     if ($package->isDev()) {
         if (!$repo->hasPackage($package)) {
             throw new \InvalidArgumentException('Package is not installed : ' . $package->getPrettyName());
         }
         $this->symlinkInstaller->uninstall($repo, $package);
     } else {
         $this->defaultInstaller->uninstall($repo, $package);
     }
 }

 private function updateInformation(Package $package, PackageInterface $data, $flags)
 {
     $em = $this->doctrine->getManager();
     $version = new Version();
     $normVersion = $data->getVersion();
     $existingVersion = $package->getVersion($normVersion);
     if ($existingVersion) {
         $source = $existingVersion->getSource();
         // update if the right flag is set, or the source reference has changed (re-tag or new commit on branch)
         if ($source['reference'] !== $data->getSourceReference() || $flags & self::UPDATE_EQUAL_REFS) {
             $version = $existingVersion;
         } else {
             // mark it updated to avoid it being pruned
             $existingVersion->setUpdatedAt(new \DateTime());
             return false;
         }
     }
     $version->setName($package->getName());
     $version->setVersion($data->getPrettyVersion());
     $version->setNormalizedVersion($normVersion);
     $version->setDevelopment($data->isDev());
     $em->persist($version);
     $descr = $this->sanitize($data->getDescription());
     $version->setDescription($descr);
     $package->setDescription($descr);
     $version->setHomepage($data->getHomepage());
     $version->setLicense($data->getLicense() ?: array());
     $version->setPackage($package);
     $version->setUpdatedAt(new \DateTime());
     $version->setReleasedAt($data->getReleaseDate());
     if ($data->getSourceType()) {
         $source['type'] = $data->getSourceType();
         $source['url'] = $data->getSourceUrl();
         $source['reference'] = $data->getSourceReference();
         $version->setSource($source);
     } else {
         $version->setSource(null);
     }
     if ($data->getDistType()) {
         $dist['type'] = $data->getDistType();
         $dist['url'] = $data->getDistUrl();
         $dist['reference'] = $data->getDistReference();
         $dist['shasum'] = $data->getDistSha1Checksum();
         $version->setDist($dist);
     } else {
         $version->setDist(null);
     }
     if ($data->getType()) {
         $type = $this->sanitize($data->getType());
         $version->setType($type);
         if ($type !== $package->getType()) {
             $package->setType($type);
         }
     }
     $version->setTargetDir($data->getTargetDir());
     $version->setAutoload($data->getAutoload());
     $version->setExtra($data->getExtra());
     $version->setBinaries($data->getBinaries());
     $version->setIncludePaths($data->getIncludePaths());
     $version->setSupport($data->getSupport());
     if ($data->getKeywords()) {
         $keywords = array();
         foreach ($data->getKeywords() as $keyword) {
             $keywords[mb_strtolower($keyword, 'UTF-8')] = $keyword;
         }
         $existingTags = [];
         foreach ($version->getTags() as $tag) {
             $existingTags[mb_strtolower($tag->getName(), 'UTF-8')] = $tag;
         }
         foreach ($keywords as $tagKey => $keyword) {
             if (isset($existingTags[$tagKey])) {
                 unset($existingTags[$tagKey]);
                 continue;
             }
             $tag = Tag::getByName($em, $keyword, true);
             if (!$version->getTags()->contains($tag)) {
                 $version->addTag($tag);
             }
         }
         foreach ($existingTags as $tag) {
             $version->getTags()->removeElement($tag);
         }
     } elseif (count($version->getTags())) {
         $version->getTags()->clear();
     }
     $authorRepository = $this->doctrine->getRepository('PackagistWebBundle:Author');
     $version->getAuthors()->clear();
     if ($data->getAuthors()) {
         foreach ($data->getAuthors() as $authorData) {
             $author = null;
             foreach (array('email', 'name', 'homepage', 'role') as $field) {
                 if (isset($authorData[$field])) {
                     $authorData[$field] = trim($authorData[$field]);
                     if ('' === $authorData[$field]) {
                         $authorData[$field] = null;
                     }
                 } else {
                     $authorData[$field] = null;
                 }
             }
//.........这里部分代码省略.........

 /**
  * {@inheritdoc}
  */
 public function isDev()
 {
     return $this->package->isDev();
 }

 private function updateInformation(Package $package, PackageInterface $data, $flags)
 {
     $em = $this->doctrine->getEntityManager();
     $version = new Version();
     $version->setNormalizedVersion($data->getVersion());
     // check if we have that version yet
     foreach ($package->getVersions() as $existingVersion) {
         if ($existingVersion->getNormalizedVersion() === $version->getNormalizedVersion()) {
             if ($existingVersion->getDevelopment() || $flags & self::UPDATE_TAGS) {
                 $version = $existingVersion;
                 break;
             }
             // mark it updated to avoid it being pruned
             $existingVersion->setUpdatedAt(new \DateTime());
             return;
         }
     }
     $version->setName($package->getName());
     $version->setVersion($data->getPrettyVersion());
     $version->setDevelopment($data->isDev());
     $em->persist($version);
     $version->setDescription($data->getDescription());
     $package->setDescription($data->getDescription());
     $version->setHomepage($data->getHomepage());
     $version->setLicense($data->getLicense() ?: array());
     $version->setPackage($package);
     $version->setUpdatedAt(new \DateTime());
     $version->setReleasedAt($data->getReleaseDate());
     if ($data->getSourceType()) {
         $source['type'] = $data->getSourceType();
         $source['url'] = $data->getSourceUrl();
         $source['reference'] = $data->getSourceReference();
         $version->setSource($source);
     }
     if ($data->getDistType()) {
         $dist['type'] = $data->getDistType();
         $dist['url'] = $data->getDistUrl();
         $dist['reference'] = $data->getDistReference();
         $dist['shasum'] = $data->getDistSha1Checksum();
         $version->setDist($dist);
     }
     if ($data->getType()) {
         $version->setType($data->getType());
         if ($data->getType() && $data->getType() !== $package->getType()) {
             $package->setType($data->getType());
         }
     }
     $version->setTargetDir($data->getTargetDir());
     $version->setAutoload($data->getAutoload());
     $version->setExtra($data->getExtra());
     $version->setBinaries($data->getBinaries());
     $version->setIncludePaths($data->getIncludePaths());
     $version->setSupport($data->getSupport());
     $version->getTags()->clear();
     if ($data->getKeywords()) {
         foreach ($data->getKeywords() as $keyword) {
             $tag = Tag::getByName($em, $keyword, true);
             if (!$version->getTags()->contains($tag)) {
                 $version->addTag($tag);
             }
         }
     }
     $authorRepository = $this->doctrine->getRepository('PackagistWebBundle:Author');
     $version->getAuthors()->clear();
     if ($data->getAuthors()) {
         foreach ($data->getAuthors() as $authorData) {
             $author = null;
             // skip authors with no information
             if (empty($authorData['email']) && empty($authorData['name'])) {
                 continue;
             }
             if (!empty($authorData['email'])) {
                 $author = $authorRepository->findOneByEmail($authorData['email']);
             }
             if (!$author && !empty($authorData['homepage'])) {
                 $author = $authorRepository->findOneBy(array('name' => $authorData['name'], 'homepage' => $authorData['homepage']));
             }
             if (!$author && !empty($authorData['name'])) {
                 $author = $authorRepository->findOneByNameAndPackage($authorData['name'], $package);
             }
             if (!$author) {
                 $author = new Author();
                 $em->persist($author);
             }
             foreach (array('email', 'name', 'homepage', 'role') as $field) {
                 if (isset($authorData[$field])) {
                     $author->{'set' . $field}($authorData[$field]);
                 }
             }
             $author->setUpdatedAt(new \DateTime());
             if (!$version->getAuthors()->contains($author)) {
                 $version->addAuthor($author);
             }
             if (!$author->getVersions()->contains($version)) {
                 $author->addVersion($version);
             }
         }
     }
     // handle links
     foreach ($this->supportedLinkTypes as $linkType => $opts) {
//.........这里部分代码省略.........

 protected function getPackagePath(PackageInterface $package)
 {
     $version = $package->getPrettyName();
     if ($package->isDev() && ($reference = $package->getSourceReference())) {
         $reference = strlen($reference) === 40 ? substr($reference, 0, 7) : $reference;
         // If there is / in reference switch to pretty version
         if (strpos($reference, '/') !== FALSE) {
             $version .= '-' . $package->getPrettyVersion();
         } else {
             $version .= '-' . $reference;
         }
     } else {
         $version .= '-' . $package->getPrettyVersion();
     }
     return $version;
 }

 /**
  * Updates package from initial to target version.
  *
  * @param PackageInterface $initial   initial package version
  * @param PackageInterface $target    target package version
  * @param string           $targetDir target dir
  *
  * @throws \InvalidArgumentException if initial package is not installed
  */
 public function update(PackageInterface $initial, PackageInterface $target, $targetDir)
 {
     $downloader = $this->getDownloaderForInstalledPackage($initial);
     if (!$downloader) {
         return;
     }
     $installationSource = $initial->getInstallationSource();
     if ('dist' === $installationSource) {
         $initialType = $initial->getDistType();
         $targetType = $target->getDistType();
     } else {
         $initialType = $initial->getSourceType();
         $targetType = $target->getSourceType();
     }
     // upgrading from a dist stable package to a dev package, force source reinstall
     if ($target->isDev() && 'dist' === $installationSource) {
         $downloader->remove($initial, $targetDir);
         $this->download($target, $targetDir);
         return;
     }
     if ($initialType === $targetType) {
         $target->setInstallationSource($installationSource);
         try {
             $downloader->update($initial, $target, $targetDir);
             return;
         } catch (\RuntimeException $e) {
             if (!$this->io->isInteractive()) {
                 throw $e;
             }
             $this->io->writeError('<error>    Update failed (' . $e->getMessage() . ')</error>');
             if (!$this->io->askConfirmation('    Would you like to try reinstalling the package instead [<comment>yes</comment>]? ', true)) {
                 throw $e;
             }
         }
     }
     $downloader->remove($initial, $targetDir);
     $this->download($target, $targetDir, 'source' === $installationSource);
 }

 /**
  * Search for dependencies in this package.
  *
  * @param PackageInterface $package The package to search in.
  *
  * @return void
  */
 private function searchInPackage(PackageInterface $package)
 {
     $this->progress->advance();
     if ($package instanceof AliasPackage || $this->searchInDevReleases && !$package->isDev() || $this->searchInReleases && $package->isDev()) {
         return;
     }
     $this->progress->setMessage($package->getName());
     $requires = $package->getRequires();
     $this->searchInRequires($package, 'prod', $requires);
     $requires = $package->getDevRequires();
     $this->searchInRequires($package, 'dev', $requires);
 }

 /**
  * Downloads package into target dir.
  *
  * @param   PackageInterface    $package        package instance
  * @param   string              $targetDir      target dir
  * @param   Boolean             $preferSource   prefer installation from source
  *
  * @throws  InvalidArgumentException            if package have no urls to download from
  */
 public function download(PackageInterface $package, $targetDir, $preferSource = null)
 {
     $preferSource = null !== $preferSource ? $preferSource : $this->preferSource;
     $sourceType = $package->getSourceType();
     $distType = $package->getDistType();
     if (!$package->isDev() && !($preferSource && $sourceType) && $distType) {
         $package->setInstallationSource('dist');
     } elseif ($sourceType) {
         $package->setInstallationSource('source');
     } elseif ($package->isDev()) {
         throw new \InvalidArgumentException('Dev package ' . $package . ' must have a source specified');
     } else {
         throw new \InvalidArgumentException('Package ' . $package . ' must have a source or dist specified');
     }
     $fs = new Filesystem();
     $fs->ensureDirectoryExists($targetDir);
     $downloader = $this->getDownloaderForInstalledPackage($package);
     $downloader->download($package, $targetDir);
 }