protected XtextResource createExpectedResource() { XtextResource _xblockexpression = null; { XtextResourceSet resourceSet = this.createFreshResourceSet(); VirtualFile _virtualFile = this.myFile.getVirtualFile(); String _url = _virtualFile.getUrl(); final URI uri = URI.createURI(_url); Resource _createResource = resourceSet.createResource(uri); final Procedure1<XtextResource> _function = new Procedure1<XtextResource>() { @Override public void apply(final XtextResource it) { try { String _text = AbstractLanguageParsingTestCase.this.myFile.getText(); byte[] _bytes = _text.getBytes(); ByteArrayInputStream _byteArrayInputStream = new ByteArrayInputStream(_bytes); it.load(_byteArrayInputStream, null); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } } }; _xblockexpression = ObjectExtensions.<XtextResource>operator_doubleArrow( ((XtextResource) _createResource), _function); } return _xblockexpression; }
public Class<?> getRawType(JvmType jvmType) { if (jvmType == null || jvmType.eIsProxy()) return null; XtextResourceSet resourceSet = (XtextResourceSet) jvmType.eResource().getResourceSet(); if (resourceSet.getClasspathURIContext() instanceof ClassLoader) { JavaReflectAccess access = new JavaReflectAccess(); access.setClassLoader((ClassLoader) resourceSet.getClasspathURIContext()); return access.getRawType(jvmType); } if (!(jvmType.eResource() instanceof TypeResource)) return null; IMirror typeMirror = ((TypeResource) jvmType.eResource()).getMirror(); Bundle bundle = null; if (typeMirror instanceof JdtTypeMirror) bundle = getBundle((JdtTypeMirror) typeMirror); if (typeMirror instanceof ClassMirror) bundle = getBundle((ClassMirror) typeMirror); if (bundle == null) return null; String className = jvmType.getQualifiedName(); try { return bundle.loadClass(className); } catch (ClassNotFoundException e) { LOG.error( "Could not find Java class for " + jvmType.eClass().getName() + " " + jvmType.getIdentifier(), e); return null; } }
private static Program parse(String input) throws ParseException { try { if (injector == null) { injector = new PrologStandaloneSetupGenerated().createInjectorAndDoEMFRegistration(); } XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet.class); resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); Resource resource = resourceSet.createResource(URI.createURI("null:/prolog.pl")); InputStream in = new ByteArrayInputStream(input.getBytes()); resource.load(in, resourceSet.getLoadOptions()); if (resource.getErrors().size() > 0) { Diagnostic d = resource.getErrors().get(0); String l = d.getLocation(); if (l == null) { try { l = "line and column: " + d.getLine() + "," + d.getColumn(); } catch (UnsupportedOperationException e) { if (d instanceof AbstractDiagnostic) { l = "offset: " + ((AbstractDiagnostic) d).getOffset(); } } } throw new ParseException( resource.getErrors().get(0).getMessage() + " at " + l + " for: " + input); } return (Program) resource.getContents().get(0); } catch (Throwable e) { throw new ParseException("Parse exception for: " + input, e); } }
@Override public AttributedFeatureModel parseFile(String fileName) throws Exception { Injector injector = new VMStandaloneSetup().createInjectorAndDoEMFRegistration(); XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet.class); resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); if (models != null) { for (String s : models) { resourceSet.getResource(URI.createURI(s), true); } } Resource resource = resourceSet.getResource(URI.createURI(fileName), true); Model model = (Model) resource.getContents().get(0); fm = new AttributedFeatureModel(); VmBlock relationships = null; VmBlock attsblock = null; VmBlock constratins = null; EList<VmBlock> bl = model.getBlocks(); for (VmBlock block : bl) { if (block instanceof Relationships) { relationships = block; } else if (block instanceof Attributes) { attsblock = block; } else if (block instanceof Constraints) { constratins = block; } else if (block instanceof PackageDeclaration) { for (VmBlock blockinpkg : ((PackageDeclaration) block).getBlocks()) { if (blockinpkg instanceof Relationships) { relationships = blockinpkg; } else if (blockinpkg instanceof Attributes) { attsblock = blockinpkg; } else if (blockinpkg instanceof Constraints) { constratins = blockinpkg; } } } } if (((Relationships) relationships) != null) { FeatureHierarchy fhs = ((Relationships) relationships).getRoot(); fr.familiar.attributedfm.Feature ffeat = new fr.familiar.attributedfm.Feature(fhs.getParent().getName()); visitFeatureHierarchy(ffeat, fhs); fm.setRoot(ffeat); } if ((Attributes) attsblock != null) { visitAttributes(((Attributes) attsblock).getAttrDefs(), fm); } if ((Constraints) constratins != null) { visitConstraints(((Constraints) constratins).getConstraints(), fm); } return fm; }
public Query parse(String input) { resourceSet.getResources().clear(); Resource resource = resourceSet.createResource(createURI("MyQuery.__query")); try { resource.load(new StringInputStream(input), null); EcoreUtil.resolveAll(resource); } catch (IOException e) { throw new RuntimeException(e); } return filter(resource.getContents(), Query.class).iterator().next(); }
public XtendFile file(final String string, final boolean validate) throws Exception { XtextResourceSet _resourceSet = this.getResourceSet(); URI _createURI = URI.createURI("abcdefg.xtend"); final Resource resource = _resourceSet.createResource(_createURI); StringInputStream _stringInputStream = new StringInputStream(string); resource.load(_stringInputStream, null); EList<EObject> _contents = resource.getContents(); EObject _head = IterableExtensions.<EObject>head(_contents); final XtendFile file = ((XtendFile) _head); return file; }
public boolean runGeneratorDir(String inputDirPath, Metadata metadata, String outputPath) { List<String> files = getFiles(inputDirPath, ".rim"); for (String modelPath : files) { resourceSet.getResources().add(resourceSet.getResource(URI.createFileURI(modelPath), true)); } boolean result = true; for (String modelPath : files) { boolean fileResult = runGenerator(modelPath, metadata, outputPath); if (!fileResult) { result = fileResult; } } return result; }
public ClassLoader getClassLoader(ResourceSet resourceSet) { if (resourceSet instanceof XtextResourceSet) { XtextResourceSet xtextResourceSet = (XtextResourceSet) resourceSet; Object ctx = xtextResourceSet.getClasspathURIContext(); if (ctx != null) { if (ctx instanceof Class<?>) { return ((Class<?>) ctx).getClassLoader(); } if (!(ctx instanceof ClassLoader)) { return ctx.getClass().getClassLoader(); } return (ClassLoader) ctx; } } return classLoader; }
protected XtendFile file(String string, boolean validate) throws Exception { XtextResourceSet set = resourceSetProvider.get(); String fileName = getFileName(string); Resource resource = set.createResource(URI.createURI(fileName + ".xtend")); resource.load(new StringInputStream(string), null); assertEquals(resource.getErrors().toString(), 0, resource.getErrors().size()); if (validate) { List<Issue> issues = ((XtextResource) resource) .getResourceServiceProvider() .getResourceValidator() .validate(resource, CheckMode.ALL, CancelIndicator.NullImpl); assertTrue("Resource contained errors : " + issues.toString(), issues.isEmpty()); } XtendFile file = (XtendFile) resource.getContents().get(0); return file; }
@Test public void testGenerateWithExpressionContext() throws Exception { EDataType dataType = EcorePackage.eINSTANCE.getEBigDecimal(); EPackage pkg = helper.createPackage("tests"); EClass clazz = helper.createClass(pkg, "NumericTests"); helper.addAttribute(clazz, dataType, "a"); EObject instance = helper.createInstance(clazz); XtextResourceSet resourceSet = expressionFactory.getInjector().getInstance(XtextResourceSet.class); Resource resource = resourceSet.createResource(URI.createURI("__synthetic.testData.expr")); resource.getContents().add(instance); // TODO could use TypeReferences getTypeForName() instead JvmTypesBuilder newTypeRef() .. Injector injector = expressionFactory.getInjector(); JvmTypesBuilder jvmTypesBuilder = injector.getInstance(JvmTypesBuilder.class); JvmTypeReferenceBuilder.Factory factory = injector.getInstance(JvmTypeReferenceBuilder.Factory.class); JvmTypeReferenceBuilder jvmTypeReferenceBuilder = factory.create(instance.eResource().getResourceSet()); JvmGenericType type = jvmTypesBuilder.toClass(instance, "tests.NumericTests"); resource.getContents().add(type); JvmField field = jvmTypesBuilder.toField( instance, "a", jvmTypeReferenceBuilder.typeRef( dataType.getInstanceClassName() /*"java.math.BigDecimal"*/)); field.setVisibility(JvmVisibility.PUBLIC); type.getMembers().add(field); ExpressionContext context = new ExpressionContext(resource); context.setType(jvmTypeReferenceBuilder.typeRef(Boolean.TYPE)); context.addVariable("t", jvmTypeReferenceBuilder.typeRef(type)); checkGeneration( "t.a == 5", Boolean.TYPE, context, "com.google.common.base.Objects.equal(t.a, new java.math.BigDecimal(\"5\"))"); }
protected XtextResource createActualResource() { XtextResource _xblockexpression = null; { PsiToEcoreTransformator _get = this.psiToEcoreTransformatorProvider.get(); final Procedure1<PsiToEcoreTransformator> _function = new Procedure1<PsiToEcoreTransformator>() { @Override public void apply(final PsiToEcoreTransformator it) { it.setXtextFile(((BaseXtextFile) AbstractLanguageParsingTestCase.this.myFile)); } }; final PsiToEcoreTransformator psiToEcoreTransformator = ObjectExtensions.<PsiToEcoreTransformator>operator_doubleArrow(_get, _function); VirtualFile _virtualFile = this.myFile.getVirtualFile(); String _url = _virtualFile.getUrl(); final URI uri = URI.createURI(_url); XtextResourceSet _createFreshResourceSet = this.createFreshResourceSet(); Resource _createResource = _createFreshResourceSet.createResource(uri); final Procedure1<XtextResource> _function_1 = new Procedure1<XtextResource>() { @Override public void apply(final XtextResource it) { try { it.setParser(psiToEcoreTransformator); byte[] _newByteArrayOfSize = new byte[0]; ByteArrayInputStream _byteArrayInputStream = new ByteArrayInputStream(_newByteArrayOfSize); it.load(_byteArrayInputStream, null); PsiToEcoreAdapter _adapter = psiToEcoreTransformator.getAdapter(); _adapter.attachToEmfObject(it); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } } }; _xblockexpression = ObjectExtensions.<XtextResource>operator_doubleArrow( ((XtextResource) _createResource), _function_1); } return _xblockexpression; }
@Override public void processFile(String data) throws Exception { byte[] hash = ((MessageDigest) messageDigest.clone()).digest(data.getBytes("UTF-8")); if (seen.add(new BigInteger(hash))) { XtextResourceSet resourceSet = resourceSetProvider.get(); resourceSet.setClasspathURIContext(classLoader); XtendFile file = parseHelper.parse(data, resourceSet); if (file != null) { try { XtextResource resource = (XtextResource) file.eResource(); ITextRegionAccess regions = regionBuilder.get().forNodeModel(resource).create(); FormatterRequest request = new FormatterRequest().setTextRegionAccess(regions); request.setExceptionHandler(ExceptionAcceptor.IGNORING); formatter.format(request); } catch (Exception e) { e.printStackTrace(); ComparisonFailure error = new ComparisonFailure(e.getMessage(), data, ""); error.setStackTrace(e.getStackTrace()); throw error; } } } }
@Override public void testTwoChapters() throws Exception { XtextResourceSet set = get(XtextResourceSet.class); Resource res = set.getResource(URI.createURI(ParserTest.TEST_FILE_DIR + "01-twoChapters.xdoc"), true); Chapter chapter0 = (Chapter) ((XdocFile) getModel((XtextResource) res)).getMainSection(); res = set.getResource(URI.createURI(ParserTest.TEST_FILE_DIR + "02-twoChapters.xdoc"), true); Chapter chapter1 = (Chapter) ((XdocFile) getModel((XtextResource) res)).getMainSection(); XdocFile file = (XdocFile) getModel( (XtextResource) set.getResource( URI.createURI(ParserTest.TEST_FILE_DIR + "twoChaptersDoc.xdoc"), true)); Document doc = (Document) file.getMainSection(); for (int i = 0; i < doc.getChapters().size(); i++) { Chapter chapter = doc.getChapters().get(i); generate(chapter); } generate(doc); validate("01-twoChapters.html", name(chapter0)); validate("02-twoChapters.html", name(chapter1)); validate("twoChaptersDoc.html", name(doc)); }
@Override protected IResource createElementResource(IProgressMonitor monitor, IPath path) { try { if (monitor == null) { monitor = new NullProgressMonitor(); } monitor.beginTask(Messages.NewMechanoidOpsFileWizard_Progress_Message, 1); URI newEmfResourceURI = URI.createURI( "platform:/resource" + //$NON-NLS-1$ path.toPortableString()); Resource emfResource = mResourceSet.createResource(newEmfResourceURI); Model model = OpServiceModelFactory.eINSTANCE.createModel(); model.setPackageName(mSelectedPackageName); emfResource.getContents().add(model); ServiceBlock service = (ServiceBlock) OpServiceModelFactory.eINSTANCE.createServiceBlock(); service.setName(mSelectedElementName); model.setService(service); emfResource.save(Collections.EMPTY_MAP); IResource resource = ResourcesPlugin.getWorkspace() .getRoot() .findMember(newEmfResourceURI.toPlatformString(true)); monitor.worked(1); return resource; } catch (Exception e) { e.printStackTrace(); } return null; }
public boolean runGenerator(String inputPath, Metadata metadata, String outputPath) { // load the resource resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); Resource resource = resourceSet.getResource(URI.createFileURI(inputPath), true); if (metadata != null) { Map<String, Object> entitiesMap = new HashMap<String, Object>(); for (State key : Iterables.<State>filter( IteratorExtensions.<EObject>toIterable(resource.getAllContents()), State.class)) { String entity = key.getEntity().getName(); if (StringUtils.isNotEmpty(entity)) { try { EntityMetadata em = metadata.getEntityMetadata(entity); if (null != em) { Map<String, Object> entityPropMap = new HashMap<String, Object>(); for (String propertySimple : em.getTopLevelProperties()) { if (!em.isPropertyList(propertySimple)) { ArrayList<String> obj = new ArrayList<String>(); String propertyName = em.getSimplePropertyName(propertySimple); if (em.isPropertyNumber(propertySimple)) { obj.add(0, "double"); } else if (em.isPropertyDate(propertySimple)) { obj.add(0, "date"); } else if (em.isPropertyTime(propertySimple)) { obj.add(0, "dateTime"); } else if (em.isPropertyBoolean(propertySimple)) { obj.add(0, "boolean"); } else { obj.add(0, "string"); } String description = em.getTermValue(propertySimple, "TERM_DESCRIPTION"); description = (null != description) ? description : ""; obj.add(1, description); entityPropMap.put(propertyName, obj); } else { String propertyName = em.getSimplePropertyName(propertySimple); entityPropMap.put(propertyName, complexTypeHandler(propertySimple, em)); } } entitiesMap.put(entity, entityPropMap); } } catch (Exception e) { System.out.println("Entity Not found: " + entity); } } } resource.getResourceSet().getLoadOptions().put("Metadata", entitiesMap); } // validate the resource List<Issue> list = validator.validate(resource, CheckMode.ALL, CancelIndicator.NullImpl); if (!list.isEmpty()) { for (Issue issue : list) { listener.notify(issue.toString()); } return false; } // configure and start the generator fileAccess.setOutputPath(outputPath); generator.doGenerate(resource, fileAccess); return true; }
@Override public ClassLoader getClassLoader(final EObject ctx) { Resource _eResource = ctx.eResource(); ResourceSet _resourceSet = _eResource.getResourceSet(); final XtextResourceSet rs = ((XtextResourceSet) _resourceSet); ResourceSetContext _get = ResourceSetContext.get(rs); final boolean isBuilder = _get.isBuilder(); ResourceSetContext _get_1 = ResourceSetContext.get(rs); final boolean isEditor = _get_1.isEditor(); if (isBuilder) { EList<Adapter> _eAdapters = rs.eAdapters(); Iterable<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter> _filter = Iterables.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>filter( _eAdapters, ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter.class); final ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter adapter = IterableExtensions.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>head( _filter); boolean _notEquals = (!Objects.equal(adapter, null)); if (_notEquals) { return adapter.getClassLoader(); } } if (isEditor) { Resource _editorResource = this.getEditorResource(ctx); EList<Adapter> _eAdapters_1 = _editorResource.eAdapters(); Iterable<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter> _filter_1 = Iterables.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>filter( _eAdapters_1, ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter.class); final ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter adapter_1 = IterableExtensions.<ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter>head( _filter_1); boolean _notEquals_1 = (!Objects.equal(adapter_1, null)); if (_notEquals_1) { ClassLoader _classLoader = adapter_1.getClassLoader(); boolean _equals = Objects.equal(_classLoader, null); if (_equals) { Resource _editorResource_1 = this.getEditorResource(ctx); EList<Adapter> _eAdapters_2 = _editorResource_1.eAdapters(); _eAdapters_2.remove(adapter_1); } else { return adapter_1.getClassLoader(); } } } Object _classpathURIContext = rs.getClasspathURIContext(); final IJavaProject project = ((IJavaProject) _classpathURIContext); final URLClassLoader classloader = this.createClassLoaderForJavaProject(project); if (isBuilder) { EList<Adapter> _eAdapters_3 = rs.eAdapters(); ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter _processorClassloaderAdapter = new ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter(classloader); _eAdapters_3.add(_processorClassloaderAdapter); } if (isEditor) { Resource _editorResource_2 = this.getEditorResource(ctx); EList<Adapter> _eAdapters_4 = _editorResource_2.eAdapters(); ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter _processorClassloaderAdapter_1 = new ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter(classloader); _eAdapters_4.add(_processorClassloaderAdapter_1); } return classloader; }