fastlane-plugin-xccov 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 412fbf91781da61f5772cbc4d3968df23fbd0ce06500e95c89e74e22fa8eb2f4
+  data.tar.gz: 3d4e2832af54b56ead2dce3ae1515cc3a786f71bdd9f480b86c3fb1fe90b80a3
+SHA512:
+  metadata.gz: cab98982bf7e5f69720f4f7b87efbede989f9b0a4aed56a0661cfd5649786c5b261fb8c9bf385b7f18c5bd350a1b065e158f8e86c2cff23f0c1af5b4658d4566
+  data.tar.gz: 2c69a18ff3b0e1c42ee1b3a0945824458cd727a85c2af31ac5abc6a42c9a6e695787cbab912b4fec85cce3f9a495dd9d77bfcd7d12922e888b05f303a2ab25f1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Manish Rathi <i.am.manish.rathi@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,206 @@
+# xccov plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-xccov)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-xccov`, add it to your project by running:
+
+```bash
+fastlane add_plugin xccov
+```
+
+## About xccov
+
+A fastlane plugin that provides integration with Apple's `xccov` command-line tool for code coverage analysis. This plugin allows you to easily view, compare, and merge code coverage reports from your iOS and macOS test runs directly in your fastlane workflows.
+
+The plugin supports all major xccov commands:
+- **view**: Examine code coverage data from .xccovarchive, .xccovreport, or .xcresult files
+- **diff**: Compare code coverage between two reports
+- **merge**: Combine multiple coverage reports into a single report
+
+## Actions
+
+### xccov_view
+
+View code coverage data from .xccovarchive, .xccovreport, or .xcresult files.
+
+```ruby
+# View code coverage data from an xcresult bundle
+xccov_view(
+  file_path: "test_result.xcresult",
+  json: true
+)
+
+# View files for a specific target
+xccov_view(
+  file_path: "test_result.xcresult",
+  report: true,
+  files_for_target: "MyAppTarget",
+  json: true
+)
+
+# View only the targets from a coverage report
+xccov_view(
+  file_path: "coverage.xccovreport",
+  only_targets: true
+)
+
+# List files in an xccovarchive
+xccov_view(
+  file_path: "coverage.xccovarchive",
+  file_list: true
+)
+
+# View coverage for a specific file
+xccov_view(
+  file_path: "coverage.xccovarchive",
+  file: "MyApp/MyClass.swift"
+)
+
+# View functions for a specific file
+xccov_view(
+  file_path: "coverage.xccovreport",
+  functions_for_file: "MyApp/MyClass.swift"
+)
+```
+
+### xccov_diff
+
+Compare code coverage between two .xccovreport or .xcresult files.
+
+```ruby
+# Compare coverage between two xccovreport files
+xccov_diff(
+  before_path: "before.xccovreport",
+  after_path: "after.xccovreport",
+  json: true
+)
+
+# Compare coverage between two xcresult bundles
+xccov_diff(
+  before_path: "before.xcresult",
+  after_path: "after.xcresult",
+  json: true
+)
+
+# Compare coverage with path equivalence for files that moved 
+xccov_diff(
+  before_path: "before.xcresult",
+  after_path: "after.xcresult",
+  path_equivalence: "/OldPath,/NewPath",
+  json: true
+)
+```
+
+### xccov_merge
+
+Merge multiple .xccovreport and (optionally) .xccovarchive files into a single coverage report.
+
+```ruby
+# Merge multiple xccovreport files
+xccov_merge(
+  reports: ["report1.xccovreport", "report2.xccovreport"],
+  out_report: "merged.xccovreport"
+)
+
+# Merge multiple xccovreport files with their corresponding archives
+xccov_merge(
+  reports: ["report1.xccovreport", "report2.xccovreport"],
+  archives: ["archive1.xccovarchive", "archive2.xccovarchive"],
+  out_report: "merged.xccovreport",
+  out_archive: "merged.xccovarchive"
+)
+```
+
+### Wrapper Action
+
+You can also use the main `xccov` action as a wrapper that delegates to the specific command actions:
+
+```ruby
+# Using the wrapper action for view
+xccov(
+  command: :view,
+  file_path: "coverage.xcresult",
+  json: true
+)
+
+# Using the wrapper action for diff
+xccov(
+  command: :diff,
+  before_path: "before.xcresult",
+  after_path: "after.xcresult",
+  json: true
+)
+
+# Using the wrapper action for merge
+xccov(
+  command: :merge,
+  reports: ["report1.xccovreport", "report2.xccovreport"],
+  out_report: "merged.xccovreport"
+)
+```
+
+## Example Fastfile
+
+Here's an example of how you might integrate xccov into your fastlane workflow:
+
+```ruby
+lane :analyze_coverage do
+  # Run tests and generate coverage report
+  scan(
+    scheme: "MyApp",
+    code_coverage: true,
+    derived_data_path: "./DerivedData",
+    result_bundle: true
+  )
+  
+  # Get the path to the latest test result
+  xcresult_path = Dir["./DerivedData/Logs/Test/Run-*.xcresult"].sort_by { |f| File.mtime(f) }.last
+  
+  # View coverage summary
+  coverage_data = xccov_view(
+    file_path: xcresult_path,
+    report: true,
+    only_targets: true,
+    json: true
+  )
+  
+  # Parse the coverage data and fail if below threshold
+  total_coverage = coverage_data.first["lineCoverage"]
+  UI.message "Total coverage: #{(total_coverage * 100).round(2)}%"
+  
+  if total_coverage < 0.7  # 70% threshold
+    UI.user_error!("Code coverage is below the required threshold of 70%")
+  end
+end
+```
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/xccov/actions/xccov_action.rb

