expressir 2.1.22 → 2.1.24

data/lib/expressir/commands/coverage.rb

@@ -47,7 +47,7 @@ module Expressir
         elsif File.extname(path).downcase == ".exp"
           handle_express_file(path, reports, ignored_files)
         elsif [".yml", ".yaml"].include?(File.extname(path).downcase)
-          handle_yaml_manifest(path, reports, ignored_files)
+          handle_schema_manifest(path, reports, ignored_files)
         else
           say "Unsupported file type: #{path}"
         end
@@ -80,7 +80,11 @@ module Expressir
             progress.increment
           end
           skip_types = parse_skip_types
-          report = Expressir::Coverage::Report.from_repository(repository, skip_types, ignored_files)
+          report = Expressir::Coverage::Report.from_repository(
+            repository,
+            skip_types,
+            ignored_files,
+          )
           reports << report
         rescue StandardError => e
           say "Error processing directory #{path}: #{e.message}"
@@ -92,42 +96,22 @@ module Expressir
         begin
           # For a single file, we don't need a progress bar
           skip_types = parse_skip_types
-          report = Expressir::Coverage::Report.from_file(path, skip_types, ignored_files)
+          report = Expressir::Coverage::Report.from_file(path, skip_types,
+                                                         ignored_files)
           reports << report
         rescue StandardError => e
           say "Error processing file #{path}: #{e.message}"
         end
       end
 
-      def handle_yaml_manifest(path, reports, ignored_files)
-        say "Processing YAML manifest: #{path}"
+      def handle_schema_manifest(path, reports, ignored_files)
+        say "Processing schema manifest: #{path}"
         begin
-          schema_list = YAML.load_file(path)
-          manifest_dir = File.dirname(path)
-
-          if schema_list.is_a?(Hash) && schema_list["schemas"]
-            schemas_data = schema_list["schemas"]
-
-            # Handle the nested structure with schema name keys and path values
-            if schemas_data.is_a?(Hash)
-              schema_files = schemas_data.values.map do |schema_data|
-                if schema_data.is_a?(Hash) && schema_data["path"]
-                  # Make path relative to the manifest location
-                  File.expand_path(schema_data["path"], manifest_dir)
-                end
-              end.compact
-
-              say "Found #{schema_files.size} schema files to process"
-            else
-              # If it's a direct array of paths (old format)
-              schema_files = schemas_data
-            end
-          elsif schema_list.is_a?(Array)
-            schema_files = schema_list
-          else
-            say "Invalid YAML format. Expected an array of schema paths or a hash with a 'schemas' key."
-            return
-          end
+          # Load schema manifest
+          manifest = Expressir::SchemaManifest.from_file(path)
+          schema_files = manifest.schemas.map(&:path)
+
+          say "Found #{schema_files.size} schema files to process"
 
           # Initialize progress bar
           if schema_files && !schema_files.empty?
@@ -150,12 +134,15 @@ module Expressir
 
             # Create and add the report
             skip_types = parse_skip_types
-            report = Expressir::Coverage::Report.from_repository(repository, skip_types, ignored_files)
+            report = Expressir::Coverage::Report.from_repository(
+              repository,
+              skip_types,
+              ignored_files,
+            )
             reports << report
           end
         rescue StandardError => e
-          say "Error processing YAML manifest #{path}: #{e.message}"
-          say "Debug: schema_list structure: #{schema_list.class}" if schema_list
+          say "Error processing schema manifest #{path}: #{e.message}"
         end
       end
 
@@ -200,7 +187,8 @@ module Expressir
         # Add rows
         dirs.each do |dir, stats|
           coverage = stats["total"].positive? ? (stats["documented"].to_f / stats["total"] * 100).round(2) : 100.0
-          table.add_row [dir, stats["total"], stats["documented"], "#{coverage}%"]
+          table.add_row [dir, stats["total"], stats["documented"],
+                         "#{coverage}%"]
         end
 
         say table
@@ -250,10 +238,12 @@ module Expressir
           },
         )
 
-        table.add_row ["Coverage Percentage", "#{overall['coverage_percentage']}%"]
+        table.add_row ["Coverage Percentage",
+                       "#{overall['coverage_percentage']}%"]
         table.add_row ["Total Entities", overall["total_entities"]]
         table.add_row ["Documented Entities", overall["documented_entities"]]
-        table.add_row ["Undocumented Entities", overall["undocumented_entities"]]
+        table.add_row ["Undocumented Entities",
+                       overall["undocumented_entities"]]
 
         say table
       end
