Просмотр архива phpanalytics


<?php declare(strict_types=1);

namespace PhpParser;

use PhpParserNodeArg;
use PhpParserNodeExpr;
use PhpParserNodeExprBinaryOpConcat;
use PhpParserNodeIdentifier;
use PhpParserNodeName;
use PhpParserNodeScalarString_;
use PhpParserNodeStmtUse_;

class BuilderFactory
{
    /**
     * Creates an attribute node.
     *
     * @param string|Name $name Name of the attribute
     * @param array       $args Attribute named arguments
     *
     * @return NodeAttribute
     */
    public function attribute($name, array $args = []) : NodeAttribute {
        return new NodeAttribute(
            BuilderHelpers::normalizeName($name),
            $this->args($args)
        );
    }

    /**
     * Creates a namespace builder.
     *
     * @param null|string|NodeName $name Name of the namespace
     *
     * @return BuilderNamespace_ The created namespace builder
     */
    public function namespace($name) : BuilderNamespace_ {
        return new BuilderNamespace_($name);
    }

    /**
     * Creates a class builder.
     *
     * @param string $name Name of the class
     *
     * @return BuilderClass_ The created class builder
     */
    public function class(string $name) : BuilderClass_ {
        return new BuilderClass_($name);
    }

    /**
     * Creates an interface builder.
     *
     * @param string $name Name of the interface
     *
     * @return BuilderInterface_ The created interface builder
     */
    public function interface(string $name) : BuilderInterface_ {
        return new BuilderInterface_($name);
    }

    /**
     * Creates a trait builder.
     *
     * @param string $name Name of the trait
     *
     * @return BuilderTrait_ The created trait builder
     */
    public function trait(string $name) : BuilderTrait_ {
        return new BuilderTrait_($name);
    }

    /**
     * Creates an enum builder.
     *
     * @param string $name Name of the enum
     *
     * @return BuilderEnum_ The created enum builder
     */
    public function enum(string $name) : BuilderEnum_ {
        return new BuilderEnum_($name);
    }

    /**
     * Creates a trait use builder.
     *
     * @param NodeName|string ...$traits Trait names
     *
     * @return BuilderTraitUse The create trait use builder
     */
    public function useTrait(...$traits) : BuilderTraitUse {
        return new BuilderTraitUse(...$traits);
    }

    /**
     * Creates a trait use adaptation builder.
     *
     * @param NodeName|string|null  $trait  Trait name
     * @param NodeIdentifier|string $method Method name
     *
     * @return BuilderTraitUseAdaptation The create trait use adaptation builder
     */
    public function traitUseAdaptation($trait, $method = null) : BuilderTraitUseAdaptation {
        if ($method === null) {
            $method = $trait;
            $trait = null;
        }

        return new BuilderTraitUseAdaptation($trait, $method);
    }

    /**
     * Creates a method builder.
     *
     * @param string $name Name of the method
     *
     * @return BuilderMethod The created method builder
     */
    public function method(string $name) : BuilderMethod {
        return new BuilderMethod($name);
    }

    /**
     * Creates a parameter builder.
     *
     * @param string $name Name of the parameter
     *
     * @return BuilderParam The created parameter builder
     */
    public function param(string $name) : BuilderParam {
        return new BuilderParam($name);
    }

    /**
     * Creates a property builder.
     *
     * @param string $name Name of the property
     *
     * @return BuilderProperty The created property builder
     */
    public function property(string $name) : BuilderProperty {
        return new BuilderProperty($name);
    }

    /**
     * Creates a function builder.
     *
     * @param string $name Name of the function
     *
     * @return BuilderFunction_ The created function builder
     */
    public function function(string $name) : BuilderFunction_ {
        return new BuilderFunction_($name);
    }

    /**
     * Creates a namespace/class use builder.
     *
     * @param NodeName|string $name Name of the entity (namespace or class) to alias
     *
     * @return BuilderUse_ The created use builder
     */
    public function use($name) : BuilderUse_ {
        return new BuilderUse_($name, Use_::TYPE_NORMAL);
    }

    /**
     * Creates a function use builder.
     *
     * @param NodeName|string $name Name of the function to alias
     *
     * @return BuilderUse_ The created use function builder
     */
    public function useFunction($name) : BuilderUse_ {
        return new BuilderUse_($name, Use_::TYPE_FUNCTION);
    }

    /**
     * Creates a constant use builder.
     *
     * @param NodeName|string $name Name of the const to alias
     *
     * @return BuilderUse_ The created use const builder
     */
    public function useConst($name) : BuilderUse_ {
        return new BuilderUse_($name, Use_::TYPE_CONSTANT);
    }

    /**
     * Creates a class constant builder.
     *
     * @param string|Identifier                          $name  Name
     * @param NodeExpr|bool|null|int|float|string|array $value Value
     *
     * @return BuilderClassConst The created use const builder
     */
    public function classConst($name, $value) : BuilderClassConst {
        return new BuilderClassConst($name, $value);
    }

    /**
     * Creates an enum case builder.
     *
     * @param string|Identifier $name  Name
     *
     * @return BuilderEnumCase The created use const builder
     */
    public function enumCase($name) : BuilderEnumCase {
        return new BuilderEnumCase($name);
    }

