expressir 0.2.8-x86-mingw32 → 0.2.9-x86-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9f1c04da8b8c78468a69c1e7af8aec0933832e91f2c9a5c26eb37e77300ae52
-  data.tar.gz: 0623ad362c34b32997d089c5f207a336871107d11dd20a364575c035aa50bdc0
+  metadata.gz: cbb9f59220d257fb94378b5af338bd85183d38a38f0b410c4970e0a3e03cbf55
+  data.tar.gz: 236ee875325b9df509932b6640df2ae4bd247f729b9032e445dac92b8530bcbe
 SHA512:
-  metadata.gz: f7807b3f35d9f6fe7cb77576ac3fa8569c10c18dfb7e9cefb1696a2a060dc38bc7301d16091d87ceb3dc1364ae3007285da08b822d86daa383e1eed2cc227635
-  data.tar.gz: 105af5f9f9e2f2aaca1f9036a1f576f4c57e3a7c6debfe86a13b502a0527fb2ab9260dd39886942b4979ed39ac945272a9cbc066b1368d53d38e0c593a5ee82c
+  metadata.gz: 0ac9baa4afb7313977a6a5b64d764a561bbee38f09e754f340446cca8f562bc9daa117d4b90b55abdbec621305743c0148698d84b318bacadf9df6e0d0217da3
+  data.tar.gz: 3d167c0cf9ed34bd2ba9f93ad33f24e5d54660a3092de890d30a39a2180aa4fdc158a3efe35cff881840029be5e9c7d5285b504abaff75368fcacc4fcb53c7e5

data/.github/workflows/release.yml

@@ -74,16 +74,10 @@ jobs:
           RUBYGEMS_API_KEY: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
         run: |
           mkdir -p ~/.gem
-          echo "---"
           cat > ~/.gem/credentials << EOF
           ---
           :rubygems_api_key: ${RUBYGEMS_API_KEY}
           EOF
-          echo "---"
           chmod 0600 ~/.gem/credentials