@@ -265,10 +255,20 @@ module Expressir
 
         overall_stats = {
           "total_entities" => reports.sum { |r| r.total_entities.size },
-          "documented_entities" => reports.sum { |r| r.documented_entities.size },
-          "undocumented_entities" => reports.sum { |r| r.undocumented_entities.size },
-          "coverage_percentage" => if reports.sum { |r| r.total_entities.size }.positive?
-                                     (reports.sum { |r| r.documented_entities.size }.to_f / reports.sum { |r| r.total_entities.size } * 100).round(2)
+          "documented_entities" => reports.sum do |r|
+            r.documented_entities.size
+          end,
+          "undocumented_entities" => reports.sum do |r|
+            r.undocumented_entities.size
+          end,
+          "coverage_percentage" => if reports.sum do |r|
+            r.total_entities.size
+          end.positive?
+                                     (reports.sum do |r|
+                                       r.documented_entities.size
+                                     end.to_f / reports.sum do |r|
+                                                  r.total_entities.size
+                                                end * 100).round(2)
                                    else
                                      100.0
                                    end,
@@ -296,7 +296,8 @@ module Expressir
 
       def display_json_output(reports)
         output_file = options[:output] || "coverage_report.json"
-        File.write(output_file, JSON.pretty_generate(build_structured_report(reports)))
+        File.write(output_file,
+                   JSON.pretty_generate(build_structured_report(reports)))
         say "JSON coverage report written to: #{output_file}"
       end
 

data/lib/expressir/coverage.rb

@@ -236,7 +236,9 @@ module Expressir
       # @return [Hash] A hash with coverage information
       def process_schema(schema)
         entities = Expressir::Coverage.find_entities(schema, @skip_types)
-        documented = entities.select { |e| Expressir::Coverage.entity_documented?(e) }
+        documented = entities.select do |e|
+          Expressir::Coverage.entity_documented?(e)
+        end
         undocumented = entities - documented
 
         coverage = entities.empty? ? 100.0 : (documented.size.to_f / entities.size) * 100
@@ -400,10 +402,18 @@ module Expressir
         entities.concat(container.subtype_constraints) if container.subtype_constraints
 
         # Recursively find nested entities in nested containers
-        container.types&.each { |type| entities.concat(find_nested_entities(type)) }
-        container.entities&.each { |entity| entities.concat(find_nested_entities(entity)) }
-        container.functions&.each { |function| entities.concat(find_nested_entities(function)) }
-        container.procedures&.each { |procedure| entities.concat(find_nested_entities(procedure)) }
+        container.types&.each do |type|
+          entities.concat(find_nested_entities(type))
+        end
+        container.entities&.each do |entity|
+          entities.concat(find_nested_entities(entity))
+        end
+        container.functions&.each do |function|
+          entities.concat(find_nested_entities(function))
+        end
+        container.procedures&.each do |procedure|
+          entities.concat(find_nested_entities(procedure))
+        end
 
       when Expressir::Model::Declarations::Rule
         # Rule nested entities
@@ -416,10 +426,18 @@ module Expressir
         entities.concat(container.subtype_constraints) if container.subtype_constraints
 
         # Recursively find nested entities in nested containers
-        container.types&.each { |type| entities.concat(find_nested_entities(type)) }
-        container.entities&.each { |entity| entities.concat(find_nested_entities(entity)) }
-        container.functions&.each { |function| entities.concat(find_nested_entities(function)) }
-        container.procedures&.each { |procedure| entities.concat(find_nested_entities(procedure)) }
+        container.types&.each do |type|
+          entities.concat(find_nested_entities(type))
+        end
+        container.entities&.each do |entity|
+          entities.concat(find_nested_entities(entity))
+        end
+        container.functions&.each do |function|
+          entities.concat(find_nested_entities(function))
+        end
+        container.procedures&.each do |procedure|
+          entities.concat(find_nested_entities(procedure))
+        end
 
       when Expressir::Model::Declarations::Procedure
         # Procedure nested entities
@@ -433,10 +451,18 @@ module Expressir
         entities.concat(container.subtype_constraints) if container.subtype_constraints
 
         # Recursively find nested entities in nested containers
-        container.types&.each { |type| entities.concat(find_nested_entities(type)) }
-        container.entities&.each { |entity| entities.concat(find_nested_entities(entity)) }
-        container.functions&.each { |function| entities.concat(find_nested_entities(function)) }
-        container.procedures&.each { |procedure| entities.concat(find_nested_entities(procedure)) }
+        container.types&.each do |type|
+          entities.concat(find_nested_entities(type))
+        end
+        container.entities&.each do |entity|
+          entities.concat(find_nested_entities(entity))
+        end
+        container.functions&.each do |function|
+          entities.concat(find_nested_entities(function))
+        end
+        container.procedures&.each do |procedure|
+          entities.concat(find_nested_entities(procedure))
+        end
 
       when Expressir::Model::Declarations::Interface
         # Interface nested entities
@@ -498,7 +524,7 @@ module Expressir
           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)
+          inner_function?(entity)
         else
           false
         end
@@ -528,7 +554,7 @@ module Expressir
     # 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)
+    def self.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)

data/lib/expressir/express/cache.rb

@@ -9,7 +9,8 @@ module Expressir
       # @param root_path [String] Express repository root path, to be stripped from Express file paths to create a portable cache file
       # @param test_overwrite_version [String] don't use, only for tests
       # @return [nil]