@@ -0,0 +1,64 @@
+require 'fastlane/action'
+require_relative '../helper/xccov_helper'
+
+module Fastlane
+  module Actions
+    class XccovAction < Action
+      def self.run(params)
+        UI.user_error!("No command specified. Use :view, :diff, or :merge") unless params[:command]
+
+        case params[:command]
+        when :view
+          return other_action.xccov_view(params.except(:command))
+        when :diff
+          return other_action.xccov_diff(params.except(:command))
+        when :merge
+          return other_action.xccov_merge(params.except(:command))
+        else
+          UI.user_error!("Unknown command: #{params[:command]}. Use :view, :diff, or :merge")
+        end
+      end
+
+      def self.description
+        "A fastlane plugin for xccov tool that provides code coverage functionality"
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.return_value
+        "Returns the result of the xccov command execution"
+      end
+
+      def self.details
+        "A fastlane plugin for the xccov tool that allows you to view, diff, and merge code coverage reports 🚀"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :command,
+                                  env_name: "XCCOV_COMMAND",
+                               description: "Which xccov command to run: view, diff, or merge",
+                                  optional: false,
+                                      type: Symbol,
+                             verify_block: proc do |value|
+                                             UI.user_error!("Command must be one of: :view, :diff, :merge") unless [:view, :diff, :merge].include?(value)
+                                           end)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xccov(command: :view, file_path: "coverage.xcresult", json: true)',
+          'xccov(command: :diff, before_path: "before.xcresult", after_path: "after.xcresult", json: true)',
+          'xccov(command: :merge, reports: ["report1.xccovreport", "report2.xccovreport"], archives: ["archive1.xccovarchive", "archive2.xccovarchive"], out_report: "merged.xccovreport")'
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xccov/actions/xccov_diff_action.rb

