expressir 0.2.0 → 0.2.1

data/lib/expressir/model/rule.rb

@@ -8,6 +8,7 @@ module Expressir
       attr_accessor :locals
       attr_accessor :where
       attr_accessor :statements
+      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
@@ -17,6 +18,36 @@ module Expressir
         @locals = options[:locals]
         @where = options[:where]
         @statements = options[:statements]
+        @remarks = options[:remarks]
+      end
+
+      def types
+        @declarations.select{|x| x.instance_of? Expressir::Model::Type}
+      end
+
+      def entities
+        @declarations.select{|x| x.instance_of? Expressir::Model::Entity}
+      end
+
+      def subtype_constraints
+        @declarations.select{|x| x.instance_of? Expressir::Model::SubtypeConstraint}
+      end
+
+      def functions
+        @declarations.select{|x| x.instance_of? Expressir::Model::Function}
+      end
+
+      def procedures
+        @declarations.select{|x| x.instance_of? Expressir::Model::Procedure}
+      end
+
+      def scope_items
+        items = []
+        items.push(*@declarations) if @declarations
+        items.push(*@constants) if @constants
+        items.push(*@locals) if @locals
+        items.push(*@where) if @where
+        items
       end
     end
   end

data/lib/expressir/model/schema.rb

@@ -7,6 +7,7 @@ module Expressir
       attr_accessor :constants
       attr_accessor :declarations
       attr_accessor :rules
+      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
@@ -15,6 +16,7 @@ module Expressir
         @constants = options[:constants]
         @declarations = options[:declarations]
         @rules = options[:rules]
+        @remarks = options[:remarks]
       end
 
       def types
@@ -36,6 +38,14 @@ module Expressir
       def procedures
         @declarations.select{|x| x.instance_of? Expressir::Model::Procedure}
       end
+
+      def scope_items
+        items = []
+        items.push(*@constants) if @constants
+        items.push(*@declarations) if @declarations
+        items.push(*@rules) if @rules
+        items
+      end
     end
   end
 end

data/lib/expressir/model/statements/alias.rb

@@ -5,11 +5,19 @@ module Expressir
         attr_accessor :id
         attr_accessor :expression
         attr_accessor :statements
+        attr_accessor :remarks
 
         def initialize(options = {})
           @id = options[:id]
           @expression = options[:expression]
           @statements = options[:statements]
+          @remarks = options[:remarks]
+        end
+
+        def scope_items
+          items = []
+          items.push(self)
+          items
         end
       end
     end

data/lib/expressir/model/statements/case_action.rb

@@ -2,11 +2,11 @@ module Expressir
   module Model
     module Statements
       class CaseAction
-        attr_accessor :label
+        attr_accessor :expression
         attr_accessor :statement
 
         def initialize(options = {})
-          @label = options[:label]
+          @expression = options[:expression]
           @statement = options[:statement]
         end
       end

data/lib/expressir/model/statements/if.rb

@@ -2,12 +2,12 @@ module Expressir
   module Model
     module Statements
       class If
-        attr_accessor :condition
+        attr_accessor :expression
         attr_accessor :statements
         attr_accessor :else_statements
 
         def initialize(options = {})
-          @condition = options[:condition]
+          @expression = options[:expression]
           @statements = options[:statements]
           @else_statements = options[:else_statements]
         end

data/lib/expressir/model/statements/repeat.rb

@@ -2,22 +2,30 @@ module Expressir
   module Model
     module Statements
       class Repeat
-        attr_accessor :variable
+        attr_accessor :id
         attr_accessor :bound1
         attr_accessor :bound2
         attr_accessor :increment
         attr_accessor :while_expression
         attr_accessor :until_expression
         attr_accessor :statements
+        attr_accessor :remarks
 
         def initialize(options = {})
-          @variable = options[:variable]
+          @id = options[:id]
           @bound1 = options[:bound1]
           @bound2 = options[:bound2]
           @increment = options[:increment]
           @while_expression = options[:while_expression]
           @until_expression = options[:until_expression]
           @statements = options[:statements]
