expressir 0.2.16 → 0.2.24

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

@@ -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
@@ -103,26 +107,28 @@ module Expressir
         target_node = node.find(path)
         return target_node if target_node
 
-        # check if path should create implicit informal proposal
-        # see https://github.com/lutaml/expressir/issues/50
+        # check if path can create implicit remark item
+        # see https://github.com/lutaml/expressir/issues/78
         rest, _, current_path = path.rpartition(".") # get last path part
         _, _, current_path = current_path.rpartition(":") # ignore prefix
+        parent_node = node.find(rest)
+        if parent_node and parent_node.class.method_defined? :remark_items
+          remark_item = Model::RemarkItem.new({
+            id: current_path
+          })
+          remark_item.parent = parent_node
 
-        # match informal proposition id
-        informal_proposition_id = current_path.match(/^IP\d+$/).to_a[0]
-        return unless informal_proposition_id
-
-        # find informal proposition target
-        target_node = node.find(rest)
-        return unless target_node and target_node.class.method_defined? :informal_propositions
-
-        # create implicit informal proposition
-        informal_proposition = Model::InformalProposition.new({
-          id: informal_proposition_id
-        })
-        target_node.informal_propositions << informal_proposition
-        informal_proposition.parent = target_node
-        informal_proposition
+          # check if path can create implicit informal proposition
+          # see https://github.com/lutaml/expressir/issues/50
+          if parent_node.class.method_defined? :informal_propositions and current_path.match(/^IP\d+$/)
+            parent_node.informal_propositions << remark_item
+          else
+            parent_node.remark_items << remark_item
+          end
+          parent_node.reset_children_by_id
+          
+          remark_item
+        end
       end
 
       def attach_remarks(ctx, node)
@@ -1925,8 +1931,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 +1943,8 @@ module Expressir
           entities: entities,
           subtype_constraints: subtype_constraints,
           functions: functions,
-          procedures: procedures,
-          rules: rules
+          rules: rules,
+          procedures: procedures
         })
       end
 
@@ -2149,7 +2155,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'
@@ -7,12 +9,12 @@ require 'expressir/model/constant'
 require 'expressir/model/entity'
 require 'expressir/model/enumeration_item'
 require 'expressir/model/function'
-require 'expressir/model/informal_proposition'
 require 'expressir/model/interface'
 require 'expressir/model/interface_item'
 require 'expressir/model/interfaced_item'
 require 'expressir/model/parameter'
 require 'expressir/model/procedure'
+require 'expressir/model/remark_item'
 require 'expressir/model/repository'
 require 'expressir/model/rule'
 require 'expressir/model/schema'

data/lib/expressir/model/attribute.rb

@@ -7,15 +7,16 @@ module Expressir
       DERIVED = :DERIVED
       INVERSE = :INVERSE
 
-      attr_accessor :kind
-      attr_accessor :supertype_attribute
-      attr_accessor :optional
-      attr_accessor :type
-      attr_accessor :expression
+      model_attr_accessor :kind
+      model_attr_accessor :supertype_attribute
+      model_attr_accessor :optional
+      model_attr_accessor :type
+      model_attr_accessor :expression
 
       def initialize(options = {})
         @id = options[:id]
         @remarks = options.fetch(:remarks, [])
+        @remark_items = options.fetch(:remark_items, [])
         @source = options[:source]
 
         @kind = options[:kind]
@@ -26,6 +27,12 @@ module Expressir
 
         super
       end
+
+      def children
+        [
+          *remark_items
+        ]
+      end
     end
   end
 end

data/lib/expressir/model/cache.rb

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

data/lib/expressir/model/constant.rb

@@ -3,12 +3,13 @@ module Expressir
     class Constant < ModelElement
       include Identifier
 
-      attr_accessor :type
-      attr_accessor :expression
+      model_attr_accessor :type
+      model_attr_accessor :expression
 
       def initialize(options = {})
         @id = options[:id]
         @remarks = options.fetch(:remarks, [])
