PHP ClassNode::getMethod方法代码示例

 /**
  * Removes special exception static methods from the doubled methods.
  *
  * @param ClassNode $node
  *
  * @return void
  */
 public function apply(ClassNode $node)
 {
     if ($node->hasMethod('setTraceOptions')) {
         $node->getMethod('setTraceOptions')->useParentCode();
     }
     if ($node->hasMethod('getTraceOptions')) {
         $node->getMethod('getTraceOptions')->useParentCode();
     }
 }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode  $node
  * @param \Prophecy\Doubler\Generator\Node\MethodNode $method
  * @param \Prophecy\Doubler\Generator\Node\MethodNode $getterMethod
  */
 function it_uses_parent_code_for_setTraceOptions($node, $method, $getterMethod)
 {
     $node->hasMethod('setTraceOptions')->willReturn(TRUE);
     $node->getMethod('setTraceOptions')->willReturn($method);
     $node->hasMethod('getTraceOptions')->willReturn(TRUE);
     $node->getMethod('getTraceOptions')->willReturn($getterMethod);
     $method->useParentCode()->shouldBeCalled();
     $getterMethod->useParentCode()->shouldBeCalled();
     $this->apply($node);
 }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode  $node
  * @param \Prophecy\Doubler\Generator\Node\MethodNode $method
  */
 function it_updates_existing_method_if_found($node, $method)
 {
     $node->hasMethod('__construct')->willReturn(true);
     $node->getMethod('__construct')->willReturn($method);
     $method->setCode(Argument::any())->shouldBeCalled();
     $this->apply($node);
 }

 /**
  *
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $class        	
  * @param \Prophecy\Doubler\Generator\Node\MethodNode $method        	
  * @param \Prophecy\Doubler\Generator\Node\ArgumentNode $arg1        	
  * @param \Prophecy\Doubler\Generator\Node\ArgumentNode $arg2        	
  */
 function it_makes_all_newInstance_arguments_optional($class, $method, $arg1, $arg2)
 {
     $class->getMethod('newInstance')->willReturn($method);
     $method->getArguments()->willReturn(array($arg1));
     $arg1->setDefault(null)->shouldBeCalled();
     $this->apply($class);
 }

    /**
     * Apply Prophecy functionality to class node.
     *
     * @param ClassNode $node
     */
    public function apply(ClassNode $node)
    {
        $node->addInterface('Prophecy\\Prophecy\\ProphecySubjectInterface');
        $node->addProperty('objectProphecy', 'private');
        foreach ($node->getMethods() as $name => $method) {
            if ('__construct' === strtolower($name)) {
                continue;
            }
            $method->setCode('return $this->getProphecy()->makeProphecyMethodCall(__FUNCTION__, func_get_args());');
        }
        $prophecySetter = new MethodNode('setProphecy');
        $prophecyArgument = new ArgumentNode('prophecy');
        $prophecyArgument->setTypeHint('Prophecy\\Prophecy\\ProphecyInterface');
        $prophecySetter->addArgument($prophecyArgument);
        $prophecySetter->setCode('$this->objectProphecy = $prophecy;');
        $prophecyGetter = new MethodNode('getProphecy');
        $prophecyGetter->setCode('return $this->objectProphecy;');
        if ($node->hasMethod('__call')) {
            $__call = $node->getMethod('__call');
        } else {
            $__call = new MethodNode('__call');
            $__call->addArgument(new ArgumentNode('name'));
            $__call->addArgument(new ArgumentNode('arguments'));
            $node->addMethod($__call);
        }
        $__call->setCode(<<<PHP
throw new \\Prophecy\\Exception\\Doubler\\MethodNotFoundException(
    sprintf('Method `%s::%s()` not found.', get_class(\$this), func_get_arg(0)),
    \$this->getProphecy(), func_get_arg(0)
);
PHP
);
        $node->addMethod($prophecySetter);
        $node->addMethod($prophecyGetter);
    }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode    $class
  * @param \Prophecy\Doubler\Generator\Node\MethodNode   $method
  * @param \Prophecy\Doubler\Generator\Node\ArgumentNode $arg1
  * @param \Prophecy\Doubler\Generator\Node\ArgumentNode $arg2
  */
 function it_makes_all_constructor_arguments_optional($class, $method, $arg1, $arg2)
 {
     $class->hasMethod('__construct')->willReturn(true);
     $class->getMethod('__construct')->willReturn($method);
     $method->getArguments()->willReturn(array($arg1, $arg2));
     $arg1->setDefault(null)->shouldBeCalled();
     $arg2->setDefault(null)->shouldBeCalled();
     $method->setCode(Argument::type('string'))->shouldBeCalled();
     $this->apply($class);
 }

 /**
  * @param \Prophecy\Doubler\Generator\Node\ClassNode $node
  * @param \Prophecy\Doubler\Generator\Node\MethodNode $method
  */
 function it_should_not_supply_a_file_for_a_directory_iterator($node, $method)
 {
     $node->hasMethod('__construct')->willReturn(true);
     $node->getMethod('__construct')->willReturn($method);
     $node->getParentClass()->willReturn('DirectoryIterator');
     $method->setCode(Argument::that(function ($value) {
         return strpos($value, '.php') === false;
     }))->shouldBeCalled();
     $this->apply($node);
 }

 /**
  * Updated constructor code to call parent one with dummy file argument.
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     if ($node->hasMethod('__construct')) {
         $constructor = $node->getMethod('__construct');
     } else {
         $constructor = new MethodNode('__construct');
         $node->addMethod($constructor);
     }
     $constructor->setCode('return parent::__construct("' . __FILE__ . '");');
 }

 function it_should_supply_a_file_for_a_spl_file_object(ClassNode $node, MethodNode $method)
 {
     $node->hasMethod('__construct')->willReturn(true);
     $node->getMethod('__construct')->willReturn($method);
     $node->getParentClass()->willReturn('SplFileObject');
     $method->setCode(Argument::that(function ($value) {
         return strpos($value, '.php') !== false;
     }))->shouldBeCalled();
     $this->apply($node);
 }

 /**
  * Updated constructor code to call parent one with dummy file argument.
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     if ($node->hasMethod('__construct')) {
         $constructor = $node->getMethod('__construct');
     } else {
         $constructor = new MethodNode('__construct');
         $node->addMethod($constructor);
     }
     if ($this->nodeIsDirectoryIterator($node)) {
         $constructor->setCode('return parent::__construct("' . __DIR__ . '");');
         return;
     }
     $constructor->useParentCode();
 }

    /**
     * Makes all class constructor arguments optional.
     *
     * @param ClassNode $node
     */
    public function apply(ClassNode $node)
    {
        if (!$node->hasMethod('__construct')) {
            $node->addMethod(new MethodNode('__construct', ''));
            return;
        }
        $constructor = $node->getMethod('__construct');
        foreach ($constructor->getArguments() as $argument) {
            $argument->setDefault(null);
        }
        $constructor->setCode(<<<PHP
if (0 < func_num_args()) {
    call_user_func_array(array('parent', '__construct'), func_get_args());
}
PHP
);
    }

 /**
  * Updates newInstance's first argument to make it optional
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     foreach ($node->getMethod('newInstance')->getArguments() as $argument) {
         $argument->setDefault(null);
     }
 }