simplecov 0.22.0 → 1.3.0

data/lib/simplecov/view_coverage/template_compiler.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ViewCoverage
+    #
+    # Compiles a single ActionView template: builds a `Template` for the file on
+    # disk and defines its method into a throwaway module, without ever
+    # rendering it.
+    #
+    # Defining the method is the whole trick. `Template#compile` hands the
+    # handler's generated Ruby to `module_eval(source, identifier, offset)`,
+    # and evaluating a `def` records the body as executable-but-unexecuted
+    # rather than running it, so `Coverage` comes away with a zeroed line array
+    # and a full set of branch tuples for the template.
+    #
+    # Never compile a template the suite already rendered. Evaluating the same
+    # identifier a second time replaces that file's entry in `Coverage` rather
+    # than adding to it, so the recompile would zero the hits the run actually
+    # earned and leave a duplicate set of branch tuples behind. `ViewCoverage`
+    # filters those out before calling here.
+    #
+    module TemplateCompiler
+      extend self
+
+      # False in any project that doesn't load ActionView, which is the common
+      # case and not an error: view coverage simply has nothing to do there.
+      def available?
+        !defined?(::ActionView::Template).nil?
+      end
+
+      # Answers whether the compile produced coverage data. A template that
+      # doesn't compile can't render either, so the suite has bigger problems
+      # than its coverage, but the report is not the place to discover that and
+      # a broken view must not take the whole run down.
+      def call(path)
+        template = build_template(path, File.binread(path))
+        return false unless template
+
+        compile_into_throwaway_module(template)
+        true
+      rescue StandardError, ScriptError => e
+        warn "[SimpleCov]: Skipping #{path}, which did not compile (#{e.class})"
+        false
+      end
+
+      # ActionView keeps `compile` private, and the module it compiles into is
+      # thrown away: what is wanted is the coverage the compile records, not the
+      # method it defines.
+      #
+      # mutant:disable -- `send` and `__send__` are the same call.
+      def compile_into_throwaway_module(template)
+        template.send(:compile, Module.new)
+      end
+
+      # The format the template renders, taken from the extension in front of the
+      # handler's: `show.html.erb` is `:html`. It reaches the handler's codegen
+      # (an HTML template escapes interpolations, a text one does not), but
+      # never the line structure, so a template named without one compiles fine
+      # as nil.
+      def format_for(path)
+        segments = File.basename(path).split(".")
+        return nil if segments.length < 3
+
+        segments.fetch(-2).to_sym
+      end
+
+      # The single place ActionView is named. The handler lookup is the one the
+      # resolver performs, so a template language the project has registered a
+      # handler for compiles here the way it does when rendered. Nil when
+      # nothing is registered for the extension, which is how a default glob
+      # naming `.haml` behaves in a project that has no Haml: ActionView would
+      # hand back the raw handler and the template would report as static text.
+      def build_template(path, source)
+        extension = File.extname(path).delete_prefix(".")
+        handler = ActionView::Template.registered_template_handler(extension)
+        return nil unless handler
+
+        no_locals = [] #: Array[Symbol]
+        ActionView::Template.new(source, path, handler, locals: no_locals, format: format_for(path))
+      end
+    end
+  end
+end

data/lib/simplecov/view_coverage.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "view_coverage/template_compiler"
+
+module SimpleCov
+  # Brings ActionView templates into the report, for projects that opt in with
+  # `cover_views`.
+  #
+  # Rendering a template is already enough to measure it: ActionView compiles
+  # each one with `module_eval(source, identifier, offset)` where `identifier`
+  # is the template's own path, and the offset cancels the `def` line its
+  # wrapper adds, so eval coverage attributes the generated code back to the
+  # `.erb` file at its own line numbers.
+  #
+  # A template no test renders is never compiled, so `Coverage` never hears
+  # about it and the report omits it entirely. That is the flattering
+  # direction to be wrong in, so every template the run didn't reach is
+  # compiled here instead, which lands it in the report at 0%.
+  module ViewCoverage
+    extend self
+
+    # Called once per process, immediately before `Coverage.result`. It has to
+    # happen here rather than at the merge point, where unloaded `.rb` files are
+    # injected, because compiling a template needs ActionView and the merging
+    # process need not have it loaded. A standalone `simplecov merge` never
+    # does.
+    def compile_unrendered
+      return [] unless enabled?
+
+      rendered = measured_paths
+      discover.reject { |path| rendered.include?(path) }
+        .select { |path| TemplateCompiler.call(path) }
+    end
+
+    def enabled?
+      SimpleCov.view_coverage? && Coverage.running? && TemplateCompiler.available?
+    end
+
+    # Expanded against `SimpleCov.root` rather than the working directory, and
+    # filtered through the same path-only filters the rest of the report honors,
+    # so `skip "app/views/admin"` keeps those templates out instead of compiling
+    # them only to drop them later.
+    def discover
+      globs = SimpleCov.view_globs || [] #: Array[String?]
+      UnloadedFileInjector.discover(globs, root: SimpleCov.root, reject: SimpleCov.filters.select(&:path_only?))
+    end
+
+    # The files `Coverage` is already holding data for, which for a template
+    # means the run rendered it. `peek_result` copies the whole coverage state
+    # to answer, so this stays a once-per-process call.
+    def measured_paths
+      Coverage.peek_result.keys.to_set
+    end
+  end
+end

data/lib/simplecov-html.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Backward-compatibility shim: simplecov-html is now part of simplecov.
+
+require_relative "simplecov/formatter/html_formatter"