/**
* Register transport implementation for a specific scheme
*
* @param string scheme
* @param lang.XPClass<peer.http.HttpTransport> class
*/
public static function register($scheme, XPClass $class)
{
if (!$class->isSubclassOf('peer.http.HttpTransport')) {
throw new \lang\IllegalArgumentException(sprintf('Given argument must be lang.XPClass<peer.http.HttpTransport>, %s given', $class->toString()));
}
self::$transports[$scheme] = $class;
}
/**
* Register an algorithm
*
* @param string name
* @param lang.XPClass<security.password.Algorithm> impl
* @throws lang.IllegalArgumentException in case the given class is not an Algorithm
*/
public static function setAlgorithm($name, \lang\XPClass $impl)
{
if (!$impl->isSubclassOf('security.password.Algorithm')) {
throw new \lang\IllegalArgumentException('Given argument is not an Algorithm class (' . \xp::stringOf($impl) . ')');
}
self::$algorithms[$name] = $impl;
}
/**
* Fetch a qname for a class.
*
* @param lang.XPClass class
* @return var xml.QName or NULL if no mapping exists
*/
public function qnameFor(\lang\XPClass $class)
{
if (!isset($this->_c2q[$class->getName()])) {
return null;
}
return $this->_qnames[$this->_c2q[$class->getName()]];
}
/**
* Register an implementation
*
* @param string algorithm
* @param lang.XPClass<security.checksum.MessageDigestImpl> class
* @throws lang.IllegalArgumentException
*/
public static function register($algorithm, \lang\XPClass $impl)
{
if (!$impl->isSubclassOf('security.checksum.MessageDigestImpl')) {
throw new \lang\IllegalArgumentException('Implementation class must be a security.checksum.MessageDigestImpl');
}
self::$implementations[$algorithm] = $impl;
}
/**
* Tries to get method start line
*
* @param lang.XPClass $class
* @param string $methodname
* @return int
*/
private function lineFor(XPClass $class, $methodname)
{
try {
return $class->reflect()->getMethod($methodname)->getStartLine();
} catch (\Exception $ignored) {
return 0;
}
}
/**
* Creates a new collector gathering the elements in a collection class
*
* @param lang.XPClass $class
* @return util.data.ICollector
*/
public static function toCollection(XPClass $class)
{
return new Collector(function () use($class) {
return $class->newInstance();
}, function ($result, $arg) {
$result->add($arg);
});
}
/**
* Locate interface by a given name
*
* @param lang.XPClass $class
* @param string $name
* @return lang.XPClass
* @throws lang.ElementNotFoundException
*/
private function interfaceNamed($class, $name)
{
foreach ($class->getInterfaces() as $iface) {
if (strstr($iface->getName(), $name)) {
return $iface;
}
}
throw new ElementNotFoundException('Class ' . $class->getName() . ' does not implement ' . $name);
}
/**
* Returns methods annotated with a given annotatoons
*
* @param lang.XPClass $self
* @param string $annotation
* @return lang.reflect.Method[]
*/
public static function methodsAnnotatedWith(\lang\XPClass $self, $annotation)
{
$name = substr($annotation, 1);
$r = array();
foreach ($self->getMethods() as $method) {
if ($method->hasAnnotation($name)) {
$r[] = $method;
}
}
return $r;
}
/**
* Add a measurable class
*
* @param lang.XPClass $class
* @param lang.reflect.Method $method
* @param var $source
* @return util.data.Sequence
*/
private function permutationOf($class, $method, $source)
{
if (is_array($source)) {
$seq = Sequence::of($source);
} else {
$seq = Sequence::of($class->getMethod($source)->setAccessible(true)->invoke(null));
}
return $seq->map(function ($args) use($class, $method) {
return $class->newInstance($method, (array) $args);
});
}
/**
* Constructor
*
* @param lang.XPClass $scriptlet
* @param string[] args
* @param [:string] env
*/
public function __construct(XPClass $scriptlet, $args, $env = [], $filters = [])
{
if ($scriptlet->hasConstructor()) {
$this->scriptlet = $scriptlet->getConstructor()->newInstance((array) $args);
} else {
$this->scriptlet = $scriptlet->newInstance();
}
foreach ($filters as $filter) {
$this->scriptlet->filter($filter);
}
$this->scriptlet->init();
$this->env = $env;
}
/**
* Show usage
*
* @param lang.XPClass class
* @return void
*/
protected function commandUsage(XPClass $class)
{
// Description
if (null !== ($comment = $class->getComment())) {
self::$err->writeLine(self::textOf($comment));
self::$err->writeLine(str_repeat('=', 72));
}
$extra = $details = $positional = [];
foreach ($class->getMethods() as $method) {
if (!$method->hasAnnotation('arg')) {
continue;
}
$arg = $method->getAnnotation('arg');
$name = strtolower(preg_replace('/^set/', '', $method->getName()));
$comment = self::textOf($method->getComment());
if (0 == $method->numParameters()) {
$optional = true;
} else {
list($first, ) = $method->getParameters();
$optional = $first->isOptional();
}
if (isset($arg['position'])) {
$details['#' . ($arg['position'] + 1)] = $comment;
$positional[$arg['position']] = $name;
} else {
if (isset($arg['name'])) {
$details['--' . $arg['name'] . ' | -' . (isset($arg['short']) ? $arg['short'] : $arg['name'][0])] = $comment;
$extra[$arg['name']] = $optional;
} else {
$details['--' . $name . ' | -' . (isset($arg['short']) ? $arg['short'] : $name[0])] = $comment;
$extra[$name] = $optional;
}
}
}
// Usage
asort($positional);
self::$err->write('Usage: $ xpcli ', Commands::nameOf($class), ' ');
foreach ($positional as $name) {
self::$err->write('<', $name, '> ');
}
foreach ($extra as $name => $optional) {
self::$err->write($optional ? '[' : '', '--', $name, $optional ? '] ' : ' ');
}
self::$err->writeLine();
// Argument details
self::$err->writeLine('Arguments:');
foreach ($details as $which => $comment) {
self::$err->writeLine('* ', $which, "\n ", str_replace("\n", "\n ", $comment), "\n");
}
}
/**
* Shows usage
*
* @param lang.XPClass $class
* @return void
*/
protected function commandUsage(XPClass $class)
{
$comment = $class->getComment();
if ('' === (string) $comment) {
$markdown = '# ' . $class->getSimpleName() . "\n\n";
$text = '';
} else {
@(list($headline, $text) = explode("\n", $comment, 2));
$markdown = '# ' . ltrim($headline, ' #') . "\n\n";
}
$markdown .= "- Usage\n ```sh\n\$ xp cmd " . Commands::nameOf($class);
$extra = $details = $positional = [];
foreach ($class->getMethods() as $method) {
if (!$method->hasAnnotation('arg')) {
continue;
}
$arg = $method->getAnnotation('arg');
$name = strtolower(preg_replace('/^set/', '', $method->getName()));
$optional = 0 === $method->numParameters() || $method->getParameters()[0]->isOptional();
$comment = $method->getComment();
if (isset($arg['position'])) {
$details[$name] = [$comment, null];
$positional[$arg['position']] = $name;
} else {
if (isset($arg['name'])) {
$details['--' . $arg['name']] = [$comment, isset($arg['short']) ? $arg['short'] : $arg['name'][0]];
$extra[$arg['name']] = $optional;
} else {
$details['--' . $name] = [$comment, isset($arg['short']) ? $arg['short'] : $name[0]];
$extra[$name] = $optional;
}
}
}
// Usage
asort($positional);
foreach ($positional as $name) {
$markdown .= ' ' . $name;
}
foreach ($extra as $name => $optional) {
$markdown .= ' ' . (($optional ? '[' : '') . '--' . $name . ($optional ? '] ' : ' '));
}
$markdown .= "\n ```\n";
// Argument details
foreach ($details as $which => $detail) {
$markdown .= sprintf(" **%s**: %s%s\n\n", $which, str_replace("\n", "\n ", $detail[0]), $detail[1] ? ' *(also: -' . $detail[1] . ')*' : '');
}
Help::render(self::$err, substr($markdown, 0, -1) . $text, $class->getClassLoader());
}
public function putParameters()
{
$params = $this->fixture->getClass()->getMethod('put')->getParameters();
$this->assertEquals(2, sizeof($params));
$this->assertEquals(Primitive::$STRING, $params[0]->getType());
$this->assertEquals(XPClass::forName('unittest.TestCase'), $params[1]->getType());
}
public function object_return_type()
{
$fixture = $this->define('{
public function fixture(): \\lang\\Object { return new \\lang\\Object(); }
}');
$this->assertEquals(XPClass::forName('lang.Object'), $this->newFixture($fixture)->methods()->named('fixture')->returns());
}
/**
* Creates a new instance
*
* @param string $source
* @param xp.scriptlet.Config $config
* @throws lang.IllegalArgumentException
*/
public function __construct($source, Config $config = null)
{
if ('-' === $source) {
$this->layout = new ServeDocumentRootStatically();
} else {
if (is_file($source)) {
$this->layout = new WebConfiguration(new Properties($source), $config);
} else {
if (is_dir($source)) {
$this->layout = new BasedOnWebroot($source, $config);
} else {
$name = ltrim($source, ':');
try {
$class = XPClass::forName($name);
} catch (ClassLoadingException $e) {
throw new IllegalArgumentException('Cannot load ' . $name, $e);
}
if ($class->isSubclassOf('xp.scriptlet.WebLayout')) {
if ($class->hasConstructor()) {
$this->layout = $class->getConstructor()->newInstance([$config]);
} else {
$this->layout = $class->newInstance();
}
} else {
if ($class->isSubclassOf('scriptlet.HttpScriptlet')) {
$this->layout = new SingleScriptlet($class->getName(), $config);
} else {
throw new IllegalArgumentException('Expecting either a scriptlet or a weblayout, ' . $class->getName() . ' given');
}
}
}
}
}
}
/**
* Main
*
* @param string[] args
*/
public static function main(array $args)
{
$way = array_shift($args);
$argc = sizeof($args);
// Read sourcecode from STDIN if no further argument is given
if (0 === $argc) {
$code = new Code(file_get_contents('php://stdin'));
} else {
if ('--' === $args[0]) {
$code = new Code(file_get_contents('php://stdin'));
} else {
$code = new Code($args[0]);
}
}
// Perform
$argv = [XPClass::nameOf(self::class)] + $args;
$return = eval($code->head() . $code->expression());
switch ($way) {
case '-w':
Console::writeLine($return);
break;
case '-d':
var_dump($return);
break;
}
}
public function genericInterface()
{
$interfaces = \lang\XPClass::forName('lang.Object')->getInterfaces();
$this->assertEquals(1, sizeof($interfaces));
$this->assertInstanceOf('lang.XPClass', $interfaces[0]);
$this->assertEquals('lang.Generic', $interfaces[0]->getName());
}
/**
* Main
*
* Exitcodes used:
* <ul>
* <li>127: Archive referenced in -xar [...] does not exist</li>
* <li>126: No manifest or manifest does not have a main-class</li>
* </ul>
*
* @see http://tldp.org/LDP/abs/html/exitcodes.html
* @param string[] args
* @return int
*/
public static function main(array $args)
{
// Open archive
$f = new File(array_shift($args));
if (!$f->exists()) {
Console::$err->writeLine('*** Cannot find archive ' . $f->getURI());
return 127;
}
// Register class loader
$cl = \lang\ClassLoader::registerLoader(new \lang\archive\ArchiveClassLoader(new Archive($f)));
if (!$cl->providesResource(self::MANIFEST)) {
Console::$err->writeLine('*** Archive ' . $f->getURI() . ' does not have a manifest');
return 126;
}
// Load manifest
$pr = Properties::fromString($cl->getResource(self::MANIFEST));
if (null === ($class = $pr->readString('archive', 'main-class', null))) {
Console::$err->writeLine('*** Archive ' . $f->getURI() . '\'s manifest does not have a main class');
return 126;
}
// Run main()
try {
return \lang\XPClass::forName($class, $cl)->getMethod('main')->invoke(null, [$args]);
} catch (\lang\reflect\TargetInvocationException $e) {
throw $e->getCause();
}
}
/**
* Constructor
*
* @param rdbms.DSN dsn
*/
public function __construct($dsn)
{
$this->dsn = $dsn;
$this->flags = $dsn->getFlags();
if (!$this->dsn->url->hasParam('autoconnect')) {
$this->flags |= DB_AUTOCONNECT;
}
$this->setTimeout($dsn->getProperty('timeout', 0));
// 0 means no timeout
// Keep this for BC reasons
$observers = $dsn->getProperty('observer', []);
if (null !== ($cat = $dsn->getProperty('log'))) {
$observers['util.log.LogObserver'] = $cat;
}
// Add observers
foreach ($observers as $observer => $param) {
$class = XPClass::forName($observer);
// Check if class implements BoundLogObserver: in that case use factory method to acquire
// instance. Otherwise, just use the constructor
if (XPClass::forName('util.log.BoundLogObserver')->isAssignableFrom($class)) {
$this->addObserver($class->getMethod('instanceFor')->invoke(null, [$param]));
} else {
$this->addObserver($class->newInstance($param));
}
}
// Time zone handling
if ($tz = $dsn->getProperty('timezone', false)) {
$this->tz = new TimeZone($tz);
}
}
static function __static()
{
self::$byName['if'] = XPClass::forName('com.handlebarsjs.IfBlockHelper');
self::$byName['unless'] = XPClass::forName('com.handlebarsjs.UnlessBlockHelper');
self::$byName['with'] = XPClass::forName('com.handlebarsjs.WithBlockHelper');
self::$byName['each'] = XPClass::forName('com.handlebarsjs.EachBlockHelper');
}
public function type_bound_to_type_provider()
{
$inject = new Injector();
$provider = new TypeProvider(XPClass::forName(FileSystem::class), $inject);
$inject->bind(Storage::class, $provider);
$this->assertInstanceOf(FileSystem::class, $inject->get(Storage::class));
}
/**
* Add Portlets
*
* @param string classname
* @param string layout
* @return xml.portlet.Portlet
*/
public function addPortlet($classname, $layout = null)
{
with($portlet = \lang\XPClass::forName($classname)->newInstance());
$portlet->setLayout($layout);
$this->portlets[] = $portlet;
return $portlet;
}
public function given_interface_class_is_implemented()
{
$class = $this->define(['interfaces' => [XPClass::forName(Runnable::class)]], '{
public function run() { }
}');
$this->assertTrue($class->isSubclassOf(Runnable::class));
}
/**
* Matches implementation
*
* @param var value
* @return bool
*/
public function matches($value)
{
if (null === $value && $this->matchNull) {
return true;
}
return \xp::typeof($value) == \lang\XPClass::forName($this->type)->getName();
}
/**
* Compile class from source and return compiled type
*
* @param string src
* @return xp.compiler.types.TypeReflection
*/
protected function compile($src)
{
$unique = 'FixtureClassFor' . $this->getClass()->getSimpleName() . ucfirst($this->name);
$r = $this->emitter->emit(Syntax::forName('xp')->parse(new MemoryInputStream(sprintf($src, $unique))), $this->scope);
$r->executeWith([]);
return new TypeReflection(\lang\XPClass::forName($r->type()->name()));
}
public function putParameters()
{
$params = $this->fixture->getClass()->getMethod('put')->getParameters();
$this->assertEquals(2, sizeof($params));
$this->assertEquals(\lang\XPClass::forName('lang.types.String'), $params[0]->getType());
$this->assertEquals(\lang\XPClass::forName('unittest.TestCase'), $params[1]->getType());
}
/**
* Get all test cases
*
* @param lang.XPClass class
* @param var[] arguments
* @return unittest.TestCase[]
*/
public function testCasesInClass(\lang\XPClass $class, $arguments = null)
{
// Verify we were actually given a testcase class
if (!$class->isSubclassOf('unittest.TestCase')) {
throw new \lang\IllegalArgumentException('Given argument is not a TestCase class (' . \xp::stringOf($class) . ')');
}
// Add all tests cases
$r = [];
foreach ($class->getMethods() as $m) {
$m->hasAnnotation('test') && ($r[] = $class->getConstructor()->newInstance(array_merge((array) $m->getName(true), (array) $arguments)));
}
// Verify we actually added tests by doing this.
if (empty($r)) {
throw new \util\NoSuchElementException('No tests found in ' . $class->getName());
}
return $r;
}
public function returnNewObjectViaMethodInvoke()
{
$class = \lang\XPClass::forName('net.xp_framework.unittest.core.AnonymousFactory');
$factory = $class->getMethod('factory');
$object = $factory->invoke($instance = NULL);
$value = ReferencesTest::registry('list', $r = NULL);
$this->assertReference($object, $value);
}
/**
* Creates a segment instance
*
* @param string $marker
* @param string $bytes
* @return self
*/
public static function read($marker, $bytes)
{
if (is_array($iptc = iptcparse($bytes))) {
return \lang\XPClass::forName('img.io.IptcSegment')->newInstance($marker, $iptc);
} else {
return new self($marker, $bytes);
}
}
/**
* Returns the implementation for the given operating system.
*
* @param string os operating system name, e.g. PHP_OS
* @param string socket default NULL
* @return rdbms.mysqlx.LocalSocket
*/
public static function forName($os, $socket = null)
{
if (0 === strncasecmp($os, 'Win', 3)) {
return \lang\XPClass::forName('rdbms.mysqlx.NamedPipe')->newInstance($socket);
} else {
return \lang\XPClass::forName('rdbms.mysqlx.UnixSocket')->newInstance($socket);
}
}
