fastlane-plugin-stream_actions 0.4.13 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 637f0d12b17b61c738e37e6530202c347d45776ec6281591c1b6ea94e162d501
-  data.tar.gz: fc3494f5e33aa0e6cde00c3bb741880e709338f670742a4a1697774f8fcd36af
+  metadata.gz: d8d838fe7bdba0809e724b8ceffcdd8a9681c65597a7315085c8eda719afd520
+  data.tar.gz: e8e093b56d26b398288396cff51df3b063e776a80a9aa82231d9859d5b76317a
 SHA512:
-  metadata.gz: 9fe31f2ee1e876d9bab6e7e434d06b74f9de6f9bf70124afda534638d8c6eb96e88c49f06c05669f432bdcfdbcf6024e4317cf4646202d53c78e82c2d58093a1
-  data.tar.gz: df42ca37cabdb7c533379f407aa3dfd21898214eb1206ca61cfad635f082562e91cc9bd35153ba06c7f736181151369c06e8b7aafd80df7a3a1bd2e118742ece
+  metadata.gz: abcc77e118f5c4c023c099544a850f0e8f2989d83510d15e9bd086b0f1a9fe00f6ea07ef753ca3cf382508032f5a26b6877ca06d3dbfb040776ab0c1a6df16f1
+  data.tar.gz: 3d7c1c83fab37d3096946d1064d30e82a733995dd7cca21813f568de18d64f61dca101241a75ca1cd8f93a0f01f308257406fead0f15ff7e62f1f47a12c09839

data/lib/fastlane/plugin/stream_actions/actions/build_test_coverage_map.rb

@@ -2,15 +2,36 @@ require 'json'
 require 'open3'
 require 'set'
 require 'time'
+require 'tmpdir'
 
 module Fastlane
   module Actions
     class BuildTestCoverageMapAction < Action
       def self.run(params)
         source_root = File.expand_path(params[:source_root] || Dir.pwd)
+        sources, tests = params[:class_dirs] ? jacoco_coverage(params, source_root) : llvm_coverage(params, source_root)
+
+        carry_over_failed_tests(tests, sources, params) unless params[:failed_tests].to_a.empty?
+        drop_untracked(tests, sources, source_root)
+
+        map = {
+          'version' => Helper::TestCoverageMapHelper::MAP_VERSION,
+          'generated_at' => Time.now.utc.iso8601,
+          'commit' => params[:commit],
+          'sources' => sources.sort,
+          'tests' => tests.sort.to_h
+        }
+        write(map, params[:output_path])
+        UI.success("Coverage map of #{tests.size} tests and #{map['sources'].size} sources saved to #{params[:output_path]}")
+        map
+      end
+
+      # iOS: one folder of .profraw files per test, `<coverage_dir>/<TestClass>/<testMethod>/`.
+      def self.llvm_coverage(params, source_root)
         test_dirs = Dir.glob(File.join(params[:coverage_dir], '*', '*')).select { |dir| File.directory?(dir) }
         UI.user_error!("No per-test coverage found in '#{params[:coverage_dir]}'") if test_dirs.empty?
 
+        UI.user_error!('Pass the instrumented binaries or the class_dirs') if params[:binaries].to_a.empty?
         binaries = params[:binaries].select { |binary| File.exist?(binary) }
         UI.user_error!('None of the instrumented binaries exist') if binaries.empty?
 
@@ -41,20 +62,81 @@ module Fastlane
           end
         end
         workers.each(&:join)
+        [sources, tests]
+      end
 
-        carry_over_failed_tests(tests, sources, params) unless params[:failed_tests].to_a.empty?
-        drop_untracked(tests, sources, source_root)
+      # Android: one JaCoCo `.ec` file per test, named `<package>.<TestClass>#<testMethod>.ec` by the test orchestrator.
+      def self.jacoco_coverage(params, source_root)
+        exec_files = Dir.glob(File.join(params[:coverage_dir], '**', '*.ec'))
+        UI.user_error!("No per-test coverage found in '#{params[:coverage_dir]}'") if exec_files.empty?
 