@@ -0,0 +1,100 @@
+require 'fastlane/action'
+require_relative '../helper/xccov_helper'
+
+module Fastlane
+  module Actions
+    class XccovDiffAction < Action
+      def self.run(params)
+        cmd = ["xcrun", "xccov", "diff"]
+        
+        # Add json flag if requested
+        cmd << "--json" if params[:json]
+        
+        # Add path equivalence if provided
+        if params[:path_equivalence]
+          from, to = params[:path_equivalence].split(",")
+          cmd << "--path-equivalence" << "#{from},#{to}"
+        end
+        
+        # Add before and after paths
+        cmd << params[:before_path]
+        cmd << params[:after_path]
+        
+        # Execute command
+        result = Helper::XccovHelper.run_command(cmd.join(" "))
+        
+        # Parse JSON if requested
+        if params[:json] && result
+          require 'json'
+          begin
+            return JSON.parse(result)
+          rescue JSON::ParserError => e
+            UI.error("Failed to parse JSON: #{e.message}")
+            return result
+          end
+        end
+        
+        return result
+      end
+
+      def self.description
+        "Compare code coverage data using Apple's xccov diff command"
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.return_value
+        "Returns the output of the xccov diff command (string or parsed JSON)"
+      end
+
+      def self.details
+        "This action allows you to compare code coverage between two .xccovreport or .xcresult files"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :before_path,
+                                  env_name: "XCCOV_DIFF_BEFORE_PATH",
+                               description: "Path to the 'before' coverage file (.xccovreport or .xcresult)",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("File does not exist at path '#{value}'") unless File.exist?(value)
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :after_path,
+                                  env_name: "XCCOV_DIFF_AFTER_PATH",
+                               description: "Path to the 'after' coverage file (.xccovreport or .xcresult)",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("File does not exist at path '#{value}'") unless File.exist?(value)
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :json,
+                                  env_name: "XCCOV_DIFF_JSON",
+                               description: "Output in JSON format",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+          FastlaneCore::ConfigItem.new(key: :path_equivalence,
+                                  env_name: "XCCOV_DIFF_PATH_EQUIVALENCE",
+                               description: "Path equivalence for different file paths in comma-separated format 'from,to'",
+                                  optional: true,
+                                      type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xccov_diff(before_path: "before.xccovreport", after_path: "after.xccovreport", json: true)',
+          'xccov_diff(before_path: "before.xcresult", after_path: "after.xcresult", json: true, path_equivalence: "/OldPath,/NewPath")'
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xccov/actions/xccov_merge_action.rb

@@ -0,0 +1,103 @@
+require 'fastlane/action'
+require_relative '../helper/xccov_helper'
+
+module Fastlane
+  module Actions
+    class XccovMergeAction < Action
+      def self.run(params)
+        cmd = ["xcrun", "xccov", "merge"]
+        
+        # Add output report path if provided
+        cmd << "--outReport" << params[:out_report] if params[:out_report]
+        
+        # Add output archive path if provided
+        cmd << "--outArchive" << params[:out_archive] if params[:out_archive]
+        
+        # Add all report and archive pairs
+        if params[:reports] && params[:archives]
+          if params[:reports].length != params[:archives].length
+            UI.user_error!("The number of reports and archives must be the same")
+          end
+          
+          params[:reports].each_with_index do |report, index|
+            cmd << report
+            cmd << params[:archives][index]
+          end
+        elsif params[:reports]
+          # Just add reports if provided without archives
+          params[:reports].each { |report| cmd << report }
+        end
+        
+        # Execute command
+        return Helper::XccovHelper.run_command(cmd.join(" "))
+      end
+
+      def self.description
+        "Merge code coverage data using Apple's xccov merge command"
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.return_value
+        "Returns the output of the xccov merge command"
+      end
+
+      def self.details
+        "This action allows you to merge multiple .xccovreport and .xccovarchive files into a single coverage report"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :reports,
+                                  env_name: "XCCOV_MERGE_REPORTS",
+                               description: "Paths to the .xccovreport files to merge",
+                                  optional: false,
+                                      type: Array,
+                              verify_block: proc do |value|
+                                              value.each do |path|
+                                                UI.user_error!("Report does not exist at path '#{path}'") unless File.exist?(path)
+                                              end
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :archives,
+                                  env_name: "XCCOV_MERGE_ARCHIVES",
+                               description: "Paths to the .xccovarchive files to merge (should match the number of reports)",
+                                  optional: true,
+                                      type: Array,
+                              verify_block: proc do |value|
+                                              value.each do |path|
+                                                UI.user_error!("Archive does not exist at path '#{path}'") unless File.exist?(path)
+                                              end
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :out_report,
+                                  env_name: "XCCOV_MERGE_OUT_REPORT",
+                               description: "Path where the merged .xccovreport will be saved",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :out_archive,
+                                  env_name: "XCCOV_MERGE_OUT_ARCHIVE",
+                               description: "Path where the merged .xccovarchive will be saved",
+                                  optional: true,
+                                      type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xccov_merge(reports: ["report1.xccovreport", "report2.xccovreport"], out_report: "merged.xccovreport")',
+          'xccov_merge(
+            reports: ["report1.xccovreport", "report2.xccovreport"],
+            archives: ["archive1.xccovarchive", "archive2.xccovarchive"],
+            out_report: "merged.xccovreport",
+            out_archive: "merged.xccovarchive"
+          )'
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xccov/actions/xccov_view_action.rb

