{@inheritdoc}
@see \Zend\Mvc\Router\Http\Regex::assemble()
429771
public function assemble(array $params = array(), array $options = array())
    {
        $mergedParams = array_merge($this->defaults, $params);
        $url = '/' . $this->spec
             . '/' . $mergedParams['theme']
             . '/' . ($mergedParams['scope']? $mergedParams['scope'] : '__theme__')
             . '/' . ltrim($mergedParams['file'], '/');

        $this->assembledParams[] = array('theme', 'scope', 'file');
        return $url;
    }
677054
public function assemble(array $params, $childName = null)
    {
        if ($childName !== null) {
            $nameParts  = explode('/', $childName, 2);
            $parentName = $nameParts[0];
            $childName  = isset($nameParts[1]) ? $nameParts[1] : null;

            if ($this->children === null) {
                throw new Exception\RuntimeException('Route has no children to assemble');
            }

            $assemblyResult = $this->children->get($parentName)->assemble($params, $childName);
        } else {
            $assemblyResult = new AssemblyResult();
        }

        if (null !== $this->secure) {
            $assemblyResult->scheme = $this->secure ? 'https' : 'http';
        }

        if (null !== $this->port) {
            $assemblyResult->port = $this->port;
        }

        if ($this->hostnameParser !== null) {
            $assemblyResult->host = $this->hostnameParser->compile($params, $this->defaults);
        }

        if ($this->pathParser !== null) {
            $assemblyResult->path = $this->pathParser->compile($params, $this->defaults) . $assemblyResult->path;
        }

        return $assemblyResult;
    }
771894
function build($url,$params=array()) {
		$params+=$this->hive['PARAMS'];
		if (is_array($url))
			foreach ($url as &$var) {
				$var=$this->build($var,$params);
				unset($var);
			}
		else {
			$i=0;
			$url=preg_replace_callback('/@(\w+)|\*/',
				function($match) use(&$i,$params) {
					$i++;
					if (isset($match[1]) &&
						array_key_exists($match[1],$params))
						return $params[$match[1]];
					return array_key_exists($i,$params)?
						$params[$i]:
						$match[0];
				},$url);
		}
		return $url;
	}
