expressir 0.2.21-x86-linux → 1.0.0-x86-linux

data/lib/expressir/express/hyperlink_formatter.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Express
+    module HyperlinkFormatter
+      def format_expressions_simple_reference(node)
+        return node.id unless node.base_path
+
+        # find closest node with path
+        current_node = node
+        while !current_node.path
+          current_node = current_node.parent
+        end
+
+        # skip if this reference and target node are in the same node with path
+        node_base_path_parts = node.base_path.split(".")
+        current_node_path_parts = current_node.path.split(".")
+        return node.id if node_base_path_parts[0..1] == current_node_path_parts[0..1]
+
+        "{{{<<express:#{node.base_path},#{node.id}>>}}}"
+      end
+    end
+  end
+end

data/lib/expressir/express/model_visitor.rb

@@ -0,0 +1,23 @@
+require "expressir/model"
+
+module Expressir
+  module Express
+    class ModelVisitor
+      def visit(node)
+        node.class.model_attrs.each do |variable|
+          value = node.send(variable)
+
+          if value.is_a? Array
+            value.each do |value|
+              if value.is_a? Model::ModelElement
+                visit(value)
+              end
+            end
+          elsif value.is_a? Model::ModelElement
+            visit(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/expressir/{express_exp → express}/parser.rb

@@ -4,7 +4,8 @@ begin
 rescue LoadError
   require_relative "express_parser"
 end
-require 'expressir/express_exp/visitor'
+require 'expressir/express/visitor'
+require 'expressir/express/resolve_references_model_visitor'
 
 =begin
 char_stream = Antlr4::Runtime::CharStreams.from_string(input, 'String')
@@ -22,9 +23,11 @@ repo = visitor.visit(parse_tree)
 =end
 
 module Expressir
-  module ExpressExp
+  module Express
     class Parser
       def self.from_file(file, options = {})
+        skip_references = options[:skip_references]
+
         input = File.read(file)
 
         parser = ::ExpressParser::Parser.parse(input)
@@ -38,13 +41,20 @@ module Expressir
           schema.file = file.to_s
         end
 
+        unless skip_references
+          resolve_references_model_visitor = ResolveReferencesModelVisitor.new
+          resolve_references_model_visitor.visit(repository)
+        end
+
         repository
       end
 
       def self.from_files(files, options = {})
+        skip_references = options[:skip_references]
+
         schemas = files.each_with_index.map do |file, i|
           # start = Time.now
-          repository = self.from_file(file, options)
+          repository = self.from_file(file, options.merge(skip_references: true))
           # STDERR.puts "#{i+1}/#{files.length} #{file} #{Time.now - start}"
           repository.schemas
         end.flatten
@@ -53,8 +63,9 @@ module Expressir
           schemas: schemas
         })
 
-        repository.schemas.each do |schema|
-          schema.parent = repository
+        unless skip_references
+          resolve_references_model_visitor = ResolveReferencesModelVisitor.new
+          resolve_references_model_visitor.visit(repository)
         end
 
         repository

data/lib/expressir/express/resolve_references_model_visitor.rb

@@ -0,0 +1,29 @@
+require "expressir/express/model_visitor"
+require "expressir/model"
+
+module Expressir
+  module Express
+    class ResolveReferencesModelVisitor < ModelVisitor
+      def visit(node)
+        if node.is_a? Model::Expressions::SimpleReference
+          visit_expressions_simple_reference(node)
+        end
+
+        super
+      end
+
+      def visit_expressions_simple_reference(node)
+        return if node.parent.is_a? Model::Expressions::AttributeReference
+
+        if node.parent.is_a? Model::InterfaceItem
+          base_item = node.find("#{node.parent.parent.schema.id}.#{node.parent.ref.id}")
+        else
+          base_item = node.find(node.id)
+        end
+        return unless base_item
+
+        node.base_path = base_item.path
+      end
+    end
+  end
+end

data/lib/expressir/{express_exp → express}/schema_head_formatter.rb

@@ -1,5 +1,5 @@
 module Expressir
-  module ExpressExp
+  module Express
     module SchemaHeadFormatter
       def format_schema(node)
         format_schema_head(node)

data/lib/expressir/{express_exp → express}/visitor.rb

@@ -32,7 +32,7 @@ require "set"
 # - e.g. see visit_schema_decl
 
 module Expressir
-  module ExpressExp
+  module Express
     class Visitor < ::ExpressParser::Visitor
       REMARK_CHANNEL = 2
 
@@ -107,27 +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
-        target_node.reset_children_by_id
-        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)
@@ -693,7 +694,7 @@ module Expressir
         id = visit_if(ctx__rule_label_id)
         expression = visit_if(ctx__expression)
 
