expressir 2.1.20 → 2.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0e1c52810ce3b1361d9f8327c0c270ac3a7f366f16d3b3236a0ed3e559155a9
-  data.tar.gz: a852899cbf8d6a7747b8609ae7ec00736eddfcfad6a9fd8d410cd453811a4188
+  metadata.gz: 5523a9cdb1e5b8168a0d2d7262cdd8a5e849b066a3eeaaad90a3bcb3a640fe38
+  data.tar.gz: 293acbebeecc50a22ba8bc56aa8413f7e156dac17fa4fa872380aff5a9bf320c
 SHA512:
-  metadata.gz: f8db59aa54a5a1edd29165ec3b79e9e98a35ebd51d8d0184735417c96bbd9d178328ddad2feef11f177bc140bd514913d5581f0c01ba8f9ee25b5a3cdf35a7d2
-  data.tar.gz: fef82dcf757767e2a1eea5b252083f0b8f9db85226263f74c7979fde768caa25895df05cca29ac525b799f21ffd19dfd138e26087d3351e0a210b62746bd1867
+  metadata.gz: b756fab7be254dc71ab78ce9ffdb220c727cc1ef8599c2e293ee2edb35d8fb7f2ab9e127683e7621d5a0ac2df4379efa5ff1c2aeaa8dd7623b94b18d5e778d7e
+  data.tar.gz: cb767afb4bef0a7555b9519a29b1cefa14ba3c96278d5154e2c2b5af29e813ba0824ffb7efbfd2e601f2e606f0a5800595b8a97b7998a83dd80c4d99448e7546

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-06-05 12:41:11 UTC using RuboCop version 1.75.2.
+# on 2025-06-07 05:08:55 UTC using RuboCop version 1.75.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -27,11 +27,25 @@ Lint/DuplicateBranch:
   Exclude:
     - 'lib/expressir/coverage.rb'
 
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+Lint/ScriptPermission:
+  Exclude:
+    - 'update_yaml_fixtures.rb'
+
 # Offense count: 3
 Lint/ShadowingOuterLocalVariable:
   Exclude:
     - 'lib/expressir/express/visitor.rb'
 
+# Offense count: 2
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AutoCorrect, IgnoreEmptyBlocks, AllowUnusedKeywordArguments.
+Lint/UnusedBlockArgument:
+  Exclude:
+    - 'lib/expressir/express/visitor.rb'
+    - 'spec/support/yaml_matchers.rb'
+
 # Offense count: 2
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: AutoCorrect, AllowUnusedKeywordArguments, IgnoreEmptyMethods, IgnoreNotImplementedMethods, NotImplementedExceptions.
@@ -41,7 +55,7 @@ Lint/UnusedMethodArgument:
     - 'lib/expressir/express/cache.rb'
     - 'lib/expressir/express/parser.rb'
 
-# Offense count: 75
+# Offense count: 76
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
@@ -60,13 +74,13 @@ Metrics/AbcSize:
     - 'lib/expressir/model/declarations/schema.rb'
     - 'lib/expressir/model/model_element.rb'
 
-# Offense count: 1
+# Offense count: 2
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 # AllowedMethods: refine
 Metrics/BlockLength:
   Max: 143
 
-# Offense count: 54
+# Offense count: 56
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -81,12 +95,12 @@ Metrics/CyclomaticComplexity:
     - 'lib/expressir/model/model_element.rb'
     - 'spec/support/model_element_helper.rb'
 
-# Offense count: 99
+# Offense count: 100
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 82
 
-# Offense count: 43
+# Offense count: 44
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
@@ -98,19 +112,29 @@ Metrics/PerceivedComplexity:
     - 'lib/expressir/model/declarations/schema.rb'
     - 'lib/expressir/model/model_element.rb'
 
