expressir 0.2.16-x86-mingw32 → 0.2.17-x86-mingw32

data/lib/expressir/express_exp/parser.rb

@@ -6,54 +6,54 @@ rescue LoadError
 end
 require 'expressir/express_exp/visitor'
 
-module Expressir
-  module ExpressExp
-    class Parser
-      def self.from_file(file)
-        input = File.read(file)
-
 =begin
-        char_stream = Antlr4::Runtime::CharStreams.from_string(input, 'String')
-        lexer = ::ExpressParser::Lexer.new(char_stream)
-        token_stream = Antlr4::Runtime::CommonTokenStream.new(lexer)
-        parser = ::ExpressParser::Parser.new(token_stream)
+char_stream = Antlr4::Runtime::CharStreams.from_string(input, 'String')
+lexer = ::ExpressParser::Lexer.new(char_stream)
+token_stream = Antlr4::Runtime::CommonTokenStream.new(lexer)
+parser = ::ExpressParser::Parser.new(token_stream)
 
-        # don't attempt to recover from any parsing error
-        parser.instance_variable_set(:@_err_handler, Antlr4::Runtime::BailErrorStrategy.new)
+# don't attempt to recover from any parsing error
+parser.instance_variable_set(:@_err_handler, Antlr4::Runtime::BailErrorStrategy.new)
 
-        parse_tree = parser.syntax()
+parse_tree = parser.syntax()
 
-        visitor = Visitor.new(token_stream)
-        repo = visitor.visit(parse_tree)
+visitor = Visitor.new(token_stream)
+repo = visitor.visit(parse_tree)
 =end
 
+module Expressir
+  module ExpressExp
+    class Parser
+      def self.from_file(file, options = {})
+        input = File.read(file)
+
         parser = ::ExpressParser::Parser.parse(input)
 
         parse_tree = parser.syntax()
 
-        visitor = Visitor.new(parser.tokens)
-        repo = visitor.visit(parse_tree)
+        visitor = Visitor.new(parser.tokens, options)
+        repository = visitor.visit(parse_tree)
 
-        repo.schemas.each{|schema| schema.file = file}
+        repository.schemas.each{|schema| schema.file = file}
 
-        repo
+        repository
       end
 
-      def self.from_files(files)
-        schemas = files.map{|file| self.from_file(file).schemas}.flatten
+      def self.from_files(files, options = {})
+        schemas = files.each_with_index.map do |file, i|
+          # start = Time.now
+          repository = self.from_file(file, options)
+          # STDERR.puts "#{i+1}/#{files.length} #{file} #{Time.now - start}"
+          repository.schemas
+        end.flatten
 
-        repo = Model::Repository.new({
+        repository = Model::Repository.new({
           schemas: schemas
         })
 
-        repo.schemas.each{|schema| schema.parent = repo}
-
-        repo
-      end
+        repository.schemas.each{|schema| schema.parent = repository}
 
-      # deprecated
-      def self.from_exp(file)
-        self.from_file(file)
+        repository
       end
     end
   end

data/lib/expressir/express_exp/schema_head_formatter.rb

@@ -2,10 +2,7 @@ module Expressir
   module ExpressExp
     module SchemaHeadFormatter
       def format_schema(node)
-        [
-          "SCHEMA #{node.id}#{node.version ? " #{format(node.version)}" : ""};",
-          *node.interfaces.map{|x| format(x)}
-        ].join("\n")
+        format_schema_head(node)
       end
     end
   end

data/lib/expressir/express_exp/visitor.rb

@@ -36,8 +36,10 @@ module Expressir
     class Visitor < ::ExpressParser::Visitor
       REMARK_CHANNEL = 2
 
-      def initialize(tokens)
+      def initialize(tokens, options = {})
         @tokens = tokens
+        @include_source = options[:include_source]
+
         @attached_remark_tokens = ::Set.new
 
         super()
@@ -45,7 +47,9 @@ module Expressir
 
       def visit(ctx)
         node = super(ctx)
-        attach_source(ctx, node)
+        if @include_source
+          attach_source(ctx, node)
+        end
         attach_remarks(ctx, node)
         node
       end
@@ -121,6 +125,7 @@ module Expressir
           id: informal_proposition_id
         })
         target_node.informal_propositions << informal_proposition