-      def self.to_file(file, content, root_path: nil, test_overwrite_version: nil)
+      def self.to_file(file, content, root_path: nil,
+test_overwrite_version: nil)
         version = test_overwrite_version || VERSION
 
         cache = Model::Cache.new(

data/lib/expressir/express/formatter.rb

@@ -91,6 +91,8 @@ module Expressir
           format_declarations_variable(node)
         when Model::Declarations::WhereRule
           format_declarations_where_rule(node)
+        when Model::Declarations::InformalPropositionRule
+          format_declarations_informal_proposition_rule(node)
         when Model::DataTypes::Aggregate
           format_data_types_aggregate(node)
         when Model::DataTypes::Array
@@ -283,9 +285,15 @@ module Expressir
           derived_attributes = []
           inverse_attributes = []
         else
-          explicit_attributes = node.attributes.select { |x| x.kind == Model::Declarations::Attribute::EXPLICIT }
-          derived_attributes = node.attributes.select { |x| x.kind == Model::Declarations::Attribute::DERIVED }
-          inverse_attributes = node.attributes.select { |x| x.kind == Model::Declarations::Attribute::INVERSE }
+          explicit_attributes = node.attributes.select do |x|
+            x.kind == Model::Declarations::Attribute::EXPLICIT
+          end
+          derived_attributes = node.attributes.select do |x|
+            x.kind == Model::Declarations::Attribute::DERIVED
+          end
+          inverse_attributes = node.attributes.select do |x|
+            x.kind == Model::Declarations::Attribute::INVERSE
+          end
         end
 
         [
@@ -393,7 +401,9 @@ module Expressir
                parameter_indent = INDENT_CHAR * "FUNCTION #{node.id}(".length
                [
                  "(",
-                 node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
+                 node.parameters.map do |x|
+                   format(x)
+                 end.join(";\n#{parameter_indent}"),
                  ")",
                ].join
              end,
@@ -513,7 +523,9 @@ module Expressir
                parameter_indent = INDENT_CHAR * "PROCEDURE #{node.id}(".length
                [
                  "(",
-                 node.parameters.map { |x| format(x) }.join(";\n#{parameter_indent}"),
+                 node.parameters.map do |x|
+                   format(x)
+                 end.join(";\n#{parameter_indent}"),
                  ")",
                ].join
              end,
@@ -825,6 +837,18 @@ module Expressir
         ].join
       end
 
+      def format_declarations_informal_proposition_rule(node)
+        [
+          *if node.id
+             [
+               node.id,
+               ":",
+               " ",
+             ].join
+           end,
+        ].join
+      end
+
       def format_expressions_aggregate_initializer(node)
         node.items ||= []
         [
@@ -912,7 +936,7 @@ module Expressir
                    ]
                  end
 
-        [format(node.function), params].flatten.join
+        [format(node.function), params].join
       end
 
       def format_expressions_interval(node)
@@ -950,7 +974,9 @@ module Expressir
           "|",
           " ",
           format(node.expression),
-          *format_remarks(node).instance_eval { |x| x&.length&.positive? ? ["\n", *x, "\n"] : x },
+          *format_remarks(node).instance_eval do |x|
+            x&.length&.positive? ? ["\n", *x, "\n"] : x
+          end,
           ")",
         ].join
       end
@@ -1409,7 +1435,9 @@ module Expressir
                     "\n",
                     indent([
                       "(",
-                      node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                      node.items.map do |x|
+                        format(x)
+                      end.join(",\n#{item_indent}"),
                       ")",
                     ].join),
                   ].join
@@ -1425,7 +1453,9 @@ module Expressir
                     "\n",
                     indent([
                       "(",
-                      node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                      node.items.map do |x|
+                        format(x)
+                      end.join(",\n#{item_indent}"),
                       ")",
                     ].join),
                   ].join
@@ -1545,7 +1575,9 @@ module Expressir
                     "\n",
                     indent([
                       "(",
-                      node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                      node.items.map do |x|
+                        format(x)
+                      end.join(",\n#{item_indent}"),
                       ")",
                     ].join),
                   ].join
@@ -1559,7 +1591,9 @@ module Expressir
                     "\n",
                     indent([
                       "(",
-                      node.items.map { |x| format(x) }.join(",\n#{item_indent}"),
+                      node.items.map do |x|
+                        format(x)
+                      end.join(",\n#{item_indent}"),
                       ")",
                     ].join),
                   ].join
@@ -1627,6 +1661,14 @@ module Expressir
             remark,
             "*)",
           ].join("\n")
+        elsif node.path.nil? && node.id.include?("IP")
+          # Handle inmediate informal propositions
+          [
+            "--",
+            node.id,
+            " ",
+            remark,
+          ].join
         else
           # Handle tail remarks
           [
@@ -1661,7 +1703,7 @@ module Expressir
         # Add tagged remarks
         if node.class.method_defined?(:remarks) && !@no_remarks &&
             !node.remarks.nil?
-          remarks.concat(node.remarks.map do |remark|
+          remarks.concat(node.remarks.compact.map do |remark|
             format_remark(node, remark)
           end)
         end

data/lib/expressir/express/hyperlink_formatter.rb

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