Regdna.xtext

/*******************************************************************************
 * Copyright (c) 2020 Bird Software Solutions Ltd
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDE-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    Neil Mackenzie - initial API and implementation
 *******************************************************************************/

grammar org.eclipse.efbt.regdna.dsl.Regdna with org.eclipse.xtext.common.Terminals

import "http://www.eclipse.org/emf/2002/Ecore" as ecore
import "http://www.eclipse.org/efbt/regdna" as regdna


Module returns regdna::Module:
	 GenerationRulesModule | ELPackage | ReportModule;
	 
	
ELClassifier returns regdna::ELClassifier:
	ELClass | ELDataType_Impl | ELEnum ;


ELStructuralFeature returns regdna::ELStructuralFeature:
	ELAttribute | ELReference;


SelectColumn returns regdna::SelectColumn:
	 SelectColumnMemberAs | SelectColumnAttributeAs | SelectDerivedColumnAs | SelectValueAs;
	 
Report returns 	regdna::Report:
	CellBasedReport | RowColumnBasedReport ;



EString returns ecore::EString:
	STRING ;


ELAnnotation returns regdna::ELAnnotation:
	{regdna::ELAnnotation}
	'@' source=[regdna::ELAnnotationDirective|QualifiedName]
	('(' details+=ELStringToStringMapEntry (',' details+=ELStringToStringMapEntry)* ')')?
;

ELStringToStringMapEntry returns regdna::ELStringToStringMapEntry:
	{regdna::ELStringToStringMapEntry}
	key=QualifiedName
	'='
	value=STRING
;

ELAnnotationDirective returns regdna::ELAnnotationDirective:
	{regdna::ELAnnotationDirective}
	=>('annotation' sourceURI=STRING) 'as' name=ID
;

GenerationRulesModule returns regdna::GenerationRulesModule:
	{regdna::GenerationRulesModule}
	'generationRuleModule'
	name=QualifiedName
	(imports += Import)*
	'{'
		('dependencies' dependencies+=[regdna::Module|QualifiedName])*
		('generationRules' '{' rulesForReport+=RulesForReport ( "," rulesForReport+=RulesForReport)* '}' )?
	'}';



ELAttribute returns regdna::ELAttribute:
	{regdna::ELAttribute}
	(eAnnotations+=ELAnnotation)*
	(iD?='id')?
	eAttributeType=[regdna::ELDataType|QualifiedName] ("[" ((  lowerBound=EInt) ".." ( upperBound=EInt))?   "]")?
	name=ID 
	;


ELClass returns regdna::ELClass:
	{regdna::ELClass}
	(eAnnotations+=ELAnnotation)*
	((eAbstract?='abstract'? 'class') ) name = ID
	('extends' eSuperTypes+=[regdna::ELClass|QualifiedName] (',' eSuperTypes+=[regdna::ELClass|QualifiedName])*)?
	'{'
	   (eStructuralFeatures+=ELStructuralFeature)*
	   (eOperations+=ELOperation)*
	'}'
	;

ELDataType_Impl returns regdna::ELDataType:
	{regdna::ELDataType}
	'type' name = ID
	'wraps' industryName = ID
	
	;

ELEnum returns regdna::ELEnum:
	{regdna::ELEnum}
	(eAnnotations+=ELAnnotation)*
	'enum' name = ID
	'{'
	  (eLiterals+=ELEnumLiteral ((',')? eLiterals+=ELEnumLiteral)*)?
	'}';

	
ELOperation returns regdna::ELOperation:
	{regdna::ELOperation}
	(eAnnotations+=ELAnnotation)*
	'op'
	eType=[regdna::ELClassifier|QualifiedName] ("["((  lowerBound=EInt) ".." ( upperBound=EInt))?  "]")?
	name=ID
	'()'
	'{'(body=EString)?'}'
	;
	

ELReference returns regdna::ELReference:
	{regdna::ELReference}
	(eAnnotations+=ELAnnotation)*
	((containment?='contains' ) |
	 ('refers') 
	)
	eType=[regdna::ELClassifier|QualifiedName] ("["((  lowerBound=EInt) ".." ( upperBound=EInt))?  "]")? 
	name=ID
	('opposite' eOpposite=[regdna::ELReference|QualifiedName])?
	;


