expressir 2.1.22 → 2.1.23

data/lib/expressir/express/schema_head_formatter.rb

@@ -9,7 +9,8 @@ module Expressir
       # @!visibility private
       def self.included(mod)
         if !mod.superclass.private_method_defined?(:format_declarations_schema) || !mod.superclass.private_method_defined?(:format_declarations_schema_head)
-          raise Error::FormatterMethodMissingError.new("SchemaHeadFormatter", "format_declarations_schema/format_declarations_schema_head")
+          raise Error::FormatterMethodMissingError.new("SchemaHeadFormatter",
+                                                       "format_declarations_schema/format_declarations_schema_head")
         end
       end
 

data/lib/expressir/express/visitor.rb

@@ -41,7 +41,9 @@ module Expressir
         end
 
         def method_missing(name, *args)
-          rulename = name.to_s.sub(/^visit_/, "").gsub(/_([a-z])/) { |m| m[1].upcase }.to_sym
+          rulename = name.to_s.sub(/^visit_/, "").gsub(/_([a-z])/) do |m|
+            m[1].upcase
+          end.to_sym
           self.class.define_method(name) { @data[rulename] }
           send name, *args
         end
@@ -84,28 +86,28 @@ module Expressir
 
         @attached_remark_tokens = Set.new
 
-        @visit_methods = Hash[
-          private_methods.grep(/^visit_/).map do |name|
-            rulename = name.to_s.sub(/^visit_/, "").gsub(/_([a-z])/) { $1.upcase }
-            [rulename.to_sym, name.to_sym]
-          end,
-        ]
+        @visit_methods = private_methods.grep(/^visit_/).to_h do |name|
+          rulename = name.to_s.sub(/^visit_/, "").gsub(/_([a-z])/) do
+            $1.upcase
+          end
+          [rulename.to_sym, name.to_sym]
+        end
       end
 
       def to_ctx(ast, name = :unnamed)
         case ast
         when Hash
-          nodes = Hash[
-            ast.map do |k, v|
-              if k =~ /^listOf_(.*)$/
-                itemkey = $1.to_sym
-                ary = Array === v ? v : [v]
-                [itemkey, to_ctx(ary.select { |v| v[itemkey] }.map { |v| v.slice(itemkey) })]
-              else
-                [k, to_ctx(v, k)]
-              end
-            end,
-          ]
+          nodes = ast.to_h do |k, v|
+            if k =~ /^listOf_(.*)$/
+              itemkey = $1.to_sym
+              ary = Array === v ? v : [v]
+              [itemkey, to_ctx(ary.select do |v|
+                v[itemkey]
+              end.map { |v| v.slice(itemkey) })]
+            else
+              [k, to_ctx(v, k)]
+            end
+          end
           Ctx.new nodes, name
         when Array
           ast.map do |element|
@@ -151,7 +153,7 @@ module Expressir
 
       def get_source(ctx)
         a, b = get_source_pos ctx
-        @source[a..b - 1].strip
+        @source[a..(b - 1)].strip
       end
 
       def visit_ast(ast, name)
@@ -177,7 +179,6 @@ module Expressir
         node
       end
 
-      # ###########################################3
       private
 
       def visit_top(ctx)
@@ -226,25 +227,34 @@ module Expressir
         # 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
+        path_prefix, _, current_path = current_path.rpartition(":")
         parent_node = node_find(node, rest)
         if parent_node&.class&.method_defined?(:remark_items)
           remark_item = Model::Declarations::RemarkItem.new(
             id: current_path,
           )
-          remark_item.parent = parent_node
 
-          # check if path can create implicit informal proposition
-          # see https://github.com/lutaml/expressir/issues/50
-          if parent_node.class.method_defined?(:informal_propositions) && current_path.match(/^IP\d+$/)
+          if parent_node.class.method_defined?(:informal_propositions) && (
+            current_path.match(/^IP\d+$/) || path_prefix.match(/^IP\d+$/)
+          )
+            id = /^IP\d+$/.match?(current_path) ? current_path : path_prefix
             parent_node.informal_propositions ||= []