+          @remarks = options[:remarks]
+        end
+
+        def scope_items
+          items = []
+          items.push(self)
+          items
         end
       end
     end

data/lib/expressir/model/subtype_constraint.rb

@@ -6,6 +6,7 @@ module Expressir
       attr_accessor :abstract_supertype
       attr_accessor :total_over
       attr_accessor :subtype_expression
+      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
@@ -13,6 +14,7 @@ module Expressir
         @abstract_supertype = options[:abstract_supertype]
         @total_over = options[:total_over]
         @subtype_expression = options[:subtype_expression]
+        @remarks = options[:remarks]
       end
     end
   end

data/lib/expressir/model/type.rb

@@ -4,11 +4,19 @@ module Expressir
       attr_accessor :id
       attr_accessor :type
       attr_accessor :where
+      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
         @type = options[:type]
         @where = options[:where]
+        @remarks = options[:remarks]
+      end
+
+      def scope_items
+        items = []
+        items.push(*@where) if @where
+        items
       end
     end
   end

data/lib/expressir/model/types/aggregate.rb

@@ -4,10 +4,12 @@ module Expressir
       class Aggregate
         attr_accessor :label
         attr_accessor :base_type
+        attr_accessor :remarks
 
         def initialize(options = {})
           @label = options[:label]
           @base_type = options[:base_type]
+          @remarks = options[:remarks]
         end
       end
     end

data/lib/expressir/model/types/enumeration.rb

@@ -3,15 +3,15 @@ module Expressir
     module Types
       class Enumeration
         attr_accessor :extensible
-        attr_accessor :list
+        attr_accessor :items
         attr_accessor :extension_type
-        attr_accessor :extension_list
+        attr_accessor :extension_items
 
         def initialize(options = {})
           @extensible = options[:extensible]
-          @list = options[:list]
+          @items = options[:items]
           @extension_type = options[:extension_type]
-          @extension_list = options[:extension_list]
+          @extension_items = options[:extension_items]
         end
       end
     end

data/lib/expressir/model/types/generic.rb

@@ -3,9 +3,11 @@ module Expressir
     module Types
       class Generic
         attr_accessor :label
+        attr_accessor :remarks
 
         def initialize(options = {})
           @label = options[:label]
+          @remarks = options[:remarks]
         end
       end
     end

data/lib/expressir/model/types/generic_entity.rb

@@ -3,9 +3,11 @@ module Expressir
     module Types
       class GenericEntity
         attr_accessor :label
+        attr_accessor :remarks
 
         def initialize(options = {})
           @label = options[:label]
+          @remarks = options[:remarks]
         end
       end
     end

data/lib/expressir/model/types/select.rb

@@ -4,16 +4,16 @@ module Expressir
       class Select
         attr_accessor :extensible
         attr_accessor :generic_entity
-        attr_accessor :list
+        attr_accessor :items
         attr_accessor :extension_type
-        attr_accessor :extension_list
+        attr_accessor :extension_items
 
         def initialize(options = {})
           @extensible = options[:extensible]
           @generic_entity = options[:generic_entity]
-          @list = options[:list]
+          @items = options[:items]
           @extension_type = options[:extension_type]
-          @extension_list = options[:extension_list]
+          @extension_items = options[:extension_items]
         end
       end
     end

data/lib/expressir/model/unique.rb

@@ -3,10 +3,12 @@ module Expressir
     class Unique
       attr_accessor :id
       attr_accessor :attributes
+      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
         @attributes = options[:attributes]
+        @remarks = options[:remarks]
       end
     end
   end

data/lib/expressir/model/where.rb

@@ -3,10 +3,12 @@ module Expressir
     class Where
       attr_accessor :id
       attr_accessor :expression
+      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
         @expression = options[:expression]
+        @remarks = options[:remarks]
       end
     end
   end

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "0.2.0".freeze
+  VERSION = "0.2.1".freeze
 end

data/original/examples/syntax/remark.exp

