expressir 0.2.2 → 0.2.7

data/lib/expressir/model.rb

@@ -1,15 +1,14 @@
+require 'expressir/model/scope'
+require 'expressir/model/identifier'
+
+require 'expressir/model/attribute'
 require 'expressir/model/constant'
-require 'expressir/model/derived'
 require 'expressir/model/entity'
 require 'expressir/model/enumeration_item'
-require 'expressir/model/explicit'
 require 'expressir/model/function'
-require 'expressir/model/inverse'
-require 'expressir/model/local'
+require 'expressir/model/interface'
 require 'expressir/model/parameter'
 require 'expressir/model/procedure'
-require 'expressir/model/ref'
-require 'expressir/model/reference'
 require 'expressir/model/renamed_ref'
 require 'expressir/model/repository'
 require 'expressir/model/rule'
@@ -17,59 +16,34 @@ require 'expressir/model/schema'
 require 'expressir/model/subtype_constraint'
 require 'expressir/model/type'
 require 'expressir/model/unique'
-require 'expressir/model/use'
+require 'expressir/model/variable'
 require 'expressir/model/where'
 require 'expressir/model/expressions/aggregate_initializer'
-require 'expressir/model/expressions/aggregate_element'
-require 'expressir/model/expressions/attribute_qualifier'
+require 'expressir/model/expressions/aggregate_item'
+require 'expressir/model/expressions/binary_expression'
+require 'expressir/model/expressions/call'
+require 'expressir/model/expressions/attribute_reference'
 require 'expressir/model/expressions/entity_constructor'
-require 'expressir/model/expressions/expression'
-require 'expressir/model/expressions/function_call'
-require 'expressir/model/expressions/group_qualifier'
-require 'expressir/model/expressions/index_qualifier'
+require 'expressir/model/expressions/group_reference'
+require 'expressir/model/expressions/index_reference'
 require 'expressir/model/expressions/interval'
-require 'expressir/model/expressions/qualified_ref'
-require 'expressir/model/expressions/query'
+require 'expressir/model/expressions/query_expression'
+require 'expressir/model/expressions/simple_reference'
+require 'expressir/model/expressions/unary_expression'
 require 'expressir/model/literals/binary'
 require 'expressir/model/literals/integer'
 require 'expressir/model/literals/logical'
 require 'expressir/model/literals/real'
 require 'expressir/model/literals/string'
-require 'expressir/model/operators/addition'
-require 'expressir/model/operators/and'
-require 'expressir/model/operators/andor'
-require 'expressir/model/operators/combine'
-require 'expressir/model/operators/equal'
-require 'expressir/model/operators/exponentiation'
-require 'expressir/model/operators/greater_than'
-require 'expressir/model/operators/greater_than_or_equal'
-require 'expressir/model/operators/in'
-require 'expressir/model/operators/instance_equal'
-require 'expressir/model/operators/instance_not_equal'
-require 'expressir/model/operators/integer_division'
-require 'expressir/model/operators/less_than'
-require 'expressir/model/operators/less_than_or_equal'
-require 'expressir/model/operators/like'
-require 'expressir/model/operators/modulo'
-require 'expressir/model/operators/multiplication'
-require 'expressir/model/operators/not'
-require 'expressir/model/operators/not_equal'
-require 'expressir/model/operators/oneof'
-require 'expressir/model/operators/or'
-require 'expressir/model/operators/real_division'
-require 'expressir/model/operators/subtraction'
-require 'expressir/model/operators/unary_plus'
-require 'expressir/model/operators/unary_minus'
-require 'expressir/model/operators/xor'
 require 'expressir/model/statements/alias'
 require 'expressir/model/statements/assignment'
+require 'expressir/model/statements/call'
 require 'expressir/model/statements/case'
 require 'expressir/model/statements/case_action'
 require 'expressir/model/statements/compound'
 require 'expressir/model/statements/escape'
 require 'expressir/model/statements/if'
 require 'expressir/model/statements/null'
-require 'expressir/model/statements/procedure_call'
 require 'expressir/model/statements/repeat'
 require 'expressir/model/statements/return'
 require 'expressir/model/statements/skip'

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

@@ -1,18 +1,26 @@
 module Expressir
   module Model
-    class Derived
-      attr_accessor :id
+    class Attribute
+      include Identifier
+
+      EXPLICIT = :EXPLICIT
+      DERIVED = :DERIVED
+      INVERSE = :INVERSE
+
+      attr_accessor :kind
       attr_accessor :supertype_attribute