-            parent_node.informal_propositions << remark_item
+            informal_proposition = Model::Declarations::InformalPropositionRule.new(id: id)
+            informal_proposition.parent = parent_node
+            parent_node.informal_propositions << informal_proposition
+
+            # Reassign the informal proposition id to the remark item
+            remark_item.id = id
+            remark_item.parent = informal_proposition
+
+            informal_proposition.remark_items ||= []
+            informal_proposition.remark_items << remark_item
           else
             parent_node.remark_items ||= []
             parent_node.remark_items << remark_item
+            remark_item.parent = parent_node
           end
           parent_node.reset_children_by_id
-
           remark_item
         end
       end
@@ -268,14 +278,16 @@ module Expressir
         remark_tokens = get_remarks ctx
 
         # skip already attached remarks
-        remark_tokens = remark_tokens.reject { |x| @attached_remark_tokens.include?(x) }
+        remark_tokens = remark_tokens.reject do |x|
+          @attached_remark_tokens.include?(x)
+        end
 
         # parse remarks, find remark targets
         tagged_remark_tokens = []
         untagged_remark_tokens = []
 
         remark_tokens.each do |span|
-          text = @source[span[0]..span[1] - 1]
+          text = @source[span[0]..(span[1] - 1)]
           remark_type = if text.start_with?("--")
                           :tail
                         else
@@ -304,6 +316,15 @@ module Expressir
                 tagged_remark_tokens << [span, remark_target, remark_text]
               end
             end
+          elsif text.match?(/^--IP\d+:/)
+            # Unquoted tagged tail remark: --IP1: content
+            remark_target_path = text[2..].strip
+            colon_end = text.index(":", 5)
+            remark_text = text[(colon_end + 1)...-2].strip.force_encoding("UTF-8")
+            remark_target = find_remark_target(node, remark_target_path)
+            if remark_target
+              tagged_remark_tokens << [span, remark_target, remark_text]
+            end
           elsif text.start_with?("--")
             # Untagged tail remark: -- content
             untagged_text = text[2..].strip.force_encoding("UTF-8")
@@ -563,7 +584,8 @@ module Expressir
         ctx__stmt = ctx.stmt
 
         id = visit_if(ctx__variable_id)
-        expression = handle_qualified_ref(visit_if(ctx__general_ref), ctx__qualifier)
+        expression = handle_qualified_ref(visit_if(ctx__general_ref),
+                                          ctx__qualifier)
         statements = visit_if_map(ctx__stmt)
 
         Model::Statements::Alias.new(
@@ -935,7 +957,8 @@ module Expressir
                     ctx__entity_head__subsuper__supertype_constraint__abstract_supertype_declaration) && true
         supertype_expression = visit_if(ctx__entity_head__subsuper__supertype_constraint__abstract_supertype_declaration ||
                                         ctx__entity_head__subsuper__supertype_constraint__supertype_rule)