@@ -0,0 +1,127 @@
+--"remarkSchema" universal scope - schema before
+
+SCHEMA remarkSchema;
+
+CONSTANT remarkConstant : STRING := 'xxx'; END_CONSTANT;
+TYPE remarkType = STRING; END_TYPE;
+ENTITY remarkEntity;
+  remarkExplicit : STRING;
+  DERIVE remarkDerived : STRING := 'xxx';
+  INVERSE remarkInverse : remarkEntity FOR remarkExplicit;
+  UNIQUE remarkUnique : remarkExplicit;
+  WHERE remarkWhere : TRUE;
+  --"remarkExplicit" entity scope - entity explicit
+  --"remarkDerived" entity scope - entity derived
+  --"remarkInverse" entity scope - entity inverse
+  --"remarkUnique" entity scope - entity unique
+  --"remarkWhere" entity scope - entity where
+END_ENTITY;
+SUBTYPE_CONSTRAINT remarkSubtypeConstraint FOR remarkEntity; END_SUBTYPE_CONSTRAINT;
+FUNCTION remarkFunction (remarkParameter : STRING) : BOOLEAN;
+  TYPE remarkType = STRING; END_TYPE;
+  CONSTANT remarkConstant : STRING := 'xxx'; END_CONSTANT;
+  LOCAL remarkLocal : STRING; END_LOCAL;
+  ALIAS remarkAlias FOR remarkLocal; ;
+    --"remarkAlias" function alias scope - function alias
+  END_ALIAS;
+  REPEAT remarkRepeat := 1 TO 9; ;
+    --"remarkRepeat" function repeat scope - function repeat
+  END_REPEAT;
+  remarkLocal := QUERY(remarkQuery <* remarkLocal | TRUE
+    --"remarkQuery" function query scope - function query
+  );
+  --"remarkParameter" function scope - function parameter
+  --"remarkType" function scope - function type
+  --"remarkConstant" function scope - function constant
+  --"remarkLocal" function scope - function local
+END_FUNCTION;
+PROCEDURE remarkProcedure (remarkParameter : STRING);
+  TYPE remarkType = STRING; END_TYPE;
+  CONSTANT remarkConstant : STRING := 'xxx'; END_CONSTANT;
+  LOCAL remarkLocal : STRING; END_LOCAL;
+  ALIAS remarkAlias FOR remarkLocal; ;
+    --"remarkAlias" procedure alias scope - procedure alias
+  END_ALIAS;
+  REPEAT remarkRepeat := 1 TO 9; ;
+    --"remarkRepeat" procedure repeat scope - procedure repeat
+  END_REPEAT;
+  remarkLocal := QUERY(remarkQuery <* remarkLocal | TRUE
+    --"remarkQuery" procedure query scope - procedure query
+  );
+  --"remarkParameter" procedure scope - procedure parameter
+  --"remarkType" procedure scope - procedure type
+  --"remarkConstant" procedure scope - procedure constant
+  --"remarkLocal" procedure scope - procedure local
+END_PROCEDURE;
+RULE remarkRule FOR (remarkEntity);
+  TYPE remarkType = STRING; END_TYPE;
+  CONSTANT remarkConstant : STRING := 'xxx'; END_CONSTANT;
+  LOCAL remarkLocal : STRING; END_LOCAL;
+  ALIAS remarkAlias FOR remarkLocal; ;
+    --"remarkAlias" rule alias scope - rule alias
+  END_ALIAS;
+  REPEAT remarkRepeat := 1 TO 9; ;
+    --"remarkRepeat" rule repeat scope - rule repeat
+  END_REPEAT;
+  remarkLocal := QUERY(remarkQuery <* remarkLocal | TRUE
+    --"remarkQuery" rule query scope - rule query
+  );
+  WHERE remarkWhere : TRUE;
+  --"remarkType" rule scope - rule type
+  --"remarkConstant" rule scope - rule constant
+  --"remarkLocal" rule scope - rule local
+  --"remarkWhere" rule scope - rule where
+END_RULE;
+
+--"remarkConstant" schema scope - constant
+--"remarkType" schema scope - type
+--"remarkEntity" schema scope - entity
+--"remarkEntity.remarkExplicit" schema scope - entity explicit
+--"remarkEntity.remarkDerived" schema scope - entity derived
+--"remarkEntity.remarkInverse" schema scope - entity inverse
+--"remarkEntity.remarkUnique" schema scope - entity unique
+--"remarkEntity.remarkWhere" schema scope - entity where
+--"remarkSubtypeConstraint" schema scope - subtype constraint
+--"remarkFunction" schema scope - function
+--"remarkFunction.remarkParameter" schema scope - function parameter
+--"remarkFunction.remarkType" schema scope - function type
+--"remarkFunction.remarkConstant" schema scope - function constant
+--"remarkFunction.remarkLocal" schema scope - function local
+--"remarkProcedure" schema scope - procedure
+--"remarkProcedure.remarkParameter" schema scope - procedure parameter
+--"remarkProcedure.remarkType" schema scope - procedure type
+--"remarkProcedure.remarkConstant" schema scope - procedure constant
+--"remarkProcedure.remarkLocal" schema scope - procedure local
+--"remarkRule" schema scope - rule
+--"remarkRule.remarkType" schema scope - rule type
+--"remarkRule.remarkConstant" schema scope - rule constant
+--"remarkRule.remarkLocal" schema scope - rule local
+--"remarkRule.remarkWhere" schema scope - rule where
+
+END_SCHEMA;
+
+--"remarkSchema" universal scope - schema
+--"remarkSchema.remarkConstant" universal scope - constant
+--"remarkSchema.remarkType" universal scope - type
+--"remarkSchema.remarkEntity" universal scope - entity
+--"remarkSchema.remarkEntity.remarkExplicit" universal scope - entity explicit
+--"remarkSchema.remarkEntity.remarkDerived" universal scope - entity derived
+--"remarkSchema.remarkEntity.remarkInverse" universal scope - entity inverse
+--"remarkSchema.remarkEntity.remarkUnique" universal scope - entity unique
+--"remarkSchema.remarkEntity.remarkWhere" universal scope - entity where
+--"remarkSchema.remarkSubtypeConstraint" universal scope - subtype constraint
+--"remarkSchema.remarkFunction" universal scope - function
+--"remarkSchema.remarkFunction.remarkParameter" universal scope - function parameter
+--"remarkSchema.remarkFunction.remarkType" universal scope - function type
+--"remarkSchema.remarkFunction.remarkConstant" universal scope - function constant
+--"remarkSchema.remarkFunction.remarkLocal" universal scope - function local
+--"remarkSchema.remarkProcedure" universal scope - procedure
+--"remarkSchema.remarkProcedure.remarkParameter" universal scope - procedure parameter
+--"remarkSchema.remarkProcedure.remarkType" universal scope - procedure type
+--"remarkSchema.remarkProcedure.remarkConstant" universal scope - procedure constant
+--"remarkSchema.remarkProcedure.remarkLocal" universal scope - procedure local
+--"remarkSchema.remarkRule" universal scope - rule
+--"remarkSchema.remarkRule.remarkType" universal scope - rule type
+--"remarkSchema.remarkRule.remarkConstant" universal scope - rule constant
+--"remarkSchema.remarkRule.remarkLocal" universal scope - rule local
+--"remarkSchema.remarkRule.remarkWhere" universal scope - rule where

