All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.regnosys.rosetta.tests.util.CodeGeneratorTestHelper Maven / Gradle / Ivy

    There is a newer version: 9.29.0
    Show newest version
    package com.regnosys.rosetta.tests.util;

import com.google.common.base.Objects;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.regnosys.rosetta.generator.RosettaGenerator;
import com.regnosys.rosetta.generator.RosettaInternalGenerator;
import com.regnosys.rosetta.generator.java.RosettaJavaPackages;
import com.regnosys.rosetta.rosetta.RosettaModel;
import com.regnosys.rosetta.tests.compiler.InMemoryJavacCompiler;
import com.regnosys.rosetta.utils.ModelIdProvider;
import com.rosetta.model.lib.RosettaModelObject;
import com.rosetta.model.lib.RosettaModelObjectBuilder;
import com.rosetta.model.lib.meta.FieldWithMeta;
import com.rosetta.util.DottedPath;
import java.io.File;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import javax.inject.Inject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.generator.GeneratorContext;
import org.eclipse.xtext.util.CancelIndicator;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Conversions;
import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ListExtensions;
import org.eclipse.xtext.xbase.lib.ObjectExtensions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.StringExtensions;
import org.eclipse.xtext.xbase.testing.RegisteringFileSystemAccess;

@SuppressWarnings("all")
public class CodeGeneratorTestHelper {
  @Inject
  @Extension
  private RosettaGenerator _rosettaGenerator;

  @Inject
  @Extension
  private ModelHelper _modelHelper;

  @Inject
  @Extension
  private ModelIdProvider _modelIdProvider;

  public Map generateCode(final CharSequence model, final RosettaInternalGenerator generator) {
    Map _xblockexpression = null;
    {
      final RegisteringFileSystemAccess fsa = new RegisteringFileSystemAccess();
      final Resource eResource = this._modelHelper.parseRosettaWithNoErrors(model).eResource();
      final Consumer _function = (RosettaModel it) -> {
        DottedPath _dottedPath = this._modelIdProvider.toDottedPath(it);
        final RosettaJavaPackages.RootPackage root = new RosettaJavaPackages.RootPackage(_dottedPath);
        final String version = it.getVersion();
        generator.generate(root, fsa, it.getElements(), version);
      };
      Iterables.filter(eResource.getContents(), RosettaModel.class).forEach(_function);
      final Function1 _function_1 = (RegisteringFileSystemAccess.GeneratedFile it) -> {
        String _javaClassName = it.getJavaClassName();
        return Boolean.valueOf((_javaClassName != null));
      };
      final Function1 _function_2 = (RegisteringFileSystemAccess.GeneratedFile it) -> {
        return it.getJavaClassName();
      };
      final Function1 _function_3 = (RegisteringFileSystemAccess.GeneratedFile it) -> {
        return it.getContents().toString();
      };
      _xblockexpression = IterableExtensions.toMap(IterableExtensions.filter(fsa.getGeneratedFiles(), _function_1), _function_2, _function_3);
    }
    return _xblockexpression;
  }

  public HashMap generateCode(final CharSequence... models) {
    HashMap _xblockexpression = null;
    {
      final Function1 _function = (RosettaModel it) -> {
        return it.eResource();
      };
      final List eResources = ListExtensions.map(this._modelHelper.parseRosettaWithNoErrors(models), _function);
      _xblockexpression = this.generateCode(eResources);
    }
    return _xblockexpression;
  }

  public HashMap generateCode(final CharSequence model) {
    HashMap _xblockexpression = null;
    {
      final Resource eResource = this._modelHelper.parseRosettaWithNoErrors(model).eResource();
      _xblockexpression = this.generateCode(Collections.unmodifiableList(CollectionLiterals.newArrayList(eResource)));
    }
    return _xblockexpression;
  }

