expressir 2.1.21 → 2.1.23

data/lib/expressir/cli.rb

@@ -24,26 +24,33 @@ module Expressir
     end
 
     desc "clean PATH", "Strip remarks and prettify EXPRESS schema at PATH"
-    method_option :output, type: :string, desc: "Output file path (defaults to stdout)"
+    method_option :output, type: :string,
+                           desc: "Output file path (defaults to stdout)"
     def clean(path)
       Commands::Clean.new(options).run(path)
     end
 
-    desc "benchmark FILE_OR_YAML", "Benchmark schema loading performance for a file or list of files from YAML"
-    method_option :ips, type: :boolean, desc: "Use benchmark-ips for detailed statistics"
+    desc "benchmark FILE_OR_YAML",
+         "Benchmark schema loading performance for a file or list of files from YAML"
+    method_option :ips, type: :boolean,
+                        desc: "Use benchmark-ips for detailed statistics"
     method_option :verbose, type: :boolean, desc: "Show verbose output"
     method_option :save, type: :boolean, desc: "Save benchmark results to file"
-    method_option :format, type: :string, desc: "Output format (json, csv, default)"
+    method_option :format, type: :string,
+                           desc: "Output format (json, csv, default)"
     def benchmark(path)
       Commands::Benchmark.new(options).run(path)
     end
 
     desc "benchmark-cache FILE_OR_YAML", "Benchmark schema loading with caching"
-    method_option :ips, type: :boolean, desc: "Use benchmark-ips for detailed statistics"
+    method_option :ips, type: :boolean,
+                        desc: "Use benchmark-ips for detailed statistics"
     method_option :verbose, type: :boolean, desc: "Show verbose output"
     method_option :save, type: :boolean, desc: "Save benchmark results to file"
-    method_option :format, type: :string, desc: "Output format (json, csv, default)"
-    method_option :cache_path, type: :string, desc: "Path to store the cache file"
+    method_option :format, type: :string,
+                           desc: "Output format (json, csv, default)"
+    method_option :cache_path, type: :string,
+                               desc: "Path to store the cache file"
     def benchmark_cache(path)
       Commands::BenchmarkCache.new(options).run(path)
     end
@@ -53,10 +60,16 @@ module Expressir
       Commands::Validate.new(options).run(paths)
     end
 
-    desc "coverage *PATH", "List EXPRESS entities and check documentation coverage"
-    method_option :format, type: :string, desc: "Output format (text, json, yaml)", default: "text"
-    method_option :exclude, type: :string, desc: "Comma-separated list of EXPRESS entity types to skip from coverage (e.g., TYPE,CONSTANT,TYPE:SELECT)"
-    method_option :output, type: :string, desc: "Output file path for JSON/YAML formats (defaults to coverage_report.json/yaml)"
+    desc "coverage *PATH",
+         "List EXPRESS entities and check documentation coverage"
+    method_option :format, type: :string,
+                           desc: "Output format (text, json, yaml)", default: "text"
+    method_option :exclude, type: :string,
+                            desc: "Comma-separated list of EXPRESS entity types to skip from coverage (e.g., TYPE,CONSTANT,TYPE:SELECT)"
+    method_option :output, type: :string,
+                           desc: "Output file path for JSON/YAML formats (defaults to coverage_report.json/yaml)"
+    method_option :ignore_files, type: :string,
+                                 desc: "Path to YAML file containing array of files to ignore from overall coverage calculation"
     def coverage(*paths)
       Commands::Coverage.new(options).run(paths)
     end

data/lib/expressir/commands/benchmark.rb

@@ -5,7 +5,7 @@ module Expressir
         configure_benchmarking
 
         if [".yml", ".yaml"].include?(File.extname(path).downcase)
-          benchmark_from_yaml(path)
+          benchmark_from_manifest(path)
         else
           benchmark_file(path)
         end
@@ -36,24 +36,15 @@ module Expressir
         end
       end
 
-      def benchmark_from_yaml(yaml_path)
-        say "Express Schema Loading Benchmark from YAML"
+      def benchmark_from_manifest(manifest_path)
+        say "Express Schema Loading Benchmark from Manifest"
         say "--------------------------------"
 