data/original/examples/syntax/syntax.exp

@@ -12,12 +12,12 @@ CONSTANT
   -- literals
   binaryExpression : STRING := %011110000111100001111000;
   integerExpression : STRING := 999;
-  logicalTrueExpression : STRING := TRUE;
-  logicalFalseExpression : STRING := FALSE;
-  logicalUnknownExpression : STRING := UNKNOWN;
+  trueLogicalExpression : STRING := TRUE;
+  falseLogicalExpression : STRING := FALSE;
+  unknownLogicalExpression : STRING := UNKNOWN;
   realExpression : STRING := 999.999;
-  stringSimpleExpression : STRING := 'xxx';
-  stringEncodedExpression : STRING := "000000780000007800000078";
+  simpleStringExpression : STRING := 'xxx';
+  encodedStringExpression : STRING := "000000780000007800000078";
 
   -- constants
   constEExpression : STRING := CONST_E;
@@ -93,10 +93,10 @@ CONSTANT
   likeExpression : STRING := 'xxx' LIKE 'xxx';
 
   -- aggregate initializers
-  aggregateExpression : STRING := ['xxx'];
-  aggregateRepeatedExpression : STRING := ['xxx' : 2];
-  aggregateComplexExpression : STRING := [4 + 2];
-  aggregateComplexRepeatedExpression : STRING := [4 + 2 : 4 + 2];
+  aggregateInitializerExpression : STRING := ['xxx'];
+  repeatedAggregateInitializerExpression : STRING := ['xxx' : 2];
+  complexAggregateInitializerExpression : STRING := [4 + 2];
+  complexRepeatedAggregateInitializerExpression : STRING := [4 + 2 : 4 + 2];
 
   -- entity constructors
   entityConstructorExpression : STRING := explicitAttributeEntity(TRUE);