+      attr_accessor :optional
       attr_accessor :type
       attr_accessor :expression
-      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
+
+        @kind = options[:kind]
         @supertype_attribute = options[:supertype_attribute]
+        @optional = options[:optional]
         @type = options[:type]
         @expression = options[:expression]
-        @remarks = options[:remarks]
       end
     end
   end

data/lib/expressir/model/constant.rb

@@ -1,16 +1,16 @@
 module Expressir
   module Model
     class Constant
-      attr_accessor :id
+      include Identifier
+
       attr_accessor :type
       attr_accessor :expression
-      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
+
         @type = options[:type]
         @expression = options[:expression]
-        @remarks = options[:remarks]
       end
     end
   end

data/lib/expressir/model/entity.rb

@@ -1,37 +1,42 @@
 module Expressir
   module Model
     class Entity
-      attr_accessor :id
+      include Scope
+      include Identifier
+
       attr_accessor :abstract
-      attr_accessor :abstract_supertype
-      attr_accessor :supertypes
-      attr_accessor :subtype_expression
-      attr_accessor :explicit
-      attr_accessor :derived
-      attr_accessor :inverse
+      attr_accessor :supertype_expression
+      attr_accessor :subtype_of
+      attr_accessor :attributes
       attr_accessor :unique
       attr_accessor :where
-      attr_accessor :remarks
 
       def initialize(options = {})
         @id = options[:id]
+
         @abstract = options[:abstract]
-        @abstract_supertype = options[:abstract_supertype]
-        @supertypes = options[:supertypes]
-        @subtype_expression = options[:subtype_expression]
-        @explicit = options[:explicit]
-        @derived = options[:derived]
-        @inverse = options[:inverse]
+        @supertype_expression = options[:supertype_expression]
+        @subtype_of = options[:subtype_of]
+        @attributes = options[:attributes]
         @unique = options[:unique]
         @where = options[:where]
-        @remarks = options[:remarks]
       end
 
-      def scope_items
+      def explicit_attributes
+        @attributes.select{|x| x.kind == Expressir::Model::Attribute::EXPLICIT}
+      end
+
+      def derived_attributes
+        @attributes.select{|x| x.kind == Expressir::Model::Attribute::DERIVED}
+      end
+
+      def inverse_attributes
+        @attributes.select{|x| x.kind == Expressir::Model::Attribute::INVERSE}
+      end
+
+      def children
         items = []
-        items.push(*@explicit) if @explicit
-        items.push(*@derived) if @derived
-        items.push(*@inverse) if @inverse
+        items.push(*@attributes) if @attributes
         items.push(*@unique) if @unique
         items.push(*@where) if @where
         items

data/lib/expressir/model/enumeration_item.rb

@@ -1,12 +1,10 @@
 module Expressir
   module Model
     class EnumerationItem
-      attr_accessor :id
-      attr_accessor :remarks
+      include Identifier
 
       def initialize(options = {})
         @id = options[:id]
-        @remarks = options[:remarks]
       end
     end
   end

data/lib/expressir/model/expressions/aggregate_initializer.rb

@@ -1,13 +1,13 @@
 module Expressir
-    module Model
-      module Expressions
-        class AggregateInitializer
-          attr_accessor :items
-  
-          def initialize(options = {})
-            @items = options[:items]
-          end
+  module Model
+    module Expressions
+      class AggregateInitializer
+        attr_accessor :items
+
+        def initialize(options = {})
+          @items = options[:items]
         end
       end
     end
-  end
+  end
+end

data/lib/expressir/model/expressions/aggregate_item.rb

@@ -0,0 +1,15 @@
+module Expressir
+  module Model
+    module Expressions
+      class AggregateItem
+        attr_accessor :expression
+        attr_accessor :repetition
+
+        def initialize(options = {})
+          @expression = options[:expression]
+          @repetition = options[:repetition]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/expressions/{attribute_qualifier.rb → attribute_reference.rb}

@@ -1,10 +1,12 @@
 module Expressir
   module Model
     module Expressions
-      class AttributeQualifier
+      class AttributeReference
+        attr_accessor :ref
         attr_accessor :attribute
 
         def initialize(options = {})
+          @ref = options[:ref]
           @attribute = options[:attribute]
         end
       end

data/lib/expressir/model/expressions/binary_expression.rb

