Implement flagged path checks

Author: danog

docs

@@ -22,5 +22,5 @@ interface ActionOp
 {
     public function build(TLContext $tl): void;
 
-    public function normalize(array $stack, string $current): ?self;
+    public function normalize(array $stack, string $current, bool $ignoreFlagged): ?self;
 }

examples/pipesbot

@@ -18,6 +18,25 @@
 
 namespace danog\MadelineProto\FileRefExtractor;
 
-interface FieldExtractorOp extends TypedOp
+abstract readonly class FieldExtractorOp implements TypedOp
 {
+    public function __construct(
+        /** @var list<list{0: string, 1: string, 2?: TypedOp|null}> */
+        public array $path,
+    ) {
+        foreach ($path as $elem) {
+            if (\count($elem) !== 2 && \count($elem) !== 3) {
+                throw new \InvalidArgumentException('Invalid path part: ' . json_encode($path));
+            }
+            if (isset($elem[2]) && !$elem[2] instanceof TypedOp && $elem[2] !== true) {
+                throw new \InvalidArgumentException('Invalid path part: ' . json_encode($path));
+            }
+        }
+    }
+
+    public function getType(TLContext $tl): string
+    {
+        return $tl->getTypeAtPosition($this);
+    }
+
 }

schemas

@@ -29,12 +29,12 @@ public function __construct(TypedOp ...$values)
     {
         $this->values = $values;
     }
-    public function normalize(array $stack, string $current): ?\danog\MadelineProto\FileRefExtractor\TypedOp
+    public function normalize(array $stack, string $current, bool $ignoreFlag): ?\danog\MadelineProto\FileRefExtractor\TypedOp
     {
         $final = [];
         $isDifferent = false;
         foreach ($this->values as $value) {
-            $normalized = $value->normalize($stack, $current);
+            $normalized = $value->normalize($stack, $current, $ignoreFlag);
             if ($normalized === null) {
                 return null;
             }

tools/FileRefExtractor/ActionOp.php

@@ -34,12 +34,12 @@ public function __construct(
     ) {
         Assert::allIsInstanceOf($args, TypedOp::class);
     }
-    public function normalize(array $stack, string $current): ?ActionOp
+    public function normalize(array $stack, string $current, bool $ignoreFlag): ?ActionOp
     {
         $final = [];
         $isDifferent = false;
         foreach ($this->args as $from => $to) {
-            $normalized = $to->normalize($stack, $current);
+            $normalized = $to->normalize($stack, $current, $ignoreFlag);
             if ($normalized === null) {
                 return null;
             }
@@ -59,7 +59,7 @@ public static function simple(string $method, string $constructor, array $args):
         $final = [];
         foreach ($args as $from => $to) {
             if (!$to instanceof TypedOp) {
-                $to = new ExtractFromHereOp([$constructor, $to]);
+                $to = new ExtractFromHereOp([[$constructor, $to]]);
             }
             $final[$from] = $to;
         }
@@ -117,12 +117,12 @@ public function build(TLContext $tl): void
                 ];
             }
         } else {
-            assert($out instanceof Ast);
+            \assert($out instanceof Ast);
             $out->output[$tl->position][] = [
                 'op' => 'call',
                 'method' => $this->method,
                 'args' => $final,
-                'needsMethod' => $out->needsMethod
+                'needsMethod' => $out->needsMethod,
             ];
         }
     }

tools/FileRefExtractor/FieldExtractorOp.php

@@ -32,12 +32,12 @@ public function __construct(
         Assert::allIsInstanceOf($args, TypedOp::class);
     }
 