-        subtype_of = visit_if(ctx__entity_head__subsuper__subtype_declaration, [])
+        subtype_of = visit_if(ctx__entity_head__subsuper__subtype_declaration,
+                              [])
         attributes = [
           *visit_if_map_flatten(ctx__entity_body__explicit_attr),
           *visit_if(ctx__entity_body__derive_clause),
@@ -1017,7 +1040,9 @@ module Expressir
 
         extensible = ctx__EXTENSIBLE && true
         based_on = visit_if(ctx__enumeration_extension__type_ref)
-        items = visit_if(ctx__enumeration_items || ctx__enumeration_extension__enumeration_items, [])
+        items = visit_if(
+          ctx__enumeration_items || ctx__enumeration_extension__enumeration_items, []
+        )
 
         Model::DataTypes::Enumeration.new(
           extensible: extensible,
@@ -1134,10 +1159,18 @@ module Expressir
         return_type = visit_if(ctx__function_head__parameter_type)
         declarations = visit_if_map(ctx__algorithm_head__declaration)
         types = declarations.select { |x| x.is_a? Model::Declarations::Type }
-        entities = declarations.select { |x| x.is_a? Model::Declarations::Entity }
-        subtype_constraints = declarations.select { |x| x.is_a? Model::Declarations::SubtypeConstraint }
-        functions = declarations.select { |x| x.is_a? Model::Declarations::Function }
-        procedures = declarations.select { |x| x.is_a? Model::Declarations::Procedure }
+        entities = declarations.select do |x|
+          x.is_a? Model::Declarations::Entity
+        end
+        subtype_constraints = declarations.select do |x|
+          x.is_a? Model::Declarations::SubtypeConstraint
+        end
+        functions = declarations.select do |x|
+          x.is_a? Model::Declarations::Function
+        end
+        procedures = declarations.select do |x|
+          x.is_a? Model::Declarations::Procedure
+        end
         constants = visit_if(ctx__algorithm_head__constant_decl, [])
         variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
@@ -1756,10 +1789,18 @@ module Expressir
         parameters = visit_if_map_flatten(ctx__procedure_head__procedure_head_parameter)
         declarations = visit_if_map(ctx__algorithm_head__declaration)
         types = declarations.select { |x| x.is_a? Model::Declarations::Type }
-        entities = declarations.select { |x| x.is_a? Model::Declarations::Entity }
-        subtype_constraints = declarations.select { |x| x.is_a? Model::Declarations::SubtypeConstraint }
-        functions = declarations.select { |x| x.is_a? Model::Declarations::Function }
-        procedures = declarations.select { |x| x.is_a? Model::Declarations::Procedure }
+        entities = declarations.select do |x|
+          x.is_a? Model::Declarations::Entity
+        end
+        subtype_constraints = declarations.select do |x|
+          x.is_a? Model::Declarations::SubtypeConstraint
+        end
+        functions = declarations.select do |x|
+          x.is_a? Model::Declarations::Function
+        end
+        procedures = declarations.select do |x|
+          x.is_a? Model::Declarations::Procedure
+        end
         constants = visit_if(ctx__algorithm_head__constant_decl, [])
         variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
@@ -2041,10 +2082,18 @@ module Expressir
         applies_to = visit_if_map(ctx__rule_head__entity_ref)
         declarations = visit_if_map(ctx__algorithm_head__declaration)
         types = declarations.select { |x| x.is_a? Model::Declarations::Type }
-        entities = declarations.select { |x| x.is_a? Model::Declarations::Entity }
-        subtype_constraints = declarations.select { |x| x.is_a? Model::Declarations::SubtypeConstraint }
-        functions = declarations.select { |x| x.is_a? Model::Declarations::Function }
-        procedures = declarations.select { |x| x.is_a? Model::Declarations::Procedure }
+        entities = declarations.select do |x|
+          x.is_a? Model::Declarations::Entity
+        end
+        subtype_constraints = declarations.select do |x|
+          x.is_a? Model::Declarations::SubtypeConstraint
+        end
+        functions = declarations.select do |x|
+          x.is_a? Model::Declarations::Function
+        end
+        procedures = declarations.select do |x|
+          x.is_a? Model::Declarations::Procedure
+        end
         constants = visit_if(ctx__algorithm_head__constant_decl, [])
         variables = visit_if(ctx__algorithm_head__local_decl, [])
         statements = visit_if_map(ctx__stmt)
@@ -2106,11 +2155,19 @@ module Expressir
         constants = visit_if(ctx__schema_body__constant_decl, [])
         declarations = visit_if_map(ctx__schema_body__schema_body_declaration)
         types = declarations.select { |x| x.is_a? Model::Declarations::Type }
-        entities = declarations.select { |x| x.is_a? Model::Declarations::Entity }
-        subtype_constraints = declarations.select { |x| x.is_a? Model::Declarations::SubtypeConstraint }
-        functions = declarations.select { |x| x.is_a? Model::Declarations::Function }
+        entities = declarations.select do |x|
+          x.is_a? Model::Declarations::Entity
+        end
+        subtype_constraints = declarations.select do |x|
+          x.is_a? Model::Declarations::SubtypeConstraint
+        end
+        functions = declarations.select do |x|
+          x.is_a? Model::Declarations::Function
+        end
         rules = declarations.select { |x| x.is_a? Model::Declarations::Rule }
-        procedures = declarations.select { |x| x.is_a? Model::Declarations::Procedure }
+        procedures = declarations.select do |x|
+          x.is_a? Model::Declarations::Procedure
+        end
 
         Model::Declarations::Schema.new(
           id: id,
@@ -2191,7 +2248,9 @@ module Expressir
         extensible = ctx__EXTENSIBLE && true
         generic_entity = ctx__GENERIC_ENTITY && true
         based_on = visit_if(ctx__select_extension__type_ref)
-        items = visit_if(ctx__select_list || ctx__select_extension__select_list, [])
+        items = visit_if(
+          ctx__select_list || ctx__select_extension__select_list, []
+        )
 
         Model::DataTypes::Select.new(
           extensible: extensible,
@@ -2405,7 +2464,9 @@ module Expressir
           if ctx__supertype_factor.length >= 2
             if ctx__ANDOR && (ctx__ANDOR.length == ctx__supertype_factor.length - 1)
               operands = ctx__supertype_factor.map { |item| visit(item) }
-              operators = ctx__ANDOR.map { Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR }
+              operators = ctx__ANDOR.map do
+                Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR
+              end
 
               handle_binary_supertype_expression(operands, operators)
             else
@@ -2427,7 +2488,9 @@ module Expressir
           if ctx__supertype_term.length >= 2
             if ctx__AND && (ctx__AND.length == ctx__supertype_term.length - 1)
               operands = ctx__supertype_term.map { |item| visit(item) }
-              operators = ctx__AND.map { Model::SupertypeExpressions::BinarySupertypeExpression::AND }
+              operators = ctx__AND.map do
+                Model::SupertypeExpressions::BinarySupertypeExpression::AND
+              end
 
               handle_binary_supertype_expression(operands, operators)
             else

data/lib/expressir/model/declarations/entity.rb

@@ -12,7 +12,8 @@ module Expressir
         attribute :attributes, Attribute, collection: true
         attribute :unique_rules, UniqueRule, collection: true
         attribute :where_rules, WhereRule, collection: true
-        attribute :informal_propositions, RemarkItem, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
         attribute :_class, :string, default: -> { send(:name) }
 
         key_value do

data/lib/expressir/model/declarations/informal_proposition_rule.rb

@@ -0,0 +1,24 @@
+module Expressir
+  module Model
+    module Declarations
+      # Informal proposition rules are used to specify constraints that cannot be formally expressed
+      class InformalPropositionRule < ModelElement
+        include Identifier
+
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+        end
+
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/rule.rb

@@ -16,7 +16,8 @@ module Expressir
         attribute :variables, Variable, collection: true
         attribute :statements, ModelElement, collection: true
         attribute :where_rules, WhereRule, collection: true
-        attribute :informal_propositions, RemarkItem, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
         attribute :_class, :string, default: -> { send(:name) }
 
         key_value do

data/lib/expressir/model/declarations/schema.rb

@@ -108,7 +108,10 @@ module Expressir
             else
               interface.items.filter_map do |item|
                 base_item = children_by_id[item.ref.id.safe_downcase]
-                create_interfaced_item(item.id || base_item.id, base_item) if base_item
+                if base_item
+                  create_interfaced_item(item.id || base_item.id,
+                                         base_item)
+                end
               end
             end
           end.compact

data/lib/expressir/model/declarations/type.rb

@@ -8,7 +8,8 @@ module Expressir
 
         attribute :underlying_type, ModelElement
         attribute :where_rules, WhereRule, collection: true
-        attribute :informal_propositions, RemarkItem, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
         attribute :_class, :string, default: -> { send(:name) }
 
         key_value do

data/lib/expressir/model/identifier.rb

@@ -4,7 +4,8 @@ module Expressir
       def self.included(mod)
         mod.attribute :id, :string
         mod.attribute :remarks, :string, collection: true
-        mod.attribute :remark_items, ::Expressir::Model::Declarations::RemarkItem, collection: true
+        mod.attribute :remark_items,
+                      ::Expressir::Model::Declarations::RemarkItem, collection: true
         mod.attribute :untagged_remarks, :string, collection: true
 
         mod.key_value do

data/lib/expressir/model/literals/string.rb

@@ -10,7 +10,8 @@ module Expressir
 
         key_value do
           map "_class", to: :_class, render_default: true
-          map "value", to: :value, value_map: { to: { nil: :empty, empty: :empty } }
+          map "value", to: :value,
+                       value_map: { to: { nil: :empty, empty: :empty } }
           map "encoded", to: :encoded
         end
       end