@@ -175,14 +175,19 @@ ENTITY explicitAttributeEntity; test : BOOLEAN; END_ENTITY;
 ENTITY explicitAttributeOptionalEntity; test : OPTIONAL BOOLEAN; END_ENTITY;
 ENTITY explicitAttributeMultipleEntity; test : BOOLEAN; test2 : BOOLEAN; END_ENTITY;
 ENTITY explicitAttributeMultipleShorthandEntity; test, test2 : BOOLEAN; END_ENTITY;
-ENTITY explicitAttributeRenamedEntity; SELF\explicitAttributeEntity.test RENAMED test2: BOOLEAN; END_ENTITY;
+ENTITY explicitAttributeRedeclaredEntity; SELF\explicitAttributeEntity.test: BOOLEAN; END_ENTITY;
+ENTITY explicitAttributeRedeclaredRenamedEntity; SELF\explicitAttributeEntity.test RENAMED test2: BOOLEAN; END_ENTITY;
 ENTITY derivedAttributeEntity; DERIVE test : BOOLEAN := TRUE; END_ENTITY;
+ENTITY derivedAttributeRedeclaredEntity; DERIVE SELF\explicitAttributeEntity.test : BOOLEAN := TRUE; END_ENTITY;
+ENTITY derivedAttributeRedeclaredRenamedEntity; DERIVE SELF\explicitAttributeEntity.test RENAMED test2 : BOOLEAN := TRUE; END_ENTITY;
 ENTITY inverseAttributeEntity; INVERSE test : explicitAttributeEntity FOR test; END_ENTITY;
 ENTITY inverseAttributeEntityEntity; INVERSE test : explicitAttributeEntity FOR explicitAttributeEntity.test; END_ENTITY;
 ENTITY inverseAttributeSetEntity; INVERSE test : SET OF explicitAttributeEntity FOR test; END_ENTITY;
 ENTITY inverseAttributeSetBoundEntity; INVERSE test : SET [1:9] OF explicitAttributeEntity FOR test; END_ENTITY;
 ENTITY inverseAttributeBagEntity; INVERSE test : BAG OF explicitAttributeEntity FOR test; END_ENTITY;
 ENTITY inverseAttributeBagBoundEntity; INVERSE test : BAG [1:9] OF explicitAttributeEntity FOR test; END_ENTITY;
+ENTITY inverseAttributeRedeclaredEntity; INVERSE SELF\explicitAttributeEntity.test : explicitAttributeEntity FOR test; END_ENTITY;
+ENTITY inverseAttributeRedeclaredRenamedEntity; INVERSE SELF\explicitAttributeEntity.test RENAMED test2 : explicitAttributeEntity FOR test; END_ENTITY;
 ENTITY uniqueEntity; UNIQUE test; END_ENTITY;
 ENTITY uniqueLabelEntity; UNIQUE UR1: test; END_ENTITY;
 ENTITY uniqueQualifiedEntity; UNIQUE SELF\explicitAttributeEntity.test; END_ENTITY;