expressir 2.1.0 → 2.1.1

data/lib/expressir/express/hyperlink_formatter.rb

@@ -9,7 +9,7 @@ module Expressir
       # @!visibility private
       def self.included(mod)
         if !mod.superclass.private_method_defined? :format_references_simple_reference
-          raise 'Missing method'
+          raise "Missing method"
         end
       end
 
@@ -33,4 +33,4 @@ module Expressir
       end
     end
   end
-end
+end

data/lib/expressir/express/model_visitor.rb

@@ -21,4 +21,4 @@ module Expressir
       end
     end
   end
-end
+end

data/lib/expressir/express/parser.rb

@@ -30,13 +30,13 @@ module Expressir
           SUBTYPE_CONSTRAINT SUPERTYPE TAN THEN TO TRUE TYPE TYPEOF TOTAL_OVER UNIQUE
           UNKNOWN UNTIL USE USEDIN VALUE VALUE_IN VALUE_UNIQUE VAR WITH WHERE WHILE
           XOR
-        ]
+        ].freeze
 
         def keyword_rule(str)
           key_chars = str.to_s.split(//)
-          key_chars.
-            collect! { |char| match("[#{char}#{char.downcase}]") }.
-            reduce(:>>) >> match["a-zA-Z0-9_"].absent?
+          key_chars
+            .collect! { |char| match("[#{char}#{char.downcase}]") }
+            .reduce(:>>) >> match["a-zA-Z0-9_"].absent?
         end
 
         KEYWORDS.each do |keyword|
@@ -44,80 +44,121 @@ module Expressir
           rule(sym) { cts(keyword_rule(keyword).as(:str)).as(sym) }
         end
 
-        rule(:abstractEntityDeclaration) { (tABSTRACT).as(:abstractEntityDeclaration) }
-        rule(:abstractSupertypeDeclaration) { (tABSTRACT >> tSUPERTYPE >> subtypeConstraint.maybe).as(:abstractSupertypeDeclaration) }
+        rule(:abstractEntityDeclaration) { tABSTRACT.as(:abstractEntityDeclaration) }
+        rule(:abstractSupertypeDeclaration) do
+          (tABSTRACT >> tSUPERTYPE >> subtypeConstraint.maybe).as(:abstractSupertypeDeclaration)
+        end
         rule(:abstractSupertype) { (tABSTRACT >> tSUPERTYPE >> op_delim).as(:abstractSupertype) }
-        rule(:actualParameterList) { (op_leftparen >> (parameter >> (op_comma >> parameter).repeat).as(:listOf_parameter) >> op_rightparen).as(:actualParameterList) }
+        rule(:actualParameterList) do
+          (op_leftparen >> (parameter >> (op_comma >> parameter).repeat).as(:listOf_parameter) >> op_rightparen)
+            .as(:actualParameterList)
+        end
         rule(:addLikeOp) { (op_plus | op_minus | tOR | tXOR).as(:addLikeOp) }
-        rule(:aggregateInitializer) { (op_leftbracket >> ((element >> (op_comma >> element).repeat).as(:listOf_element)).maybe >> op_rightbracket).as(:aggregateInitializer) }
-        rule(:aggregateSource) { (simpleExpression).as(:aggregateSource) }
-        rule(:aggregateType) { (tAGGREGATE >> (op_colon >> typeLabel).maybe >> tOF >> parameterType).as(:aggregateType) }
+        rule(:aggregateInitializer) do
+          (op_leftbracket >> (element >> (op_comma >> element).repeat).as(:listOf_element).maybe >> op_rightbracket)
+            .as(:aggregateInitializer)
+        end
+        rule(:aggregateSource) { simpleExpression.as(:aggregateSource) }
+        rule(:aggregateType) do
+          (tAGGREGATE >> (op_colon >> typeLabel).maybe >> tOF >> parameterType).as(:aggregateType)
+        end
         rule(:aggregationTypes) { (arrayType | bagType | listType | setType).as(:aggregationTypes) }
-        rule(:algorithmHead) { (declaration.repeat.as(:declaration) >> constantDecl.maybe >> localDecl.maybe).as(:algorithmHead) }
-        rule(:aliasStmt) { (tALIAS >> variableId >> tFOR >> generalRef >> qualifier.repeat.as(:qualifier) >> op_delim >> stmt.repeat(1).as(:stmt) >> tEND_ALIAS >> (op_delim.as(:op_delim2))).as(:aliasStmt) }
+        rule(:algorithmHead) do
+          (declaration.repeat.as(:declaration) >> constantDecl.maybe >> localDecl.maybe).as(:algorithmHead)
+        end
+        rule(:aliasStmt) do
+          (tALIAS >> variableId >> tFOR >> generalRef >> qualifier.repeat.as(:qualifier) >>
+            op_delim >> stmt.repeat(1).as(:stmt) >> tEND_ALIAS >> (op_delim.as(:op_delim2))).as(:aliasStmt)
+        end
         rule(:anyKeyword) { KEYWORDS.map { |kw| send("t#{kw}") }.inject(:|) }
-        rule(:arrayType) { (tARRAY >> boundSpec >> tOF >> tOPTIONAL.maybe >> tUNIQUE.maybe >> instantiableType).as(:arrayType) }
+        rule(:arrayType) do
+          (tARRAY >> boundSpec >> tOF >> tOPTIONAL.maybe >> tUNIQUE.maybe >> instantiableType).as(:arrayType)
+        end
         rule(:assignmentStmt) { (generalRef >> qualifier.repeat.as(:qualifier) >> op_decl >> expression >> op_delim).as(:assignmentStmt) }
         rule(:attributeDecl) { (attributeId | redeclaredAttribute).as(:attributeDecl) }
-        rule(:attributeId) { (simpleId).as(:attributeId) }
+        rule(:attributeId) { simpleId.as(:attributeId) }
         rule(:attributeQualifier) { (op_period >> attributeRef).as(:attributeQualifier) }
-        rule(:attributeRef) { (attributeId).as(:attributeRef) }
+        rule(:attributeRef) { attributeId.as(:attributeRef) }
         rule(:bagType) { (tBAG >> boundSpec.maybe >> tOF >> instantiableType).as(:bagType) }
         rule(:binaryLiteral) { cts((str("%") >> bit.repeat(1)).as(:str)).as(:binaryLiteral) }
         rule(:binaryType) { (tBINARY >> widthSpec.maybe).as(:binaryType) }
-        rule(:bit) { (match["0-1"]) }
-        rule(:booleanType) { (tBOOLEAN).as(:booleanType) }
-        rule(:bound1) { (numericExpression).as(:bound1) }
-        rule(:bound2) { (numericExpression).as(:bound2) }
+        rule(:bit) { match["0-1"] }
+        rule(:booleanType) { tBOOLEAN.as(:booleanType) }
+        rule(:bound1) { numericExpression.as(:bound1) }
+        rule(:bound2) { numericExpression.as(:bound2) }
         rule(:boundSpec) { (op_leftbracket >> bound1 >> op_colon >> bound2 >> op_rightbracket).as(:boundSpec) }
         rule(:builtInConstant) { (tCONST_E | tPI | tSELF | op_question_mark).as(:builtInConstant) }
-        rule(:builtInFunction) { (tABS | tACOS | tASIN | tATAN | tBLENGTH | tCOS | tEXISTS | tEXP | tFORMAT | tHIBOUND | tHIINDEX | tLENGTH | tLOBOUND | tLOINDEX | tLOG2 | tLOG10 | tLOG | tNVL | tODD | tROLESOF | tSIN | tSIZEOF | tSQRT | tTAN | tTYPEOF | tUSEDIN | tVALUE_IN | tVALUE_UNIQUE | tVALUE).as(:builtInFunction) }
+        rule(:builtInFunction) do
+          (
+            tABS | tACOS | tASIN | tATAN | tBLENGTH | tCOS | tEXISTS | tEXP | tFORMAT | tHIBOUND | tHIINDEX | tLENGTH |
+            tLOBOUND | tLOINDEX | tLOG2 | tLOG10 | tLOG | tNVL | tODD | tROLESOF | tSIN | tSIZEOF | tSQRT | tTAN |
+            tTYPEOF | tUSEDIN | tVALUE_IN | tVALUE_UNIQUE | tVALUE
+          ).as(:builtInFunction)
+        end
         rule(:builtInProcedure) { (tINSERT | tREMOVE).as(:builtInProcedure) }
         rule(:caseAction) { ((caseLabel >> (op_comma >> caseLabel).repeat).as(:listOf_caseLabel) >> op_colon >> stmt).as(:caseAction) }
-        rule(:caseLabel) { (expression).as(:caseLabel) }
-        rule(:caseStmt) { (tCASE >> selector >> tOF >> caseAction.repeat.as(:caseAction) >> (tOTHERWISE >> op_colon >> stmt).maybe >> tEND_CASE >> op_delim).as(:caseStmt) }
+        rule(:caseLabel) { expression.as(:caseLabel) }
+        rule(:caseStmt) do
+          (tCASE >> selector >> tOF >> caseAction.repeat.as(:caseAction) >> (tOTHERWISE >> op_colon >> stmt).maybe >> tEND_CASE >> op_delim).as(:caseStmt)
+        end
         rule(:compoundStmt) { (tBEGIN >> stmt.repeat(1).as(:stmt) >> tEND >> op_delim).as(:compoundStmt) }
         rule(:concreteTypes) { (aggregationTypes | simpleTypes | typeRef).as(:concreteTypes) }
         rule(:constantBody) { (constantId >> op_colon >> instantiableType >> op_decl >> expression >> op_delim).as(:constantBody) }
         rule(:constantDecl) { (tCONSTANT >> constantBody.repeat(1).as(:constantBody) >> tEND_CONSTANT >> op_delim).as(:constantDecl) }
         rule(:constantFactor) { (builtInConstant | constantRef).as(:constantFactor) }
-        rule(:constantId) { (simpleId).as(:constantId) }
-        rule(:constantRef) { (constantId).as(:constantRef) }
+        rule(:constantId) { simpleId.as(:constantId) }
+        rule(:constantRef) { constantId.as(:constantRef) }
         rule(:constructedTypes) { (enumerationType | selectType).as(:constructedTypes) }
         rule(:declaration) { (entityDecl | functionDecl | procedureDecl | subtypeConstraintDecl | typeDecl).as(:declaration) }
         rule(:delim) { cts(str(";").as(:delim)) }
         rule(:deriveClause) { (tDERIVE >> derivedAttr.repeat(1).as(:derivedAttr)).as(:deriveClause) }
         rule(:derivedAttr) { (attributeDecl >> op_colon >> parameterType >> op_decl >> expression >> op_delim).as(:derivedAttr) }
-        rule(:digit) { (match["0-9"]) }
+        rule(:digit) { match["0-9"] }
         rule(:digits) { (digit >> digit.repeat) }
         rule(:domainRule) { ((ruleLabelId >> op_colon).maybe >> expression).as(:domainRule) }
         rule(:element) { (expression >> (op_colon >> repetition).maybe).as(:element) }
         rule(:embeddedRemark) { (str("(*") >> (str("*)").absent? >> (embeddedRemark | any)).repeat >> str("*)")).as(:embeddedRemark) }
         rule(:encodedCharacter) { (octet >> octet >> octet >> octet) }
         rule(:encodedStringLiteral) { cts((str('"') >> (encodedCharacter.repeat(1)) >> str('"')).as(:str)).as(:encodedStringLiteral) }
-        rule(:entityBody) { (explicitAttr.repeat.as(:explicitAttr) >> deriveClause.maybe >> inverseClause.maybe >> uniqueClause.maybe >> whereClause.maybe).as(:entityBody) }
-        rule(:entityConstructor) { (entityRef >> op_leftparen >> (expression >> (op_comma >> expression).repeat).as(:listOf_expression).maybe >> op_rightparen).as(:entityConstructor) }
+        rule(:entityBody) do
+          (explicitAttr.repeat.as(:explicitAttr) >> deriveClause.maybe >> inverseClause.maybe >> uniqueClause.maybe >> whereClause.maybe).as(:entityBody)
+        end
+        rule(:entityConstructor) do
+          (entityRef >> op_leftparen >> (expression >> (op_comma >> expression).repeat).as(:listOf_expression).maybe >> op_rightparen).as(:entityConstructor)
+        end
         rule(:entityDecl) { (entityHead >> entityBody >> tEND_ENTITY >> op_delim).as(:entityDecl) }
         rule(:entityHead) { (tENTITY >> entityId >> subsuper >> op_delim).as(:entityHead) }
-        rule(:entityId) { (simpleId).as(:entityId) }
-        rule(:entityRef) { (entityId).as(:entityRef) }
+        rule(:entityId) { simpleId.as(:entityId) }
+        rule(:entityRef) { entityId.as(:entityRef) }
         rule(:enumerationExtension) { (tBASED_ON >> typeRef >> (tWITH >> enumerationItems).maybe).as(:enumerationExtension) }
-        rule(:enumerationId) { (simpleId).as(:enumerationId) }
-        rule(:enumerationItem) { (enumerationId).as(:enumerationItem) }
-        rule(:enumerationItems) { (op_leftparen >> (enumerationItem >> (op_comma >> enumerationItem).repeat).as(:listOf_enumerationItem) >> op_rightparen).as(:enumerationItems) }
-        rule(:enumerationRef) { (enumerationId).as(:enumerationRef) }
+        rule(:enumerationId) { simpleId.as(:enumerationId) }
+        rule(:enumerationItem) { enumerationId.as(:enumerationItem) }
+        rule(:enumerationItems) do
+          (op_leftparen >> (enumerationItem >> (op_comma >> enumerationItem).repeat).as(:listOf_enumerationItem) >> op_rightparen).as(:enumerationItems)
+        end
+        rule(:enumerationRef) { enumerationId.as(:enumerationRef) }
         rule(:enumerationReference) { ((typeRef >> op_period).maybe >> enumerationRef).as(:enumerationReference) }
         rule(:enumerationType) { (tEXTENSIBLE.maybe >> tENUMERATION >> (tOF >> enumerationItems | enumerationExtension).maybe).as(:enumerationType) }
         rule(:escapeStmt) { (tESCAPE >> op_delim).as(:escapeStmt) }
-        rule(:explicitAttr) { ((attributeDecl >> (op_comma >> attributeDecl).repeat).as(:listOf_attributeDecl) >> op_colon >> tOPTIONAL.maybe >> parameterType >> op_delim).as(:explicitAttr) }
+        rule(:explicitAttr) do
+          (
+            (attributeDecl >> (op_comma >> attributeDecl).repeat).as(:listOf_attributeDecl) >> op_colon >>
+              tOPTIONAL.maybe >> parameterType >> op_delim
+          ).as(:explicitAttr)
+        end
         rule(:expression) { (simpleExpression >> (relOpExtended >> simpleExpression.as(:rhs)).maybe).as(:expression) }
         rule(:factor) { (simpleFactor >> (op_double_asterisk >> simpleFactor.as(:rhs)).maybe).as(:factor) }
         rule(:formalParameter) { ((parameterId >> (op_comma >> parameterId).repeat).as(:listOf_parameterId) >> op_colon >> parameterType).as(:formalParameter) }
         rule(:functionCall) { ((builtInFunction | functionRef) >> actualParameterList.maybe).as(:functionCall) }
         rule(:functionDecl) { (functionHead >> algorithmHead >> stmt.repeat(1).as(:stmt) >> tEND_FUNCTION >> op_delim).as(:functionDecl) }
-        rule(:functionHead) { (tFUNCTION >> functionId >> (op_leftparen >> (formalParameter >> (op_delim >> formalParameter).repeat).as(:listOf_formalParameter) >> op_rightparen).maybe >> op_colon >> parameterType >> (op_delim.as(:op_delim2))).as(:functionHead) }
-        rule(:functionId) { (simpleId).as(:functionId) }
-        rule(:functionRef) { (functionId).as(:functionRef) }
+        rule(:functionHead) do
+          (tFUNCTION >> functionId >>
+            (op_leftparen >> (formalParameter >> (op_delim >> formalParameter).repeat).as(:listOf_formalParameter) >> op_rightparen).maybe >>
+            op_colon >> parameterType >> (op_delim.as(:op_delim2))
+          ).as(:functionHead)
+        end
+        rule(:functionId) { simpleId.as(:functionId) }
+        rule(:functionRef) { functionId.as(:functionRef) }
         rule(:generalAggregationTypes) { (generalArrayType | generalBagType | generalListType | generalSetType).as(:generalAggregationTypes) }
         rule(:generalArrayType) { (tARRAY >> boundSpec.maybe >> tOF >> tOPTIONAL.maybe >> tUNIQUE.maybe >> parameterType).as(:generalArrayType) }
         rule(:generalBagType) { (tBAG >> boundSpec.maybe >> tOF >> parameterType).as(:generalBagType) }
@@ -129,43 +170,59 @@ module Expressir
         rule(:genericType) { (tGENERIC >> (op_colon >> typeLabel).maybe).as(:genericType) }
         rule(:groupQualifier) { (op_double_backslash >> entityRef).as(:groupQualifier) }
         rule(:hexDigit) { match["0-9a-fA-F"] }
-        rule(:ifStmtElseStatements) { (stmt.repeat(1).as(:stmt)).as(:ifStmtElseStatements) }
-        rule(:ifStmtStatements) { (stmt.repeat(1).as(:stmt)).as(:ifStmtStatements) }
+        rule(:ifStmtElseStatements) { stmt.repeat(1).as(:stmt).as(:ifStmtElseStatements) }
+        rule(:ifStmtStatements) { stmt.repeat(1).as(:stmt).as(:ifStmtStatements) }
         rule(:ifStmt) { (tIF >> logicalExpression >> tTHEN >> ifStmtStatements >> (tELSE >> ifStmtElseStatements).maybe >> tEND_IF >> op_delim).as(:ifStmt) }
         rule(:incrementControl) { (variableId >> op_decl >> bound1 >> tTO >> bound2 >> (tBY >> increment).maybe).as(:incrementControl) }
-        rule(:increment) { (numericExpression).as(:increment) }
-        rule(:index1) { (index).as(:index1) }
-        rule(:index2) { (index).as(:index2) }
-        rule(:index) { (numericExpression).as(:index) }
+        rule(:increment) { numericExpression.as(:increment) }
+        rule(:index1) { index.as(:index1) }
+        rule(:index2) { index.as(:index2) }
+        rule(:index) { numericExpression.as(:index) }
         rule(:indexQualifier) { (op_leftbracket >> index1 >> (op_colon >> index2).maybe >> op_rightbracket).as(:indexQualifier) }
         rule(:instantiableType) { (concreteTypes | entityRef).as(:instantiableType) }
         rule(:integerLiteral) { cts(digits.as(:str)).as(:integerLiteral) }
-        rule(:integerType) { (tINTEGER).as(:integerType) }
+        rule(:integerType) { tINTEGER.as(:integerType) }
         rule(:interfaceSpecification) { (referenceClause | useClause).as(:interfaceSpecification) }
-        rule(:intervalHigh) { (simpleExpression).as(:intervalHigh) }
-        rule(:intervalItem) { (simpleExpression).as(:intervalItem) }
-        rule(:intervalLow) { (simpleExpression).as(:intervalLow) }
-        rule(:interval) { (op_left_curly_brace >> intervalLow >> intervalOp >> intervalItem >> (intervalOp.as(:intervalOp2)) >> intervalHigh >> op_right_curly_brace).as(:interval) }
+        rule(:intervalHigh) { simpleExpression.as(:intervalHigh) }
+        rule(:intervalItem) { simpleExpression.as(:intervalItem) }
+        rule(:intervalLow) { simpleExpression.as(:intervalLow) }
+        rule(:interval) do
+          (op_left_curly_brace >> intervalLow >> intervalOp >> intervalItem >> (intervalOp.as(:intervalOp2)) >>
+            intervalHigh >> op_right_curly_brace
+          ).as(:interval)
+        end
         rule(:intervalOp) { (op_less_equal | op_less_than).as(:intervalOp) }
-        rule(:inverseAttr) { (attributeDecl >> op_colon >> inverseAttrType >> tFOR >> (entityRef >> op_period).maybe >> attributeRef >> op_delim).as(:inverseAttr) }
+        rule(:inverseAttr) do
+          (attributeDecl >> op_colon >> inverseAttrType >> tFOR >> (entityRef >> op_period).maybe >> attributeRef >> op_delim).as(:inverseAttr)
+        end
         rule(:inverseAttrType) { (((tSET | tBAG) >> boundSpec.maybe >> tOF).maybe >> entityRef).as(:inverseAttrType) }
         rule(:inverseClause) { (tINVERSE >> inverseAttr.repeat(1).as(:inverseAttr)).as(:inverseClause) }
         rule(:letter) { match["a-zA-Z"] }
         rule(:listType) { (tLIST >> boundSpec.maybe >> tOF >> tUNIQUE.maybe >> instantiableType).as(:listType) }
         rule(:literal) { (binaryLiteral | logicalLiteral | realLiteral | integerLiteral | stringLiteral).as(:literal) }
         rule(:localDecl) { (tLOCAL >> localVariable.repeat(1).as(:localVariable) >> tEND_LOCAL >> op_delim).as(:localDecl) }
-        rule(:localVariable) { ((variableId >> (op_comma >> variableId).repeat).as(:listOf_variableId) >> op_colon >> parameterType >> (op_decl >> expression).maybe >> op_delim).as(:localVariable) }
-        rule(:logicalExpression) { (expression).as(:logicalExpression) }
+        rule(:localVariable) do
+          ((variableId >> (op_comma >> variableId).repeat).as(:listOf_variableId) >>
+            op_colon >> parameterType >>
+            (op_decl >> expression).maybe >> op_delim
+          ).as(:localVariable)
+        end
+        rule(:logicalExpression) { expression.as(:logicalExpression) }
         rule(:logicalLiteral) { (tFALSE | tTRUE | tUNKNOWN).as(:logicalLiteral) }
-        rule(:logicalType) { (tLOGICAL).as(:logicalType) }
+        rule(:logicalType) { tLOGICAL.as(:logicalType) }
         rule(:multiplicationLikeOp) { (op_asterisk | op_slash | tDIV | tMOD | tAND | op_double_pipe).as(:multiplicationLikeOp) }
         rule(:namedTypeOrRename) { (namedTypes >> (tAS >> (entityId | typeId)).maybe).as(:namedTypeOrRename) }
         rule(:namedTypes) { (entityRef | typeRef).as(:namedTypes) }
-        rule(:nullStmt) { (op_delim).as(:nullStmt) }
-        rule(:numberType) { (tNUMBER).as(:numberType) }
-        rule(:numericExpression) { (simpleExpression).as(:numericExpression) }
+        rule(:nullStmt) { op_delim.as(:nullStmt) }
+        rule(:numberType) { tNUMBER.as(:numberType) }
+        rule(:numericExpression) { simpleExpression.as(:numericExpression) }
         rule(:octet) { hexDigit >> hexDigit }
-        rule(:oneOf) { (tONEOF >> op_leftparen >> (supertypeExpression >> (op_comma >> supertypeExpression).repeat).as(:listOf_supertypeExpression) >> op_rightparen).as(:oneOf) }
+        rule(:oneOf) do
+          (
+            tONEOF >> op_leftparen >> (supertypeExpression >>
+            (op_comma >> supertypeExpression).repeat).as(:listOf_supertypeExpression) >> op_rightparen
+          ).as(:oneOf)
+        end
         rule(:op_asterisk) { cstr("*").as(:op_asterisk) }
         rule(:op_colon) { cstr(":").as(:op_colon) }
         rule(:op_colon_equals_colon) { cstr(":=:").as(:op_colon_equals_colon) }
@@ -174,7 +231,7 @@ module Expressir
         rule(:op_decl) { cstr(":=").as(:op_decl) }
         rule(:op_delim) { cstr(";").as(:op_delim) }
         rule(:op_double_asterisk) { cstr("**").as(:op_double_asterisk) }
-        rule(:op_double_backslash) { cstr('\\').as(:op_double_backslash) }
+        rule(:op_double_backslash) { cstr("\\").as(:op_double_backslash) }
         rule(:op_double_pipe) { cstr("||").as(:op_double_pipe) }
         rule(:op_equals) { cstr("=").as(:op_equals) }
         rule(:op_greater_equal) { cstr(">=").as(:op_greater_equal) }
@@ -196,57 +253,97 @@ module Expressir
         rule(:op_right_curly_brace) { cstr("}").as(:op_right_curly_brace) }
         rule(:op_rightparen) { cstr(")").as(:op_rightparen) }
         rule(:op_slash) { cstr("/").as(:op_slash) }
-        rule(:parameter) { (expression).as(:parameter) }
-        rule(:parameterId) { (simpleId).as(:parameterId) }
-        rule(:parameterRef) { (parameterId).as(:parameterRef) }
+        rule(:parameter) { expression.as(:parameter) }
+        rule(:parameterId) { simpleId.as(:parameterId) }
+        rule(:parameterRef) { parameterId.as(:parameterRef) }
         rule(:parameterType) { (generalizedTypes | namedTypes | simpleTypes).as(:parameterType) }
-        rule(:population) { (entityRef).as(:population) }
-        rule(:precisionSpec) { (numericExpression).as(:precisionSpec) }
+        rule(:population) { entityRef.as(:population) }
+        rule(:precisionSpec) { numericExpression.as(:precisionSpec) }
         rule(:primary) { (literal | qualifiableFactor >> qualifier.repeat.as(:qualifier)).as(:primary) }
         rule(:procedureCallStmt) { ((builtInProcedure | procedureRef) >> actualParameterList.maybe >> op_delim).as(:procedureCallStmt) }
         rule(:procedureDecl) { (procedureHead >> algorithmHead >> stmt.repeat.as(:stmt) >> tEND_PROCEDURE >> op_delim).as(:procedureDecl) }
         rule(:procedureHeadParameter) { (tVAR.maybe >> formalParameter).as(:procedureHeadParameter) }
-        rule(:procedureHead) { (tPROCEDURE >> procedureId >> (op_leftparen >> (procedureHeadParameter >> (op_delim >> procedureHeadParameter).repeat).as(:listOf_procedureHeadParameter) >> op_rightparen).maybe >> (op_delim.as(:op_delim2))).as(:procedureHead) }
-        rule(:procedureId) { (simpleId).as(:procedureId) }
-        rule(:procedureRef) { (procedureId).as(:procedureRef) }
-        rule(:qualifiableFactor) { (attributeRef | constantFactor | functionCall | generalRef | population).as(:qualifiableFactor) }
+        rule(:procedureHead) do
+          (
+            tPROCEDURE >> procedureId >>
+            (
+              op_leftparen >> (
+                procedureHeadParameter >>
+                (op_delim >> procedureHeadParameter).repeat
+              ).as(:listOf_procedureHeadParameter) >> op_rightparen
+            ).maybe >> (op_delim.as(:op_delim2))).as(:procedureHead)
+        end
+        rule(:procedureId) { simpleId.as(:procedureId) }
+        rule(:procedureRef) { procedureId.as(:procedureRef) }
+        rule(:qualifiableFactor) { (functionCall | attributeRef | constantFactor | generalRef | population).as(:qualifiableFactor) }
         rule(:qualifiedAttribute) { (tSELF >> groupQualifier >> attributeQualifier).as(:qualifiedAttribute) }
         rule(:qualifier) { (attributeQualifier | groupQualifier | indexQualifier).as(:qualifier) }
-        rule(:queryExpression) { (tQUERY >> op_leftparen >> variableId >> op_query_begin >> aggregateSource >> op_pipe >> logicalExpression >> op_rightparen).as(:queryExpression) }
+        rule(:queryExpression) do
+          (tQUERY >> op_leftparen >> variableId >> op_query_begin >> aggregateSource >> op_pipe >> logicalExpression >> op_rightparen).as(:queryExpression)
+        end
         rule(:realLiteral) { cts((digits >> str(".") >> digits.maybe >> (match["eE"] >> sign.maybe >> digits).maybe).as(:str)).as(:realLiteral) }
         rule(:realType) { (tREAL >> (op_leftparen >> precisionSpec >> op_rightparen).maybe).as(:realType) }
         rule(:redeclaredAttribute) { (qualifiedAttribute >> (tRENAMED >> attributeId).maybe).as(:redeclaredAttribute) }
-        rule(:referenceClause) { (tREFERENCE >> tFROM >> schemaRef >> (op_leftparen >> (resourceOrRename >> (op_comma >> resourceOrRename).repeat).as(:listOf_resourceOrRename) >> op_rightparen).maybe >> op_delim).as(:referenceClause) }
+        rule(:referenceClause) do
+          (
+            tREFERENCE >> tFROM >> schemaRef >>
+            (op_leftparen >> (resourceOrRename >> (
+              op_comma >> resourceOrRename
+            ).repeat).as(:listOf_resourceOrRename) >> op_rightparen).maybe >> op_delim
+          ).as(:referenceClause)
+        end
         rule(:referencedAttribute) { (attributeRef | qualifiedAttribute).as(:referencedAttribute) }
         rule(:relOpExtended) { (relOp | tIN | tLIKE).as(:relOpExtended) }
-        rule(:relOp) { (op_less_equal | op_greater_equal | op_less_greater | op_less_than | op_greater_than | op_equals | op_colon_less_greater_colon | op_colon_equals_colon).as(:relOp) }
+        rule(:relOp) do
+          (
+            op_less_equal | op_greater_equal | op_less_greater | op_less_than | op_greater_than | op_equals |
+            op_colon_less_greater_colon | op_colon_equals_colon
+          ).as(:relOp)
+        end
         rule(:renameId) { (constantId | entityId | functionId | procedureId | typeId).as(:renameId) }
         rule(:repeatControl) { (incrementControl.maybe >> whileControl.maybe >> untilControl.maybe).as(:repeatControl) }
         rule(:repeatStmt) { (tREPEAT >> repeatControl >> op_delim >> stmt.repeat(1).as(:stmt) >> tEND_REPEAT >> (op_delim.as(:op_delim2))).as(:repeatStmt) }
-        rule(:repetition) { (numericExpression).as(:repetition) }
+        rule(:repetition) { numericExpression.as(:repetition) }
         rule(:resourceOrRename) { (resourceRef >> (tAS >> renameId).maybe).as(:resourceOrRename) }
         rule(:resourceRef) { (constantRef | entityRef | functionRef | procedureRef | typeRef).as(:resourceRef) }
         rule(:returnStmt) { (tRETURN >> (op_leftparen >> expression >> op_rightparen).maybe >> op_delim).as(:returnStmt) }
         rule(:ruleDecl) { (ruleHead >> algorithmHead >> stmt.repeat.as(:stmt) >> whereClause >> tEND_RULE >> op_delim).as(:ruleDecl) }
-        rule(:ruleHead) { (tRULE >> ruleId >> tFOR >> op_leftparen >> (entityRef >> (op_comma >> entityRef).repeat).as(:listOf_entityRef) >> op_rightparen >> op_delim).as(:ruleHead) }
-        rule(:ruleId) { (simpleId).as(:ruleId) }
-        rule(:ruleLabelId) { (simpleId).as(:ruleLabelId) }
-        rule(:ruleLabelRef) { (ruleLabelId).as(:ruleLabelRef) }
-        rule(:ruleRef) { (ruleId).as(:ruleRef) }
+        rule(:ruleHead) do
+          (
+            tRULE >> ruleId >> tFOR >> op_leftparen >>
+            (entityRef >> (op_comma >> entityRef).repeat).as(:listOf_entityRef) >> op_rightparen >> op_delim
+          ).as(:ruleHead)
+        end
+        rule(:ruleId) { simpleId.as(:ruleId) }
+        rule(:ruleLabelId) { simpleId.as(:ruleLabelId) }
+        rule(:ruleLabelRef) { ruleLabelId.as(:ruleLabelRef) }
+        rule(:ruleRef) { ruleId.as(:ruleRef) }
         rule(:schemaBodyDeclaration) { (declaration | ruleDecl).as(:schemaBodyDeclaration) }
-        rule(:schemaBody) { (interfaceSpecification.repeat.as(:interfaceSpecification) >> constantDecl.maybe >> schemaBodyDeclaration.repeat.as(:schemaBodyDeclaration)).as(:schemaBody) }
-        rule(:schemaDecl) { (tSCHEMA >> schemaId >> schemaVersionId.maybe >> op_delim >> schemaBody >> tEND_SCHEMA >> (op_delim.as(:op_delim2))).as(:schemaDecl) }
-        rule(:schemaId) { (simpleId).as(:schemaId) }
-        rule(:schemaRef) { (schemaId).as(:schemaRef) }
-        rule(:schemaVersionId) { (stringLiteral).as(:schemaVersionId) }
+        rule(:schemaBody) do
+          (
+            interfaceSpecification.repeat.as(:interfaceSpecification) >> constantDecl.maybe >>
+            schemaBodyDeclaration.repeat.as(:schemaBodyDeclaration)
+          ).as(:schemaBody)
+        end
+        rule(:schemaDecl) do
+          (tSCHEMA >> schemaId >> schemaVersionId.maybe >> op_delim >> schemaBody >> tEND_SCHEMA >> (op_delim.as(:op_delim2))).as(:schemaDecl)
+        end
+        rule(:schemaId) { simpleId.as(:schemaId) }
+        rule(:schemaRef) { schemaId.as(:schemaRef) }
+        rule(:schemaVersionId) { stringLiteral.as(:schemaVersionId) }
         rule(:selectExtension) { (tBASED_ON >> typeRef >> (tWITH >> selectList).maybe).as(:selectExtension) }
         rule(:selectList) { (op_leftparen >> (namedTypes >> (op_comma >> namedTypes).repeat).as(:listOf_namedTypes) >> op_rightparen).as(:selectList) }
-        rule(:selector) { (expression).as(:selector) }
+        rule(:selector) { expression.as(:selector) }
         rule(:selectType) { ((tEXTENSIBLE >> tGENERIC_ENTITY.maybe).maybe >> tSELECT >> (selectList | selectExtension).maybe).as(:selectType) }
         rule(:setType) { (tSET >> boundSpec.maybe >> tOF >> instantiableType).as(:setType) }
         rule(:sign) { match["+-"] }
         rule(:simpleExpression) { (term >> (addLikeOp.as(:operator) >> term).as(:item).repeat.as(:rhs)).as(:simpleExpression) }
-        rule(:simpleFactor) { (aggregateInitializer | entityConstructor | interval | queryExpression | simpleFactorExpression | simpleFactorUnaryExpression | enumerationReference).as(:simpleFactor) }
+        rule(:simpleFactor) do
+          (
+            aggregateInitializer | entityConstructor | interval | queryExpression | simpleFactorExpression |
+            simpleFactorUnaryExpression | enumerationReference
+          ).as(:simpleFactor)
+        end
         rule(:simpleFactorExpression) { (op_leftparen >> expression >> op_rightparen | primary).as(:simpleFactorExpression) }
         rule(:simpleFactorUnaryExpression) { (unaryOp >> simpleFactorExpression).as(:simpleFactorUnaryExpression) }
         rule(:simpleId) { anyKeyword.absent? >> cts((match["a-zA-Z_"] >> match["a-zA-Z0-9_"].repeat).as(:str)).as(:simpleId) }
@@ -255,17 +352,24 @@ module Expressir
         rule(:skipStmt) { (tSKIP >> op_delim).as(:skipStmt) }
         rule(:space) { match[" \r\n\t\f"] | embeddedRemark | tailRemark }
         rule(:spaces) { space.repeat.as(:spaces) }
-        rule(:stmt) { (aliasStmt | assignmentStmt | caseStmt | compoundStmt | escapeStmt | ifStmt | nullStmt | procedureCallStmt | repeatStmt | returnStmt | skipStmt).as(:stmt) }
+        rule(:stmt) do
+          (
+            aliasStmt | assignmentStmt | caseStmt | compoundStmt | escapeStmt | ifStmt |
+            nullStmt | procedureCallStmt | repeatStmt | returnStmt | skipStmt
+          ).as(:stmt)
+        end
         rule(:stringLiteral) { (simpleStringLiteral | encodedStringLiteral).as(:stringLiteral) }
         rule(:stringType) { (tSTRING >> widthSpec.maybe).as(:stringType) }
         rule(:subsuper) { (supertypeConstraint.maybe >> subtypeDeclaration.maybe).as(:subsuper) }
         rule(:subtypeConstraintBody) { (abstractSupertype.maybe >> totalOver.maybe >> (supertypeExpression >> op_delim).maybe).as(:subtypeConstraintBody) }
         rule(:subtypeConstraintDecl) { (subtypeConstraintHead >> subtypeConstraintBody >> tEND_SUBTYPE_CONSTRAINT >> op_delim).as(:subtypeConstraintDecl) }
         rule(:subtypeConstraintHead) { (tSUBTYPE_CONSTRAINT >> subtypeConstraintId >> tFOR >> entityRef >> op_delim).as(:subtypeConstraintHead) }
-        rule(:subtypeConstraintId) { (simpleId).as(:subtypeConstraintId) }
-        rule(:subtypeConstraintRef) { (subtypeConstraintId).as(:subtypeConstraintRef) }
+        rule(:subtypeConstraintId) { simpleId.as(:subtypeConstraintId) }
+        rule(:subtypeConstraintRef) { subtypeConstraintId.as(:subtypeConstraintRef) }
         rule(:subtypeConstraint) { (tOF >> op_leftparen >> supertypeExpression >> op_rightparen).as(:subtypeConstraint) }
-        rule(:subtypeDeclaration) { (tSUBTYPE >> tOF >> op_leftparen >> entityRef >> (op_comma >> entityRef).repeat >> op_rightparen).as(:listOf_entityRef).as(:subtypeDeclaration) }
+        rule(:subtypeDeclaration) do
+          (tSUBTYPE >> tOF >> op_leftparen >> entityRef >> (op_comma >> entityRef).repeat >> op_rightparen).as(:listOf_entityRef).as(:subtypeDeclaration)
+        end
         rule(:supertypeConstraint) { (abstractSupertypeDeclaration | abstractEntityDeclaration | supertypeRule).as(:supertypeConstraint) }
         rule(:supertypeExpression) { (supertypeFactor >> (tANDOR.as(:operator) >> supertypeFactor).as(:item).repeat.as(:rhs)).as(:supertypeExpression) }
         rule(:supertypeFactor) { (supertypeTerm >> (tAND.as(:operator) >> supertypeTerm).as(:item).repeat.as(:rhs)).as(:supertypeFactor) }
@@ -274,24 +378,44 @@ module Expressir
         rule(:syntax) { (spaces.as(:spaces) >> schemaDecl.repeat(1).as(:schemaDecl) >> spaces.as(:trailer)).as(:syntax) }
         rule(:tailRemark) { (str("--") >> (str("\n").absent? >> any).repeat >> str("\n")).as(:tailRemark) }
         rule(:term) { (factor >> (multiplicationLikeOp >> factor).as(:item).repeat.as(:rhs)).as(:term) }
-        rule(:totalOver) { (tTOTAL_OVER >> op_leftparen >> (entityRef >> (op_comma >> entityRef).repeat).as(:listOf_entityRef) >> op_rightparen >> op_delim).as(:totalOver) }
-        rule(:typeDecl) { (tTYPE >> typeId >> op_equals >> underlyingType >> op_delim >> whereClause.maybe >> tEND_TYPE >> (op_delim.as(:op_delim2))).as(:typeDecl) }
-        rule(:typeId) { (simpleId).as(:typeId) }
-        rule(:typeLabelId) { (simpleId).as(:typeLabelId) }
-        rule(:typeLabelRef) { (typeLabelId).as(:typeLabelRef) }
+        rule(:totalOver) do
+          (tTOTAL_OVER >> op_leftparen >> (entityRef >> (op_comma >> entityRef).repeat).as(:listOf_entityRef) >> op_rightparen >> op_delim).as(:totalOver)
+        end
+        rule(:typeDecl) do
+          (tTYPE >> typeId >> op_equals >> underlyingType >> op_delim >> whereClause.maybe >> tEND_TYPE >> (op_delim.as(:op_delim2))).as(:typeDecl)
+        end
+        rule(:typeId) { simpleId.as(:typeId) }
+        rule(:typeLabelId) { simpleId.as(:typeLabelId) }
+        rule(:typeLabelRef) { typeLabelId.as(:typeLabelRef) }
         rule(:typeLabel) { (typeLabelId | typeLabelRef).as(:typeLabel) }
-        rule(:typeRef) { (typeId).as(:typeRef) }
+        rule(:typeRef) { typeId.as(:typeRef) }
         rule(:unaryOp) { (op_plus | op_minus | tNOT).as(:unaryOp) }
         rule(:underlyingType) { (concreteTypes | constructedTypes).as(:underlyingType) }
-        rule(:uniqueClause) { (tUNIQUE >> (uniqueRule >> op_delim >> (uniqueRule >> (op_delim.as(:op_delim2))).repeat).as(:listOf_uniqueRule)).as(:uniqueClause) }
-        rule(:uniqueRule) { ((ruleLabelId >> op_colon).maybe >> (referencedAttribute >> (op_comma >> referencedAttribute).repeat).as(:listOf_referencedAttribute)).as(:uniqueRule) }
+        rule(:uniqueClause) do
+          (tUNIQUE >> (uniqueRule >> op_delim >> (uniqueRule >> (op_delim.as(:op_delim2))).repeat).as(:listOf_uniqueRule)).as(:uniqueClause)
+        end
+        rule(:uniqueRule) do
+          ((ruleLabelId >> op_colon).maybe >> (referencedAttribute >> (op_comma >> referencedAttribute).repeat).as(:listOf_referencedAttribute)).as(:uniqueRule)
+        end
         rule(:untilControl) { (tUNTIL >> logicalExpression).as(:untilControl) }
-        rule(:useClause) { (tUSE >> tFROM >> schemaRef >> (op_leftparen >> (namedTypeOrRename >> (op_comma >> namedTypeOrRename).repeat).as(:listOf_namedTypeOrRename) >> op_rightparen).maybe >> op_delim).as(:useClause) }
-        rule(:variableId) { (simpleId).as(:variableId) }
-        rule(:variableRef) { (variableId).as(:variableRef) }
+        rule(:useClause) do
+          (
+            tUSE >> tFROM >> schemaRef >>
+            (
+              op_leftparen >> (
+                namedTypeOrRename >> (
+                  op_comma >>
+                  namedTypeOrRename
+                ).repeat
+              ).as(:listOf_namedTypeOrRename) >> op_rightparen
+            ).maybe >> op_delim
+          ).as(:useClause)
+        end
+        rule(:variableId) { simpleId.as(:variableId) }
+        rule(:variableRef) { variableId.as(:variableRef) }
         rule(:whereClause) { (tWHERE >> (domainRule >> op_delim).repeat.as(:listOf_domainRule)).as(:whereClause) }
         rule(:whileControl) { (tWHILE >> logicalExpression).as(:whileControl) }
-        rule(:width) { (numericExpression).as(:width) }
+        rule(:width) { numericExpression.as(:width) }
         rule(:widthSpec) { (op_leftparen >> width >> op_rightparen >> tFIXED.maybe).as(:widthSpec) }
       end
 
@@ -326,9 +450,9 @@ module Expressir
       # @param [Boolean] include_source attach original source code to model elements
       # @return [Model::Repository]
       def self.from_files(files, skip_references: nil, include_source: nil)
-        schemas = files.each_with_index.map do |file, i|
+        schemas = files.each_with_index.map do |file, _i|
           # start = Time.now
-          repository = self.from_file(file, skip_references: true)
+          repository = from_file(file, skip_references: true)
           # STDERR.puts "#{i+1}/#{files.length} #{file} #{Time.now - start}"
           repository.schemas
         end.flatten

data/lib/expressir/express/resolve_references_model_visitor.rb

@@ -17,15 +17,15 @@ module Expressir
       def visit_references_simple_reference(node)
         return if node.parent.is_a? Model::References::AttributeReference
 
-        if node.parent.is_a? Model::Declarations::InterfaceItem
-          base_item = node.find("#{node.parent.parent.schema.id}.#{node.parent.ref.id}")
-        else
-          base_item = node.find(node.id)
-        end
+        base_item = if node.parent.is_a? Model::Declarations::InterfaceItem
+                      node.find("#{node.parent.parent.schema.id}.#{node.parent.ref.id}")
+                    else
+                      node.find(node.id)
+                    end
         return unless base_item
 
         node.base_path = base_item.path
       end
     end
   end
-end
+end

data/lib/expressir/express/schema_head_formatter.rb

@@ -8,8 +8,8 @@ module Expressir
     module SchemaHeadFormatter
       # @!visibility private
       def self.included(mod)
-        if !mod.superclass.private_method_defined? :format_declarations_schema or !mod.superclass.private_method_defined? :format_declarations_schema_head
-          raise 'Missing method'
+        if !mod.superclass.private_method_defined?(:format_declarations_schema) || !mod.superclass.private_method_defined?(:format_declarations_schema_head)
+          raise "Missing method"
         end
       end
 
@@ -20,4 +20,4 @@ module Expressir
       end
     end
   end
-end
+end