@@ -0,0 +1,40 @@
+module Expressir
+  module Model
+    module Expressions
+      class BinaryExpression
+        ADDITION = :ADDITION
+        AND = :AND
+        ANDOR = :ANDOR
+        COMBINE = :COMBINE
+        EQUAL = :EQUAL
+        EXPONENTIATION = :EXPONENTIATION
+        GREATER_THAN = :GREATER_THAN
+        GREATER_THAN_OR_EQUAL = :GREATER_THAN_OR_EQUAL
+        IN = :IN
+        INSTANCE_EQUAL = :INSTANCE_EQUAL
+        INSTANCE_NOT_EQUAL = :INSTANCE_NOT_EQUAL
+        INTEGER_DIVISION = :INTEGER_DIVISION
+        LESS_THAN = :LESS_THAN
+        LESS_THAN_OR_EQUAL = :LESS_THAN_OR_EQUAL
+        LIKE = :LIKE
+        MODULO = :MODULO
+        MULTIPLICATION = :MULTIPLICATION
+        NOT_EQUAL = :NOT_EQUAL
+        OR = :OR
+        REAL_DIVISION = :REAL_DIVISION
+        SUBTRACTION = :SUBTRACTION
+        XOR = :XOR
+
+        attr_accessor :operator
+        attr_accessor :operand1
+        attr_accessor :operand2
+
+        def initialize(options = {})
+          @operator = options[:operator]
+          @operand1 = options[:operand1]
+          @operand2 = options[:operand2]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/expressions/{function_call.rb → call.rb}

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

data/lib/expressir/model/expressions/entity_constructor.rb

@@ -1,15 +1,15 @@
 module Expressir
-    module Model
-      module Expressions
-        class EntityConstructor
-          attr_accessor :entity
-          attr_accessor :parameters
-  
-          def initialize(options = {})
-            @entity = options[:entity]
-            @parameters = options[:parameters]
-          end
+  module Model
+    module Expressions
+      class EntityConstructor
+        attr_accessor :entity
+        attr_accessor :parameters
+
+        def initialize(options = {})
+          @entity = options[:entity]
+          @parameters = options[:parameters]
         end
       end
     end
-  end
+  end
+end

data/lib/expressir/model/expressions/{group_qualifier.rb → group_reference.rb}

@@ -1,10 +1,12 @@
 module Expressir
   module Model
     module Expressions
-      class GroupQualifier
+      class GroupReference
+        attr_accessor :ref
         attr_accessor :entity
 
         def initialize(options = {})
+          @ref = options[:ref]
           @entity = options[:entity]
         end
       end

data/lib/expressir/model/expressions/{index_qualifier.rb → index_reference.rb}

@@ -1,11 +1,13 @@
 module Expressir
   module Model
     module Expressions
-      class IndexQualifier
+      class IndexReference
+        attr_accessor :ref
         attr_accessor :index1
         attr_accessor :index2
 
         def initialize(options = {})
+          @ref = options[:ref]
           @index1 = options[:index1]
           @index2 = options[:index2]
         end

data/lib/expressir/model/expressions/interval.rb

@@ -1,21 +1,21 @@
 module Expressir
-    module Model
-      module Expressions
-        class Interval
-          attr_accessor :low
-          attr_accessor :operator1
-          attr_accessor :item
-          attr_accessor :operator2
-          attr_accessor :high
-  
-          def initialize(options = {})
-            @low = options[:low]
-            @operator1 = options[:operator1]
-            @item = options[:item]
-            @operator2 = options[:operator2]
-            @high = options[:high]
-          end
+  module Model
+    module Expressions
+      class Interval
+        attr_accessor :low
+        attr_accessor :operator1
+        attr_accessor :item
+        attr_accessor :operator2
+        attr_accessor :high
+
+        def initialize(options = {})
+          @low = options[:low]
+          @operator1 = options[:operator1]
+          @item = options[:item]
+          @operator2 = options[:operator2]
+          @high = options[:high]
         end
       end
     end
-  end
+  end
+end

data/lib/expressir/model/expressions/query_expression.rb

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module Expressions
+      class QueryExpression
+        include Scope
+        include Identifier
+
+        attr_accessor :aggregate_source
+        attr_accessor :expression
+
+        def initialize(options = {})
+          @id = options[:id]
+
+          @aggregate_source = options[:aggregate_source]
+          @expression = options[:expression]
+        end
+
+        def children
+          items = []
+          items.push(self)
+          items
+        end
+      end
+    end
+  end
+end