@@ -0,0 +1,146 @@
+require 'fastlane/action'
+require_relative '../helper/xccov_helper'
+
+module Fastlane
+  module Actions
+    class XccovViewAction < Action
+      def self.run(params)
+        cmd = ["xcrun", "xccov", "view"]
+
+        # Handle file viewing options
+        if params[:file_list]
+          cmd << "--file-list"
+        elsif params[:file]
+          cmd << "--file" << params[:file]
+        end
+
+        # Handle target viewing options
+        if params[:only_targets]
+          cmd << "--only-targets"
+        elsif params[:files_for_target]
+          cmd << "--files-for-target" << params[:files_for_target]
+        elsif params[:functions_for_file]
+          cmd << "--functions-for-file" << params[:functions_for_file]
+        end
+
+        # Handle result bundle modes
+        if params[:archive]
+          cmd << "--archive"
+        elsif params[:report]
+          cmd << "--report"
+        end
+
+        # Handle JSON output
+        cmd << "--json" if params[:json]
+
+        # Add the file path at the end
+        cmd << params[:file_path]
+
+        # Execute command
+        result = Helper::XccovHelper.run_command(cmd.join(" "))
+
+        # Parse JSON if requested
+        if params[:json] && result
+          require 'json'
+          begin
+            return JSON.parse(result)
+          rescue JSON::ParserError => e
+            UI.error("Failed to parse JSON: #{e.message}")
+            return result
+          end
+        end
+
+        return result
+      end
+
+      def self.description
+        "View code coverage data using Apple's xccov tool"
+      end
+
+      def self.authors
+        ["crazymanish"]
+      end
+
+      def self.return_value
+        "Returns the output of the xccov view command (string or parsed JSON)"
+      end
+
+      def self.details
+        "This action allows you to view code coverage data from .xccovarchive, .xccovreport, or .xcresult files"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :file_path,
+                                  env_name: "XCCOV_FILE_PATH",
+                               description: "Path to the coverage file (.xccovarchive, .xccovreport, or .xcresult)",
+                                  optional: false,
+                                      type: String,
+                              verify_block: proc do |value|
+                                              UI.user_error!("File does not exist at path '#{value}'") unless File.exist?(value)
+                                            end),
+          FastlaneCore::ConfigItem.new(key: :file_list,
+                                  env_name: "XCCOV_FILE_LIST",
+                               description: "Display list of files",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+          FastlaneCore::ConfigItem.new(key: :file,
+                                  env_name: "XCCOV_FILE",
+                               description: "Path to a specific file to view coverage for",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :only_targets,
+                                  env_name: "XCCOV_ONLY_TARGETS",
+                               description: "Display only the targets from the report",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+          FastlaneCore::ConfigItem.new(key: :files_for_target,
+                                  env_name: "XCCOV_FILES_FOR_TARGET",
+                               description: "Display the files for a specific target",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :functions_for_file,
+                                  env_name: "XCCOV_FUNCTIONS_FOR_FILE",
+                               description: "Display the functions for a specific file",
+                                  optional: true,
+                                      type: String),
+          FastlaneCore::ConfigItem.new(key: :json,
+                                  env_name: "XCCOV_JSON",
+                               description: "Output in JSON format",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+          FastlaneCore::ConfigItem.new(key: :archive,
+                                  env_name: "XCCOV_ARCHIVE",
+                               description: "Treat .xcresult as an archive",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false),
+          FastlaneCore::ConfigItem.new(key: :report,
+                                  env_name: "XCCOV_REPORT",
+                               description: "Treat .xcresult as a report",
+                                  optional: true,
+                                 is_string: false,
+                             default_value: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'xccov_view(file_path: "coverage.xcresult", json: true)',
+          'xccov_view(file_path: "coverage.xccovarchive", file_list: true)',
+          'xccov_view(file_path: "coverage.xccovreport", only_targets: true)',
+          'xccov_view(file_path: "coverage.xccovarchive", file: "MyApp/MyClass.swift")',
+          'xccov_view(file_path: "coverage.xcresult", archive: true, json: true)',
+          'xccov_view(file_path: "coverage.xcresult", report: true, files_for_target: "MyTarget")'
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xccov/helper/xccov_helper.rb

@@ -0,0 +1,32 @@
+require 'fastlane_core/ui/ui'
+require 'open3'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class XccovHelper
+      # Executes a shell command and returns the output
+      def self.run_command(command)
+        UI.verbose("Running command: #{command}")
+        
+        stdout, stderr, status = Open3.capture3(command)
+        
+        if status.success?
+          return stdout.strip
+        else
+          UI.error("Command failed: #{command}")
+          UI.error("Error: #{stderr}")
+          UI.user_error!("Failed to execute xccov command")
+        end
+      end
+
+      # class methods that you define here become available in your action
+      # as `Helper::XccovHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the xccov plugin helper!")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module Xccov
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/xccov.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/xccov/version'
+
+module Fastlane
+  module Xccov
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::Xccov.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-xccov
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Manish Rathi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-05-09 00:00:00.000000000 Z
+dependencies: []
+description:
+email: i.am.manish.rathi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/xccov.rb
+- lib/fastlane/plugin/xccov/actions/xccov_action.rb
+- lib/fastlane/plugin/xccov/actions/xccov_diff_action.rb
+- lib/fastlane/plugin/xccov/actions/xccov_merge_action.rb
+- lib/fastlane/plugin/xccov/actions/xccov_view_action.rb
+- lib/fastlane/plugin/xccov/helper/xccov_helper.rb
+- lib/fastlane/plugin/xccov/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: A fastlane plugin for xcov.
+test_files: []