  protected HashMap generateCode(final List resources) {
    final RegisteringFileSystemAccess fsa = new RegisteringFileSystemAccess();
    GeneratorContext _generatorContext = new GeneratorContext();
    final Procedure1 _function = (GeneratorContext it) -> {
      it.setCancelIndicator(CancelIndicator.NullImpl);
    };
    final GeneratorContext ctx = ObjectExtensions.operator_doubleArrow(_generatorContext, _function);
    final ResourceSet resourceSet = IterableExtensions.head(resources).getResourceSet();
    try {
      this._rosettaGenerator.beforeAllGenerate(resourceSet, fsa, ctx);
      final Consumer _function_1 = (Resource it) -> {
        try {
          this._rosettaGenerator.beforeGenerate(it, fsa, ctx);
          this._rosettaGenerator.doGenerate(it, fsa, ctx);
        } finally {
          this._rosettaGenerator.afterGenerate(it, fsa, ctx);
        }
      };
      resources.forEach(_function_1);
    } finally {
      this._rosettaGenerator.afterAllGenerate(resourceSet, fsa, ctx);
    }
    final HashMap generatedCode = CollectionLiterals.newHashMap();
    final Consumer _function_1 = (RegisteringFileSystemAccess.GeneratedFile it) -> {
      String _javaClassName = it.getJavaClassName();
      boolean _tripleNotEquals = (_javaClassName != null);
      if (_tripleNotEquals) {
        generatedCode.put(it.getJavaClassName(), it.getContents().toString());
      }
    };
    fsa.getGeneratedFiles().forEach(_function_1);
    return generatedCode;
  }

  public HashMap generateCode(final RosettaModel model) {
    HashMap _xblockexpression = null;
    {
      final Resource eResource = model.eResource();
      _xblockexpression = this.generateCode(Collections.unmodifiableList(CollectionLiterals.newArrayList(eResource)));
    }
    return _xblockexpression;
  }

  public Map> compileToClasses(final Map code) {
    return this.inMemoryCompileToClasses(code, this.getClass().getClassLoader());
  }

  public Map> compileJava8(final CharSequence model) {
    Map> _xblockexpression = null;
    {
      final HashMap code = this.generateCode(model);
      _xblockexpression = this.inMemoryCompileToClasses(code, this.getClass().getClassLoader());
    }
    return _xblockexpression;
  }

  public Enum createEnumInstance(final Map> classes, final String className, final String enumValue) {
    Enum _xblockexpression = null;
    {
      RosettaJavaPackages.RootPackage _rootPackage = this._modelHelper.rootPackage();
      String _plus = (_rootPackage + ".");
      String _plus_1 = (_plus + className);
      Class _get = classes.get(_plus_1);
      final Class myEnumClass = ((Class) _get);
      Enum _valueOf = Enum.valueOf(myEnumClass, enumValue);
      _xblockexpression = ((Enum) _valueOf);
    }
    return _xblockexpression;
  }

  public RosettaModelObject createInstanceUsingBuilder(final Map> classes, final String className, final Map itemsToSet) {
    return this.createInstanceUsingBuilder(classes, this._modelHelper.rootPackage(), className, itemsToSet);
  }

  public RosettaModelObject createInstanceUsingBuilder(final Map> classes, final RosettaJavaPackages.RootPackage namespace, final String className, final Map itemsToSet) {
    return this.createInstanceUsingBuilder(classes, namespace, className, itemsToSet, ImmutableMap.>of());
  }

  public RosettaModelObject createInstanceUsingBuilder(final Map> classes, final String className, final Map itemsToSet, final Map> itemsToAddToList) {
    return this.createInstanceUsingBuilder(classes, this._modelHelper.rootPackage(), className, itemsToSet, itemsToAddToList);
  }