+# Offense count: 1
+# Configuration parameters: NamePrefix, ForbiddenPrefixes, AllowedMethods, MethodDefinitionMacros, UseSorbetSigs.
+# NamePrefix: is_, has_, have_, does_
+# ForbiddenPrefixes: is_, has_, have_, does_
+# AllowedMethods: is_a?
+# MethodDefinitionMacros: define_method, define_singleton_method
+Naming/PredicateName:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/expressir/coverage.rb'
+
 # Offense count: 5
 Performance/FixedSize:
   Exclude:
     - 'lib/expressir/express/formatter.rb'
 
-# Offense count: 6
-# This cop supports unsafe autocorrection (--autocorrect-all).
-# Configuration parameters: AllowRegexpMatch.
-Performance/RedundantEqualityComparisonBlock:
-  Exclude:
-    - 'spec/expressir/coverage_spec.rb'
-
 # Offense count: 1
 Style/MissingRespondToMissing:
   Exclude:
     - 'lib/expressir/express/visitor.rb'
+
+# Offense count: 2
+# This cop supports unsafe autocorrection (--autocorrect-all).
+Style/SlicingWithRange:
+  Exclude:
+    - 'lib/expressir/express/visitor.rb'

data/README.adoc

@@ -344,6 +344,42 @@ expressir coverage --exclude=TYPE:SELECT schemas/resources/action_schema/action_
 expressir coverage --exclude=TYPE:SELECT,TYPE:ENUMERATION schemas/resources/action_schema/action_schema.exp
 ----
 
+==== FUNCTION subtype exclusion
+
+For FUNCTION elements, you can exclude inner functions (functions nested within
+other functions, rules, or procedures) using the `FUNCTION:INNER` syntax:
+
+[source, sh]
+----
+# Exclude inner functions from coverage analysis
+expressir coverage --exclude=FUNCTION:INNER schemas/resources/action_schema/action_schema.exp
+
+# Combine with other exclusions
+expressir coverage --exclude=TYPE:SELECT,FUNCTION:INNER schemas/resources/action_schema/action_schema.exp
+----
+
+This is useful when you want to focus documentation coverage on top-level
+functions while excluding nested helper functions that may not require
+individual documentation.
+
+Valid FUNCTION subtypes that can be excluded:
+
+`INNER`:: Inner functions nested within other functions, rules, or procedures
++
+[example]
+====
+----
+FUNCTION outer_function : BOOLEAN;
+  -- This inner function would be excluded with FUNCTION:INNER
+  FUNCTION inner_helper_function : BOOLEAN;
+    RETURN (TRUE);
+  END_FUNCTION;
+
+  RETURN (TRUE);
+END_FUNCTION;
+----
+====
+
 Valid TYPE subtypes that can be excluded:
 
 `AGGREGATE`:: Aggregate type

data/lib/expressir/commands/coverage.rb

@@ -307,11 +307,11 @@ module Expressir
         requested_types
       end
 
-      # Validate a single skip type (supports TYPE:SUBTYPE syntax)
+      # Validate a single skip type (supports TYPE:SUBTYPE and FUNCTION:SUBTYPE syntax)
       # @param type [String] The type to validate
       def validate_skip_type(type)
         if type.include?(":")
-          # Handle TYPE:SUBTYPE format
+          # Handle TYPE:SUBTYPE and FUNCTION:SUBTYPE format
           main_type, subtype = type.split(":", 2)
 
           # Validate main type
@@ -326,8 +326,14 @@ module Expressir
               exit_with_error "Invalid TYPE subtype: #{subtype}. " \
                               "Valid TYPE subtypes are: #{Expressir::Coverage::TYPE_SUBTYPES.join(', ')}"
             end
+          # For FUNCTION, validate subtype
+          elsif main_type == "FUNCTION"
+            unless subtype == "INNER"
+              exit_with_error "Invalid FUNCTION subtype: #{subtype}. " \
+                              "Valid FUNCTION subtypes are: INNER"
+            end
           else
-            exit_with_error "Subtype syntax (#{type}) is only supported for TYPE entities"
+            exit_with_error "Subtype syntax (#{type}) is only supported for TYPE and FUNCTION entities"
           end
         else
           # Handle simple type format

