| @@ -36,7 +36,7 @@ discard block | ||
| 36 | 36 |              ->method('getArgument') | 
| 37 | 37 | ->willReturnOnConsecutiveCalls(5, 'foo', ['foo', 'bar'], 0.5, true); | 
| 38 | 38 | |
| 39 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 39 | +        $command = new #[AsCommand('foo')] class extends Command{ | |
| 40 | 40 | #[Argument] | 
| 41 | 41 | public int $intVal; | 
| 42 | 42 | |
| @@ -75,7 +75,7 @@ discard block | ||
| 75 | 75 | ->expects($this->never()) | 
| 76 | 76 |              ->method('getArgument'); | 
| 77 | 77 | |
| 78 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 78 | +        $command = new #[AsCommand('foo')] class extends Command{ | |
| 79 | 79 | #[Argument] | 
| 80 | 80 | public int $arg; | 
| 81 | 81 | }; | 
| @@ -98,7 +98,7 @@ discard block | ||
| 98 | 98 |              ->method('getOption') | 
| 99 | 99 | ->willReturnOnConsecutiveCalls(5, 'foo', ['foo', 'bar'], 0.5, true, true); | 
| 100 | 100 | |
| 101 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 101 | +        $command = new #[AsCommand('foo')] class extends Command{ | |
| 102 | 102 | #[Option(mode: InputOption::VALUE_REQUIRED)] | 
| 103 | 103 | public int $intVal; | 
| 104 | 104 | |
| @@ -141,7 +141,7 @@ discard block | ||
| 141 | 141 | ->expects($this->never()) | 
| 142 | 142 |              ->method('getOption'); | 
| 143 | 143 | |
| 144 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 144 | +        $command = new #[AsCommand('foo')] class extends Command{ | |
| 145 | 145 | #[Option(mode: InputOption::VALUE_REQUIRED)] | 
| 146 | 146 | public int $option; | 
| 147 | 147 | }; | 
| @@ -36,7 +36,8 @@ discard block | ||
| 36 | 36 |              ->method('getArgument') | 
| 37 | 37 | ->willReturnOnConsecutiveCalls(5, 'foo', ['foo', 'bar'], 0.5, true); | 
| 38 | 38 | |
| 39 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 39 | +        $command = new #[AsCommand('foo')] class extends Command | |
| 40 | +        { | |
| 40 | 41 | #[Argument] | 
| 41 | 42 | public int $intVal; | 
| 42 | 43 | |
| @@ -75,7 +76,8 @@ discard block | ||
| 75 | 76 | ->expects($this->never()) | 
| 76 | 77 |              ->method('getArgument'); | 
| 77 | 78 | |
| 78 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 79 | +        $command = new #[AsCommand('foo')] class extends Command | |
| 80 | +        { | |
| 79 | 81 | #[Argument] | 
| 80 | 82 | public int $arg; | 
| 81 | 83 | }; | 
| @@ -98,7 +100,8 @@ discard block | ||
| 98 | 100 |              ->method('getOption') | 
| 99 | 101 | ->willReturnOnConsecutiveCalls(5, 'foo', ['foo', 'bar'], 0.5, true, true); | 
| 100 | 102 | |
| 101 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 103 | +        $command = new #[AsCommand('foo')] class extends Command | |
| 104 | +        { | |
| 102 | 105 | #[Option(mode: InputOption::VALUE_REQUIRED)] | 
| 103 | 106 | public int $intVal; | 
| 104 | 107 | |
| @@ -141,7 +144,8 @@ discard block | ||
| 141 | 144 | ->expects($this->never()) | 
| 142 | 145 |              ->method('getOption'); | 
| 143 | 146 | |
| 144 | -        $command = new #[AsCommand('foo')] class extends Command { | |
| 147 | +        $command = new #[AsCommand('foo')] class extends Command | |
| 148 | +        { | |
| 145 | 149 | #[Option(mode: InputOption::VALUE_REQUIRED)] | 
| 146 | 150 | public int $option; | 
| 147 | 151 | }; | 
| @@ -234,7 +234,7 @@ | ||
| 234 | 234 | $result = $this->parser->parse(new \ReflectionClass( | 
| 235 | 235 |              new #[AsCommand(name: 'foo')] class { | 
| 236 | 236 | #[Option(mode: InputOption::VALUE_OPTIONAL)] | 
| 237 | - private int|\stdClass $option; | |
| 237 | + private int | \stdClass $option; | |
| 238 | 238 | } | 
| 239 | 239 | )); | 
| 240 | 240 | |
| @@ -26,7 +26,8 @@ discard block | ||
| 26 | 26 | public function testRequired(): void | 
| 27 | 27 |      { | 
| 28 | 28 | $result = $this->parser->parse(new \ReflectionClass( | 
| 29 | -            new #[AsCommand(name: 'foo')] class { | |
| 29 | + new #[AsCommand(name: 'foo')] class | |
| 30 | +            { | |
| 30 | 31 | #[Option(mode: InputOption::VALUE_REQUIRED)] | 
| 31 | 32 | private int $option; | 
| 32 | 33 | } | 
| @@ -44,7 +45,8 @@ discard block | ||
| 44 | 45 | public function testDefaultValue(): void | 
| 45 | 46 |      { | 
| 46 | 47 | $result = $this->parser->parse(new \ReflectionClass( | 
| 47 | -            new #[AsCommand(name: 'foo')] class { | |
| 48 | + new #[AsCommand(name: 'foo')] class | |
| 49 | +            { | |
| 48 | 50 | #[Option(mode: InputOption::VALUE_OPTIONAL)] | 
| 49 | 51 | private string $option = 'some'; | 
| 50 | 52 | } | 
| @@ -62,7 +64,8 @@ discard block | ||
| 62 | 64 | public function testNullable(): void | 
| 63 | 65 |      { | 
| 64 | 66 | $result = $this->parser->parse(new \ReflectionClass( | 
| 65 | -            new #[AsCommand(name: 'foo')] class { | |
| 67 | + new #[AsCommand(name: 'foo')] class | |
| 68 | +            { | |
| 66 | 69 | #[Option(mode: InputOption::VALUE_OPTIONAL)] | 
| 67 | 70 | private ?string $option; | 
| 68 | 71 | } | 
| @@ -80,7 +83,8 @@ discard block | ||
| 80 | 83 | public function testWithName(): void | 
| 81 | 84 |      { | 
| 82 | 85 | $result = $this->parser->parse(new \ReflectionClass( | 
| 83 | -            new #[AsCommand(name: 'foo')] class { | |
| 86 | + new #[AsCommand(name: 'foo')] class | |
| 87 | +            { | |
| 84 | 88 | #[Option(name: 'customName', mode: InputOption::VALUE_OPTIONAL)] | 
| 85 | 89 | private ?string $option; | 
| 86 | 90 | } | 
| @@ -98,7 +102,8 @@ discard block | ||
| 98 | 102 | public function testWithShortcut(): void | 
| 99 | 103 |      { | 
| 100 | 104 | $result = $this->parser->parse(new \ReflectionClass( | 
| 101 | -            new #[AsCommand(name: 'foo')] class { | |
| 105 | + new #[AsCommand(name: 'foo')] class | |
| 106 | +            { | |
| 102 | 107 | #[Option(shortcut: 't', mode: InputOption::VALUE_OPTIONAL)] | 
| 103 | 108 | private ?string $option; | 
| 104 | 109 | } | 
| @@ -116,7 +121,8 @@ discard block | ||
| 116 | 121 | public function testWithDescription(): void | 
| 117 | 122 |      { | 
| 118 | 123 | $result = $this->parser->parse(new \ReflectionClass( | 
| 119 | -            new #[AsCommand(name: 'foo')] class { | |
| 124 | + new #[AsCommand(name: 'foo')] class | |
| 125 | +            { | |
| 120 | 126 | #[Option(description: 'Some description', mode: InputOption::VALUE_OPTIONAL)] | 
| 121 | 127 | private ?string $option; | 
| 122 | 128 | } | 
| @@ -134,7 +140,8 @@ discard block | ||
| 134 | 140 | public function testModeOptionalArray(): void | 
| 135 | 141 |      { | 
| 136 | 142 | $result = $this->parser->parse(new \ReflectionClass( | 
| 137 | -            new #[AsCommand(name: 'foo')] class { | |
| 143 | + new #[AsCommand(name: 'foo')] class | |
| 144 | +            { | |
| 138 | 145 | #[Option(mode: InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY)] | 
| 139 | 146 | private array $option = []; | 
| 140 | 147 | } | 
| @@ -152,7 +159,8 @@ discard block | ||
| 152 | 159 | public function testModeRequiredArray(): void | 
| 153 | 160 |      { | 
| 154 | 161 | $result = $this->parser->parse(new \ReflectionClass( | 
| 155 | -            new #[AsCommand(name: 'foo')] class { | |
| 162 | + new #[AsCommand(name: 'foo')] class | |
| 163 | +            { | |
| 156 | 164 | #[Option(mode: InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY)] | 
| 157 | 165 | private array $option = []; | 
| 158 | 166 | } | 
| @@ -170,7 +178,8 @@ discard block | ||
| 170 | 178 | public function testModeValueNegatable(): void | 
| 171 | 179 |      { | 
| 172 | 180 | $result = $this->parser->parse(new \ReflectionClass( | 
| 173 | -            new #[AsCommand(name: 'foo')] class { | |
| 181 | + new #[AsCommand(name: 'foo')] class | |
| 182 | +            { | |
| 174 | 183 | #[Option(mode: InputOption::VALUE_NEGATABLE)] | 
| 175 | 184 | private bool $option; | 
| 176 | 185 | } | 
| @@ -188,7 +197,8 @@ discard block | ||
| 188 | 197 | public function testModeValueNone(): void | 
| 189 | 198 |      { | 
| 190 | 199 | $result = $this->parser->parse(new \ReflectionClass( | 
| 191 | -            new #[AsCommand(name: 'foo')] class { | |
| 200 | + new #[AsCommand(name: 'foo')] class | |
| 201 | +            { | |
| 192 | 202 | #[Option(mode: InputOption::VALUE_NONE)] | 
| 193 | 203 | private bool $option; | 
| 194 | 204 | } | 
| @@ -206,7 +216,8 @@ discard block | ||
| 206 | 216 | public function testWithSuggestedValue(): void | 
| 207 | 217 |      { | 
| 208 | 218 | $result = $this->parser->parse(new \ReflectionClass( | 
| 209 | -            new #[AsCommand(name: 'foo')] class { | |
| 219 | + new #[AsCommand(name: 'foo')] class | |
| 220 | +            { | |
| 210 | 221 | #[Option(mode: InputOption::VALUE_REQUIRED, suggestedValues: [1, 0])] | 
| 211 | 222 | private int $option; | 
| 212 | 223 | } | 
| @@ -232,7 +243,8 @@ discard block | ||
| 232 | 243 | public function testUnionTypeWithBuiltInAndNot(): void | 
| 233 | 244 |      { | 
| 234 | 245 | $result = $this->parser->parse(new \ReflectionClass( | 
| 235 | -            new #[AsCommand(name: 'foo')] class { | |
| 246 | + new #[AsCommand(name: 'foo')] class | |
| 247 | +            { | |
| 236 | 248 | #[Option(mode: InputOption::VALUE_OPTIONAL)] | 
| 237 | 249 | private int|\stdClass $option; | 
| 238 | 250 | } | 
| @@ -251,7 +263,8 @@ discard block | ||
| 251 | 263 |      { | 
| 252 | 264 | $this->expectException(ConfiguratorException::class); | 
| 253 | 265 | $this->parser->parse(new \ReflectionClass( | 
| 254 | -            new #[AsCommand(name: 'foo')] class { | |
| 266 | + new #[AsCommand(name: 'foo')] class | |
| 267 | +            { | |
| 255 | 268 | #[Option] | 
| 256 | 269 | private \stdClass $option; | 
| 257 | 270 | } | 
| @@ -262,7 +275,8 @@ discard block | ||
| 262 | 275 |      { | 
| 263 | 276 | $this->expectException(ConfiguratorException::class); | 
| 264 | 277 | $this->parser->parse(new \ReflectionClass( | 
| 265 | -            new #[AsCommand(name: 'foo')] class { | |
| 278 | + new #[AsCommand(name: 'foo')] class | |
| 279 | +            { | |
| 266 | 280 | #[Option] | 
| 267 | 281 | private \stdClass&\Traversable $option; | 
| 268 | 282 | } | 
| @@ -182,7 +182,7 @@ | ||
| 182 | 182 | $result = $this->parser->parse(new \ReflectionClass( | 
| 183 | 183 |              new #[AsCommand(name: 'foo')] class { | 
| 184 | 184 | #[Argument] | 
| 185 | - private int|\stdClass $arg; | |
| 185 | + private int | \stdClass $arg; | |
| 186 | 186 | } | 
| 187 | 187 | )); | 
| 188 | 188 | |
| @@ -25,7 +25,8 @@ discard block | ||
| 25 | 25 | public function testRequired(): void | 
| 26 | 26 |      { | 
| 27 | 27 | $result = $this->parser->parse(new \ReflectionClass( | 
| 28 | -            new #[AsCommand(name: 'foo')] class { | |
| 28 | + new #[AsCommand(name: 'foo')] class | |
| 29 | +            { | |
| 29 | 30 | #[Argument] | 
| 30 | 31 | private int $arg; | 
| 31 | 32 | } | 
| @@ -41,7 +42,8 @@ discard block | ||
| 41 | 42 | public function testWithDefaultValue(): void | 
| 42 | 43 |      { | 
| 43 | 44 | $result = $this->parser->parse(new \ReflectionClass( | 
| 44 | -            new #[AsCommand(name: 'foo')] class { | |
| 45 | + new #[AsCommand(name: 'foo')] class | |
| 46 | +            { | |
| 45 | 47 | #[Argument] | 
| 46 | 48 | private int $arg = 1; | 
| 47 | 49 | } | 
| @@ -57,7 +59,8 @@ discard block | ||
| 57 | 59 | public function testNullable(): void | 
| 58 | 60 |      { | 
| 59 | 61 | $result = $this->parser->parse(new \ReflectionClass( | 
| 60 | -            new #[AsCommand(name: 'foo')] class { | |
| 62 | + new #[AsCommand(name: 'foo')] class | |
| 63 | +            { | |
| 61 | 64 | #[Argument] | 
| 62 | 65 | private ?int $arg; | 
| 63 | 66 | } | 
| @@ -73,7 +76,8 @@ discard block | ||
| 73 | 76 | public function testWithName(): void | 
| 74 | 77 |      { | 
| 75 | 78 | $result = $this->parser->parse(new \ReflectionClass( | 
| 76 | -            new #[AsCommand(name: 'foo')] class { | |
| 79 | + new #[AsCommand(name: 'foo')] class | |
| 80 | +            { | |
| 77 | 81 | #[Argument(name: 'customName')] | 
| 78 | 82 | private int $arg; | 
| 79 | 83 | } | 
| @@ -89,7 +93,8 @@ discard block | ||
| 89 | 93 | public function testWithDescription(): void | 
| 90 | 94 |      { | 
| 91 | 95 | $result = $this->parser->parse(new \ReflectionClass( | 
| 92 | -            new #[AsCommand(name: 'foo')] class { | |
| 96 | + new #[AsCommand(name: 'foo')] class | |
| 97 | +            { | |
| 93 | 98 | #[Argument(description: 'Some description')] | 
| 94 | 99 | private int $arg; | 
| 95 | 100 | } | 
| @@ -105,7 +110,8 @@ discard block | ||
| 105 | 110 | public function testWithSuggestedValue(): void | 
| 106 | 111 |      { | 
| 107 | 112 | $result = $this->parser->parse(new \ReflectionClass( | 
| 108 | -            new #[AsCommand(name: 'foo')] class { | |
| 113 | + new #[AsCommand(name: 'foo')] class | |
| 114 | +            { | |
| 109 | 115 | #[Argument(suggestedValues: [1, 0])] | 
| 110 | 116 | private int $arg; | 
| 111 | 117 | } | 
| @@ -129,7 +135,8 @@ discard block | ||
| 129 | 135 | public function testArrayRequired(): void | 
| 130 | 136 |      { | 
| 131 | 137 | $result = $this->parser->parse(new \ReflectionClass( | 
| 132 | -            new #[AsCommand(name: 'foo')] class { | |
| 138 | + new #[AsCommand(name: 'foo')] class | |
| 139 | +            { | |
| 133 | 140 | #[Argument] | 
| 134 | 141 | private array $arg; | 
| 135 | 142 | } | 
| @@ -145,7 +152,8 @@ discard block | ||
| 145 | 152 | public function testArrayNotRequired(): void | 
| 146 | 153 |      { | 
| 147 | 154 | $result = $this->parser->parse(new \ReflectionClass( | 
| 148 | -            new #[AsCommand(name: 'foo')] class { | |
| 155 | + new #[AsCommand(name: 'foo')] class | |
| 156 | +            { | |
| 149 | 157 | #[Argument] | 
| 150 | 158 | private ?array $arg; | 
| 151 | 159 | } | 
| @@ -161,7 +169,8 @@ discard block | ||
| 161 | 169 | public function testArrayShouldBeLast(): void | 
| 162 | 170 |      { | 
| 163 | 171 | $result = $this->parser->parse(new \ReflectionClass( | 
| 164 | -            new #[AsCommand(name: 'foo')] class { | |
| 172 | + new #[AsCommand(name: 'foo')] class | |
| 173 | +            { | |
| 165 | 174 | #[Argument] | 
| 166 | 175 | private ?array $arg; | 
| 167 | 176 | |
| @@ -180,7 +189,8 @@ discard block | ||
| 180 | 189 | public function testUnionTypeWithBuiltInAndNot(): void | 
| 181 | 190 |      { | 
| 182 | 191 | $result = $this->parser->parse(new \ReflectionClass( | 
| 183 | -            new #[AsCommand(name: 'foo')] class { | |
| 192 | + new #[AsCommand(name: 'foo')] class | |
| 193 | +            { | |
| 184 | 194 | #[Argument] | 
| 185 | 195 | private int|\stdClass $arg; | 
| 186 | 196 | } | 
| @@ -197,7 +207,8 @@ discard block | ||
| 197 | 207 |      { | 
| 198 | 208 | $this->expectException(ConfiguratorException::class); | 
| 199 | 209 | $this->parser->parse(new \ReflectionClass( | 
| 200 | -            new #[AsCommand(name: 'foo')] class { | |
| 210 | + new #[AsCommand(name: 'foo')] class | |
| 211 | +            { | |
| 201 | 212 | #[Argument] | 
| 202 | 213 | private \stdClass $arg; | 
| 203 | 214 | } | 
| @@ -208,7 +219,8 @@ discard block | ||
| 208 | 219 |      { | 
| 209 | 220 | $this->expectException(ConfiguratorException::class); | 
| 210 | 221 | $this->parser->parse(new \ReflectionClass( | 
| 211 | -            new #[AsCommand(name: 'foo')] class { | |
| 222 | + new #[AsCommand(name: 'foo')] class | |
| 223 | +            { | |
| 212 | 224 | #[Argument] | 
| 213 | 225 | private \stdClass&\Traversable $arg; | 
| 214 | 226 | } | 
| @@ -219,7 +231,8 @@ discard block | ||
| 219 | 231 |      { | 
| 220 | 232 | $this->expectException(ConfiguratorException::class); | 
| 221 | 233 | $this->parser->parse(new \ReflectionClass( | 
| 222 | -            new #[AsCommand(name: 'foo')] class { | |
| 234 | + new #[AsCommand(name: 'foo')] class | |
| 235 | +            { | |
| 223 | 236 | #[Argument] | 
| 224 | 237 | private array $arg; | 
| 225 | 238 | |
| @@ -13,6 +13,6 @@ | ||
| 13 | 13 | public readonly string $name, | 
| 14 | 14 | public readonly ?string $description = null, | 
| 15 | 15 | public readonly ?string $help = null | 
| 16 | -    ) { | |
| 16 | +    ){ | |
| 17 | 17 | } | 
| 18 | 18 | } | 
| @@ -19,10 +19,10 @@ | ||
| 19 | 19 | */ | 
| 20 | 20 | public function __construct( | 
| 21 | 21 | public readonly ?string $name = null, | 
| 22 | - public readonly string|array|null $shortcut = null, | |
| 22 | + public readonly string | array | null $shortcut = null, | |
| 23 | 23 | public readonly ?string $description = null, | 
| 24 | 24 | public readonly int $mode = InputOption::VALUE_NONE, | 
| 25 | - public readonly \Closure|array $suggestedValues = [] | |
| 26 | -    ) { | |
| 25 | + public readonly \Closure | array $suggestedValues = [] | |
| 26 | +    ){ | |
| 27 | 27 | } | 
| 28 | 28 | } | 
| @@ -17,7 +17,7 @@ | ||
| 17 | 17 | public function __construct( | 
| 18 | 18 | public readonly ?string $name = null, | 
| 19 | 19 | public readonly ?string $description = null, | 
| 20 | - public readonly \Closure|array $suggestedValues = [], | |
| 21 | -    ) { | |
| 20 | + public readonly \Closure | array $suggestedValues = [], | |
| 21 | +    ){ | |
| 22 | 22 | } | 
| 23 | 23 | } | 
| @@ -13,6 +13,6 @@ | ||
| 13 | 13 | public function __construct( | 
| 14 | 14 | public readonly string $question, | 
| 15 | 15 | public readonly ?string $argument = null | 
| 16 | -    ) { | |
| 16 | +    ){ | |
| 17 | 17 | } | 
| 18 | 18 | } | 
| @@ -14,13 +14,13 @@ | ||
| 14 | 14 | public function configure(Command $command, \ReflectionClass $reflection): void | 
| 15 | 15 |      { | 
| 16 | 16 |          $command->setName($reflection->getConstant('NAME')); | 
| 17 | -        $command->setDescription((string) $reflection->getConstant('DESCRIPTION')); | |
| 17 | +        $command->setDescription((string)$reflection->getConstant('DESCRIPTION')); | |
| 18 | 18 | |
| 19 | -        foreach ($reflection->getMethod('defineOptions')->invoke($command) as $option) { | |
| 19 | +        foreach ($reflection->getMethod('defineOptions')->invoke($command) as $option){ | |
| 20 | 20 | \call_user_func_array([$command, 'addOption'], $option); | 
| 21 | 21 | } | 
| 22 | 22 | |
| 23 | -        foreach ($reflection->getMethod('defineArguments')->invoke($command) as $argument) { | |
| 23 | +        foreach ($reflection->getMethod('defineArguments')->invoke($command) as $argument){ | |
| 24 | 24 | \call_user_func_array([$command, 'addArgument'], $argument); | 
| 25 | 25 | } | 
| 26 | 26 | } | 
| @@ -16,11 +16,13 @@ | ||
| 16 | 16 |          $command->setName($reflection->getConstant('NAME')); | 
| 17 | 17 |          $command->setDescription((string) $reflection->getConstant('DESCRIPTION')); | 
| 18 | 18 | |
| 19 | -        foreach ($reflection->getMethod('defineOptions')->invoke($command) as $option) { | |
| 19 | +        foreach ($reflection->getMethod('defineOptions')->invoke($command) as $option) | |
| 20 | +        { | |
| 20 | 21 | \call_user_func_array([$command, 'addOption'], $option); | 
| 21 | 22 | } | 
| 22 | 23 | |
| 23 | -        foreach ($reflection->getMethod('defineArguments')->invoke($command) as $argument) { | |
| 24 | +        foreach ($reflection->getMethod('defineArguments')->invoke($command) as $argument) | |
| 25 | +        { | |
| 24 | 26 | \call_user_func_array([$command, 'addArgument'], $argument); | 
| 25 | 27 | } | 
| 26 | 28 | } | 
| @@ -14,7 +14,7 @@ discard block | ||
| 14 | 14 |  { | 
| 15 | 15 | public function __construct( | 
| 16 | 16 | private readonly Parser $parser | 
| 17 | -    ) { | |
| 17 | +    ){ | |
| 18 | 18 | } | 
| 19 | 19 | |
| 20 | 20 | public function canConfigure(Command $command, \ReflectionClass $reflection): bool | 
| @@ -27,14 +27,14 @@ discard block | ||
| 27 | 27 | $result = $this->parser->parse($reflection); | 
| 28 | 28 | |
| 29 | 29 | $command->setName($result->name); | 
| 30 | - $command->setDescription((string) $result->description); | |
| 31 | - $command->setHelp((string) $result->help); | |
| 30 | + $command->setDescription((string)$result->description); | |
| 31 | + $command->setHelp((string)$result->help); | |
| 32 | 32 | |
| 33 | -        foreach ($result->options as $option) { | |
| 33 | +        foreach ($result->options as $option){ | |
| 34 | 34 | $command->getDefinition()->addOption($option); | 
| 35 | 35 | } | 
| 36 | 36 | |
| 37 | -        foreach ($result->arguments as $argument) { | |
| 37 | +        foreach ($result->arguments as $argument){ | |
| 38 | 38 | $command->getDefinition()->addArgument($argument); | 
| 39 | 39 | } | 
| 40 | 40 | } | 
| @@ -30,11 +30,13 @@ | ||
| 30 | 30 | $command->setDescription((string) $result->description); | 
| 31 | 31 | $command->setHelp((string) $result->help); | 
| 32 | 32 | |
| 33 | -        foreach ($result->options as $option) { | |
| 33 | + foreach ($result->options as $option) | |
| 34 | +        { | |
| 34 | 35 | $command->getDefinition()->addOption($option); | 
| 35 | 36 | } | 
| 36 | 37 | |
| 37 | -        foreach ($result->arguments as $argument) { | |
| 38 | + foreach ($result->arguments as $argument) | |
| 39 | +        { | |
| 38 | 40 | $command->getDefinition()->addArgument($argument); | 
| 39 | 41 | } | 
| 40 | 42 | } |