Code Coverage |
||||||||||
Lines |
Functions and Methods |
Classes and Traits |
||||||||
| Total | |
0.00% |
0 / 85 |
|
0.00% |
0 / 7 |
CRAP | |
0.00% |
0 / 1 |
| TemplateHandlerArguments | |
0.00% |
0 / 85 |
|
0.00% |
0 / 7 |
992 | |
0.00% |
0 / 1 |
| __construct | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
| getSrcOffsets | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
| getOrderedArgs | |
0.00% |
0 / 26 |
|
0.00% |
0 / 1 |
90 | |||
| getNamedArgs | |
0.00% |
0 / 41 |
|
0.00% |
0 / 1 |
210 | |||
| checkSpread | |
0.00% |
0 / 12 |
|
0.00% |
0 / 1 |
20 | |||
| isNamed | |
0.00% |
0 / 1 |
|
0.00% |
0 / 1 |
2 | |||
| stringify | |
0.00% |
0 / 3 |
|
0.00% |
0 / 1 |
2 | |||
| 1 | <?php |
| 2 | declare( strict_types = 1 ); |
| 3 | |
| 4 | namespace Wikimedia\Parsoid\Wt2Html\TT; |
| 5 | |
| 6 | use Wikimedia\Parsoid\Core\DomSourceRange; |
| 7 | use Wikimedia\Parsoid\Ext\Arguments; |
| 8 | use Wikimedia\Parsoid\Ext\EmptyArguments; |
| 9 | use Wikimedia\Parsoid\Ext\ParsoidExtensionAPI; |
| 10 | use Wikimedia\Parsoid\Fragments\WikitextPFragment; |
| 11 | use Wikimedia\Parsoid\Tokens\KV; |
| 12 | use Wikimedia\Parsoid\Tokens\PreprocTk; |
| 13 | |
| 14 | /** |
| 15 | * An implementation of the Arguments interface used by TemplateHandler |
| 16 | * to invoke PFragmentHandlers. |
| 17 | * |
| 18 | * @unstable This may change further as named-argument support (T390344) |
| 19 | * is developed. |
| 20 | */ |
| 21 | class TemplateHandlerArguments implements Arguments { |
| 22 | |
| 23 | public function __construct( |
| 24 | /** @var list<KV> Where keys and values are list<string|PreprocTk> */ |
| 25 | private array $args, |
| 26 | /** @var ?DomSourceRange The region corresponding to this transclusion. */ |
| 27 | private ?DomSourceRange $srcOffsets, |
| 28 | ) { |
| 29 | } |
| 30 | |
| 31 | /** @inheritDoc */ |
| 32 | public function getSrcOffsets(): ?DomSourceRange { |
| 33 | return $this->srcOffsets; |
| 34 | } |
| 35 | |
| 36 | /** @inheritDoc */ |
| 37 | public function getOrderedArgs( |
| 38 | ParsoidExtensionAPI $extApi, |
| 39 | $expandAndTrim = true |
| 40 | ): array { |
| 41 | // The ordered arg array squashes the key and value together. |
| 42 | $result = []; |
| 43 | foreach ( $this->args as $kv ) { |
| 44 | $spread = self::checkSpread( $extApi, $kv ); |
| 45 | if ( $spread ) { |
| 46 | foreach ( $spread->getOrderedArgs( $extApi, false ) as $v ) { |
| 47 | $i = count( $result ); |
| 48 | $shouldExpand = is_array( $expandAndTrim ) ? |
| 49 | ( $expandAndTrim[$i] ?? true ) : $expandAndTrim; |
| 50 | if ( $shouldExpand ) { |
| 51 | $v = $v->expand( $extApi )->trim(); |
| 52 | } |
| 53 | $result[] = $v; |
| 54 | } |
| 55 | continue; |
| 56 | } |
| 57 | $i = count( $result ); |
| 58 | $shouldExpand = is_array( $expandAndTrim ) ? |
| 59 | ( $expandAndTrim[$i] ?? true ) : $expandAndTrim; |
| 60 | $tsr = $kv->srcOffsets->span(); |
| 61 | $v = self::stringify( $kv->v ); |
| 62 | if ( self::isNamed( $kv ) ) { |
| 63 | $v = self::stringify( $kv->k ) . "=$v"; |
| 64 | } |
| 65 | $v = WikitextPFragment::newFromWt( |
| 66 | $v, DomSourceRange::fromTsr( $tsr ) |
| 67 | ); |
| 68 | if ( $shouldExpand ) { |
| 69 | $v = $v->expand( $extApi )->trim(); |
| 70 | } |
| 71 | $result[] = $v; |
| 72 | } |
| 73 | return $result; |
| 74 | } |
| 75 | |
| 76 | /** @inheritDoc */ |
| 77 | public function getNamedArgs( |
| 78 | ParsoidExtensionAPI $extApi, |
| 79 | $expandAndTrim = true |
| 80 | ): array { |
| 81 | $unnamedIdx = 1; |
| 82 | $result = []; |
| 83 | foreach ( $this->args as $kv ) { |
| 84 | $spread = self::checkSpread( $extApi, $kv ); |
| 85 | if ( $spread ) { |
| 86 | $spreadArgs = $spread->getNamedArgs( $extApi, false ); |
| 87 | // Treat numeric keys as "unnamed" and renumber |
| 88 | for ( $i = 1; isset( $spreadArgs[$i] ); $i++ ) { |
| 89 | $key = strval( $unnamedIdx++ ); |
| 90 | $v = $spreadArgs[$i]; |
| 91 | $shouldExpand = is_array( $expandAndTrim ) ? |
| 92 | ( $expandAndTrim[$key] ?? true ) : $expandAndTrim; |
| 93 | if ( $shouldExpand ) { |
| 94 | $v = $v->expand( $extApi )->trim(); |
| 95 | } |
| 96 | $result[$key] = $v; |
| 97 | } |
| 98 | foreach ( $spreadArgs as $key => $v ) { |
| 99 | if ( preg_match( '/^[1-9][0-9]*$/D', (string)$key ) && |
| 100 | intval( $key ) < $i ) { |
| 101 | // We already processed this key as "unnamed" |
| 102 | continue; |
| 103 | } |
| 104 | $shouldExpand = is_array( $expandAndTrim ) ? |
| 105 | ( $expandAndTrim[$key] ?? true ) : $expandAndTrim; |
| 106 | if ( $shouldExpand ) { |
| 107 | $v = $v->expand( $extApi )->trim(); |
| 108 | } |
| 109 | $result[$key] = $v; |
| 110 | } |
| 111 | continue; |
| 112 | } |
| 113 | if ( self::isNamed( $kv ) ) { |
| 114 | $key = WikitextPFragment::newFromWt( |
| 115 | self::stringify( $kv->k ), |
| 116 | DomSourceRange::fromTsr( $kv->srcOffsets->key ) |
| 117 | )->expand( $extApi )->trim()->killMarkers(); |
| 118 | } else { |
| 119 | $key = strval( $unnamedIdx++ ); |
| 120 | } |
| 121 | $shouldExpand = is_array( $expandAndTrim ) ? |
| 122 | ( $expandAndTrim[$key] ?? true ) : |
| 123 | $expandAndTrim; |
| 124 | $v = WikitextPFragment::newFromWt( |
| 125 | self::stringify( $kv->v ), |
| 126 | DomSourceRange::fromTsr( $kv->srcOffsets->value ) |
| 127 | ); |
| 128 | if ( $shouldExpand ) { |
| 129 | $v = $v->expand( $extApi )->trim(); |
| 130 | } |
| 131 | // Note that (by design) this may overwrite earlier values |
| 132 | // for the same key. Rightmost argument wins. |
| 133 | $result[$key] = $v; |
| 134 | } |
| 135 | return $result; |
| 136 | } |
| 137 | |
| 138 | /** |
| 139 | * Check to see if the key for this named argument is `...` and the |
| 140 | * expanded value is an instanceof `Arguments`. If so, return the |
| 141 | * Arguments; otherwise return null. |
| 142 | */ |
| 143 | private static function checkSpread( ParsoidExtensionAPI $extApi, KV $kv ): ?Arguments { |
| 144 | if ( !self::isNamed( $kv ) ) { |
| 145 | // Not a named argument. |
| 146 | return null; |
| 147 | } |
| 148 | $k = self::stringify( $kv->k ); |
| 149 | if ( trim( $k ) !== '...' ) { |
| 150 | // Not a "spread" argument. |
| 151 | return null; |
| 152 | } |
| 153 | $srcOffsets = DomSourceRange::fromTsr( $kv->srcOffsets->value ); |
| 154 | $v = WikitextPFragment::newFromWt( |
| 155 | self::stringify( $kv->v ), $srcOffsets |
| 156 | )->expand( $extApi )->trim(); |
| 157 | if ( !( $v instanceof Arguments ) ) { |
| 158 | // The value we're trying to spread doesn't actually |
| 159 | // implement Arguments. This is an error, but return an |
| 160 | // empty arguments array so this isn't re-interpreted as a |
| 161 | // valid named or positional argument. |
| 162 | return new EmptyArguments( $srcOffsets ); |
| 163 | } |
| 164 | // This is a correct spread. |
| 165 | // (covered by #f7_kv test function in ParserTestsPFragmentHandlers) |
| 166 | return $v; |
| 167 | } |
| 168 | |
| 169 | /** |
| 170 | * @return true if the given KV represents a named argument. |
| 171 | */ |
| 172 | private static function isNamed( KV $kv ): bool { |
| 173 | return $kv->srcOffsets->key->end !== $kv->srcOffsets->value->start; |
| 174 | } |
| 175 | |
| 176 | /** |
| 177 | * Convert the preprocessed contents back into the original wikitext. |
| 178 | * @param list<string|PreprocTk> $contents |
| 179 | * @return string |
| 180 | */ |
| 181 | private static function stringify( array $contents ): string { |
| 182 | return PreprocTk::printContents( |
| 183 | PreprocTk::newContentsKV( $contents, null ), false |
| 184 | ); |
| 185 | } |
| 186 | } |