org.jnario.feature.GenerateFeature.mwe2 Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.jnario.standalone Show documentation
The required libraries to execute Jnario specifications without Eclipse.
The newest version!
module org.jnario.feature.GenerateFeature

import org.eclipse.emf.mwe.utils.*
import org.eclipse.xtext.generator.*
import org.eclipse.xtext.ui.generator.*

var grammarURI = "classpath:/org/jnario/feature/Feature.xtext"
var file.extensions = "feature"
var projectName = "org.jnario.feature"
var runtimeProject = "../${projectName}"
var backtrack = false
var memoize = false

Workflow {
    bean = StandaloneSetup {
		ignoreBrokenProjectFiles = true
        scanClassPath = true
        platformUri = "${runtimeProject}/.."
		registerGenModelFile = "platform:/resource/org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel"
		registerGenModelFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel"
		registerGenModelFile = "platform:/resource/org.eclipse.xtend.core/model/Xtend.genmodel"
		registerGenModelFile = "platform:/resource/org.jnario/model/Jnario.genmodel"
    }
    
    bean = StandaloneSetup {
		resourceSet = org.eclipse.xtext.resource.XtextResourceSet : resourceSet {}
        scanClassPath = true
        
		registerEcoreFile = "platform:/resource/org.eclipse.xtext.common.types/model/JavaVMTypes.ecore"
		registerEcoreFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xtype.ecore"
		registerEcoreFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.ecore"
		registerEcoreFile = "platform:/resource/org.eclipse.xtext.xbase/model/XAnnotations.ecore"
		registerEcoreFile = "platform:/resource/org.eclipse.xtend.core/model/Xtend.ecore"        
		registerEcoreFile = "platform:/resource/org.jnario/model/Jnario.ecore"        
		registerEcoreFile = "platform:/resource/${projectName}/model/Feature.ecore"
    }
    
    component = DirectoryCleaner {
		directory = "${runtimeProject}/emf-gen"
	}

	component = org.jnario.PatchedEcoreGenerator {
		genModel = "platform:/resource/${projectName}/model/Feature.genmodel"
		srcPath ="platform:/resource/${projectName}/src"
		srcPath ="platform:/resource/org.eclipse.xtext.common.types/src"
		srcPath ="platform:/resource/org.eclipse.xtext.xbase/src"
		srcPath ="platform:/resource/org.eclipse.xtend.core/src"
		srcPath ="platform:/resource/org.jnario/src"
	}

    component = DirectoryCleaner {
        directory = "${runtimeProject}/src-gen"
    }

    component = DirectoryCleaner {
        directory = "${runtimeProject}.ui/src-gen"
    }

//	component = org.eclipse.xtend.core.parser.JFlexLoader : jFlexMain {}

    component = Generator {
        pathRtProject = runtimeProject
        pathUiProject = "${runtimeProject}.ui"
        pathTestProject = "../../tests/org.jnario.tests"
        projectNameRt = projectName
        projectNameUi = "${projectName}.ui"
        language = {
        	forcedResourceSet=resourceSet
            uri = grammarURI
            fileExtensions = file.extensions

            // Java API to access grammar elements (required by several other fragments)
            fragment = grammarAccess.GrammarAccessFragment {
            }

            // generates Java API for the generated EPackages
            //fragment = ecore.EcoreGeneratorFragment {
            
            // referencedGenModels = "
            //  platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel,
            //  platform:/resource/org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel
            // "
            //}

            // Serializer 2.0
            fragment = serializer.SerializerFragment {
            	generateStub = false
            }
            
            // a custom ResourceFactory for use with EMF
            fragment = resourceFactory.ResourceFactoryFragment {
                fileExtensions = file.extensions
            }

		// The antlr parser generator fragment.
			fragment = parser.antlr.XtextAntlrGeneratorFragment {
				options = auto-inject {}
				antlrParam = "-Xconversiontimeout"
				antlrParam = "10000"
				options = {
					classSplitting = true
				}
			}
            // java-based API for validation
            fragment = validation.JavaValidatorFragment {
            //    composedCheck = "org.eclipse.xtext.validation.ImportUriValidator"
            //    composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
            }

            // scoping and exporting API
            // fragment = scoping.ImportURIScopingFragment {}
            // fragment = exporting.SimpleNamesFragment {}

            // scoping and exporting API
            fragment = scoping.ImportNamespacesScopingFragment {}	
            fragment = exporting.QualifiedNamesFragment {}
            fragment = builder.BuilderIntegrationFragment {}

            // generator API
            fragment = generator.GeneratorFragment {
                generateMwe = false
                generateJavaMain = false
            }

            // formatter API
            fragment = formatting.FormatterFragment {}

            // labeling API
            fragment = labeling.LabelProviderFragment {}

            // outline API
            fragment = outline.OutlineTreeProviderFragment {}
            fragment = outline.QuickOutlineFragment {}

            // quickfix API
            fragment = quickfix.QuickfixProviderFragment {}

            // content assist API
            fragment = contentAssist.JavaBasedContentAssistFragment {}

              // generates a more lightweight Antlr parser and lexer tailored for content assist
            fragment = parser.antlr.XtextAntlrUiGeneratorFragment {
            	options = auto-inject {}
            	antlrParam = "-Xconversiontimeout" antlrParam = "10000"
            	options = {
			  		classSplitting = true
     			}
            }

            // generates junit test support classes into Generator#pathTestProject
            fragment = junit.Junit4Fragment {}

            // project wizard (optional)
            // fragment = projectWizard.SimpleProjectWizardFragment {
            //      generatorProjectName = "${projectName}"
            //      modelFileExtension = file.extensions
            // }

            // provides the necessary bindings for java types integration
            fragment = types.TypesGeneratorFragment {}

            // generates the required bindings only if the grammar inherits from Xbase
            fragment = xbase.XbaseGeneratorFragment {
            	generateXtendInferrer=false
            }

            // provides a preference page for template proposals
            fragment = templates.CodetemplatesGeneratorFragment {}

            // rename refactoring
            fragment = refactoring.RefactorElementNameFragment {
            	useJdtRefactoring = true
            }

            // provides a compare view
            fragment = compare.CompareFragment {
                 fileExtensions = file.extensions
            }
//            			fragment = org.eclipse.xtend.core.parser.JFlexGeneratorFragment auto-inject {
//				patternPath = "/org/jnario/feature/parser/antlr/internal/patterns.incl"
//				additionalRulePath = "/org/jnario/feature/parser/antlr/internal/rules.incl"
//			}
//			fragment = org.eclipse.xtend.core.parser.JFlexGeneratorFragment auto-inject {
//				ui = true
//				patternPath = "/org/jnario/feature/parser/antlr/internal/patterns.incl"
//				additionalRulePath = "/org/jnario/feature/parser/antlr/internal/rules.incl"
//			}

        }
    }
}