ELEnumLiteral returns regdna::ELEnumLiteral:
	{regdna::ELEnumLiteral}
	(eAnnotations+=ELAnnotation)*
	name=ID
    ('as' literal=STRING)?
    ('=' value=EInt)?
    ;

EInt returns ecore::EInt:
	'-'? INT;


QualifiedName:
	ID ('.' ID)*;
	
Import returns regdna::Import:
	{regdna::Import}
        'import' importedNamespace=QualifiedNameWithWildcard;


QualifiedNameWithWildcard :
	QualifiedName '.*'?;
	




ELPackage returns regdna::ELPackage:
	{regdna::ELPackage}
	'package'
	name = QualifiedName
	(imports += Import)*
	(annotationDirectives += ELAnnotationDirective)*
	(eClassifiers += ELClassifier)*
	;

RulesForReport returns regdna::RulesForReport:
	{regdna::RulesForReport}
	'outputLayerEntity' outputLayerCube=[regdna::ELClass|QualifiedName]
	'{'
		(rulesForTable+=RulesForILTable (rulesForTable+=RulesForILTable)*  )?
	'}';
	
RulesForILTable returns regdna::RulesForILTable:
	{regdna::RulesForILTable}
	'mainEntity' inputLayerTable=[regdna::ELClass|QualifiedName]
	'{'
		(rulesForTablePart+=RuleForILTablePart (rulesForTablePart+=RuleForILTablePart)*  )?
	'}';
	
RuleForILTablePart returns regdna::RuleForILTablePart:
	{regdna::RuleForILTablePart}
	'inputSlice'
	name=ID
	'{'
		( columns+=SelectColumn ( columns+=SelectColumn)*  )?
		('where' whereClause=TableFilter)?
	'}';



	
	
TableFilter returns regdna::TableFilter:
	{regdna::TableFilter}
		 (predicate=Predicate )?
	;

Predicate returns regdna::Predicate:
	AndPredicate | OrPredicate | NotPredicate | AttributePredicate;
	
AndPredicate returns regdna::AndPredicate:
	{regdna::AndPredicate}
	'And('
		(operands+=Predicate ( "and" operands+=Predicate)*  )?
	')'
;

OrPredicate returns regdna::OrPredicate:
	{regdna::OrPredicate}
	'Or('
		(operands+=Predicate ( "or" operands+=Predicate)*  )?
	')'
;

NotPredicate returns regdna::NotPredicate:
	{regdna::NotPredicate}
	'Not('
		( operand=Predicate)?
	')';

AttributePredicate returns regdna::AttributePredicate:
	{regdna::AttributePredicate}
	'filter'

		( attribute1=[regdna::ELStructuralFeature|QualifiedName])?
		( comparitor=Comparitor)?
		('theMember' member=[regdna::ELEnumLiteral|QualifiedName])?
		('theValue' value=EString)?
	;
	
SelectColumnMemberAs returns regdna::SelectColumnMemberAs:
	{regdna::SelectColumnMemberAs}
	'selectMember'
		( memberAsConstant=[regdna::ELEnumLiteral|QualifiedName])?
		('as' asAttribute=[regdna::ELOperation|QualifiedName])?
		;
	
SelectColumnAttributeAs returns regdna::SelectColumnAttributeAs:
	{regdna::SelectColumnAttributeAs}
	'selectAttribute'
		( attribute=[regdna::ELAttribute|QualifiedName])?
		('as' asAttribute=[regdna::ELOperation|QualifiedName])?
	;
	
SelectDerivedColumnAs returns regdna::SelectDerivedColumnAs:
	{regdna::SelectDerivedColumnAs}
	'selectDerivedAttribute'
		( attribute=[regdna::ELOperation|QualifiedName])?
		('as' asAttribute=[regdna::ELOperation|QualifiedName])?
	;
	
SelectValueAs returns regdna::SelectValueAs:
	{regdna::SelectValueAs}
	'selectValue'
		( value=EString)?
		('as' asAttribute=[regdna::ELOperation|QualifiedName])?
	;
	
