expressir 0.2.15-arm64-darwin → 0.2.21-arm64-darwin

data/lib/expressir/express_exp/hyperlink_formatter.rb

@@ -1,8 +1,6 @@
-require "expressir/express_exp/formatter"
-
 module Expressir
   module ExpressExp
-    class HyperlinkFormatter < Formatter
+    module HyperlinkFormatter
       def format_expressions_simple_reference(node)
         return node.id if node.parent.is_a? Model::Expressions::AttributeReference
 

data/lib/expressir/express_exp/parser.rb

@@ -6,54 +6,58 @@ 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 do |schema|
+          schema.file = file.to_s
+        end
 
-        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 do |schema|
+          schema.parent = repository
+        end
 
-      # deprecated
-      def self.from_exp(file)
-        self.from_file(file)
+        repository
       end
     end
   end

data/lib/expressir/express_exp/schema_head_formatter.rb

@@ -1,13 +1,8 @@
-require "expressir/express_exp/formatter"
-
 module Expressir
   module ExpressExp
-    class SchemaHeadFormatter < Formatter
+    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
@@ -92,35 +96,11 @@ module Expressir
         @tokens[start_index..stop_index]
       end
 
-      def get_head_tokens(ctx)
-        start_index, stop_index = if ctx.is_a? ::ExpressParser::SchemaDeclContext
-          start_index = ctx.start.token_index
-          stop_index = if ctx.schema_body.interface_specification.length > 0
-            ctx.schema_body.interface_specification.last.stop.token_index
-          elsif ctx.schema_version_id
-            ctx.schema_version_id.stop.token_index + 1
-          else
-            ctx.schema_id.stop.token_index + 1
-          end
-
-          [start_index, stop_index]
-        end
-
-        if start_index and stop_index
-          @tokens[start_index..stop_index]
-        end
-      end
-
       def attach_source(ctx, node)
         if node.class.method_defined? :source
           tokens = get_tokens(ctx)
           node.source = get_tokens_source(tokens)
         end
-
-        if node.class.method_defined? :head_source
-          tokens = get_head_tokens(ctx)
-          node.head_source = get_tokens_source(tokens)
-        end
       end
 
       def find_remark_target(node, path)
@@ -145,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
@@ -1949,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,
@@ -1961,8 +1942,8 @@ module Expressir
           entities: entities,
           subtype_constraints: subtype_constraints,
           functions: functions,
-          procedures: procedures,
-          rules: rules
+          rules: rules,
+          procedures: procedures
         })
       end
 
@@ -2173,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.rb

@@ -1,5 +1,7 @@
 require 'expressir/model/model_element'
 
+require 'expressir/model/cache'
+
 require 'expressir/model/identifier'
 
 require 'expressir/model/attribute'

data/lib/expressir/model/cache.rb

@@ -0,0 +1,13 @@
+module Expressir
+  module Model
+    class Cache < ModelElement
+      attr_accessor :version
+      attr_accessor :content
+
+      def initialize(options = {})
+        @version = options[:version]
+        @content = options[:content]
+      end
+    end
+  end
+end

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

@@ -1,7 +1,12 @@
+require 'pathname'
+
 module Expressir
   module Model
     class ModelElement
       CLASS_KEY = '_class'
+      FILE_KEY = 'file'
+      PARENT_KEY = 'parent'
+      CHILDREN_BY_ID_KEY = 'children_by_id'
       SOURCE_KEY = 'source'
 
       attr_accessor :parent
@@ -10,6 +15,11 @@ module Expressir
         attach_parent_to_children
       end
 
+      def model_instance_variables
+        skip_variables = [FILE_KEY, PARENT_KEY, CHILDREN_BY_ID_KEY].map{|x| "@#{x}".to_sym}
+        instance_variables.select{|x| !skip_variables.include?(x)}
+      end
+
       def path
         return id if is_a? Statements::Alias or is_a? Statements::Repeat or is_a? Expressions::QueryExpression
 
@@ -28,7 +38,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 +67,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,20 +85,33 @@ 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]
+        root_path = options[:root_path]
         formatter = options[:formatter]
+        include_empty = options[:include_empty] || !options[:skip_empty] # TODO: remove skip_empty
 
         hash = {}
         hash[CLASS_KEY] = self.class.name
+        if self.is_a? Schema and file
+          hash[FILE_KEY] = root_path ? Pathname.new(file).relative_path_from(root_path).to_s : file
+        end
 
-        instance_variables.select{|x| x != :@parent}.each_with_object(hash) do |variable, result|
+        model_instance_variables.each do |variable|
           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))
-            result[key] = if value.is_a? Array
+          # skip empty values
+          if !empty or include_empty
+            hash[key] = if value.is_a? Array
               value.map do |value|
                 if value.is_a? ModelElement
                   value.to_hash(options)
@@ -104,28 +127,35 @@ module Expressir
           end
         end
 
-        if formatter
+        if self.class.method_defined? :source and formatter
           hash[SOURCE_KEY] = formatter.format(self)
         end
 
         hash
       end
 
-      def self.from_hash(hash)
+      def self.from_hash(hash, options = {})
+        root_path = options[:root_path]
+
         node_class = hash[CLASS_KEY]
-        node_options = hash.select{|x| x != CLASS_KEY}.each_with_object({}) do |(variable, value), result|
+        node_options = {}
+        if node_class == 'Expressir::Model::Schema' and hash[FILE_KEY]
+          node_options[FILE_KEY.to_sym] = root_path ? File.expand_path("#{root_path}/#{hash[FILE_KEY]}") : hash[FILE_KEY]
+        end
+
+        hash.select{|x| x != CLASS_KEY && x != FILE_KEY}.each do |variable, value|
           key = variable.to_sym
 
-          result[key] = if value.is_a? Array
+          node_options[key] = if value.is_a? Array
             value.map do |value|
               if value.is_a? Hash
-                self.from_hash(value)
+                self.from_hash(value, options)
               else
                 value
               end
             end
           elsif value.is_a? Hash
-            self.from_hash(value)
+            self.from_hash(value, options)
           else
             value
           end