Revert "Merge branch 'feature/fix_pattern_properties_problem' into fe…

…ature/fix_all_blackbox_tests"

This reverts commit 30da8fd, reversing
changes made to 1792c05.

docs/contributing.md

@@ -25,7 +25,7 @@ The Acceptance Criteria for _adding new features_ requires a few things in order
 1. **No documentation, no feature:** If a user cannot understand a new feature, that feature basically doesn't exist! Remember to make sure that any and all relevant [documentation](./) is consistently updated.
     - New features such as new presets, generators or inputs, etc, need associated use case documentation along side [examples](../examples). This is not only to showcase the feature, but to ensure it will always work. Checkout our [adding examples](#-adding-examples) doc for more information on how to do this.
 
-### Adding examples
+### Adding Examples
 The Acceptance Criteria Process for _adding examples_ is not only something we use to showcase features, but also to ensure those features always work. _(This is important since it is picked up by [our CI system](#What-does–the-CI-system-do-when-I-create-a-PR).)_
 
 Adding examples is quite straight forward, so don't feel shy! Here's how to do it:
@@ -37,55 +37,7 @@ Adding examples is quite straight forward, so don't feel shy! Here's how to do i
 
 Aaaand you are done! :tada: 
 
-### Adding a new preset 
-Presets are for when you want to customize the generated output, they work like middleware that layers on top of each other, you can read more [about presets here](./presets.md).
-
-Here is how you add a new preset:
-1. All presets are located under `src/generators/${language}/presets`, either duplicate an existing preset and adapt it or create an empty TypeScript file.
-2. The preset file has the syntax:
-```ts
-export const LANGUAGE_MY_PRESET: LanguagePreset = {
-  class: {
-    // Add preset hooks here
-  }, 
-  // enum: {
-    // Add preset hooks here
-  // }
-};
-```
-Replace `LANGUAGE` with the generator the preset is for (for example `TYPESCRIPT`), and replace `LanguagePreset` with the generator the preset is for (for example `TypeScriptPreset`). It is optional which models you add preset hooks for, i.e. you can add preset hooks for `enum` alongside for `class`, but it's not required. Each generator has a set of outputs you can change, read more [about the presets here](./presets.md).
-
-3. Add your preset to the `src/generators/${language}/presets/index.ts` file.
-4. Add an [example](#adding-examples) to showcase your new feature.
-5. Add documentation to [the language docs](./languages/) that explain the use case and links to your new example.
-6. In most cases you want to add specific tests for edge cases or simply to test the preset. To do this add a new test file in `test/generators/${language}/presets/MyPreset.spec.ts` and replace `MyPreset` with your preset name. Now add a test using the following syntax:
-```ts
-describe('LANGUAGE_MY_PRESET', () => {
-  let generator: LanguageGenerator;
-  beforeEach(() => {
-    generator = new LanguageGenerator({ presets: [LANGUAGE_MY_PRESET] });
-  });
-
-  test('should render xxx', async () => {
-    const input = {
-      $id: 'Clazz',
-      type: 'object',
-      properties: {
-        min_number_prop: { type: 'number' },
-        max_number_prop: { type: 'number' },
-      },
-    };
-    const models = await generator.generate(input);
-    expect(models).toHaveLength(1);
-    expect(models[0].result).toMatchSnapshot();
-  });
-});
-```
-Remember to replace `LANGUAGE` and `Language` with the appropriate values.
-
-Aaaand you are done! :tada: 
-
-### Adding a new input processor
+### New input processor
 Input processors are the translators from inputs to MetaModel (read more about [the input processing here](./input-processing.md)). 
 
 Here is how you can add a new input processor:
@@ -105,7 +57,7 @@ Thats it for the code and tests, now all that remains is docs and examples! :fir
 
 Aaaand you are done! :tada: 
 
-### Adding a new generator
+### New Generators
 Generators sits as the core of Modelina, which frames the core concepts of what you can generate. Therefore it's also no small task to create a new one, so dont get discourage, we are here to help you! 
 
 To make it easier to contribute a new generator, and to avoid focusing too much of the internals of Modelina, we created a template generator to get you started. If you encounter discreprencies with the following guide or templates, make sure to raise it as an issue so it can be fixed!

docs/inputs/JSON_Schema.md

@@ -13,7 +13,7 @@ The order of interpretation:
 - `true` boolean schema infers all model types (`object`, `string`, `number`, `array`, `boolean`, `null`, `integer`) schemas.
 - `type` infers the initial model type.
 - `required` are interpreted as is.
-- `patternProperties` are interpreted as is, where duplicate patterns for the model are [merged](#Merging-models).
+- `patternProperties` are merged together with any additionalProperties, where duplicate additionalProperties are [merged](#Merging-models).
 - `additionalProperties` are interpreted as is, where duplicate additionalProperties for the model are [merged](#Merging-models). If the schema does not define `additionalProperties` it defaults to `true` schema.
 - `additionalItems` are interpreted as is, where duplicate additionalItems for the model are [merged](#Merging-models). If the schema does not define `additionalItems` it defaults to `true` schema.
 - `items` are interpreted as ether tuples or simple array, where more than 1 item are [merged](#Merging-models). Usage of `items` infers `array` model type.
@@ -49,7 +49,6 @@ Because of the recursive nature of the interpreter (and the nested nature of JSO
 
 If only one side has a property defined, it is used as is, if both have it defined they are merged based on the following logic (look [here](./input_processing.md#Internal-model-representation) for more information about the CommonModel and its properties):
 - `additionalProperties` if both models contain it the two are recursively merged together. 
-- `patternProperties` if both models contain a pattern the corresponding models are recursively merged together. 
 - `properties` if both models contain the same property the corresponding models are recursively merged together. 
 - `items` are merged together based on a couple of rules:
     - If both models are simple arrays those item models are merged together as is.

examples/csharp-generate-newtonsoft-serializer/__snapshots__/index.spec.ts.snap

@@ -16,12 +16,12 @@ public class Root
 
 public class RootConverter : JsonConverter<Root>
 {
-  public override Root ReadJson(JsonReader reader, System.Type objectType, Root existingValue, bool hasExistingValue, JsonSerializer serializer)
+  public override Root ReadJson(JsonReader reader, Type objectType, Root existingValue, bool hasExistingValue, JsonSerializer serializer)
 {
   JObject jo = JObject.Load(reader);
   Root value = new Root();
 
-  if(jo[\\"email\\"] != null) {
+  if(jo[\\"email\\" != null) {
   value.Email = jo[\\"email\\"].ToObject<string>(serializer);
 }
 
@@ -32,7 +32,7 @@ public class RootConverter : JsonConverter<Root>
 {
   JObject jo = new JObject();
 
-  if (value.Email != null)
+  if (value.email != null)
 {
   jo.Add(\\"email\\", JToken.FromObject(value.Email, serializer));
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/modelina",
-  "version": "1.0.0-next.28",
+  "version": "1.0.0-next.26",
   "description": "Library for generating data models based on inputs such as AsyncAPI, OpenAPI, or JSON Schema documents",
   "license": "Apache-2.0",
   "homepage": "https://github.com/asyncapi/modelina",
@@ -80,10 +80,8 @@
     "docker:test": "npm run docker:build && docker run asyncapi/modelina npm run test",
     "docker:test:blackbox": "npm run docker:build && docker run asyncapi/modelina npm run test:blackbox",
     "test": "npm run test:library && npm run test:examples",
-    "test:update": "npm run test:library -- -u && npm run test:examples:update",
     "test:library": "cross-env CI=true jest --coverage --testPathIgnorePatterns ./test/blackbox --testPathIgnorePatterns ./examples",
     "test:examples": "npm run test:examples:regular && npm run test:examples:websites",
-    "test:examples:update": "npm run test:examples:regular -- -u && npm run test:examples:websites -- -u",
     "test:examples:regular": "cross-env CI=true jest ./examples --testPathIgnorePatterns ./examples/integrate-with-react",
     "test:examples:websites": "cd ./examples/integrate-with-react && npm i && npm run test",
     "test:blackbox": "concurrently --group -n csharp,go,java,javascript,python,rust,typescript \"npm run test:blackbox:csharp\" \"npm run test:blackbox:go\" \"npm run test:blackbox:java\" \"npm run test:blackbox:javascript\" \"npm run test:blackbox:python\" \"npm run test:blackbox:rust\" \"npm run test:blackbox:typescript\"",

src/generators/csharp/presets/NewtonsoftSerializerPreset.ts

@@ -23,7 +23,7 @@ var jsonStringCompliant = stringEnumValue == "True" || stringEnumValue == "False
 var jsonToken = JToken.Parse(jsonStringCompliant);
 jo.Add("${prop.unconstrainedPropertyName}", jsonToken);`;
       }
-      return `if (value.${propertyAccessor} != null)
+      return `if (value.${prop.propertyName} != null)
 {
   ${toJson}
 }`;
@@ -70,7 +70,7 @@ function renderDeserialize({ model }: {
         && prop.property.ref instanceof ConstrainedEnumModel) {
       toValue = `${prop.property.type}Extensions.To${prop.property.type}(jo["${prop.unconstrainedPropertyName}"])`;
     }
-    return `if(jo["${prop.unconstrainedPropertyName}"] != null) {
+    return `if(jo["${prop.unconstrainedPropertyName}" != null) {
   value.${propertyAccessor} = ${toValue};
 }`;
   });
@@ -92,7 +92,7 @@ function renderDeserialize({ model }: {
   {
     ${unwrapDictionaryRead.join('\n')}
   }` : '';
-  return `public override ${model.name} ReadJson(JsonReader reader, System.Type objectType, ${model.name} existingValue, bool hasExistingValue, JsonSerializer serializer)
+  return `public override ${model.name} ReadJson(JsonReader reader, Type objectType, ${model.name} existingValue, bool hasExistingValue, JsonSerializer serializer)
 {
   JObject jo = JObject.Load(reader);
   ${model.name} value = new ${model.name}();
@@ -115,7 +115,6 @@ export const CSHARP_NEWTONSOFT_SERIALIZER_PRESET: CSharpPreset<CSharpOptions> =
       renderer.addDependency('using Newtonsoft.Json;');
       renderer.addDependency('using Newtonsoft.Json.Linq;');
       renderer.addDependency('using System.Collections.Generic;');
-      renderer.addDependency('using System.Linq;');
 
       const deserialize = renderDeserialize({ model });
       const serialize = renderSerialize({ model });

src/generators/rust/constrainer/EnumConstrainer.ts

@@ -46,7 +46,22 @@ export function defaultEnumKeyConstraints(customConstraints?: Partial<ModelEnumK
 }
 
 export function defaultEnumValueConstraints(): EnumValueConstraint {
-  return ({enumValue}) => {
-    return enumValue;
+  return ({ enumValue }) => {
+    switch (typeof enumValue) {
+    case 'boolean':
+      return 'bool';
+    case 'bigint':
+      return 'i64';
+    case 'number': {
+      return 'f64';
+    }
+    case 'object': {
+      return 'HashMap<String, serde_json::Value>';
+    }
+    case 'string':
+    default: {
+      return 'String';
+    }
+    }
   };
 }

src/generators/rust/renderers/EnumRenderer.ts

@@ -43,38 +43,15 @@ ${additionalContent}`;
   runStructMacroPreset(): Promise<string> {
     return this.runPreset('structMacro');
   }
-
-  /**
-   * Returns the type for the JSON value
-   */
-  renderEnumValueType(value: any): string {
-    switch (typeof value) {
-    case 'boolean':
-      return 'bool';
-    case 'bigint':
-      return 'i64';
-    case 'number': {
-      return 'f64';
-    }
-    case 'object': {
-      return 'HashMap<String, serde_json::Value>';
-    }
-    case 'string':
-    default: {
-      return 'String';
-    }
-    }
-  }
 }
 
 export const RUST_DEFAULT_ENUM_PRESET: EnumPresetType<RustOptions> = {
   self({ renderer }) {
     return renderer.defaultSelf();
   },
-  item({ item, renderer }) {
-    const typeOfEnumValue = renderer.renderEnumValueType(item.value);
-    if (typeOfEnumValue === 'HashMap<String, serde_json::Value>') {
-      return `${item.key}(${typeOfEnumValue})`;
+  item({ item }) {
+    if (item.value === 'HashMap<String, serde_json::Value>') {
+      return `${item.key}(${item.value})`;
     }
     return `${item.key}`;
   },

src/helpers/CommonModelToMetaModel.ts

@@ -219,31 +219,14 @@ export function convertToObjectModel(jsonSchemaModel: CommonModel, name: string,
     metaModel.properties[String(propertyName)] = propertyModel;
   }
 
-  if(jsonSchemaModel.additionalProperties !== undefined || jsonSchemaModel.patternProperties !== undefined) {
+  if (jsonSchemaModel.additionalProperties !== undefined) {
     let propertyName = 'additionalProperties';
     while (metaModel.properties[String(propertyName)] !== undefined) {
       propertyName = `reserved_${propertyName}`;
     }
-    const keyModel = new StringModel(propertyName, jsonSchemaModel.originalInput);
-    const modelsAsValue = new Map<string, MetaModel>();
-    if (jsonSchemaModel.additionalProperties !== undefined) {
-      const additionalPropertyModel = convertToMetaModel(jsonSchemaModel.additionalProperties, alreadySeenModels);
-      modelsAsValue.set(additionalPropertyModel.name, additionalPropertyModel);
-    }
-
-    if (jsonSchemaModel.patternProperties !== undefined) {
-      for (const patternModel of Object.values(jsonSchemaModel.patternProperties)) {
-        const patternPropertyModel = convertToMetaModel(patternModel);
-        modelsAsValue.set(patternPropertyModel.name, patternPropertyModel);
-      }
-    }
-    let valueModel: MetaModel;
-    if (modelsAsValue.size === 1) {
-      valueModel = Array.from(modelsAsValue.values())[0];
-    } else {
-      valueModel = new UnionModel(propertyName, jsonSchemaModel.originalInput, Array.from(modelsAsValue.values()));
-    }
-    const dictionaryModel = new DictionaryModel(propertyName, jsonSchemaModel.originalInput, keyModel, valueModel, 'unwrap');
+    const keyModel = new StringModel(propertyName, jsonSchemaModel.additionalProperties.originalInput);
+    const valueModel = convertToMetaModel(jsonSchemaModel.additionalProperties, alreadySeenModels);
+    const dictionaryModel = new DictionaryModel(propertyName, jsonSchemaModel.additionalProperties.originalInput, keyModel, valueModel, 'unwrap');
     const propertyModel = new ObjectPropertyModel(propertyName, false, dictionaryModel);
     metaModel.properties[String(propertyName)] = propertyModel;
   }

src/interpreter/InterpretPatternProperties.ts

@@ -11,10 +11,10 @@ import { Interpreter, InterpreterOptions, InterpreterSchemaType } from './Interp
  */
 export default function interpretPatternProperties(schema: InterpreterSchemaType, model: CommonModel, interpreter : Interpreter, interpreterOptions: InterpreterOptions = Interpreter.defaultInterpreterOptions): void {
   if (typeof schema === 'boolean') {return;}
-  for (const [pattern, patternSchema] of Object.entries(schema.patternProperties || {})) {
+  for (const [,patternSchema] of Object.entries(schema.patternProperties || {})) {
     const patternModel = interpreter.interpret(patternSchema as any, interpreterOptions);
     if (patternModel !== undefined) {
-      model.addPatternProperty(pattern, patternModel, schema);
+      model.addAdditionalProperty(patternModel, schema);
     }
   }
 }