ReportModule returns regdna::ReportModule:
	{regdna::ReportModule}
	'ReportModule'
	name=QualifiedName
	'{'
		('theDescription' theDescription=EString)?
		('license' license=EString)?
		('version' version=EString)?
		('dependencies' '(' dependencies+=[regdna::Module|QualifiedName] ( "," dependencies+=[regdna::Module|QualifiedName])* ')' )?
		('imports' '{' imports+=Import ( "," imports+=Import)* '}' )?
		('reports' '{' reports+=Report ( "," reports+=Report)* '}' )?
	'}';
	
CellBasedReport returns regdna::CellBasedReport:
	{regdna::CellBasedReport}
	'CellBasedReport'
	'{'
		('outputLayer' outputLayer=[regdna::ELClass|QualifiedName])?
		('rows' '{' rows+=ReportRow (  rows+=ReportRow)* '}' )?
		('columns' '{' columns+=ReportColumn (  columns+=ReportColumn)* '}' )?
		('reportCells' '{' reportCells+=ReportCell (  reportCells+=ReportCell)* '}' )?
	'}';
	
RowColumnBasedReport returns regdna::RowColumnBasedReport:
	{regdna::RowColumnBasedReport}
	'RowColumnBasedReport'
	'{'
		('outputLayer' outputLayer=[regdna::ELClass|QualifiedName])?
		('rows' '{' rows+=ReportRow (  rows+=ReportRow)* '}' )?
		('columns' '{' columns+=ReportColumn (  columns+=ReportColumn)* '}' )?
		('wholeReportFilters' '{' wholeReportFilters=WholeReportFilters '}' )?
		('rowFilters' '{' rowFilters+=RowFilters (  rowFilters+=RowFilters)* '}' )?
		('columnFilters' '{' columnFilters+=ColumnFilters (  columnFilters+=ColumnFilters )* '}' )?
		
	'}';
	
RowFilters returns regdna::RowFilters:
	{regdna::RowFilters}
	'RowFilters'
	'{'
		('row' row=[regdna::ReportRow|QualifiedName])?
		('metric' metric=[regdna::ELOperation|QualifiedName])?
		('filters' '{' filters+=Filter (  filters+=Filter)* '}' )?
	'}';

ColumnFilters returns regdna::ColumnFilters:
	{regdna::ColumnFilters}
	'ColumnFilters'
	'{'
		('column' column=[regdna::ReportColumn|QualifiedName])?
		('metric' metric=[regdna::ELOperation|QualifiedName])?
		('filters' '{' filters+=Filter (  filters+=Filter)* '}' )?
	'}';
	
WholeReportFilters returns regdna::WholeReportFilters:
	{regdna::WholeReportFilters}
	'WholeReportFilters'
	'{'
		('filters' '{' filters+=Filter (  filters+=Filter)* '}' )?
	'}';


ReportRow returns regdna::ReportRow:
	{regdna::ReportRow}
	'ReportRow'
	name=ID;

ReportColumn returns regdna::ReportColumn:
	{regdna::ReportColumn}
	'ReportColumn'
	name=ID;

ReportCell returns regdna::ReportCell:
	{regdna::ReportCell}
	'ReportCell'
	'{'
		('datapointID' datapointID=EString)?
		('row' row=[regdna::ReportRow|QualifiedName])?
		('column' column=[regdna::ReportColumn|QualifiedName])?
		('metric' metric=[regdna::ELOperation|QualifiedName])?
		('filters' '{' filters+=Filter (  filters+=Filter)* '}' )?
	'}';

Filter returns regdna::Filter:
	{regdna::Filter}
	'Filter'
	'{'
		('outputLayer' outputLayer=[regdna::ELClass|QualifiedName])?
		('operation' operation=[regdna::ELOperation|QualifiedName])?
		('item' '('(  member+=[regdna::ELEnumLiteral|QualifiedName])* ')' )?
	'}';

enum Comparitor returns regdna::Comparitor:
				less_than = 'is_less_than' | equals = 'is_equals' | not_equals = 'is_not_equals' | greater_than = 'is_greater_than';