PHP Expr::method方法代码示例

 public function testRemoveBindingsWithTypeAndParameterWorksOnLoadedDiscovery()
 {
     $binding1 = new StringBinding('string1', Foo::clazz, array('param2' => 'bar'));
     $binding2 = new StringBinding('string2', Foo::clazz);
     $binding3 = new StringBinding('string3', Foo::clazz, array('param1' => 'bar'));
     $discovery = $this->createDiscovery();
     $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING, array(new BindingParameter('param1', BindingParameter::OPTIONAL, 'foo'), new BindingParameter('param2'))));
     $discovery->addBinding($binding1);
     $discovery->addBinding($binding2);
     $discovery->addBinding($binding3);
     $discovery = $this->loadDiscoveryFromStorage($discovery);
     // Bindings need to be initialized for this to work
     $discovery->removeBindings(Foo::clazz, Expr::method('getParameterValue', 'param1', Expr::same('foo')));
     $this->assertEquals(array($binding3), $discovery->findBindings(Foo::clazz));
     $this->assertEquals(array($binding3), $discovery->getBindings());
 }

 /**
  * Handles the "puli type --list" command.
  *
  * @param Args $args The console arguments.
  * @param IO   $io   The I/O.
  *
  * @return int The status code.
  */
 public function handleList(Args $args, IO $io)
 {
     $packageNames = ArgsUtil::getPackageNames($args, $this->packages);
     $states = $this->getBindingTypeStates($args);
     $printStates = count($states) > 1;
     $printPackageName = count($packageNames) > 1;
     $printHeaders = $printStates || $printPackageName;
     $printTypeAdvice = true;
     $printBindAdvice = false;
     $indentation = $printStates && $printPackageName ? 8 : ($printStates || $printPackageName ? 4 : 0);
     foreach ($states as $state) {
         $statePrinted = !$printStates;
         foreach ($packageNames as $packageName) {
             $expr = Expr::method('getContainingPackage', Expr::method('getName', Expr::same($packageName)))->andMethod('getState', Expr::same($state));
             $bindingTypes = $this->discoveryManager->findTypeDescriptors($expr);
             if (!$bindingTypes) {
                 continue;
             }
             $printTypeAdvice = false;
             if (!$statePrinted) {
                 $this->printBindingTypeState($io, $state);
                 $statePrinted = true;
                 // Only print the advice if at least one type was printed
                 $printBindAdvice = true;
             }
             if ($printPackageName) {
                 $prefix = $printStates ? '    ' : '';
                 $io->writeLine("{$prefix}Package: {$packageName}");
                 $io->writeLine('');
             }
             $styleTag = BindingTypeState::ENABLED === $state ? null : 'bad';
             $this->printTypeTable($io, $bindingTypes, $styleTag, $indentation);
             if ($printHeaders) {
                 $io->writeLine('');
             }
         }
     }
     if ($printTypeAdvice) {
         $io->writeLine('No types defined. Use "puli type --define <name>" to define a type.');
     }
     if ($printBindAdvice) {
         $io->writeLine('Use "puli bind <resource> <type>" to bind a resource to a type.');
     }
     return 0;
 }

 /**
  * {@inheritdoc}
  */
 public function hasRootBindingDescriptors(Expression $expr = null)
 {
     $expr2 = Expr::method('getContainingModule', Expr::same($this->rootModule));
     if ($expr) {
         $expr2 = $expr2->andX($expr);
     }
     return $this->hasBindingDescriptors($expr2);
 }

 /**
  * {@inheritdoc}
  */
 public function leaveExpression(Expression $expr)
 {
     if ($expr instanceof Method) {
         switch ($expr->getMethodName()) {
             case 'getUuid':
                 return Expr::method('getUuid', $expr->getExpression());
             case 'getGlob':
                 $queryExpr = $expr->getExpression();
                 if ($queryExpr instanceof Same) {
                     $queryExpr = Expr::same($queryExpr->getComparedValue() . '{,/**/*}');
                 } elseif ($queryExpr instanceof Equals) {
                     $queryExpr = Expr::equals($queryExpr->getComparedValue() . '{,/**/*}');
                 } elseif ($queryExpr instanceof NotSame) {
                     $queryExpr = Expr::notSame($queryExpr->getComparedValue() . '{,/**/*}');
                 } elseif ($queryExpr instanceof NotEquals) {
                     $queryExpr = Expr::notEquals($queryExpr->getComparedValue() . '{,/**/*}');
                 } elseif ($queryExpr instanceof EndsWith) {
                     $queryExpr = Expr::endsWith($queryExpr->getAcceptedSuffix() . '{,/**/*}');
                 }
                 return Expr::method('getBinding', Expr::method('getQuery', $queryExpr));
             case 'getServerName':
                 return Expr::method('getParameterValue', DiscoveryUrlGenerator::SERVER_PARAMETER, $expr->getExpression());
             case 'getServerPath':
                 return Expr::method('getParameterValue', DiscoveryUrlGenerator::PATH_PARAMETER, $expr->getExpression());
         }
     }
     return $expr;
 }

 /**
  * Returns the packages that should be displayed for the given console
  * arguments.
  *
  * @param Args $args The console arguments.
  *
  * @return PackageCollection The packages.
  */
 private function getSelectedPackages(Args $args)
 {
     $states = $this->getSelectedStates($args);
     $expr = Expr::true();
     $envs = array();
     if ($states !== PackageState::all()) {
         $expr = $expr->andMethod('getState', Expr::in($states));
     }
     if ($args->isOptionSet('installer')) {
         $expr = $expr->andMethod('getInstallInfo', Expr::method('getInstallerName', Expr::same($args->getOption('installer'))));
     }
     if ($args->isOptionSet('prod')) {
         $envs[] = Environment::PROD;
     }
     if ($args->isOptionSet('dev')) {
         $envs[] = Environment::DEV;
     }
     if (count($envs) > 0) {
         $expr = $expr->andMethod('getInstallInfo', Expr::method('getEnvironment', Expr::in($envs)));
     }
     return $this->packageManager->findPackages($expr);
 }

 /**
  * Returns the resource discovery manager.
  *
  * @return DiscoveryManager The discovery manager.
  */
 public function getDiscoveryManager()
 {
     if (!$this->started) {
         throw new LogicException('Puli was not started');
     }
     if (!$this->discoveryManager && $this->context instanceof ProjectContext) {
         $this->discoveryManager = new DiscoveryManagerImpl($this->context, $this->getDiscovery(), $this->getPackageManager()->findPackages(Expr::method('isEnabled', Expr::same(true))), $this->getPackageFileStorage(), $this->logger);
     }
     return $this->discoveryManager;
 }

 /**
  * {@inheritdoc}
  */
 public function hasAssetMapping(Uuid $uuid)
 {
     $expr = Expr::method('getUuid', Expr::method('toString', Expr::same($uuid->toString())))->andX($this->exprBuilder->buildExpression());
     return $this->discoveryManager->hasBindingDescriptors($expr);
 }

 /**
  * {@inheritdoc}
  */
 public function hasRootPathMappings(Expression $expr = null)
 {
     $expr2 = Expr::method('getContainingModule', Expr::same($this->rootModule));
     if ($expr) {
         $expr2 = $expr2->andX($expr);
     }
     return $this->hasPathMappings($expr2);
 }

 /**
  * @param string $uuidPrefix
  *
  * @return BindingDescriptor
  */
 private function getBindingByUuidPrefix($uuidPrefix)
 {
     $expr = Expr::method('getUuid', Expr::startsWith($uuidPrefix));
     $descriptors = $this->discoveryManager->findBindingDescriptors($expr);
     if (0 === count($descriptors)) {
         throw new RuntimeException(sprintf('The binding "%s" does not exist.', $uuidPrefix));
     }
     if (count($descriptors) > 1) {
         throw new RuntimeException(sprintf('More than one binding matches the UUID prefix "%s".', $uuidPrefix));
     }
     return reset($descriptors);
 }

 public function testRemoveBindingsWithTypeAndParametersDoesNothingIfTypeNotFound()
 {
     $discovery = $this->createDiscovery();
     $discovery->removeBindings(Foo::clazz, Expr::method('getParameterValue', 'param1', Expr::same('foo')));
     $discovery = $this->loadDiscoveryFromStorage($discovery);
     $this->assertCount(0, $discovery->getBindings());
 }

 /**
  * @param string $uuidPrefix
  *
  * @return AssetMapping
  */
 private function getMappingByUuidPrefix($uuidPrefix)
 {
     $expr = Expr::method('getUuid', Expr::startsWith($uuidPrefix));
     $mappings = $this->assetManager->findAssetMappings($expr);
     if (!$mappings) {
         throw new RuntimeException(sprintf('The mapping with the UUID prefix "%s" does not exist.', $uuidPrefix));
     }
     if (count($mappings) > 1) {
         throw new RuntimeException(sprintf('More than one mapping matches the UUID prefix "%s".', $uuidPrefix));
     }
     return reset($mappings);
 }

 /**
  * Handles the "puli map --list" command.
  *
  * @param Args $args The console arguments.
  * @param IO   $io   The I/O.
  *
  * @return int The status code.
  */
 public function handleList(Args $args, IO $io)
 {
     $packageNames = ArgsUtil::getPackageNames($args, $this->packages);
     $states = $this->getPathMappingStates($args);
     $printState = count($states) > 1;
     $printPackageName = count($packageNames) > 1;
     $printHeaders = $printState || $printPackageName;
     $printAdvice = true;
     $indentation = $printState && $printPackageName ? 8 : ($printState || $printPackageName ? 4 : 0);
     foreach ($states as $state) {
         $statePrinted = !$printState;
         if (PathMappingState::CONFLICT === $state) {
             $expr = Expr::method('getContainingPackage', Expr::method('getName', Expr::in($packageNames)))->andMethod('getState', Expr::same($state));
             $mappings = $this->repoManager->findPathMappings($expr);
             if (!$mappings) {
                 continue;
             }
             $printAdvice = false;
             if ($printState) {
                 $this->printPathMappingStateHeader($io, $state);
             }
             $this->printConflictTable($io, $mappings, $printState ? 4 : 0);
             if ($printHeaders) {
                 $io->writeLine('');
             }
             continue;
         }
         foreach ($packageNames as $packageName) {
             $expr = Expr::method('getContainingPackage', Expr::method('getName', Expr::same($packageName)))->andMethod('getState', Expr::same($state));
             $mappings = $this->repoManager->findPathMappings($expr);
             if (!$mappings) {
                 continue;
             }
             $printAdvice = false;
             if (!$statePrinted) {
                 $this->printPathMappingStateHeader($io, $state);
                 $statePrinted = true;
             }
             if ($printPackageName) {
                 $prefix = $printState ? '    ' : '';
                 $io->writeLine(sprintf('%sPackage: %s', $prefix, $packageName));
                 $io->writeLine('');
             }
             $this->printMappingTable($io, $mappings, $indentation, PathMappingState::ENABLED === $state);
             if ($printHeaders) {
                 $io->writeLine('');
             }
         }
     }
     if ($printAdvice) {
         $io->writeLine('No path mappings. Use "puli map <path> <file>" to map a Puli path to a file or directory.');
     }
     return 0;
 }

 /**
  * @expectedException \InvalidArgumentException
  * @expectedExceptionMessage stdClass
  */
 public function testHasBindingsWithTypeAndParametersFailsIfInvalidType()
 {
     $discovery = $this->createLoadedDiscovery();
     $discovery->hasBindings(new stdClass(), Expr::method('getParameterValue', 'param', Expr::same('foo')));
 }

 /**
  * Transform the expression to Webmozarts' Expression.
  *
  * @param Expression $expression
  *
  * @return \Webmozart\Expression\Expression
  */
 protected function transform(Expression $expression)
 {
     $constraint = $expression->getConstraint();
     $getter = 'get' . ucfirst($expression->getSelector());
     return Expr::method($getter, new $constraint($expression->getValue()));
 }

 /**
  * {@inheritdoc}
  */
 public function removeServer($serverName)
 {
     $this->removeServers(Expr::method('getName', Expr::same($serverName)));
 }