-        map = {
-          'version' => Helper::TestCoverageMapHelper::MAP_VERSION,
-          'generated_at' => Time.now.utc.iso8601,
-          'commit' => params[:commit],
-          'sources' => sources.sort,
-          'tests' => tests.sort.to_h
-        }
-        write(map, params[:output_path])
-        UI.success("Coverage map of #{tests.size} tests and #{map['sources'].size} sources saved to #{params[:output_path]}")
-        map
+        class_dirs = params[:class_dirs].select { |dir| File.directory?(dir) }
+        UI.user_error!('None of the class_dirs exist') if class_dirs.empty?
+
+        UI.message("Building the coverage map of #{exec_files.size} tests ⌛️")
+        cli = params[:jacoco_cli] || download_jacoco_cli
+        paths = kotlin_and_java_paths(source_root)
+        source_of_class = jacoco_class_sources(cli, class_dirs).transform_values { |key| paths[key] }.compact
+
+        tests = {}
+        jacoco_executed_classes(cli, exec_files).each do |file, classes|
+          test_class, method = File.basename(file, '.ec').split('#', 2)
+          next UI.important("#{File.basename(file)} is not named <TestClass>#<testMethod>.ec, skipping") if method.nil?
+
+          tests["#{test_class.split('.').last}/#{method}"] = classes.flat_map { |name| source_of_class[name].to_a }.uniq
+        end
+        [source_of_class.values.flatten.uniq, tests]
+      end
+
+      # Class name => `<package path>/<source file name>`, from an XML report of the class files without execution data.
+      # Classes without code (interfaces, annotations, constants) are empty `<class/>` elements and stay out, like
+      # declaration-only files in llvm-cov. One report per folder, as JaCoCo fails on a class name that two folders
+      # define differently (e.g. a stale build).
+      def self.jacoco_class_sources(cli, class_dirs)
+        Dir.mktmpdir('jacoco') do |dir|
+          xml = File.join(dir, 'classes.xml')
+          class_dirs.each_with_object({}) do |class_dir, sources|
+            Helper::TestCoverageMapHelper.command('java', '-jar', cli, 'report', '--classfiles', class_dir, '--xml', xml, '--quiet')
+            File.read(xml).scan(/<class name="([^"]+)" sourcefilename="([^"]+)">/).each do |name, source|
+              sources[name] ||= "#{File.dirname(name)}/#{source}"
+            end
+          end
+        end
+      end
+
+      # Exec file => names of the classes with at least one executed probe.
+      def self.jacoco_executed_classes(cli, exec_files)
+        exec_files.each_slice(100).with_object({}) do |slice, result|
+          current = nil
+          Helper::TestCoverageMapHelper.command('java', '-jar', cli, 'execinfo', *slice).each_line do |line|
+            if (loaded = line[/\[INFO\] Loading exec file (.+)\.$/, 1])
+              current = result[loaded] = []
+            elsif current && (hit = line.match(/^\h+\s+(\d+) of\s+\d+\s+(\S+)$/)) && hit[1].to_i.positive?
+              current << hit[2]
+            end
+          end
+        end
+      end
+
+      # `<package path>/<file name>` => repository paths of the tracked Kotlin and Java files. The package comes from the
+      # file, as a Kotlin file does not have to sit in the folder of its package.
+      def self.kotlin_and_java_paths(source_root)
+        files = Helper::TestCoverageMapHelper.command('git', '-C', source_root, 'ls-files', '*.kt', '*.java').split("\n")
+        files.each_with_object({}) do |file, paths|
+          package = File.foreach(File.join(source_root, file)).lazy.map { |line| line[/^\s*package\s+([\w.]+)/, 1] }.find(&:itself)
+          (paths["#{package.to_s.tr('.', '/')}/#{File.basename(file)}".delete_prefix('/')] ||= []) << file
+        end
+      end
+
+      def self.download_jacoco_cli
+        version = '0.8.13'
+        path = File.join(Dir.tmpdir, "jacococli-#{version}.jar")
+        return path if File.exist?(path)
+
+        url = "https://repo1.maven.org/maven2/org/jacoco/org.jacoco.cli/#{version}/org.jacoco.cli-#{version}-nodeps.jar"
+        Helper::TestCoverageMapHelper.command('curl', '-sSfL', '-o', "#{path}.part", url)
+        File.rename("#{path}.part", path)
+        path
       end
 
       # Returns the instrumented files (`all`) and the files with at least one executed line (`covered`).
@@ -152,15 +234,21 @@ module Fastlane
       #####################################################
 
       def self.description
-        'Builds a map of which source files every test executes, from per-test LLVM coverage profiles'
+        'Builds a map of which source files every test executes, from per-test LLVM or JaCoCo coverage'
       end
 
       def self.details
         <<~DETAILS
-          Expects one folder per test, `<coverage_dir>/<TestClass>/<testMethod>/`, holding the `.profraw` files
+          iOS: expects one folder per test, `<coverage_dir>/<TestClass>/<testMethod>/`, holding the `.profraw` files
           the app wrote while that test ran (e.g. via `LLVM_PROFILE_FILE=<dir>/<TestClass>/<testMethod>/%m_%p%c.profraw`
           in the app's launch environment). Each folder is merged with `llvm-profdata` and exported with `llvm-cov`
-          against the instrumented `binaries`. The resulting JSON map feeds `select_impacted_tests`.
+          against the instrumented `binaries`.
+
+          Android: pass `class_dirs` instead of `binaries`, and a `coverage_dir` holding one JaCoCo `.ec` file per test,
+          `<package>.<TestClass>#<testMethod>.ec`, which the test orchestrator writes with `-e coverage true
+          -e coverageFilePath <dir>/`. A source file counts as executed when one of its classes ran a probe.
+
+          The resulting JSON map feeds `select_impacted_tests`.
         DETAILS
       end
 
@@ -178,7 +266,19 @@ module Fastlane
           FastlaneCore::ConfigItem.new(
             key: :binaries,
             description: 'Instrumented binaries the profiles belong to, e.g. the app executable (or its .debug.dylib) and every SDK framework',
-            type: Array
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :class_dirs,
+            description: 'Android: folders with the compiled classes of the app and its modules. Switches to JaCoCo coverage',
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :jacoco_cli,
+            description: 'Android: path to the JaCoCo CLI jar (org.jacoco.cli nodeps). Downloaded when not set',
+            optional: true
           ),
           FastlaneCore::ConfigItem.new(
             key: :source_root,
@@ -240,6 +340,11 @@ module Fastlane
             coverage_dir: "test_output/coverage",
             binaries: ["App.app/App.debug.dylib", "App.app/Frameworks/SDK.framework/SDK"],
             output_path: "test_output/e2e_coverage_map.json"
+          )',
+          'build_test_coverage_map(
+            coverage_dir: "coverage",
+            class_dirs: Dir.glob("*/build/intermediates/classes/debug/**/dirs"),
+            output_path: "e2e_coverage_map.json"
           )'
         ]
       end