-        # Load schema list from YAML
-        schema_list = YAML.load_file(yaml_path)
-        if schema_list.is_a?(Hash) && schema_list["schemas"]
-          # Handle format: { "schemas": ["path1", "path2", ...] }
-          schema_files = schema_list["schemas"]
-        elsif schema_list.is_a?(Array)
-          # Handle format: ["path1", "path2", ...]
-          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(manifest_path)
+        schema_files = manifest.schemas.map(&:path)
 
-        say "YAML File: #{yaml_path}"
+        say "Manifest File: #{manifest_path}"
         say "Number of schemas in list: #{schema_files.size}"
         say "--------------------------------"
 

data/lib/expressir/commands/benchmark_cache.rb

@@ -8,7 +8,7 @@ module Expressir
         cache_path = options[:cache_path] || generate_temp_cache_path
 
         if [".yml", ".yaml"].include?(File.extname(path).downcase)
-          benchmark_cache_from_yaml(path, cache_path)
+          benchmark_cache_from_manifest(path, cache_path)
         else
           benchmark_cache_file(path, cache_path)
         end
@@ -32,7 +32,8 @@ module Expressir
         say "--------------------------------"
 
         # Benchmark with caching
-        results = Expressir::Benchmark.measure_with_cache(path, cache_path) do |file|
+        results = Expressir::Benchmark.measure_with_cache(path,
+                                                          cache_path) do |file|
           Expressir::Express::Parser.from_file(file)
         end
 
@@ -44,24 +45,15 @@ module Expressir
         end
       end
 
-      def benchmark_cache_from_yaml(yaml_path, cache_path)
-        say "Express Schema Loading Benchmark with Caching from YAML"
+      def benchmark_cache_from_manifest(manifest_path, cache_path)
+        say "Express Schema Loading Benchmark with Caching from Manifest"
         say "--------------------------------"
 
-        # Load schema list from YAML
-        schema_list = YAML.load_file(yaml_path)
-        if schema_list.is_a?(Hash) && schema_list["schemas"]
-          # Handle format: { "schemas": ["path1", "path2", ...] }
-          schema_files = schema_list["schemas"]
-        elsif schema_list.is_a?(Array)
-          # Handle format: ["path1", "path2", ...]
-          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(manifest_path)
+        schema_files = manifest.schemas.map(&:path)
 
-        say "YAML File: #{yaml_path}"
+        say "Manifest File: #{manifest_path}"
         say "Number of schemas in list: #{schema_files.size}"
         say "Cache: #{cache_path}"
         say "--------------------------------"

data/lib/expressir/commands/coverage.rb

@@ -32,27 +32,28 @@ module Expressir
 
       def collect_reports(paths)
         reports = []
+        ignored_files = parse_ignore_files
 
         paths.each do |path|
-          handle_path(path, reports)
+          handle_path(path, reports, ignored_files)
         end
 
         reports
       end
 
-      def handle_path(path, reports)
+      def handle_path(path, reports, ignored_files)
         if File.directory?(path)
-          handle_directory(path, reports)
+          handle_directory(path, reports, ignored_files)
         elsif File.extname(path).downcase == ".exp"
-          handle_express_file(path, reports)
+          handle_express_file(path, reports, ignored_files)
         elsif [".yml", ".yaml"].include?(File.extname(path).downcase)
-          handle_yaml_manifest(path, reports)
+          handle_schema_manifest(path, reports, ignored_files)
         else
           say "Unsupported file type: #{path}"
         end
       end
 
-      def handle_directory(path, reports)
+      def handle_directory(path, reports, ignored_files)
         say "Processing directory: #{path}"
         exp_files = Dir.glob(File.join(path, "**", "*.exp"))
         if exp_files.empty?
@@ -79,54 +80,38 @@ module Expressir
             progress.increment
           end
           skip_types = parse_skip_types