data/lib/expressir/coverage.rb

@@ -413,16 +413,19 @@ module Expressir
     def self.filter_skipped_entities(entities, skip_types)
       return entities if skip_types.empty?
 
-      # Parse skip_types into simple types and TYPE subtypes
+      # Parse skip_types into simple types, TYPE subtypes, and FUNCTION subtypes
       simple_skips = []
       type_subtype_skips = []
+      function_subtype_skips = []
 
       skip_types.each do |skip_type|
         if skip_type.include?(":")
-          # Handle TYPE:SUBTYPE format
+          # Handle TYPE:SUBTYPE and FUNCTION:SUBTYPE format
           main_type, subtype = skip_type.split(":", 2)
           if main_type == "TYPE" && TYPE_SUBTYPES.include?(subtype)
             type_subtype_skips << subtype
+          elsif main_type == "FUNCTION" && subtype == "INNER"
+            function_subtype_skips << subtype
           end
         else
           # Handle simple type format
@@ -445,6 +448,9 @@ module Expressir
         elsif entity_class == "Expressir::Model::Declarations::Type" && type_subtype_skips.any?
           entity_subtype = get_type_subtype(entity)
           type_subtype_skips.include?(entity_subtype)
+        # Check FUNCTION:INNER exclusions
+        elsif entity_class == "Expressir::Model::Declarations::Function" && function_subtype_skips.include?("INNER")
+          is_inner_function?(entity)
         else
           false
         end
@@ -470,5 +476,18 @@ module Expressir
         underlying_class.split("::").last&.upcase
       end
     end
+
+    # Check if a function is an inner function (nested within another function, rule, or procedure)
+    # @param function_entity [Expressir::Model::Declarations::Function] The function entity to check
+    # @return [Boolean] True if the function is nested within another function, rule, or procedure
+    def self.is_inner_function?(function_entity)
+      return false unless function_entity.respond_to?(:parent) && function_entity.parent
+
+      # Check if the parent is a function, rule, or procedure (not a schema)
+      parent = function_entity.parent
+      parent.is_a?(Expressir::Model::Declarations::Function) ||
+        parent.is_a?(Expressir::Model::Declarations::Rule) ||
+        parent.is_a?(Expressir::Model::Declarations::Procedure)
+    end
   end
 end

data/lib/expressir/express/formatter.rb

@@ -208,7 +208,8 @@ module Expressir
       private
 
       def format_repository(node)
-        node.schemas&.map { |x| format(x) }&.join("\n\n")
+        result = node.schemas&.map { |x| format(x) }&.join("\n\n")
+        result ? "#{result}\n" : ""
       end
 
       def format_declarations_attribute(node)
@@ -1615,39 +1616,65 @@ module Expressir
       end
 
       def format_remark(node, remark)
+        # Handle embedded remarks
         if remark.include?("\n")
           [
             [
-              "(*",
-              '"',
+              "(*\"",
               node.path || node.id,
-              '"',
+              "\"",
             ].join,
             remark,
             "*)",
           ].join("\n")
         else
+          # Handle tail remarks
           [
-            "--",
-            '"',
+            "--\"",
             node.path || node.id,
-            '"',
-            " ",
+            "\" ",
+            remark,
+          ].join
+        end
+      end
+
+      def format_untagged_remark(remark)
+        # Handle embedded remarks
+        if remark.include?("\n")
+          [
+            "(*",
+            remark,
+            "*)",
+          ].join("\n")
+        else
+          # Handle tail remarks
+          [
+            "-- ",
             remark,
           ].join
         end
       end
 
       def format_remarks(node)
+        remarks = []
+
+        # Add tagged remarks
         if node.class.method_defined?(:remarks) && !@no_remarks &&
             !node.remarks.nil?
-
-          node.remarks.map do |remark|
+          remarks.concat(node.remarks.map do |remark|
             format_remark(node, remark)
-          end
-        else
-          []
+          end)
+        end
+
+        # Add untagged remarks
+        if node.respond_to?(:untagged_remarks) && !@no_remarks &&
+            !node.untagged_remarks.nil?
+          remarks.concat(node.untagged_remarks.map do |remark|
+            format_untagged_remark(remark)
+          end)
         end