    /**
     * Creates node a for a literal value.
     *
     * @param Expr|bool|null|int|float|string|array $value $value
     *
     * @return Expr
     */
    public function val($value) : Expr {
        return BuilderHelpers::normalizeValue($value);
    }

    /**
     * Creates variable node.
     *
     * @param string|Expr $name Name
     *
     * @return ExprVariable
     */
    public function var($name) : ExprVariable {
        if (!is_string($name) && !$name instanceof Expr) {
            throw new LogicException('Variable name must be string or Expr');
        }

        return new ExprVariable($name);
    }

    /**
     * Normalizes an argument list.
     *
     * Creates Arg nodes for all arguments and converts literal values to expressions.
     *
     * @param array $args List of arguments to normalize
     *
     * @return Arg[]
     */
    public function args(array $args) : array {
        $normalizedArgs = [];
        foreach ($args as $key => $arg) {
            if (!($arg instanceof Arg)) {
                $arg = new Arg(BuilderHelpers::normalizeValue($arg));
            }
            if (is_string($key)) {
                $arg->name = BuilderHelpers::normalizeIdentifier($key);
            }
            $normalizedArgs[] = $arg;
        }
        return $normalizedArgs;
    }

    /**
     * Creates a function call node.
     *
     * @param string|Name|Expr $name Function name
     * @param array            $args Function arguments
     *
     * @return ExprFuncCall
     */
    public function funcCall($name, array $args = []) : ExprFuncCall {
        return new ExprFuncCall(
            BuilderHelpers::normalizeNameOrExpr($name),
            $this->args($args)
        );
    }

    /**
     * Creates a method call node.
     *
     * @param Expr                   $var  Variable the method is called on
     * @param string|Identifier|Expr $name Method name
     * @param array                  $args Method arguments
     *
     * @return ExprMethodCall
     */
    public function methodCall(Expr $var, $name, array $args = []) : ExprMethodCall {
        return new ExprMethodCall(
            $var,
            BuilderHelpers::normalizeIdentifierOrExpr($name),
            $this->args($args)
        );
    }

    /**
     * Creates a static method call node.
     *
     * @param string|Name|Expr       $class Class name
     * @param string|Identifier|Expr $name  Method name
     * @param array                  $args  Method arguments
     *
     * @return ExprStaticCall
     */
    public function staticCall($class, $name, array $args = []) : ExprStaticCall {
        return new ExprStaticCall(
            BuilderHelpers::normalizeNameOrExpr($class),
            BuilderHelpers::normalizeIdentifierOrExpr($name),
            $this->args($args)
        );
    }

    /**
     * Creates an object creation node.
     *
     * @param string|Name|Expr $class Class name
     * @param array            $args  Constructor arguments
     *
     * @return ExprNew_
     */
    public function new($class, array $args = []) : ExprNew_ {
        return new ExprNew_(
            BuilderHelpers::normalizeNameOrExpr($class),
            $this->args($args)
        );
    }

    /**
     * Creates a constant fetch node.
     *
     * @param string|Name $name Constant name
     *
     * @return ExprConstFetch
     */
    public function constFetch($name) : ExprConstFetch {
        return new ExprConstFetch(BuilderHelpers::normalizeName($name));
    }

    /**
     * Creates a property fetch node.
     *
     * @param Expr                   $var  Variable holding object
     * @param string|Identifier|Expr $name Property name
     *
     * @return ExprPropertyFetch
     */
    public function propertyFetch(Expr $var, $name) : ExprPropertyFetch {
        return new ExprPropertyFetch($var, BuilderHelpers::normalizeIdentifierOrExpr($name));
    }

    /**
     * Creates a class constant fetch node.
     *
     * @param string|Name|Expr  $class Class name
     * @param string|Identifier $name  Constant name
     *
     * @return ExprClassConstFetch
     */
    public function classConstFetch($class, $name): ExprClassConstFetch {
        return new ExprClassConstFetch(
            BuilderHelpers::normalizeNameOrExpr($class),
            BuilderHelpers::normalizeIdentifier($name)
        );
    }

    /**
     * Creates nested Concat nodes from a list of expressions.
     *
     * @param Expr|string ...$exprs Expressions or literal strings
     *
     * @return Concat
     */
    public function concat(...$exprs) : Concat {
        $numExprs = count($exprs);
        if ($numExprs < 2) {
            throw new LogicException('Expected at least two expressions');
        }

        $lastConcat = $this->normalizeStringExpr($exprs[0]);
        for ($i = 1; $i < $numExprs; $i++) {
            $lastConcat = new Concat($lastConcat, $this->normalizeStringExpr($exprs[$i]));
        }
        return $lastConcat;
    }

    /**
     * @param string|Expr $expr
     * @return Expr
     */
    private function normalizeStringExpr($expr) : Expr {
        if ($expr instanceof Expr) {
            return $expr;
        }

        if (is_string($expr)) {
            return new String_($expr);
        }

        throw new LogicException('Expected string or Expr');
    }
}