+        target_node.reset_children_by_id
         informal_proposition.parent = target_node
         informal_proposition
       end
@@ -1925,8 +1930,8 @@ module Expressir
         entities = declarations.select{|x| x.is_a? Model::Entity}
         subtype_constraints = declarations.select{|x| x.is_a? Model::SubtypeConstraint}
         functions = declarations.select{|x| x.is_a? Model::Function}
-        procedures = declarations.select{|x| x.is_a? Model::Procedure}
         rules = declarations.select{|x| x.is_a? Model::Rule}
+        procedures = declarations.select{|x| x.is_a? Model::Procedure}
 
         Model::Schema.new({
           id: id,
@@ -1937,8 +1942,8 @@ module Expressir
           entities: entities,
           subtype_constraints: subtype_constraints,
           functions: functions,
-          procedures: procedures,
-          rules: rules
+          rules: rules,
+          procedures: procedures
         })
       end
 
@@ -2149,7 +2154,7 @@ module Expressir
         id = visit_if(ctx__subtype_constraint_head__subtype_constraint_id)
         applies_to = visit_if(ctx__subtype_constraint_head__entity_ref)
         abstract = ctx__subtype_constraint_body__abstract_supertype && true
-        total_over = visit_if(ctx__subtype_constraint_body__total_over)
+        total_over = visit_if(ctx__subtype_constraint_body__total_over, [])
         supertype_expression = visit_if(ctx__subtype_constraint_body__supertype_expression)
 
         Model::SubtypeConstraint.new({

data/lib/expressir/model/entity.rb

@@ -28,12 +28,12 @@ module Expressir
       end
 
       def children
-        items = []
-        items.push(*@attributes)
-        items.push(*@unique)
-        items.push(*@where)
-        items.push(*@informal_propositions)
-        items
+        [
+          *attributes,
+          *unique,
+          *where,
+          *informal_propositions
+        ]
       end
     end
   end

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

@@ -19,9 +19,9 @@ module Expressir
         end
 
         def children
-          items = []
-          items.push(self)
-          items
+          [
+            self
+          ]
         end
       end
     end

data/lib/expressir/model/function.rb

@@ -33,18 +33,22 @@ module Expressir
         super
       end
 
+      def enumeration_items
+        types.flat_map{|x| x.enumeration_items}
+      end
+
       def children
-        items = []
-        items.push(*@parameters)
-        items.push(*@types)
-        items.push(*@types.flat_map{|x| x.type.is_a?(Types::Enumeration) ? x.type.items : []})
-        items.push(*@entities)
-        items.push(*@subtype_constraints)
-        items.push(*@functions)
-        items.push(*@procedures)
-        items.push(*@constants)
-        items.push(*@variables)
-        items
+        [
+          *parameters,
+          *types,
+          *enumeration_items,
+          *entities,
+          *subtype_constraints,
+          *functions,
+          *procedures,
+          *constants,
+          *variables
+        ]
       end
     end
   end

data/lib/expressir/model/informal_proposition.rb

@@ -3,10 +3,13 @@ module Expressir
     class InformalProposition < ModelElement
       include Identifier
 
+      undef :source
+      undef :source=
+
       def initialize(options = {})
         @id = options[:id]
         @remarks = options.fetch(:remarks, [])
-        @source = options[:source]
+        # @source = options[:source]
 
         super
       end

data/lib/expressir/model/interfaced_item.rb

@@ -3,12 +3,15 @@ module Expressir
     class InterfacedItem < ModelElement
       include Identifier
 
+      undef :source
+      undef :source=
+
       attr_accessor :base_item
 
       def initialize(options = {})
         @id = options[:id]
         @remarks = options.fetch(:remarks, [])
-        @source = options[:source]
+        # @source = options[:source]
 
         @base_item = options[:base_item]
 

data/lib/expressir/model/model_element.rb

@@ -10,6 +10,10 @@ module Expressir
         attach_parent_to_children
       end
 
+      def model_instance_variables
+        instance_variables.select{|x| x != :@file && x != :@parent && x != :@children_by_id}
+      end
+
       def path
         return id if is_a? Statements::Alias or is_a? Statements::Repeat or is_a? Expressions::QueryExpression
 
@@ -28,7 +32,7 @@ module Expressir
       end
 
       def attach_parent_to_children
-        instance_variables.select{|x| x != :@parent}.each do |variable|
+        model_instance_variables.each do |variable|
           value = instance_variable_get(variable)
 
           if value.is_a? Array
@@ -57,7 +61,7 @@ module Expressir
           # find in current scope
           current_node = current_scope
           path_parts.each do |current_path|
-            current_node = current_node.children.find{|x| x.id and x.id.downcase == current_path}
+            current_node = current_node.children_by_id[current_path]
             break unless current_node
           end
           target_node = current_node
@@ -75,19 +79,28 @@ module Expressir
         []
       end
 
+      def children_by_id
+        @children_by_id ||= children.select{|x| x.id}.map{|x| [x.id.downcase, x]}.to_h
+      end
+
+      def reset_children_by_id
+        @children_by_id = nil
+      end
+
       def to_hash(options = {})
-        skip_empty = options[:skip_empty]
+        include_empty = options[:include_empty] || !options[:skip_empty] # TODO: remove skip_empty
         formatter = options[:formatter]
 
         hash = {}
         hash[CLASS_KEY] = self.class.name
 
-        instance_variables.select{|x| x != :@parent}.each_with_object(hash) do |variable, result|
+        model_instance_variables.each_with_object(hash) do |variable, result|
           key = variable.to_s.sub(/^@/, '')
           value = instance_variable_get(variable)
+          empty = value.nil? || (value.is_a?(Array) && value.count == 0)
 
-          # skip empty values (nil, empty array)
-          if !skip_empty or !(value.nil? or (value.is_a? Array and value.count == 0))
+          # skip empty values
+          if !empty or include_empty
             result[key] = if value.is_a? Array
               value.map do |value|
                 if value.is_a? ModelElement
@@ -104,7 +117,7 @@ module Expressir
           end
         end
 
-        if formatter
+        if self.class.method_defined? :source and formatter
           hash[SOURCE_KEY] = formatter.format(self)
         end
 

data/lib/expressir/model/procedure.rb

@@ -31,18 +31,22 @@ module Expressir
         super
       end
 
+      def enumeration_items
+        types.flat_map{|x| x.enumeration_items}
+      end
+
       def children
-        items = []
-        items.push(*@parameters)
-        items.push(*@types)
-        items.push(*@types.flat_map{|x| x.type.is_a?(Types::Enumeration) ? x.type.items : []})
-        items.push(*@entities)
-        items.push(*@subtype_constraints)
-        items.push(*@functions)
-        items.push(*@procedures)
-        items.push(*@constants)
-        items.push(*@variables)
-        items
+        [
+          *parameters,
+          *types,
+          *enumeration_items,
+          *entities,
+          *subtype_constraints,
+          *functions,
+          *procedures,
+          *constants,
+          *variables
+        ]
       end
     end
   end

data/lib/expressir/model/repository.rb

@@ -10,9 +10,9 @@ module Expressir
       end
 
       def children
-        items = []
-        items.push(*@schemas)
-        items
+        [
+          *schemas
+        ]
       end
     end
   end

data/lib/expressir/model/rule.rb

@@ -35,19 +35,23 @@ module Expressir
         super
       end
 
+      def enumeration_items
+        types.flat_map{|x| x.enumeration_items}
+      end
+
       def children
-        items = []
-        items.push(*@types)
-        items.push(*@types.flat_map{|x| x.type.is_a?(Types::Enumeration) ? x.type.items : []})
-        items.push(*@entities)
-        items.push(*@subtype_constraints)
-        items.push(*@functions)
-        items.push(*@procedures)
-        items.push(*@constants)
-        items.push(*@variables)
-        items.push(*@where)
-        items.push(*@informal_propositions)
-        items
+        [
+          *types,
+          *enumeration_items,
+          *entities,
+          *subtype_constraints,
+          *functions,
+          *procedures,
+          *constants,
+          *variables,
+          *where,
+          *informal_propositions
+        ]
       end
     end
   end

data/lib/expressir/model/schema.rb

@@ -12,8 +12,8 @@ module Expressir
       attr_accessor :entities
       attr_accessor :subtype_constraints
       attr_accessor :functions
-      attr_accessor :procedures
       attr_accessor :rules
+      attr_accessor :procedures
 
       def initialize(options = {})
         @file = options[:file]
@@ -29,60 +29,67 @@ module Expressir
         @entities = options.fetch(:entities, [])
         @subtype_constraints = options.fetch(:subtype_constraints, [])
         @functions = options.fetch(:functions, [])
-        @procedures = options.fetch(:procedures, [])
         @rules = options.fetch(:rules, [])
+        @procedures = options.fetch(:procedures, [])
 
         super
       end
 
-      def children(skip_references = false)
-        items = []
-        unless skip_references
-          items.push(*@interfaces.flat_map do |interface|
-            schema_id = interface.schema.id.downcase
-            schema = parent.schemas.find{|x| x.id.downcase == schema_id}
-            if schema
-              schema_children = schema.children(true) # prevent infinite recursion
-              if interface.items.length > 0
-                interface.items.map do |item|
-                  ref_id = item.ref.id.downcase
-                  id = item.id || ref_id
-                  base_item = schema_children.find{|x| x.id and x.id.downcase == ref_id}
-
-                  interfaced_item = InterfacedItem.new({
-                    id: id
-                  })
-                  interfaced_item.base_item = base_item # skip overriding parent
-                  interfaced_item.parent = self
-                  interfaced_item
-                end
-              else
-                schema_children.map do |item|
-                  id = item.id
-                  base_item = item
+      def create_interfaced_item(id, base_item)
+        interfaced_item = InterfacedItem.new({
+          id: id
+        })
+        interfaced_item.base_item = base_item # skip overriding parent
+        interfaced_item.parent = self
+        interfaced_item
+      end
 
-                  interfaced_item = InterfacedItem.new({
-                    id: id
-                  })
-                  interfaced_item.base_item = base_item # skip overriding parent
-                  interfaced_item.parent = self
-                  interfaced_item
+      def interfaced_items
+        interfaces.flat_map do |interface|
+          schema = parent.children_by_id[interface.schema.id.downcase]
+          if schema
+            schema_safe_children = schema.safe_children
+            schema_safe_children_by_id = schema_safe_children.select{|x| x.id}.map{|x| [x.id.downcase, x]}.to_h
+            if interface.items.length > 0
+              interface.items.map do |interface_item|
+                base_item = schema_safe_children_by_id[interface_item.ref.id.downcase]
+                if base_item
+                  id = interface_item.id || base_item.id
+                  create_interfaced_item(id, base_item)
                 end
               end
             else
-              []
+              schema_safe_children.map do |base_item|
+                id = base_item.id
+                create_interfaced_item(id, base_item)
+              end
             end
-          end)
-        end
-        items.push(*@constants)
-        items.push(*@types)
-        items.push(*@types.flat_map{|x| x.type.is_a?(Types::Enumeration) ? x.type.items : []})
-        items.push(*@entities)
-        items.push(*@subtype_constraints)
-        items.push(*@functions)
-        items.push(*@procedures)
-        items.push(*@rules)
-        items
+          end
+        end.select{|x| x}
+      end
+
+      def enumeration_items
+        types.flat_map{|x| x.enumeration_items}
+      end
+
+      def safe_children
+        [
+          *constants,
+          *types,
+          *enumeration_items,
+          *entities,
+          *subtype_constraints,
+          *functions,
+          *rules,
+          *procedures
+        ]
+      end
+
+      def children
+        [
+          *interfaced_items,
+          *safe_children
+        ]
       end
     end
   end