-          echo "---"
-          ls -la ~/.gem
-          echo "---"
-          gem signin --debug
-          echo "---"
+          gem signin
           for gem in pkg/*.gem; do gem push $gem -V; done

data/expressir.gemspec

@@ -32,11 +32,11 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "nokogiri", "~> 1.10"
   spec.add_runtime_dependency "thor", "~> 1.0"
-  spec.add_runtime_dependency "rice", "~> 2.2.0"
+  spec.add_runtime_dependency "rice", "~> 3"
   spec.add_development_dependency "antlr4-native", "~> 1.1.0"
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "pry", "~> 0.12.2"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rake-compiler", "~> 1.1"
   spec.add_development_dependency "rake-compiler-dock", "~> 1.1"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/expressir/express_exp/formatter.rb

@@ -395,7 +395,7 @@ module Expressir
               "\n",
               INDENT,
               '(',
-              node.items.map{|x| format(x)},
+              node.items.map{|x| format(x)}.join(', '),
               ')'
             ].join('')
           end,
@@ -1437,11 +1437,7 @@ module Expressir
         [
           *format_remarks(node),
           *if node.class.method_defined? :children
-            node.children.flat_map do |x|
-              if x != node
-                format_scope_remarks(x)
-              end
-            end
+            node.children.select{|x| x.parent == node}.flat_map{|x| format_scope_remarks(x)}
           end
         ]
       end

data/lib/expressir/express_exp/parser.rb

@@ -9,7 +9,7 @@ require 'expressir/express_exp/visitor'
 module Expressir
   module ExpressExp
     class Parser
-      def self.from_exp(file)
+      def self.from_file(file)
         input = File.read(file)
 
 =begin
@@ -36,6 +36,19 @@ module Expressir
 
         repo
       end
+
+      def self.from_files(files)
+        schemas = files.map{|file| self.from_file(file).schemas}.flatten
+
+        Model::Repository.new({
+          schemas: schemas
+        })
+      end
+
+      # deprecated
+      def self.from_exp(file)
+        self.from_file(file)
+      end
     end
   end
 end

data/lib/expressir/express_exp/visitor.rb

@@ -5,10 +5,8 @@ rescue LoadError
   require_relative "express_parser"
 end
 require "expressir/model"
+require "set"
 
-# static shorthands are unwrapped
-# - entity attributes, function/procedure parameters, local variables
-#
 # reference type is not recognized
 # see note in A.1.5 Interpreted identifiers
 # > It is expected that identifiers matching these syntax rules are known to an implementation.
@@ -25,6 +23,9 @@ require "expressir/model"
 # > A syntactic construct such as ARRAY[1:3] OF REAL satisfies two syntactic productions —
 # > aggregation_type and general_aggregation_type. It is considered to be instantiable no matter which
 # > production it is required to satisfy in the syntax.
+#
+# static shorthands are unwrapped
+# - entity attributes, function/procedure parameters, local variables
 
 module Expressir
   module ExpressExp
@@ -33,7 +34,7 @@ module Expressir
 
       def initialize(tokens)
         @tokens = tokens
-        @attached_remarks = Set.new
+        @attached_remark_tokens = ::Set.new
 
         super()
       end
@@ -58,6 +59,14 @@ module Expressir
         ctx.map{|ctx2| visit(ctx2)}.flatten if ctx
       end
 
+      def get_tokens_source(tokens)
+        if tokens.last.text == '<EOF>'
+          tokens.pop
+        end
+
+        tokens.map{|x| x.text}.join('').force_encoding('UTF-8')
+      end
+
       def get_tokens(ctx)
         start_index, stop_index = if ctx.instance_of? ::ExpressParser::SyntaxContext
           [0, @tokens.size - 1]
@@ -68,66 +77,93 @@ module Expressir
         @tokens[start_index..stop_index]
       end
 
+      def get_head_tokens(ctx)
+        start_index, stop_index = if ctx.instance_of? ::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
-          source_tokens = get_tokens(ctx).select{|x| x.text != '<EOF>'}
-          node.source = source_tokens.map{|x| x.text}.join('').force_encoding('UTF-8')
+          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 attach_parent(ctx, node)
         if node.class.method_defined? :children
           node.children.each do |child_node|
-            if child_node.class.method_defined? :parent
+            if child_node.class.method_defined? :parent and !child_node.parent
               child_node.parent = node
             end
           end
         end
       end
 
+      def find_remark_target(node, path)
+        current_node = node
+        target_node = nil
+
+        if current_node.class.method_defined? :find_or_create
+          target_node = current_node.find_or_create(path)
+        end
+        while !target_node and current_node.class.method_defined? :parent and current_node.parent.class.method_defined? :find_or_create
+          current_node = current_node.parent
+          target_node = current_node.find_or_create(path)
+        end
+
+        target_node
+      end
+
       def attach_remarks(ctx, node)
         remark_tokens = get_tokens(ctx).select{|x| x.channel == REMARK_CHANNEL}
-        if remark_tokens
-          remark_tokens.each do |remark_token|
-            remark_text = remark_token.text
-
-            # check if it is tagged remark
-            match = if remark_text.start_with?('--')
-              remark_text[2..-1].match(/^"([^"]*)"(.*)$/)
-            elsif remark_text.start_with?('(*') and remark_text.end_with?('*)')
-              remark_text[2..-3].match(/^"([^"]*)"(.*)$/m)
-            end
-            if !match
-              next
-            end
 
-            # don't attach already attached tagged remark
-            if @attached_remarks.include? remark_token
-              next
-            end
+        # skip already attached remarks
+        remark_tokens = remark_tokens.select{|x| !@attached_remark_tokens.include?(x)}
 
-            # attach tagged remark
-            remark_tag = match[1]
-            remark_content = match[2].strip.force_encoding('UTF-8')
+        # parse remarks, find remark targets
+        tagged_remark_tokens = remark_tokens.map do |remark_token|
+          _, remark_tag, remark_text = if remark_token.text.start_with?('--')
+            remark_token.text.match(/^--"([^"]*)"(.*)$/).to_a
+          else
+            remark_token.text.match(/^\(\*"([^"]*)"(.*)\*\)$/m).to_a
+          end
 
-            target_node = nil
-            current_node = node
-            if current_node.class.method_defined? :find
-              target_node = current_node.find(remark_tag)
-            end
-            while !target_node and current_node.class.method_defined? :parent and current_node.parent.class.method_defined? :find
-              current_node = current_node.parent
-              target_node = current_node.find(remark_tag)
-            end
+          if remark_tag
+            remark_target = find_remark_target(node, remark_tag)
+          end
+          if remark_text
+            remark_text = remark_text.strip.force_encoding('UTF-8')
+          end
 
-            if target_node
-              target_node.remarks ||= []
-              target_node.remarks << remark_content
+          [remark_token, remark_target, remark_text]
+        end.select{|x| x[1]}
 
-              # mark remark as attached, so that it is not attached again at higher nesting level
-              @attached_remarks << remark_token
-            end
-          end
+        tagged_remark_tokens.each do |remark_token, remark_target, remark_text|
+          # attach remark
+          remark_target.remarks ||= []
+          remark_target.remarks << remark_text
+
+          # mark remark as attached, so that it is not attached again at higher nesting level
+          @attached_remark_tokens << remark_token
         end
       end
 

data/lib/expressir/model.rb

@@ -6,6 +6,7 @@ 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/parameter'
 require 'expressir/model/procedure'

data/lib/expressir/model/entity.rb

@@ -10,6 +10,7 @@ module Expressir
       attr_accessor :attributes
       attr_accessor :unique
       attr_accessor :where
+      attr_accessor :informal_propositions
 
       def initialize(options = {})
         @id = options[:id]
@@ -20,6 +21,7 @@ module Expressir
         @attributes = options[:attributes]
         @unique = options[:unique]
         @where = options[:where]
+        @informal_propositions = options[:informal_propositions]
       end
 
       def explicit_attributes
@@ -39,6 +41,7 @@ module Expressir
         items.push(*@attributes) if @attributes
         items.push(*@unique) if @unique
         items.push(*@where) if @where
+        items.push(*@informal_propositions) if @informal_propositions
         items
       end
     end

data/lib/expressir/model/informal_proposition.rb

@@ -0,0 +1,11 @@
+module Expressir
+  module Model
+    class InformalProposition
+      include Identifier
+
+      def initialize(options = {})
+        @id = options[:id]
+      end
+    end
+  end
+end

data/lib/expressir/model/rule.rb

@@ -10,6 +10,7 @@ module Expressir
       attr_accessor :variables
       attr_accessor :statements
       attr_accessor :where
+      attr_accessor :informal_propositions
 
       def initialize(options = {})
         @id = options[:id]
@@ -20,6 +21,7 @@ module Expressir
         @variables = options[:variables]
         @statements = options[:statements]
         @where = options[:where]
+        @informal_propositions = options[:informal_propositions]
       end
 
       def types
@@ -55,6 +57,7 @@ module Expressir
         items.push(*@constants) if @constants
         items.push(*@variables) if @variables
         items.push(*@where) if @where
+        items.push(*@informal_propositions) if @informal_propositions
         items
       end
     end

data/lib/expressir/model/schema.rb

@@ -9,6 +9,8 @@ module Expressir
       attr_accessor :constants
       attr_accessor :declarations
 
+      attr_accessor :head_source
+
       def initialize(options = {})
         @id = options[:id]
         @version = options[:version]

data/lib/expressir/model/scope.rb

@@ -4,20 +4,54 @@ module Expressir
       attr_accessor :source
 
       def find(path)
-        current, rest = path.downcase.split(".", 2)
+        current_path, _, rest = path.partition(".")
 
-        # ignore `wr:`, `ip:` part
-        if current.include? ":"
-          _, current = current.split(":", 2)
+        # ignore prefix
+        _, _, current_path = current_path.rpartition(":")
+
+        current_path = current_path.downcase
+        child = children.find{|x| x.id and x.id.downcase == current_path}
+
+        if !rest.empty? and child.class.method_defined? :find
+          child.find(rest)
+        else
+          child
         end
+      end
+
+      def find_or_create(path)
+        child = find(path)
 
-        child = children.find{|x| x.id.downcase == current}
+        if !child
+          # check if path should create implicit informal proposal
+          # see https://github.com/lutaml/expressir/issues/50
+          rest, _, current_path = path.rpartition(".")
 
-        if rest
-          if child.class.method_defined? :find
-            child.find(rest)
+          if !rest.empty?
+            child = find(rest)
           else
-            nil
+            child = self
+          end
+
+          if child.class.method_defined? :informal_propositions
+            # ignore prefix
+            _, _, current_path = current_path.rpartition(":")
+
+            # match informal proposition id
+            informal_proposition_id = current_path.match(/^IP\d+$/).to_a[0]
+
+            if informal_proposition_id
+              # create implicit informal proposition
+              informal_proposition = Model::InformalProposition.new({
+                id: informal_proposition_id
+              })
+              informal_proposition.parent = child
+
+              child.informal_propositions ||= []
+              child.informal_propositions << informal_proposition
+
+              informal_proposition
+            end
           end
         else
           child

data/lib/expressir/model/type.rb

@@ -6,17 +6,25 @@ module Expressir
 
       attr_accessor :type
       attr_accessor :where
+      attr_accessor :informal_propositions
 
       def initialize(options = {})
         @id = options[:id]
 
         @type = options[:type]
         @where = options[:where]
+        @informal_propositions = options[:informal_propositions]
       end
 
       def children
         items = []
+        items.push(*[
+          *if @type.instance_of? Expressir::Model::Types::Enumeration
+            @type.items
+          end
+        ])
         items.push(*@where) if @where
+        items.push(*@informal_propositions) if @informal_propositions
         items
       end
     end