@@ -249,7 +354,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        [:ios, :mac].include?(platform)
+        [:ios, :mac, :android].include?(platform)
       end
     end
   end

data/lib/fastlane/plugin/stream_actions/actions/select_impacted_tests.rb

@@ -6,7 +6,8 @@ module Fastlane
   module Actions
     class SelectImpactedTestsAction < Action
       CODE_EXTENSIONS = %w[.swift .m .mm .h .kt .java .dart .js .jsx .ts .tsx].freeze
-      MODIFIERS = '(?:(?:public|open|internal|fileprivate|private|final|indirect|nonisolated|data|sealed|abstract|export|default)\\s+)*'
+      # Kotlin's `enum class` and `fun interface` name the type after the second keyword.
+      MODIFIERS = '(?:(?:public|open|internal|fileprivate|private|protected|final|indirect|nonisolated|data|sealed|abstract|annotation|value|inline|inner|enum(?=\\s+class\\b)|fun(?=\\s+interface\\b)|export|default)\\s+)*'
       DECLARATION = /^\s*(?:@\w+(?:\([^)\n]*\))?\s+)*#{MODIFIERS}(class|struct|enum|protocol|actor|typealias|extension|interface|object)\s+([A-Za-z_]\w*)/.freeze
 
       def self.run(params)

data/lib/fastlane/plugin/stream_actions/actions/show_sdk_size.rb

@@ -6,6 +6,7 @@ module Fastlane
         fail_status = '🔴' # Failure if a branch is more than #{max_tolerance} less performant than the benchmark
         success_status = '🟢' # Success if a branch is more performant or equals to the benchmark
         outstanding_status = '🚀' # Outstanding performance
+        new_status = '🆕' # No benchmark yet, e.g. a newly tracked size
 
         metrics_dir = 'metrics'
         FileUtils.remove_dir(metrics_dir, force: true)
@@ -23,7 +24,13 @@ module Fastlane
         params[:branch_sizes].each do |sdk_name, branch_value_kb|
           branch_value_mb = (branch_value_kb / 1024.0).round(2)
           branch_value = is_kb ? branch_value_kb.round(0) : branch_value_mb
-          benchmark_value_kb = benchmark_sizes[sdk_name.to_s] || 0
+          benchmark_value_kb = benchmark_sizes[sdk_name.to_s]
+          # A size the benchmark doesn't track yet has nothing to compare against. Only a push to the base
+          # branch or a release branch run rewrites the benchmark (see below), so PRs show it as new until then.
+          if benchmark_value_kb.nil?
+            markdown_table << "|#{sdk_name}|n/a|#{branch_value} #{params[:size_ext]}|n/a|#{new_status}|\n"
+            next
+          end
           benchmark_value_mb = (benchmark_value_kb / 1024.0).round(2)
           benchmark_value = is_kb ? benchmark_value_kb.round(0) : benchmark_value_mb
 
@@ -32,8 +39,8 @@ module Fastlane
           diff = is_kb ? diff_b : diff_kb
           diff_ext = is_kb ? 'B' : 'KB'
 
-          max_tolerance = params[:max_tolerance] || diff_ext == 'B' ? 5000 : 500 # By default, Max Tolerance is 5000 Bytes or 500 Kilobytes
-          fine_tolerance = params[:fine_tolerance] || diff_ext == 'B' ? 2500 : 250 # By default, Fine Tolerance is 2500 Bytes or 250 Kilobytes
+          max_tolerance = params[:max_tolerance] || (diff_ext == 'B' ? 5000 : 500) # By default, Max Tolerance is 5000 Bytes or 500 Kilobytes
+          fine_tolerance = params[:fine_tolerance] || (diff_ext == 'B' ? 2500 : 250) # By default, Fine Tolerance is 2500 Bytes or 250 Kilobytes
 
           diff_sign = if diff.zero?
                         ''

data/lib/fastlane/plugin/stream_actions/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module StreamActions
-    VERSION = '0.4.13'
+    VERSION = '0.4.15'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-stream_actions
 version: !ruby/object:Gem::Version
-  version: 0.4.13
+  version: 0.4.15
 platform: ruby
 authors:
 - GetStream
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xctest_list
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: fastlane
   requirement: !ruby/object:Gem::Requirement