-          report = Expressir::Coverage::Report.from_repository(repository, skip_types)
+          report = Expressir::Coverage::Report.from_repository(
+            repository,
+            skip_types,
+            ignored_files,
+          )
           reports << report
         rescue StandardError => e
           say "Error processing directory #{path}: #{e.message}"
         end
       end
 
-      def handle_express_file(path, reports)
+      def handle_express_file(path, reports, ignored_files)
         say "Processing file: #{path}"
         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)
+          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)
-        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?
@@ -149,12 +134,15 @@ module Expressir
 
             # Create and add the report
             skip_types = parse_skip_types
-            report = Expressir::Coverage::Report.from_repository(repository, skip_types)
+            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
 
@@ -199,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
@@ -249,34 +238,66 @@ 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
 
       def build_structured_report(reports)
-        {
-          "overall" => {
-            "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)
-                                     else
-                                       100.0
-                                     end,
-          },
+        # Calculate ignored file statistics
+        ignored_files = reports.flat_map(&:ignored_file_reports)
+        ignored_entities_count = ignored_files.sum { |f| f["total"] }
+
+        overall_stats = {
+          "total_entities" => reports.sum { |r| r.total_entities.size },
+          "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,
+        }
+
+        # Add ignored file information if there are any
+        if ignored_files.any?
+          overall_stats["ignored_files_count"] = ignored_files.size
+          overall_stats["ignored_entities_count"] = ignored_entities_count
+        end
+
+        structured_report = {
+          "overall" => overall_stats,
           "files" => reports.flat_map(&:file_reports),
           "directories" => reports.flat_map(&:directory_reports),
         }
+
+        # Add ignored files section if there are any
+        if ignored_files.any?
+          structured_report["ignored_files"] = ignored_files
+        end
+
+        structured_report
       end
 
       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
 
@@ -343,6 +364,55 @@ module Expressir
           end
         end
       end
+
+      # Parse and expand ignore files from YAML
+      # @return [Hash] Hash mapping absolute file paths to their matched patterns
+      def parse_ignore_files
+        ignore_files_option = options["ignore_files"] || options[:ignore_files]
+        return {} unless ignore_files_option
+
+        unless File.exist?(ignore_files_option)
+          say "Warning: Ignore files YAML not found: #{ignore_files_option}"
+          return {}
+        end
+
+        begin
+          patterns = YAML.load_file(ignore_files_option)
+          unless patterns.is_a?(Array)
+            say "Warning: Invalid ignore files YAML format. Expected an array of file patterns."
+            return {}
+          end
+
+          ignore_files_dir = File.dirname(File.expand_path(ignore_files_option))
+          expanded_files = {}
+
+          patterns.each do |pattern|
+            # Resolve pattern relative to the YAML file's directory
+            full_pattern = File.expand_path(pattern, ignore_files_dir)
+
+            # Expand glob pattern
+            matched_files = Dir.glob(full_pattern)
+
+            if matched_files.empty?
+              say "Warning: No files matched pattern: #{pattern}"
+            else
+              matched_files.each do |file_path|
+                # Store absolute path and the original pattern that matched it
+                expanded_files[File.expand_path(file_path)] = pattern
+              end
+            end
+          end
+
+          if expanded_files.any?
+            say "Found #{expanded_files.size} files to ignore from patterns"
+          end
+
+          expanded_files
+        rescue StandardError => e
+          say "Warning: Error processing ignore files YAML #{ignore_files_option}: #{e.message}"
+          {}
+        end
+      end
     end
   end
 end

data/lib/expressir/coverage.rb

@@ -59,14 +59,16 @@ module Expressir
     # Represents a documentation coverage report for EXPRESS schemas
     class Report
       attr_reader :repository, :schema_reports, :total_entities, :documented_entities,
-                  :undocumented_entities
+                  :undocumented_entities, :ignored_files
 
       # Initialize a coverage report
       # @param repository [Expressir::Model::Repository] The repository to analyze
       # @param skip_types [Array<String>] Array of entity type names to skip from coverage
-      def initialize(repository, skip_types = [])
+      # @param ignored_files [Hash] Hash mapping absolute file paths to their matched patterns
+      def initialize(repository, skip_types = [], ignored_files = {})
         @repository = repository
         @skip_types = skip_types
+        @ignored_files = ignored_files
         @schema_reports = []
         @total_entities = []
         @documented_entities = []
@@ -78,18 +80,20 @@ module Expressir
       # Create a report from a repository
       # @param repository [Expressir::Model::Repository] The repository to analyze
       # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+      # @param ignored_files [Hash] Hash mapping absolute file paths to their matched patterns
       # @return [Report] The coverage report
-      def self.from_repository(repository, skip_types = [])
-        new(repository, skip_types)
+      def self.from_repository(repository, skip_types = [], ignored_files = {})
+        new(repository, skip_types, ignored_files)
       end
 
       # Create a report from a schema file
       # @param path [String] Path to the schema file
       # @param skip_types [Array<String>] Array of entity type names to skip from coverage
+      # @param ignored_files [Hash] Hash mapping absolute file paths to their matched patterns
       # @return [Report] The coverage report
-      def self.from_file(path, skip_types = [])
+      def self.from_file(path, skip_types = [], ignored_files = {})
         repository = Expressir::Express::Parser.from_file(path)
-        new(repository, skip_types)
+        new(repository, skip_types, ignored_files)
       end
 
       # Calculate the overall coverage percentage
@@ -113,6 +117,39 @@ module Expressir
             absolute_path
           end
 
+          file_report = {
+            "file" => relative_path,
+            "file_basename" => File.basename(absolute_path),
+            "directory" => File.dirname(absolute_path),
+            "total" => report[:total].size,
+            "documented" => report[:documented].size,
+            "undocumented" => report[:undocumented],
+            "coverage" => report[:coverage],
+            "ignored" => report[:ignored] || false,
+          }
+
+          # Add matched pattern for ignored files
+          if report[:ignored] && report[:matched_pattern]
+            file_report["matched_pattern"] = report[:matched_pattern]
+          end
+
+          file_report
+        end
+      end
+
+      # Get ignored file reports
+      # @return [Array<Hash>] Array of ignored file report hashes
+      def ignored_file_reports
+        @schema_reports.select { |report| report[:ignored] }.map do |report|
+          absolute_path = report[:schema].file
+          relative_path = begin
+            Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
+          rescue ArgumentError
+            # If paths are on different drives or otherwise incompatible,
+            # fall back to the absolute path
+            absolute_path
+          end
+
           {
             "file" => relative_path,
             "file_basename" => File.basename(absolute_path),
@@ -121,6 +158,7 @@ module Expressir
             "documented" => report[:documented].size,
             "undocumented" => report[:undocumented],
             "coverage" => report[:coverage],
+            "matched_pattern" => report[:matched_pattern],
           }
         end
       end
@@ -182,11 +220,14 @@ module Expressir
           schema_report = process_schema(schema)
           @schema_reports << schema_report
 
-          @total_entities.concat(schema_report[:total])
-          @documented_entities.concat(schema_report[:documented])
-          @undocumented_entities.concat(schema_report[:undocumented].map do |entity|
-            { schema: schema.id, entity: entity }
-          end)
+          # Only include non-ignored files in overall statistics
+          unless schema_report[:ignored]
+            @total_entities.concat(schema_report[:total])
+            @documented_entities.concat(schema_report[:documented])
+            @undocumented_entities.concat(schema_report[:undocumented].map do |entity|
+              { schema: schema.id, entity: entity }
+            end)
+          end
         end
       end
 
@@ -195,17 +236,26 @@ 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
 
+        # Check if this schema file is ignored
+        schema_file = File.expand_path(schema.file) if schema.file
+        ignored = @ignored_files.key?(schema_file)
+        matched_pattern = @ignored_files[schema_file] if ignored
+
         {
           schema: schema,
           total: entities,
           documented: documented,
           undocumented: undocumented.map { |e| format_entity(e) },
           coverage: coverage,
+          ignored: ignored,
+          matched_pattern: matched_pattern,
         }
       end
 
@@ -352,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
@@ -368,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
@@ -385,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
@@ -450,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
@@ -480,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(