-    public function normalize(array $stack, string $current): ?\danog\MadelineProto\FileRefExtractor\TypedOp
+    public function normalize(array $stack, string $current, bool $ignoreFlag): ?\danog\MadelineProto\FileRefExtractor\TypedOp
     {
         $final = [];
         $isDifferent = false;
         foreach ($this->args as $from => $to) {
-            $normalized = $to->normalize($stack, $current);
+            $normalized = $to->normalize($stack, $current, $ignoreFlag);
             if ($normalized === null) {
                 return null;
             }

tools/FileRefExtractor/Ops/ArrayOp.php

@@ -19,7 +19,6 @@
 namespace danog\MadelineProto\FileRefExtractor\Ops;
 
 use danog\MadelineProto\FileRefExtractor\ActionOp;
-use danog\MadelineProto\FileRefExtractor\BuildMode;
 use danog\MadelineProto\FileRefExtractor\BuildMode\Ast;
 use danog\MadelineProto\FileRefExtractor\TLContext;
 use Webmozart\Assert\Assert;
@@ -30,7 +29,7 @@ public function __construct(private readonly string $method)
     {
     }
 
-    public function normalize(array $stack, string $current): ?\danog\MadelineProto\FileRefExtractor\ActionOp
+    public function normalize(array $stack, string $current, bool $ignoreFlag): ?\danog\MadelineProto\FileRefExtractor\ActionOp
     {
         Assert::eq($current, $this->method);
         Assert::isEmpty($stack);
@@ -43,12 +42,12 @@ public function build(TLContext $tl): void
         $tl->tl->tl->getMethods()->findByMethod($this->method)['type']; // Validate type
         $out = $tl->buildMode;
         if ($out instanceof Ast) {
-            $out->output[$this->method][] = [
+            /*$out->output[$this->method][] = [
                 'op' => 'copyMethodCall',
                 'ctx' => $out->contextName,
                 'method' => $this->method,
-            ];
-        } else {
+            ];*/
         }
+
     }
 }

tools/FileRefExtractor/Ops/CallOp.php

@@ -20,59 +20,48 @@
 
 use danog\MadelineProto\FileRefExtractor\FieldExtractorOp;
 use danog\MadelineProto\FileRefExtractor\TLContext;
+use danog\MadelineProto\FileRefExtractor\TypedOp;
 use Webmozart\Assert\Assert;
 
-final readonly class ExtractFromHereOp implements FieldExtractorOp
+final readonly class ExtractFromHereOp extends FieldExtractorOp
 {
-    public function __construct(
-        /** @var string[] */
-        public readonly array $path,
-        public readonly bool $isFlag = false,
-        public readonly ?FieldExtractorOp $ifEmptyFlag = null,
-    ) {
-        if ($ifEmptyFlag !== null) {
-            Assert::true($isFlag);
-        }
-    }
-
-    public function normalize(array $stack, string $current): ?\danog\MadelineProto\FileRefExtractor\TypedOp
+    public function normalize(array $stack, string $current, bool $ignoreFlag): ?\danog\MadelineProto\FileRefExtractor\TypedOp
     {
-        $if = $this->ifEmptyFlag?->normalize($stack, $current);
-        if ($if === null && $this->ifEmptyFlag !== null) {
-            return null;
+        $new = [];
+        foreach ($this->path as $i => $part) {
+            if ($ignoreFlag && \array_key_exists(2, $part) && $part[2] === null) {
+                return null;
+            }
+            if (isset($part[2]) && $part[2] instanceof TypedOp) {
+                $n = $part[2]->normalize($stack, $current, $ignoreFlag);
+                if ($n === null) {
+                    return null;
+                }
+                $part[2] = $n;
+            }
+            $new[$i] = $part;
         }
-        Assert::eq($current, $this->path[0]);
+        Assert::eq($current, $this->path[0][0]);
         return new self(
-            [...$stack, ...$this->path],
-            $this->isFlag,
-            $if
+            [...$stack, ...$new],
         );
     }
 
-    public function getType(TLContext $tl): string
-    {
-        $t = $tl->getTypeAtPosition($this);
-        if ($this->ifEmptyFlag !== null) {
-            Assert::eq($this->ifEmptyFlag->getType($tl), $t);
-        }
-        return $t;
-    }
-
-    public function extend(string ...$path): self
-    {
-        return new self(...$this->path, ...$path);
-    }
-
     public function build(TLContext $tl): array
     {
         // Validate
         $this->getType($tl);
 
+        $new = [];
+        foreach ($this->path as $part) {
+            if (isset($part[2]) && $part[2] !== true) {
+                $part[2] = $part[2]->build($tl);
+            }
+            $new[] = $part;
+        }
         return [
             'op' => 'extractFromHere',
-            'isFlag' => $this->isFlag,
-            'ifFlagEmptyUse' => $this->ifEmptyFlag?->build($tl),
-            'path' => $this->path,
+            'path' => $new,
         ];
     }
 }