-        Model::Where.new({
+        Model::WhereRule.new({
           id: id,
           expression: expression
         })
@@ -758,8 +759,8 @@ module Expressir
           *visit_if(ctx__entity_body__derive_clause),
           *visit_if(ctx__entity_body__inverse_clause)
         ]
-        unique = visit_if(ctx__entity_body__unique_clause, [])
-        where = visit_if(ctx__entity_body__where_clause, [])
+        unique_rules = visit_if(ctx__entity_body__unique_clause, [])
+        where_rules = visit_if(ctx__entity_body__where_clause, [])
 
         Model::Entity.new({
           id: id,
@@ -767,8 +768,8 @@ module Expressir
           supertype_expression: supertype_expression,
           subtype_of: subtype_of,
           attributes: attributes,
-          unique: unique,
-          where: where
+          unique_rules: unique_rules,
+          where_rules: where_rules
         })
       end
 
@@ -833,15 +834,13 @@ module Expressir
         ctx__enumeration_extension__enumeration_items = ctx__enumeration_extension&.enumeration_items
 
         extensible = ctx__EXTENSIBLE && true
-        items = visit_if(ctx__enumeration_items, [])
-        extension_type = visit_if(ctx__enumeration_extension__type_ref)
-        extension_items = visit_if(ctx__enumeration_extension__enumeration_items, [])
+        based_on = visit_if(ctx__enumeration_extension__type_ref)
+        items = visit_if(ctx__enumeration_items || ctx__enumeration_extension__enumeration_items, [])
 
         Model::Types::Enumeration.new({
           extensible: extensible,
-          items: items,
-          extension_type: extension_type,
-          extension_items: extension_items
+          based_on: based_on,
+          items: items
         })
       end
 
@@ -1869,7 +1868,7 @@ module Expressir
         constants = visit_if(ctx__algorithm_head__constant_decl, [])
         variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
-        where = visit_if(ctx__where_clause, [])
+        where_rules = visit_if(ctx__where_clause, [])
 
         Model::Rule.new({
           id: id,
@@ -1882,7 +1881,7 @@ module Expressir
           constants: constants,
           variables: variables,
           statements: statements,
-          where: where
+          where_rules: where_rules
         })
       end
 
@@ -1956,7 +1955,33 @@ module Expressir
       def visit_schema_version_id(ctx)
         ctx__string_literal = ctx.string_literal
 
-        visit_if(ctx__string_literal)
+        value = visit_if(ctx__string_literal)
+        value = value.value
+
+        items = if value.start_with?('{') and value.end_with?('}')
+          parts = value.sub(/^\{/, '').sub(/\}$/, '').split(' ')
+          parts.map do |part|
+            if match = part.match(/^(.+)\((\d+)\)$/)
+              Model::SchemaVersionItem.new({
+                name: match[1],
+                value: match[2]
+              })
+            elsif part.match(/^\d+$/)
+              Model::SchemaVersionItem.new({
+                value: part
+              })
+            else
+              Model::SchemaVersionItem.new({
+                name: part
+              })
+            end
+          end
+        end
+        
+        Model::SchemaVersion.new({
+          value: value,
+          items: items
+        })
       end
 
       def visit_selector(ctx)
@@ -1985,16 +2010,14 @@ module Expressir
 
         extensible = ctx__EXTENSIBLE && true
         generic_entity = ctx__GENERIC_ENTITY && true
-        items = visit_if(ctx__select_list, [])
-        extension_type = visit_if(ctx__select_extension__type_ref)
-        extension_items = visit_if(ctx__select_extension__select_list, [])
+        based_on = visit_if(ctx__select_extension__type_ref)
+        items = visit_if(ctx__select_list || ctx__select_extension__select_list, [])
 
         Model::Types::Select.new({
           extensible: extensible,
           generic_entity: generic_entity,
-          items: items,
-          extension_type: extension_type,
-          extension_items: extension_items
+          based_on: based_on,
+          items: items
         })
       end
 
@@ -2288,13 +2311,13 @@ module Expressir
         ctx__where_clause = ctx.where_clause
 
         id = visit_if(ctx__type_id)
-        type = visit_if(ctx__underlying_type)
-        where = visit_if(ctx__where_clause, [])
+        underlying_type = visit_if(ctx__underlying_type)
+        where_rules = visit_if(ctx__where_clause, [])
 
         Model::Type.new({
           id: id,
-          type: type,
-          where: where
+          underlying_type: underlying_type,
+          where_rules: where_rules
         })
       end
 
@@ -2354,7 +2377,7 @@ module Expressir
         id = visit_if(ctx__rule_label_id)
         attributes = visit_if_map(ctx__referenced_attribute)
 
-        Model::Unique.new({
+        Model::UniqueRule.new({
           id: id,
           attributes: attributes
         })

data/lib/expressir/model.rb

@@ -9,20 +9,22 @@ 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'
+require 'expressir/model/schema_version'
+require 'expressir/model/schema_version_item'
 require 'expressir/model/subtype_constraint'
 require 'expressir/model/type'
-require 'expressir/model/unique'
+require 'expressir/model/unique_rule'
 require 'expressir/model/variable'
-require 'expressir/model/where'
+require 'expressir/model/where_rule'
 require 'expressir/model/expressions/aggregate_initializer'
 require 'expressir/model/expressions/aggregate_item'
 require 'expressir/model/expressions/binary_expression'

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, [])
+        @remarks = options[:remarks] || []
+        @remark_items = options[: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

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

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, [])
+        @remarks = options[:remarks] || []
+        @remark_items = options[:remark_items] || []
         @source = options[:source]
 
         @type = options[:type]
@@ -16,6 +17,12 @@ module Expressir
 
         super
       end
+
+      def children
+        [
+          *remark_items
+        ]
+      end
     end
   end
 end