Merge pull request #65 from slackhq/ih_more_refactor

Refactor codegen; support top-level refs

Author: ianhoffman

src/Codegen/Codegen.php

@@ -2,16 +2,20 @@
 
 namespace Slack\Hack\JsonSchema\Codegen;
 
-use namespace HH\Lib\Vec;
+use namespace HH\Lib\{Str, Vec};
 use type Facebook\HackCodegen\{
+  CodegenClass,
   CodegenFile,
+  CodegenFileType,
   CodegenGeneratedFrom,
+  CodegenMethod,
+  HackBuilder,
   HackCodegenConfig,
   HackCodegenFactory,
   IHackCodegenConfig,
 };
 
-final class Codegen {
+final class Codegen implements IBuilder {
 
   const type TValidatorRefsUniqueConfig = shape(
     /* The root path where all of the schemas live */
@@ -108,23 +112,45 @@ final class Codegen {
     ),
   );
 
-  private ValidatorBuilder $builder;
+  private ?CodegenGeneratedFrom $generatedFrom;
+  private HackCodegenFactory $cg;
+  private bool $discardChanges = false;
+  private bool $createAbstract = false;
+  private SchemaBuilder $builder;
+  private CodegenClass $class;
+  private CodegenFile $file;
+  private ?Codegen::TSanitizeStringConfig $sanitizeString = null;
 
   private function __construct(private dict<arraykey, mixed> $schema, private self::TCodegenConfig $config) {
-    $config = $this->config['validator'];
+    $this->cg = new HackCodegenFactory($this->getHackCodegenConfig());
 
-    $builder = new ValidatorBuilder(
+    $validatorConfig = $config['validator'];
+
+    $this->class = $this->cg->codegenClass($validatorConfig['class']);
+
+    $this->file = $this->cg
+      ->codegenFile($validatorConfig['file'])
+      ->setFileType(CodegenFileType::HACK_STRICT)
+      ->setGeneratedFrom($this->getGeneratedFrom())
+      ->setDoClobber($config['discardChanges'] ?? false)
+      ->useNamespace('Slack\Hack\JsonSchema');
+
+    if (Shapes::keyExists($validatorConfig, 'namespace')) {
+      $this->file->setNamespace($validatorConfig['namespace']);
+    }
+
+    $context = new Context(
       $this->config,
-      $this->getHackCodegenConfig(),
+      $this->cg,
       $this->getJsonSchemaCodegenConfig(),
       $this->schema,
+      $this->class->getName(),
+      $this->file,
     );
+    $typed_schema = type_assert_type($this->schema, TSchema::class);
+    $this->builder = new SchemaBuilder($context, '', $typed_schema, $this->class);
 
-    $this->builder = $builder
-      ->setCreateAbstractClass(false)
-      ->setGeneratedFrom($this->getGeneratedFrom())
-      ->setDiscardChanges($this->config['discardChanges'] ?? false)
-      ->setSanitizeString($config['sanitize_string'] ?? null);
+    $this->sanitizeString = $validatorConfig['sanitize_string'] ?? null;
   }
 
   /**
@@ -228,11 +254,64 @@ private function getJsonSchemaCodegenConfig(): IJsonSchemaCodegenConfig {
     return $this->config['jsonSchemaCodegenConfig'] ?? new JsonSchemaCodegenConfig();
   }
 
-  public function build(): CodegenFile {
-    return $this->builder->build();
+  public function build(): this {
+    $this->builder->build();
+
+    if ($this->builder->isUniqueRef()) {
+      // No need to do anything, we're building a top-level ref.
+      return $this;
+    }
+
+    $this->class = $this->class
+      ->setExtends("JsonSchema\BaseValidator<{$this->builder->getType()}>")
+      ->setIsAbstract(false)
+      ->setIsFinal(true)
+      ->addMethod($this->getCodegenClassProcessMethod());
+
+    $this->file->addClass($this->class);
+
+    $contents = $this->file->render();
+    if (Str\contains($contents, 'Constraints\\')) {
+      $this->file->useNamespace('Slack\Hack\JsonSchema\Constraints');
+    }
+
+    $this->file->save();
+
+    return $this;
+  }
+
+  private function getCodegenClassProcessMethod(): CodegenMethod {
+    $hb = new HackBuilder($this->getHackCodegenConfig());
+    $hb->addMultilineCall('return self::check', vec['$this->input', '$this->pointer']);
+
+    return $this->cg
+      ->codegenMethod('process')
+      ->setReturnType($this->builder->getType())
+      ->addEmptyUserAttribute('__Override')
+      ->setProtected()
+      ->setBody($hb->getCode());
+  }
+
+  public function getClass(): CodegenClass {
+    return $this->class;
+  }
+
+  public function getFile(): CodegenFile {
+    return $this->file;
+  }
+
+  public function getClassName(): string {
+    return $this->builder->getClassName();
+  }
+
+  public function getType(): string {
+    return $this->builder->getType();
+  }
+
+  public function isArrayKeyType(): bool {
+    return $this->builder->isArrayKeyType();
   }
 
-  public function getBuilder(): ValidatorBuilder {
-    return $this->builder;
+  public function setSuffix(string $_suffix): void {
   }
 }

src/Codegen/Constraints/ArrayBuilder.php

@@ -264,12 +264,7 @@ private function setupSingleItemSchemaBuilder(): void {
    * Determine the type of hack array we will generate.
    */
   private function determineHackArrayType(): void {
-    $items = $this->typed_schema['items'] ?? null;
-    if (
-      Shapes::idx($this->typed_schema, 'uniqueItems') &&
-      $this->isSchema($items) &&
-      $this->singleItemSchemaBuilder?->isArrayKeyType()
-    ) {
+    if (Shapes::idx($this->typed_schema, 'uniqueItems') && $this->singleItemSchemaBuilder?->isArrayKeyType()) {
       $this->hackArrayType = HackArrayType::KEYSET;
     }
   }

src/Codegen/Constraints/IBuilder.php

@@ -3,9 +3,9 @@
 namespace Slack\Hack\JsonSchema\Codegen;
 
 interface IBuilder {
-  public function build(): this;
   public function getClassName(): string;
   public function getType(): string;
   public function isArrayKeyType(): bool;
+  public function build(): this;
   public function setSuffix(string $suffix): void;
 }

src/Codegen/Constraints/RootBuilder.php

@@ -175,4 +175,8 @@ public function getResolvedContext(): Context {
   public function setSuffix(string $suffix): void {
     $this->builder->setSuffix($suffix);
   }
+
+  public function isUniqueRef(): bool {
+    return $this->getBuilder() is UniqueRefBuilder;
+  }
 }

src/Codegen/Constraints/SchemaBuilder.php

@@ -13,7 +13,7 @@ class UniqueRefBuilder implements IBuilder {
 
   private string $classname;
   private string $filename;
-  private ?RootBuilder $builder;
+  private ?RefCache::TCachedRef $cached_ref;
 
   public function __construct(protected Context $ctx, protected string $ref, protected TSchema $schema) {
     $this->classname = '';
@@ -63,15 +63,18 @@ public function build(): this {
     $codegen_config['validator']['context'] = $context_config;
 
     if (RefCache::isRefCached($this->filename)) {
-      $codegen = RefCache::getCachedCodegen($this->filename);
+      $this->cached_ref = RefCache::getCachedRef($this->filename);
     } else {
       $codegen = Codegen::forSchema(Shapes::toDict($this->schema), $codegen_config, $root_directory);
       $codegen->build();
-      RefCache::cacheRef($this->filename, $codegen);
+      $this->cached_ref = shape(
+        'type' => $codegen->getType(),
+        'classname' => $codegen->getClassName(),
+        'isArrayKeyType' => $codegen->isArrayKeyType(),
+      );
+      RefCache::cacheRef($this->filename, $this->cached_ref);
     }
 
-    $validator_builder = $codegen->getBuilder();
-    $this->builder = $validator_builder->getBuilder();
     return $this;
   }
 
@@ -80,13 +83,13 @@ public function getClassName(): string {
   }
 
   public function getType(): string {
-    invariant($this->builder is nonnull, 'must call `build` method before accessing type');
-    return $this->builder->getType();
+    invariant($this->cached_ref is nonnull, 'must call `build` method before accessing type');
+    return $this->cached_ref['type'];
   }
 
   public function isArrayKeyType(): bool {
-    invariant($this->builder is nonnull, 'must call `build` method before accessing type');
-    return $this->builder->isArrayKeyType();
+    invariant($this->cached_ref is nonnull, 'must call `build` method before accessing type');
+    return $this->cached_ref['isArrayKeyType'];
   }
 
   public function setSuffix(string $_suffix): void {

src/Codegen/Constraints/UniqueRefBuilder.php

@@ -5,8 +5,13 @@
 use namespace HH\Lib\C;
 
 final class RefCache {
+  const type TCachedRef = shape(
+    'type' => string,
+    'classname' => string,
+    'isArrayKeyType' => bool,
+  );
 
-  static private dict<string, Codegen> $generatedRefs = dict[];
+  static private dict<string, self::TCachedRef> $generatedRefs = dict[];
 
   //
   // Run this resetCache before using any other method
@@ -17,12 +22,12 @@ static public function resetCache(): void {
   }
 
   //
-  // Cache the ref by passing in a CodegenFile object. The $refName should be
+  // Cache the ref by passing in a Cached Ref. The $refName should be
   // the full pathname of the file.
   //
 
-  static public function cacheRef(string $refName, Codegen $codegen): void {
-    RefCache::$generatedRefs[$refName] = $codegen;
+  static public function cacheRef(string $refName, self::TCachedRef $ref): void {
+    RefCache::$generatedRefs[$refName] = $ref;
   }
 
   //
@@ -35,11 +40,11 @@ static public function isRefCached(string $refName): bool {
 
   //
   // Do not use this function unless you have already verified that a
-  // Codegen exists for $refName. This function will not gracefully
+  // Cached Ref exists for $refName. This function will not gracefully
   // handle the case when $refName is not found in the cache.
   //
 
-  static public function getCachedCodegen(string $refName): Codegen {
+  static public function getCachedRef(string $refName): this::TCachedRef {
     return RefCache::$generatedRefs[$refName];
   }
 }