+
+        remarks
       end
 
       def format_scope_remarks(node)

data/lib/expressir/express/visitor.rb

@@ -271,32 +271,67 @@ module Expressir
         remark_tokens = remark_tokens.reject { |x| @attached_remark_tokens.include?(x) }
 
         # parse remarks, find remark targets
-        tagged_remark_tokens = remark_tokens.map do |span|
+        tagged_remark_tokens = []
+        untagged_remark_tokens = []
+
+        remark_tokens.each do |span|
           text = @source[span[0]..span[1] - 1]
-          _, remark_tag, remark_text = if text.start_with?("--")
-                                         text.match(/^--"([^"]*)"(.*)$/).to_a
-                                       else
-                                         text.match(/^\(\*"([^"]*)"(.*)\*\)$/m).to_a
-                                       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")
+          remark_type = if text.start_with?("--")
+                          :tail
+                        else
+                          :embedded
+                        end
+
+          if text.start_with?("--\"") && text.include?("\"")
+            # Tagged tail remark: --"tag" content
+            quote_end = text.index("\"", 3)
+            if quote_end
+              remark_target_path = text[3...quote_end]
+              remark_text = text[(quote_end + 1)..].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
+            end
+          elsif text.start_with?("(*\"") && text.include?("\"")
+            # Tagged embedded remark: (*"tag" content *)
+            quote_end = text.index("\"", 3)
+            if quote_end
+              remark_target_path = text[3...quote_end]
+              remark_text = text[(quote_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
+            end
+          elsif text.start_with?("--")
+            # Untagged tail remark: -- content
+            untagged_text = text[2..].strip.force_encoding("UTF-8")
+            untagged_remark_tokens << [span, untagged_text, remark_type]
+          else
+            # Untagged embedded remark: (* content *)
+            untagged_text = text[2...-2].strip.force_encoding("UTF-8")
+            untagged_remark_tokens << [span, untagged_text, remark_type]
           end
+        end
 
-          [span, remark_target, remark_text]
-        end.select { |x| x[1] }
-
+        # Attach tagged remarks
         tagged_remark_tokens.each do |span, 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 << span
         end
+
+        # Attach untagged remarks to the current node if it supports them
+        # All ModelElements support untagged remarks, but we may get Arrays here
+        if node.respond_to?(:untagged_remarks) && !untagged_remark_tokens.empty?
+          node.untagged_remarks ||= []
+          untagged_remark_tokens.each do |span, untagged_text, _remark_type|
+            # Handle both embedded and tail remarks
+            node.untagged_remarks << untagged_text
+            @attached_remark_tokens << span
+          end
+        end
       end
 
       def visit_attribute_ref(ctx)

data/lib/expressir/model/identifier.rb

@@ -5,11 +5,13 @@ module Expressir
         mod.attribute :id, :string
         mod.attribute :remarks, :string, collection: true
         mod.attribute :remark_items, ::Expressir::Model::Declarations::RemarkItem, collection: true
+        mod.attribute :untagged_remarks, :string, collection: true
 
         mod.key_value do
           map "id", to: :id
           map "remarks", to: :remarks
           map "remark_items", to: :remark_items
+          map "untagged_remarks", to: :untagged_remarks
         end
       end
     end

data/lib/expressir/model/model_element.rb

@@ -13,6 +13,7 @@ module Expressir
       attribute :_class, :string, default: -> { send(:name) },
                                   polymorphic_class: true
       attribute :source, :string
+      attribute :untagged_remarks, :string, collection: true
 
       # TODO: Add basic mappings that can be inherited by all subclasses
       key_value do

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.1.20".freeze
+  VERSION = "2.1.21".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.1.20
+  version: 2.1.21
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-05 00:00:00.000000000 Z
+date: 2025-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64