  public RosettaModelObjectBuilder createBuilderInstance(final Map> classes, final RosettaJavaPackages.RootPackage namespace, final String className) {
    try {
      String _plus = (namespace + ".");
      String _plus_1 = (_plus + className);
      Object _invoke = classes.get(_plus_1).getMethod("builder").invoke(null);
      return ((RosettaModelObjectBuilder) _invoke);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  public RosettaModelObjectBuilder createBuilderInstance(final Map> classes, final String className) {
    return this.createBuilderInstance(classes, this._modelHelper.rootPackage(), className);
  }

  public Object setAttribute(final RosettaModelObjectBuilder rosettaClassBuilderInstance, final String name, final Object value) {
    try {
      Object _xblockexpression = null;
      {
        Class _class = rosettaClassBuilderInstance.getClass();
        String _firstUpper = StringExtensions.toFirstUpper(name);
        String _plus = ("set" + _firstUpper);
        Class _class_1 = null;
        if (value!=null) {
          _class_1=value.getClass();
        }
        final Method setter = this.getMatchingMethod(_class, _plus, Collections.>unmodifiableList(CollectionLiterals.>newArrayList(_class_1)));
        if ((setter == null)) {
          StringConcatenation _builder = new StringConcatenation();
          _builder.append("No method #");
          String _firstUpper_1 = StringExtensions.toFirstUpper(name);
          String _plus_1 = ("set" + _firstUpper_1);
          _builder.append(_plus_1);
          _builder.append("(");
          Class _class_2 = null;
          if (value!=null) {
            _class_2=value.getClass();
          }
          String _simpleName = null;
          if (_class_2!=null) {
            _simpleName=_class_2.getSimpleName();
          }
          _builder.append(_simpleName);
          _builder.append(") in ");
          Class _class_3 = rosettaClassBuilderInstance.getClass();
          _builder.append(_class_3);
          throw new RuntimeException(_builder.toString());
        }
        Class _class_4 = rosettaClassBuilderInstance.getClass();
        String _firstUpper_2 = StringExtensions.toFirstUpper(name);
        String _plus_2 = ("set" + _firstUpper_2);
        Class _class_5 = null;
        if (value!=null) {
          _class_5=value.getClass();
        }
        _xblockexpression = this.getMatchingMethod(_class_4, _plus_2, Collections.>unmodifiableList(CollectionLiterals.>newArrayList(_class_5))).invoke(rosettaClassBuilderInstance, value);
      }
      return _xblockexpression;
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  public RosettaModelObject createInstanceUsingBuilder(final Map> classes, final RosettaJavaPackages.RootPackage namespace, final String className, final Map itemsToSet, final Map> itemsToAddToList) {
    try {
      String _plus = (namespace + ".");
      String _plus_1 = (_plus + className);
      final Class clazz = classes.get(_plus_1);
      if ((clazz == null)) {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("Class ");
        String _plus_2 = (namespace + ".");
        String _plus_3 = (_plus_2 + className);
        _builder.append(_plus_3);
        _builder.append(" not found");
        throw new RuntimeException(_builder.toString());
      }
      final RosettaModelObjectBuilder rosettaClassBuilderInstance = this.createBuilderInstance(classes, namespace, className);
      final BiConsumer _function = (String name, Object value) -> {
        this.setAttribute(rosettaClassBuilderInstance, name, value);
      };
      itemsToSet.forEach(_function);
      final BiConsumer> _function_1 = (String name, List objectsToAdd) -> {
        final Consumer _function_2 = (Object value) -> {
          try {
            final Class builderClazz = rosettaClassBuilderInstance.getClass();
            String _firstUpper = StringExtensions.toFirstUpper(name);
            String _plus_4 = ("add" + _firstUpper);
            final Function1> _function_3 = (Object it) -> {
              return it.getClass();
            };
            final Method meth = this.getMatchingMethod(builderClazz, _plus_4, ListExtensions.>map(Collections.unmodifiableList(CollectionLiterals.newArrayList(value)), _function_3));
            meth.invoke(rosettaClassBuilderInstance, value);
          } catch (Throwable _e) {
            throw Exceptions.sneakyThrow(_e);
          }
        };
        objectsToAdd.forEach(_function_2);
      };
      itemsToAddToList.forEach(_function_1);
      Object _invoke = rosettaClassBuilderInstance.getClass().getMethod("build").invoke(rosettaClassBuilderInstance);
      return ((RosettaModelObject) _invoke);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  public FieldWithMeta createFieldWithMetaString(final Map> classes, final String value, final String scheme) {
    try {
      final Object metaFieldsBuilder = classes.get("com.rosetta.model.metafields.MetaFields").getMethod("builder").invoke(null);
      Class _class = scheme.getClass();
      this.getMatchingMethod(metaFieldsBuilder.getClass(), "setScheme", Collections.>unmodifiableList(CollectionLiterals.>newArrayList(_class))).invoke(metaFieldsBuilder, scheme);
      final Object fieldWithMetaStringBuilder = classes.get("com.rosetta.model.metafields.FieldWithMetaString").getMethod("builder").invoke(null);
      Class _class_1 = value.getClass();
      this.getMatchingMethod(fieldWithMetaStringBuilder.getClass(), "setValue", Collections.>unmodifiableList(CollectionLiterals.>newArrayList(_class_1))).invoke(fieldWithMetaStringBuilder, value);
      Class _class_2 = metaFieldsBuilder.getClass();
      this.getMatchingMethod(fieldWithMetaStringBuilder.getClass(), "setMeta", Collections.>unmodifiableList(CollectionLiterals.>newArrayList(_class_2))).invoke(fieldWithMetaStringBuilder, metaFieldsBuilder);
      Object _invoke = fieldWithMetaStringBuilder.getClass().getMethod("build").invoke(fieldWithMetaStringBuilder);
      return ((FieldWithMeta) _invoke);
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  public Method getMatchingMethod(final Class clazz, final String name, final List> values) {
    Method _xblockexpression = null;
    {
      final Function1 _function = (Method m) -> {
        String _name = m.getName();
        return Boolean.valueOf(Objects.equal(_name, name));
      };
      Iterable methods = IterableExtensions.filter(((Iterable)Conversions.doWrapArray(clazz.getMethods())), _function);
      int _xifexpression = (int) 0;
      if ((values == null)) {
        _xifexpression = 0;
      } else {
        _xifexpression = values.size();
      }
      final int size = _xifexpression;
      final Function1 _function_1 = (Method m) -> {
        int _parameterCount = m.getParameterCount();
        return Boolean.valueOf((_parameterCount == size));
      };
      methods = IterableExtensions.filter(methods, _function_1);
      final Function1 _function_2 = (Method m) -> {
        return Boolean.valueOf(CodeGeneratorTestHelper.paramsMatch(m, values));
      };
      final Method meth = IterableExtensions.findFirst(methods, _function_2);
      _xblockexpression = meth;
    }
    return _xblockexpression;
  }

  public static boolean paramsMatch(final Method m, final List> value) {
    for (int i = 0; (i < ((List>)Conversions.doWrapArray(m.getParameterTypes())).size()); i++) {
      {
        final Class clazz = value.get(i);
        final Class p = m.getParameterTypes()[i];
        if (((clazz != null) && (!p.isAssignableFrom(clazz)))) {
          return false;
        }
      }
    }
    return true;
  }

  public Object createCalculationInstance(final Map> classes, final String className) {
    try {
      DottedPath _functions = this._modelHelper.rootPackage().functions();
      String _plus = (_functions + ".");
      final String fqn = (_plus + className);
      final Class foundClazz = classes.get(fqn);
      if ((foundClazz == null)) {
        StringConcatenation _builder = new StringConcatenation();
        _builder.append("No generated class \'");
        _builder.append(fqn);
        _builder.append("\' found");
        throw new IllegalStateException(_builder.toString());
      }
      return foundClazz.getDeclaredConstructor().newInstance();
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  @Deprecated
  public Map writeClasses(final Map code, final String directory) {
    try {
      Set> _entrySet = code.entrySet();
      for (final Map.Entry entry : _entrySet) {
        {
          final String name = entry.getKey();
          final String pathName = name.replace(".", File.separator);
          boolean _endsWith = pathName.endsWith("Factory");
          boolean _not = (!_endsWith);
          if (_not) {
            final Path path = Paths.get((("target/" + directory) + "/java"), (pathName + ".java"));
            Files.createDirectories(path.getParent());
            Files.write(path, entry.getValue().getBytes());
          }
        }
      }
      return code;
    } catch (Throwable _e) {
      throw Exceptions.sneakyThrow(_e);
    }
  }

  private Map> inMemoryCompileToClasses(final Map sources, final ClassLoader scope) {
    Map> _xblockexpression = null;
    {
      final InMemoryJavacCompiler inMemoryCompiler = InMemoryJavacCompiler.newInstance().useParentClassLoader(scope).useOptions("--release", "8", "-Xlint:all", "-Xdiags:verbose");
      final BiConsumer _function = (String className, String sourceCode) -> {
        inMemoryCompiler.addSource(className, sourceCode);
      };
      sources.forEach(_function);
      _xblockexpression = inMemoryCompiler.compileAll();
    }
    return _xblockexpression;
  }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy