expressir 0.2.0 → 0.2.5

data/lib/expressir/model/statements/{procedure_call.rb → call.rb}

@@ -1,12 +1,12 @@
 module Expressir
   module Model
     module Statements
-      class ProcedureCall
-        attr_accessor :procedure
+      class Call
+        attr_accessor :ref
         attr_accessor :parameters
 
         def initialize(options = {})
-          @procedure = options[:procedure]
+          @ref = options[:ref]
           @parameters = options[:parameters]
         end
       end

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

@@ -2,12 +2,12 @@ module Expressir
   module Model
     module Statements
       class Case
-        attr_accessor :selector
+        attr_accessor :expression
         attr_accessor :actions
         attr_accessor :otherwise_statement
 
         def initialize(options = {})
-          @selector = options[:selector]
+          @expression = options[:expression]
           @actions = options[:actions]
           @otherwise_statement = options[:otherwise_statement]
         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 :labels
         attr_accessor :statement
 
         def initialize(options = {})
-          @label = options[:label]
+          @labels = options[:labels]
           @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,7 +2,9 @@ module Expressir
   module Model
     module Statements
       class Repeat
-        attr_accessor :variable
+        include Scope
+        include Identifier
+
         attr_accessor :bound1
         attr_accessor :bound2
         attr_accessor :increment
@@ -11,7 +13,8 @@ module Expressir
         attr_accessor :statements
 
         def initialize(options = {})
-          @variable = options[:variable]
+          @id = options[:id]
+
           @bound1 = options[:bound1]
           @bound2 = options[:bound2]
           @increment = options[:increment]
@@ -19,6 +22,12 @@ module Expressir
           @until_expression = options[:until_expression]
           @statements = options[:statements]
         end
+
+        def children
+          items = []
+          items.push(self)
+          items
+        end
       end
     end
   end

data/lib/expressir/model/subtype_constraint.rb

@@ -1,18 +1,26 @@
 module Expressir
   module Model
     class SubtypeConstraint
-      attr_accessor :id
+      include Scope
+      include Identifier
+
       attr_accessor :applies_to
-      attr_accessor :abstract_supertype
+      attr_accessor :abstract
       attr_accessor :total_over
-      attr_accessor :subtype_expression
+      attr_accessor :supertype_expression
 
       def initialize(options = {})
         @id = options[:id]
+
         @applies_to = options[:applies_to]
-        @abstract_supertype = options[:abstract_supertype]
+        @abstract = options[:abstract]
         @total_over = options[:total_over]
-        @subtype_expression = options[:subtype_expression]
+        @supertype_expression = options[:supertype_expression]
+      end
+
+      def children
+        items = []
+        items
       end
     end
   end

data/lib/expressir/model/type.rb

@@ -1,15 +1,24 @@
 module Expressir
   module Model
     class Type
-      attr_accessor :id
+      include Scope
+      include Identifier
+
       attr_accessor :type
       attr_accessor :where
 
       def initialize(options = {})
         @id = options[:id]
+
         @type = options[:type]
         @where = options[:where]
       end
+
+      def children
+        items = []
+        items.push(*@where) if @where
+        items
+      end
     end
   end
 end

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

@@ -2,11 +2,13 @@ module Expressir
   module Model
     module Types
       class Aggregate
-        attr_accessor :label
+        include Identifier
+
         attr_accessor :base_type
 
         def initialize(options = {})
-          @label = options[:label]
+          @id = options[:id]
+
           @base_type = options[:base_type]
         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

@@ -2,10 +2,10 @@ module Expressir
   module Model
     module Types
       class Generic
-        attr_accessor :label
+        include Identifier
 
         def initialize(options = {})
-          @label = options[:label]
+          @id = options[:id]
         end
       end
     end

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

@@ -2,10 +2,10 @@ module Expressir
   module Model
     module Types
       class GenericEntity
-        attr_accessor :label
+        include Identifier
 
         def initialize(options = {})
-          @label = options[:label]
+          @id = options[:id]
         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

@@ -1,11 +1,13 @@
 module Expressir
   module Model
     class Unique
-      attr_accessor :id
+      include Identifier
+
       attr_accessor :attributes
 
       def initialize(options = {})
         @id = options[:id]
+
         @attributes = options[:attributes]
       end
     end

data/lib/expressir/model/{derived.rb → variable.rb}

@@ -1,12 +1,14 @@
 module Expressir
   module Model
-    class Derived
-      attr_accessor :id
+    class Variable
+      include Identifier
+
       attr_accessor :type
       attr_accessor :expression
 
       def initialize(options = {})
         @id = options[:id]
+
         @type = options[:type]
         @expression = options[:expression]
       end

data/lib/expressir/model/where.rb

@@ -1,11 +1,13 @@
 module Expressir
   module Model
     class Where
-      attr_accessor :id
+      include Identifier
+
       attr_accessor :expression
 
       def initialize(options = {})
         @id = options[:id]
+
         @expression = options[:expression]
       end
     end

data/lib/expressir/version.rb

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

data/original/examples/syntax/remark.exp

@@ -0,0 +1,145 @@
+(*"remark_schema"
+Any character within the EXPRESS character set may occur between the start and end of
+an embedded remark including the newline character; therefore, embedded remarks can span
+several physical lines.
+*)
+--"remark_schema" The tail remark is written at the end of a physical line.
+
+--"remark_schema" universal scope - schema before
+
+SCHEMA remark_schema;
+
+CONSTANT remark_constant : STRING := 'xxx'; END_CONSTANT;
+TYPE remark_type = ENUMERATION OF (remark_enumeration_item); END_TYPE;
+ENTITY remark_entity;
+  remark_attribute : STRING;
+  DERIVE remark_derived_attribute : STRING := 'xxx';
+  INVERSE remark_inverse_attribute : remark_entity FOR remark_attribute;
+  UNIQUE remark_unique : remark_attribute;
+  WHERE remark_where : TRUE;
+  --"remark_attribute" entity scope - entity attribute
+  --"remark_derived_attribute" entity scope - entity derived attribute
+  --"remark_inverse_attribute" entity scope - entity inverse attribute
+  --"remark_unique" entity scope - entity unique
+  --"remark_where" entity scope - entity where
+END_ENTITY;
+SUBTYPE_CONSTRAINT remark_subtype_constraint FOR remark_entity; END_SUBTYPE_CONSTRAINT;
+FUNCTION remark_function(remark_parameter : STRING) : BOOLEAN;
+  TYPE remark_type = ENUMERATION OF (remark_enumeration_item); END_TYPE;
+  CONSTANT remark_constant : STRING := 'xxx'; END_CONSTANT;
+  LOCAL remark_variable : STRING; END_LOCAL;
+  ALIAS remark_alias FOR remark_variable; ;
+    --"remark_alias" function alias scope - function alias
+  END_ALIAS;
+  REPEAT remark_repeat := 1 TO 9; ;
+    --"remark_repeat" function repeat scope - function repeat
+  END_REPEAT;
+  remark_variable := QUERY(remark_query <* remark_variable | TRUE
+    --"remark_query" function query scope - function query
+  );
+  --"remark_parameter" function scope - function parameter
+  --"remark_type" function scope - function type
+  --"remark_enumeration_item" function scope - function enumeration item
+  --"remark_constant" function scope - function constant
+  --"remark_variable" function scope - function variable
+END_FUNCTION;
+PROCEDURE remark_procedure(remark_parameter : STRING);
+  TYPE remark_type = ENUMERATION OF (remark_enumeration_item); END_TYPE;
+  CONSTANT remark_constant : STRING := 'xxx'; END_CONSTANT;
+  LOCAL remark_variable : STRING; END_LOCAL;
+  ALIAS remark_alias FOR remark_variable; ;
+    --"remark_alias" procedure alias scope - procedure alias
+  END_ALIAS;
+  REPEAT remark_repeat := 1 TO 9; ;
+    --"remark_repeat" procedure repeat scope - procedure repeat
+  END_REPEAT;
+  remark_variable := QUERY(remark_query <* remark_variable | TRUE
+    --"remark_query" procedure query scope - procedure query
+  );
+  --"remark_parameter" procedure scope - procedure parameter
+  --"remark_type" procedure scope - procedure type
+  --"remark_enumeration_item" procedure scope - procedure enumeration item
+  --"remark_constant" procedure scope - procedure constant
+  --"remark_variable" procedure scope - procedure variable
+END_PROCEDURE;
+RULE remark_rule FOR (remark_entity);
+  TYPE remark_type = ENUMERATION OF (remark_enumeration_item); END_TYPE;
+  CONSTANT remark_constant : STRING := 'xxx'; END_CONSTANT;
+  LOCAL remark_variable : STRING; END_LOCAL;
+  ALIAS remark_alias FOR remark_variable; ;
+    --"remark_alias" rule alias scope - rule alias
+  END_ALIAS;
+  REPEAT remark_repeat := 1 TO 9; ;
+    --"remark_repeat" rule repeat scope - rule repeat
+  END_REPEAT;
+  remark_variable := QUERY(remark_query <* remark_variable | TRUE
+    --"remark_query" rule query scope - rule query
+  );
+  WHERE remark_where : TRUE;
+  --"remark_type" rule scope - rule type
+  --"remark_enumeration_item" rule scope - rule enumeration item
+  --"remark_constant" rule scope - rule constant
+  --"remark_variable" rule scope - rule variable
+  --"remark_where" rule scope - rule where
+END_RULE;
+
+--"remark_constant" schema scope - constant
+--"remark_type" schema scope - type
+--"remark_enumeration_item" schema scope - enumeration item
+--"remark_entity" schema scope - entity
+--"remark_entity.remark_attribute" schema scope - entity attribute
+--"remark_entity.remark_derived_attribute" schema scope - entity derived attribute
+--"remark_entity.remark_inverse_attribute" schema scope - entity inverse attribute
+--"remark_entity.remark_unique" schema scope - entity unique
+--"remark_entity.remark_where" schema scope - entity where
+--"remark_subtype_constraint" schema scope - subtype constraint
+--"remark_function" schema scope - function
+--"remark_function.remark_parameter" schema scope - function parameter
+--"remark_function.remark_type" schema scope - function type
+--"remark_function.remark_enumeration_item" schema scope - function enumeration item
+--"remark_function.remark_constant" schema scope - function constant
+--"remark_function.remark_variable" schema scope - function variable
+--"remark_procedure" schema scope - procedure
+--"remark_procedure.remark_parameter" schema scope - procedure parameter
+--"remark_procedure.remark_type" schema scope - procedure type
+--"remark_procedure.remark_enumeration_item" schema scope - procedure enumeration item
+--"remark_procedure.remark_constant" schema scope - procedure constant
+--"remark_procedure.remark_variable" schema scope - procedure variable
+--"remark_rule" schema scope - rule
+--"remark_rule.remark_type" schema scope - rule type
+--"remark_rule.remark_enumeration_item" schema scope - rule enumeration item
+--"remark_rule.remark_constant" schema scope - rule constant
+--"remark_rule.remark_variable" schema scope - rule variable
+--"remark_rule.remark_where" schema scope - rule where
+
+END_SCHEMA;
+
+--"remark_schema" universal scope - schema
+--"remark_schema.remark_constant" universal scope - constant
+--"remark_schema.remark_type" universal scope - type
+--"remark_schema.remark_enumeration_item" universal scope - enumeration item
+--"remark_schema.remark_entity" universal scope - entity
+--"remark_schema.remark_entity.remark_attribute" universal scope - entity attribute
+--"remark_schema.remark_entity.remark_derived_attribute" universal scope - entity derived attribute
+--"remark_schema.remark_entity.remark_inverse_attribute" universal scope - entity inverse attribute
+--"remark_schema.remark_entity.remark_unique" universal scope - entity unique
+--"remark_schema.remark_entity.remark_where" universal scope - entity where
+--"remark_schema.remark_subtype_constraint" universal scope - subtype constraint
+--"remark_schema.remark_function" universal scope - function
+--"remark_schema.remark_function.remark_parameter" universal scope - function parameter
+--"remark_schema.remark_function.remark_type" universal scope - function type
+--"remark_schema.remark_function.remark_enumeration_item" universal scope - function enumeration item
+--"remark_schema.remark_function.remark_constant" universal scope - function constant
+--"remark_schema.remark_function.remark_variable" universal scope - function variable
+--"remark_schema.remark_procedure" universal scope - procedure
+--"remark_schema.remark_procedure.remark_parameter" universal scope - procedure parameter
+--"remark_schema.remark_procedure.remark_type" universal scope - procedure type
+--"remark_schema.remark_procedure.remark_enumeration_item" universal scope - procedure enumeration item
+--"remark_schema.remark_procedure.remark_constant" universal scope - procedure constant
+--"remark_schema.remark_procedure.remark_variable" universal scope - procedure variable
+--"remark_schema.remark_rule" universal scope - rule
+--"remark_schema.remark_rule.remark_type" universal scope - rule type
+--"remark_schema.remark_rule.remark_enumeration_item" universal scope - rule enumeration item
+--"remark_schema.remark_rule.remark_constant" universal scope - rule constant
+--"remark_schema.remark_rule.remark_variable" universal scope - rule variable
+--"remark_schema.remark_rule.remark_where" universal scope - rule where

data/original/examples/syntax/remark_formatted.exp

@@ -0,0 +1,174 @@
+SCHEMA remark_schema;
+CONSTANT
+  remark_constant : STRING := 'xxx';
+END_CONSTANT;
+TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
+END_TYPE;
+
+ENTITY remark_entity;
+  remark_attribute : STRING;
+  DERIVE
+    remark_derived_attribute : STRING := 'xxx';
+  INVERSE
+    remark_inverse_attribute : remark_entity FOR remark_attribute;
+  UNIQUE
+    remark_unique : remark_attribute;
+  WHERE
+    remark_where : TRUE;
+END_ENTITY;
+
+SUBTYPE_CONSTRAINT remark_subtype_constraint FOR remark_entity;
+END_SUBTYPE_CONSTRAINT;
+
+FUNCTION remark_function(remark_parameter : STRING) : BOOLEAN;
+  TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
+  END_TYPE;
+  CONSTANT
+    remark_constant : STRING := 'xxx';
+  END_CONSTANT;
+  LOCAL
+    remark_variable : STRING;
+  END_LOCAL;
+  ALIAS remark_alias FOR remark_variable;
+    ;
+  --"remark_alias" function alias scope - function alias
+  END_ALIAS;
+  REPEAT remark_repeat := 1 TO 9;
+    ;
+  --"remark_repeat" function repeat scope - function repeat
+  END_REPEAT;
+  remark_variable := QUERY(remark_query <* remark_variable | TRUE
+  --"remark_query" function query scope - function query
+  );
+END_FUNCTION;
+
+PROCEDURE remark_procedure(remark_parameter : STRING);
+  TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
+  END_TYPE;
+  CONSTANT
+    remark_constant : STRING := 'xxx';
+  END_CONSTANT;
+  LOCAL
+    remark_variable : STRING;
+  END_LOCAL;
+  ALIAS remark_alias FOR remark_variable;
+    ;
+  --"remark_alias" procedure alias scope - procedure alias
+  END_ALIAS;
+  REPEAT remark_repeat := 1 TO 9;
+    ;
+  --"remark_repeat" procedure repeat scope - procedure repeat
+  END_REPEAT;
+  remark_variable := QUERY(remark_query <* remark_variable | TRUE
+  --"remark_query" procedure query scope - procedure query
+  );
+END_PROCEDURE;
+
+RULE remark_rule FOR (remark_entity);
+  TYPE remark_type = ENUMERATION OF (remark_enumeration_item);
+  END_TYPE;
+  CONSTANT
+    remark_constant : STRING := 'xxx';
+  END_CONSTANT;
+  LOCAL
+    remark_variable : STRING;
+  END_LOCAL;
+  ALIAS remark_alias FOR remark_variable;
+    ;
+  --"remark_alias" rule alias scope - rule alias
+  END_ALIAS;
+  REPEAT remark_repeat := 1 TO 9;
+    ;
+  --"remark_repeat" rule repeat scope - rule repeat
+  END_REPEAT;
+  remark_variable := QUERY(remark_query <* remark_variable | TRUE
+  --"remark_query" rule query scope - rule query
+  );
+  WHERE
+    remark_where : TRUE;
+END_RULE;
+END_SCHEMA;
+(*"remark_schema"
+Any character within the EXPRESS character set may occur between the start and end of
+an embedded remark including the newline character; therefore, embedded remarks can span
+several physical lines.
+*)
+--"remark_schema" The tail remark is written at the end of a physical line.
+--"remark_schema" universal scope - schema before
+--"remark_schema" universal scope - schema
+--"remark_schema.remark_constant" schema scope - constant
+--"remark_schema.remark_constant" universal scope - constant
+--"remark_schema.remark_type" schema scope - type
+--"remark_schema.remark_type" universal scope - type
+--"remark_schema.remark_enumeration_item" schema scope - enumeration item
+--"remark_schema.remark_enumeration_item" universal scope - enumeration item
+--"remark_schema.remark_entity" schema scope - entity
+--"remark_schema.remark_entity" universal scope - entity
+--"remark_schema.remark_entity.remark_attribute" entity scope - entity attribute
+--"remark_schema.remark_entity.remark_attribute" schema scope - entity attribute
+--"remark_schema.remark_entity.remark_attribute" universal scope - entity attribute
+--"remark_schema.remark_entity.remark_derived_attribute" entity scope - entity derived attribute
+--"remark_schema.remark_entity.remark_derived_attribute" schema scope - entity derived attribute
+--"remark_schema.remark_entity.remark_derived_attribute" universal scope - entity derived attribute
+--"remark_schema.remark_entity.remark_inverse_attribute" entity scope - entity inverse attribute
+--"remark_schema.remark_entity.remark_inverse_attribute" schema scope - entity inverse attribute
+--"remark_schema.remark_entity.remark_inverse_attribute" universal scope - entity inverse attribute
+--"remark_schema.remark_entity.remark_unique" entity scope - entity unique
+--"remark_schema.remark_entity.remark_unique" schema scope - entity unique
+--"remark_schema.remark_entity.remark_unique" universal scope - entity unique
+--"remark_schema.remark_entity.remark_where" entity scope - entity where
+--"remark_schema.remark_entity.remark_where" schema scope - entity where
+--"remark_schema.remark_entity.remark_where" universal scope - entity where
+--"remark_schema.remark_subtype_constraint" schema scope - subtype constraint
+--"remark_schema.remark_subtype_constraint" universal scope - subtype constraint
+--"remark_schema.remark_function" schema scope - function
+--"remark_schema.remark_function" universal scope - function
+--"remark_schema.remark_function.remark_parameter" function scope - function parameter
+--"remark_schema.remark_function.remark_parameter" schema scope - function parameter
+--"remark_schema.remark_function.remark_parameter" universal scope - function parameter
+--"remark_schema.remark_function.remark_type" function scope - function type
+--"remark_schema.remark_function.remark_type" schema scope - function type
+--"remark_schema.remark_function.remark_type" universal scope - function type
+--"remark_schema.remark_function.remark_enumeration_item" function scope - function enumeration item
+--"remark_schema.remark_function.remark_enumeration_item" schema scope - function enumeration item
+--"remark_schema.remark_function.remark_enumeration_item" universal scope - function enumeration item
+--"remark_schema.remark_function.remark_constant" function scope - function constant
+--"remark_schema.remark_function.remark_constant" schema scope - function constant
+--"remark_schema.remark_function.remark_constant" universal scope - function constant
+--"remark_schema.remark_function.remark_variable" function scope - function variable
+--"remark_schema.remark_function.remark_variable" schema scope - function variable
+--"remark_schema.remark_function.remark_variable" universal scope - function variable
+--"remark_schema.remark_procedure" schema scope - procedure
+--"remark_schema.remark_procedure" universal scope - procedure
+--"remark_schema.remark_procedure.remark_parameter" procedure scope - procedure parameter
+--"remark_schema.remark_procedure.remark_parameter" schema scope - procedure parameter
+--"remark_schema.remark_procedure.remark_parameter" universal scope - procedure parameter
+--"remark_schema.remark_procedure.remark_type" procedure scope - procedure type
+--"remark_schema.remark_procedure.remark_type" schema scope - procedure type
+--"remark_schema.remark_procedure.remark_type" universal scope - procedure type
+--"remark_schema.remark_procedure.remark_enumeration_item" procedure scope - procedure enumeration item
+--"remark_schema.remark_procedure.remark_enumeration_item" schema scope - procedure enumeration item
+--"remark_schema.remark_procedure.remark_enumeration_item" universal scope - procedure enumeration item
+--"remark_schema.remark_procedure.remark_constant" procedure scope - procedure constant
+--"remark_schema.remark_procedure.remark_constant" schema scope - procedure constant
+--"remark_schema.remark_procedure.remark_constant" universal scope - procedure constant
+--"remark_schema.remark_procedure.remark_variable" procedure scope - procedure variable
+--"remark_schema.remark_procedure.remark_variable" schema scope - procedure variable
+--"remark_schema.remark_procedure.remark_variable" universal scope - procedure variable
+--"remark_schema.remark_rule" schema scope - rule
+--"remark_schema.remark_rule" universal scope - rule
+--"remark_schema.remark_rule.remark_type" rule scope - rule type
+--"remark_schema.remark_rule.remark_type" schema scope - rule type
+--"remark_schema.remark_rule.remark_type" universal scope - rule type
+--"remark_schema.remark_rule.remark_enumeration_item" rule scope - rule enumeration item
+--"remark_schema.remark_rule.remark_enumeration_item" schema scope - rule enumeration item
+--"remark_schema.remark_rule.remark_enumeration_item" universal scope - rule enumeration item
+--"remark_schema.remark_rule.remark_constant" rule scope - rule constant
+--"remark_schema.remark_rule.remark_constant" schema scope - rule constant
+--"remark_schema.remark_rule.remark_constant" universal scope - rule constant
+--"remark_schema.remark_rule.remark_variable" rule scope - rule variable
+--"remark_schema.remark_rule.remark_variable" schema scope - rule variable
+--"remark_schema.remark_rule.remark_variable" universal scope - rule variable
+--"remark_schema.remark_rule.remark_where" rule scope - rule where
+--"remark_schema.remark_rule.remark_where" schema scope - rule where
+--"remark_schema.remark_rule.remark_where" universal scope - rule where