+        @remark_items = options.fetch(:remark_items, [])
         @source = options[:source]
 
         @type = options[:type]
@@ -16,6 +17,12 @@ module Expressir
 
         super
       end
+
+      def children
+        [
+          *remark_items
+        ]
+      end
     end
   end
 end

data/lib/expressir/model/entity.rb

@@ -3,17 +3,18 @@ module Expressir
     class Entity < ModelElement
       include Identifier
 
-      attr_accessor :abstract
-      attr_accessor :supertype_expression
-      attr_accessor :subtype_of
-      attr_accessor :attributes
-      attr_accessor :unique
-      attr_accessor :where
-      attr_accessor :informal_propositions
+      model_attr_accessor :abstract
+      model_attr_accessor :supertype_expression
+      model_attr_accessor :subtype_of
+      model_attr_accessor :attributes
+      model_attr_accessor :unique
+      model_attr_accessor :where
+      model_attr_accessor :informal_propositions
 
       def initialize(options = {})
         @id = options[:id]
         @remarks = options.fetch(:remarks, [])
+        @remark_items = options.fetch(:remark_items, [])
         @source = options[:source]
 
         @abstract = options[:abstract]
@@ -28,12 +29,13 @@ 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,
+          *remark_items
+        ]
       end
     end
   end

data/lib/expressir/model/enumeration_item.rb

@@ -6,10 +6,17 @@ module Expressir
       def initialize(options = {})
         @id = options[:id]
         @remarks = options.fetch(:remarks, [])
+        @remark_items = options.fetch(:remark_items, [])
         @source = options[:source]
 
         super
       end
+
+      def children
+        [
+          *remark_items
+        ]
+      end
     end
   end
 end

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

@@ -2,7 +2,7 @@ module Expressir
   module Model
     module Expressions
       class AggregateInitializer < ModelElement
-        attr_accessor :items
+        model_attr_accessor :items
 
         def initialize(options = {})
           @items = options.fetch(:items, [])

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

@@ -2,8 +2,8 @@ module Expressir
   module Model
     module Expressions
       class AggregateItem < ModelElement
-        attr_accessor :expression
-        attr_accessor :repetition
+        model_attr_accessor :expression
+        model_attr_accessor :repetition
 
         def initialize(options = {})
           @expression = options[:expression]

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

@@ -2,8 +2,8 @@ module Expressir
   module Model
     module Expressions
       class AttributeReference < ModelElement
-        attr_accessor :ref
-        attr_accessor :attribute
+        model_attr_accessor :ref
+        model_attr_accessor :attribute
 
         def initialize(options = {})
           @ref = options[:ref]

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

@@ -25,9 +25,9 @@ module Expressir
         SUBTRACTION = :SUBTRACTION
         XOR = :XOR
 
-        attr_accessor :operator
-        attr_accessor :operand1
-        attr_accessor :operand2
+        model_attr_accessor :operator
+        model_attr_accessor :operand1
+        model_attr_accessor :operand2
 
         def initialize(options = {})
           @operator = options[:operator]

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

@@ -2,8 +2,8 @@ module Expressir
   module Model
     module Expressions
       class Call < ModelElement
-        attr_accessor :ref
-        attr_accessor :parameters
+        model_attr_accessor :ref
+        model_attr_accessor :parameters
 
         def initialize(options = {})
           @ref = options[:ref]

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

@@ -2,8 +2,8 @@ module Expressir
   module Model
     module Expressions
       class EntityConstructor < ModelElement
-        attr_accessor :entity
-        attr_accessor :parameters
+        model_attr_accessor :entity
+        model_attr_accessor :parameters
 
         def initialize(options = {})
           @entity = options[:entity]

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

@@ -2,8 +2,8 @@ module Expressir
   module Model
     module Expressions
       class GroupReference < ModelElement
-        attr_accessor :ref
-        attr_accessor :entity
+        model_attr_accessor :ref
+        model_attr_accessor :entity
 
         def initialize(options = {})
           @ref = options[:ref]