193854
protected function build(array $parameters)
    {
        $route    = preg_split('`([/.-])`', $this->route, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
        $regex    = array();
        $position = 0;

        foreach ($route as $index => $element) {
            switch ($element) {
                case '.':
                    $regex[$element . '-' . $index] = '\\' . $element;
                    break;
                case '/':
                case '-':
                    $regex[$element . '-' . $index] = $element;
                    break;

                default:

                    if (':' === substr($element, 0, 1)) {
                        $elementName = substr($element, 1);
                        $position++;

                        if (!isset($parameters[$elementName])) {
                            $parameters[$elementName] = new Parameter($elementName);
                        }

                        $regex[$elementName] = '(' . $parameters[$elementName]->getType() . ')';

                        $this->parameterCollection->add($parameters[$elementName]);
                    } else {
                        $regex[$element] = $element;
                    }
            }
        }

        $this->pattern = '`^' . implode('', $regex) . '$`i';
    }
912688
public function assemble() {
		$keysTag = new Tag('meta');
		$keysTag->setClosed();

		$keysTag->name    = 'keywords';
		$keysTag->content = $this->getKeywords();

		return $keysTag->render();
	}
95515
protected function assembler()
    {
        if (null === $this->assembler) {
            $this->assembler = (new Assembler($this->model));
        }

        return $this->assembler;
    }
727416
def assemble
      parts = [id]
      data.each do |k, v|
        # Characters ", ] and \ must be escaped to prevent any parsing errors
        v = v.gsub(/(\"|\]|\\)/) { |match| '\\' + match }
        parts << "#{k}=\"#{v}\""
      end
      "[#{parts.join(' ')}]"
    end
929902
public function buildFromDirectory($dir, $regex = null)
    {
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator(
                $dir,
                FilesystemIterator::KEY_AS_PATHNAME
                | FilesystemIterator::CURRENT_AS_FILEINFO
                | FilesystemIterator::SKIP_DOTS
            )
        );

        if ($regex) {
            $iterator = new RegexIterator($iterator, $regex);
        }

        $this->buildFromIterator($iterator, $dir);
    }
951622
public static function assembleMethodName($fromValue, $prefix = ''): string
    {
        $methodName = static::toVariableName($fromValue);
        if ($prefix === '') {
            return $methodName;
        }
        $prefix = \trim(ToString::toString($prefix));
        if ($prefix === '') {
            return $methodName;
        }

        return $prefix . \ucfirst($methodName);
    }
309091
public function assemble(array $params = array(), array $options = array())
    {
        $options = $this->getOptions();

        $path = $options['route'];

        if (!empty($params['page'])) {
            $path = rtrim($path, '/').'/'.$params['page'];
        }

        if (!empty($params['revision'])) {
            $path = rtrim($path, '/').'/'.$params['revision'];
        }

        return $path;
    }
1234496
protected function assemble()
    {
        $this->push('UPDATE');
        $this->pushTable();
        $this->push('SET');
        $this->pushValues();
        $this->pushWhere();
        $this->pushOrder();
        $this->pushLimit();
    }
1235262
private function _assembleCSS($pValue = array())
	{
		$pairs = array();
		foreach ($pValue as $property => $value) {
			$pairs[] = $property . ':' . $value;
		}
		$string = implode('; ', $pairs);

		return $string;
	}
707582
public function assemble(array $params = [], array $options = [])
    {
        $elements              = [];
        $mergedParams          = array_replace($this->defaults, $params);
        $this->assembledParams = [];

        foreach ($this->exclude as $key) {
            unset($mergedParams[$key]);
        }

        if ($mergedParams) {
            foreach ($mergedParams as $key => $value) {
                if (is_array($value)) {
                    foreach ($value as $ivalue) {
                        $elements[] = rawurlencode($key) . $this->keyValueDelimiter . rawurlencode($ivalue);
                    }
                } else {
                    $elements[] = rawurlencode($key) . $this->keyValueDelimiter . rawurlencode($value);
                }
                $this->assembledParams[] = $key;
            }

            return $this->paramDelimiter . implode($this->paramDelimiter, $elements);
        }

        return '';
    }
1121630
protected function assemble()
    {
        $assembled = $this->command;
        foreach ($this->arguments as $key => $value) {
            if (is_int($key)
                && false === strpos((string) $key, '-')) {
                $assembled .= ' '.escapeshellarg($value);
                continue;
            }
            $assembled .= ' '.escapeshellarg($key);
            $assembled .= ' '.escapeshellarg($value);
        }

        return $assembled;
    }
1006968
public function compile()
    {
        $route = $this->getRoute();

        //
        $optionals = $this->extractOptionalParameters($uri = $route->uri());

        $path = preg_replace('/\{(\w+?)\?\}/', '{$1}', $uri);

        $domain = $route->domain() ?: '';

        return with(
            new SymfonyRoute($path, $optionals, $route->patterns(), array(), $domain)

        )->compile();
    }
705158
public function attachAssemblersToFactory(AssemblerFactory $factory, Application $app)
    {
        // @codingStandardsIgnoreStart because we limit the verbosity by making all closures single-line
        $fileMatcher      = function ($criteria) { return $criteria instanceof FileReflector; };
        $constantMatcher  = function ($criteria) {
            return $criteria instanceof ConstantReflector || $criteria instanceof ClassConstant;
        };
        $traitMatcher     = function ($criteria) { return $criteria instanceof TraitReflector; };
        $classMatcher     = function ($criteria) { return $criteria instanceof ClassReflector; };
        $interfaceMatcher = function ($criteria) { return $criteria instanceof InterfaceReflector; };
        $propertyMatcher  = function ($criteria) { return $criteria instanceof ClassReflector\PropertyReflector; };
        $methodMatcher    = function ($criteria) { return $criteria instanceof ClassReflector\MethodReflector; };
        $argumentMatcher  = function ($criteria) { return $criteria instanceof FunctionReflector\ArgumentReflector; };
        $functionMatcher  = function ($criteria) { return $criteria instanceof FunctionReflector; };

        $authorMatcher      = function ($criteria) { return $criteria instanceof AuthorTag; };
        $deprecatedMatcher  = function ($criteria) { return $criteria instanceof DeprecatedTag; };
        $exampleMatcher     = function ($criteria) { return $criteria instanceof ExampleTag; };
        $linkMatcher        = function ($criteria) { return $criteria instanceof LinkTag; };
        $methodTagMatcher   = function ($criteria) { return $criteria instanceof MethodTag; };
        $propertyTagMatcher = function ($criteria) { return $criteria instanceof PropertyTag; };
        $paramMatcher       = function ($criteria) { return $criteria instanceof ParamTag; };
        $throwsMatcher      = function ($criteria) { return $criteria instanceof ThrowsTag; };
        $returnMatcher      = function ($criteria) { return $criteria instanceof ReturnTag; };
        $usesMatcher        = function ($criteria) { return $criteria instanceof UsesTag; };
        $seeMatcher         = function ($criteria) { return $criteria instanceof SeeTag; };
        $sinceMatcher       = function ($criteria) { return $criteria instanceof SinceTag; };
        $varMatcher         = function ($criteria) { return $criteria instanceof VarTag; };
        $versionMatcher     = function ($criteria) { return $criteria instanceof Tag\VersionTag; };

        $typeCollectionMatcher = function ($criteria) { return $criteria instanceof TypeCollection; };

        $tagFallbackMatcher = function ($criteria) { return $criteria instanceof Tag; };
        // @codingStandardsIgnoreEnd

        $argumentAssembler = new ArgumentAssembler();
        $factory->register($fileMatcher, new FileAssembler());
        $factory->register($constantMatcher, new ConstantAssembler());
        $factory->register($traitMatcher, new TraitAssembler());
        $factory->register($classMatcher, new ClassAssembler());
        $factory->register($interfaceMatcher, new InterfaceAssembler());
        $factory->register($propertyMatcher, new PropertyAssembler());
        $factory->register($argumentMatcher, $argumentAssembler);
        $factory->register($methodMatcher, new MethodAssembler($argumentAssembler));
        $factory->register($functionMatcher, new FunctionAssembler($argumentAssembler));

        $factory->register($authorMatcher, new AuthorAssembler());
        $factory->register($deprecatedMatcher, new DeprecatedAssembler());
        $factory->register($exampleMatcher, new ExampleAssembler($app['parser.example.finder']));
        $factory->register($linkMatcher, new LinkAssembler());
        $factory->register($methodTagMatcher, new MethodTagAssembler());
        $factory->register($propertyTagMatcher, new PropertyTagAssembler());
        $factory->register($varMatcher, new VarAssembler());
        $factory->register($paramMatcher, new ParamAssembler());
        $factory->register($throwsMatcher, new ThrowsAssembler());
        $factory->register($returnMatcher, new ReturnAssembler());
        $factory->register($usesMatcher, new UsesAssembler());
        $factory->register($seeMatcher, new SeeAssembler());
        $factory->register($sinceMatcher, new SinceAssembler());
        $factory->register($versionMatcher, new VersionAssembler());

        $factory->register($typeCollectionMatcher, new TypeCollectionAssembler());

        $factory->registerFallback($tagFallbackMatcher, new GenericTagAssembler());

        return $factory;
    }
1318356
public function assemble(ContextInterface $context)
    {
        $class = $context->getClass();
        $properties = $context->getType()->getProperties();
        $firstProperty = count($properties) ? current($properties) : null;

        try {
            $interfaceAssembler = new InterfaceAssembler(ResultProviderInterface::class);
            if ($interfaceAssembler->canAssemble($context)) {
                $interfaceAssembler->assemble($context);
            }

            if ($firstProperty) {
                $this->implementGetResult($context, $class, $firstProperty);
            }
        } catch (\Exception $e) {
            throw AssemblerException::fromException($e);
        }
    }