fastlane-plugin-xbluepill 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e04d8dc9e2e9a52225a2b69f0ed58b1acb4fa98c
+  data.tar.gz: df5521cf0ddddb337dbadac239116cc9f0d17b4f
+SHA512:
+  metadata.gz: aabb968c7a494c50b8703e6bbfd345fc269982d4462fb512c13e47a9f18ca033e7e3cbd4172fa693d1d417e2df0bf725322ba1aa0b9965fad8be8c8a72933377
+  data.tar.gz: 9b80d85ffd814cd896b3be1e9cf8065ff8f48c0029be32bc85c955e67b9274d8a259605b5a67614ce09298d3fd40d06d4a183a9a0aaba43d3dbb2eec671e47fc

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 UladzimirKisialiou <uladzimir_kisialiou@epam.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,81 @@
+# xbluepill plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-xbluepill)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-xbluepill`, add it to your project by running:
+
+```bash
+fastlane add_plugin xbluepill
+```
+
+## About xbluepill
+
+It is a fastlane plugin that allows to use bluepill (linkedin library) as a fastlane command
+
+**Note to author:** Add a more detailed description about this plugin here. If your plugin contains multiple actions, make sure to mention them here.
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+
+**Note to author:** Please set up a sample project to make it easy for users to explore what your plugin does. Provide everything that is necessary to try out the plugin in this project (including a sample Xcode/Android project if necessary)
+
+## 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).
+
+## License of Bluepill
+
+BSD 2-CLAUSE LICENSE
+
+Copyright 2016 LinkedIn Corporation.
+All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/lib/fastlane/plugin/xbluepill.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/xbluepill/version'
+
+module Fastlane
+  module Xbluepill
+    # 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::Xbluepill.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/xbluepill/actions/xbluepill_action.rb

@@ -0,0 +1,344 @@
+require 'fastlane/action'
+require 'fastlane/actions/scan'
+require_relative '../helper/xbluepill_helper'
+
+module Fastlane
+  module Actions
+    class XbluepillAction < Action
+      def self.run(params)
+        puts(params)
+        UI.message("The xbluepill plugin is working!")
+
+        sh("rm -rf ./xbluepill")
+        sh("rm -rf ./xbluepill_output")
+
+        scan_options = {}
+        scan_options[:workspace] = params[:workspace]
+        scan_options[:scheme] = params[:scheme]
+        scan_options[:build_for_testing] = true
+        scan_options[:derived_data_path] = "./xbluepill"
+        scan_options[:buildlog_path] = "./xbluepill/logs/"
+        config = FastlaneCore::Configuration.create(Fastlane::Actions::ScanAction.available_options, scan_options)
+        Fastlane::Actions::ScanAction.run(config)
+
+        xctestrun_path = Dir.glob("./xbluepill/Build/Products/*.xctestrun")[0].to_s
+        app = Dir.glob("./xbluepill/Build/Products/Debug-*/*.app")[0].to_s
+
+        cmd = get_bp_binary.to_s
+
+        add_required_param(cmd, "--xctestrun-path", xctestrun_path)
+        add_required_param(cmd, "-o", params[:output_dir])
+
+        add_optional_param(cmd, "-a", app)
+        add_optional_param(cmd, "-c", params[:config])
+        add_optional_param(cmd, "-d", params[:device])
+        add_optional_param_array(cmd, "-x", params[:exclude])
+        add_optional_param_array(cmd, "-i", params[:include])
+        add_optional_param_not_string(cmd, "--headless", params[:headless])
+        add_optional_param(cmd, "-X", params[:xcode_path])
+        add_optional_param_not_string(cmd, "-J", params[:json_output])
+        add_optional_param_not_string(cmd, "-j", params[:junit_output])
+        add_optional_param_not_string(cmd, "-l", params[:list_tests])
+        add_optional_param_not_string(cmd, "-n", params[:num_sims])
+        add_optional_param_not_string(cmd, "-p", params[:plain_output])
+        add_optional_param(cmd, "-P", params[:printf_config])
+        add_optional_param_not_string(cmd, "-R", params[:error_retries])
+        add_optional_param_not_string(cmd, "-f", params[:failure_tolerance])
+        add_optional_param_not_string(cmd, "-F", params[:only_retry_failed])
+        add_optional_param(cmd, "-r", params[:runtime])
+        add_optional_param(cmd, "-S", params[:stuck_timeout])
+        add_optional_param(cmd, "-T", params[:test_timeout])
+        add_optional_param(cmd, "-t", params[:test_bundle_path])
+        add_optional_param_not_string(cmd, "--additional-unit-xctests", params[:additional_unit_xctests])
+        add_optional_param_not_string(cmd, "--additional-ui-xctests", params[:additional_ui_xctests])
+        add_optional_param_not_string(cmd, "-C", params[:repeat_count])
+        add_optional_param(cmd, "-N", params[:no_split])
+        add_optional_param_not_string(cmd, "-q", params[:quiet])
+        add_optional_param_not_string(cmd, "--reuse-simulator", params[:reuse_simulator])
+        add_optional_param_not_string(cmd, "--diagnostics", params[:diagnostics])
+        add_optional_param(cmd, "-h", params[:help])
+        add_optional_param(cmd, "-u", params[:runner_app_path])
+        add_optional_param(cmd, "--screenshots-directory", params[:screenshots_directory])
+        add_optional_param_not_string(cmd, "-V", params[:video_paths])
+        add_optional_param_not_string(cmd, "-I", params[:image_paths])
+
+        sh(cmd)
+
+        reset = params[:reset_simulators].to_s.empty? ? false : params[:reset_simulators]
+        sh("xcrun simctl shutdown all ; export SNAPSHOT_FORCE_DELETE=true ; fastlane snapshot reset_simulators --force") if reset
+      end
+
+      def self.add_required_param(cmd, param_name, param_value)
+        cmd << " #{param_name} '#{param_value}'"
+      end
+
+      def self.add_optional_param(cmd, param_name, param_value)
+        cmd << " #{param_name} '#{param_value}'" unless param_value.to_s.empty?
+      end
+
+      def self.add_optional_param_not_string(cmd, param_name, param_value)
+        cmd << " #{param_name} #{param_value}" unless param_value.to_s.empty?
+      end
+
+      def self.add_optional_param_array(cmd, param_name, param_value)
+        cmd << " #{param_name} #{param_value.join(' -i ')}" unless param_value.to_s.empty?
+      end
+
+      def self.get_bp_binary
+        File.expand_path('../../../../../../bin/bluepill', __FILE__)
+      end
+
+      def self.description
+        "Fastlane plugin that allows to use bluepill (linkedin library) as a fastlane command"
+      end
+
+      def self.authors
+        ["Vova"]
+      end
+
+      # Nothing to return here
+      def self.return_value; end
+
+      def self.details
+        "Bluepill is powered by LinkedIn: https://github.com/linkedin/bluepill"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :scheme,
+                                       env_name: "XBLUEPILL_scheme".upcase,
+                                       description: "XCode scheme",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :workspace,
+                                       env_name: "XBLUEPILL_workspace".upcase,
+                                       description: "XCode workspace",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :reset_simulators,
+                                       env_name: "XBLUEPILL_reset_simulators".upcase,
+                                       description: "Delete and re-create all iOS and tvOS simulators",
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :output_dir,
+                                       env_name: "XBLUEPILL_output_dir".upcase,
+                                       description: "Directory where to put output log files (bluepill only)",
+                                       optional: false,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :config,
+                                       env_name: "XBLUEPILL_config".upcase,
+                                       description: "Read options from the specified configuration file instead of the command line",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :device,
+                                       env_name: "XBLUEPILL_device".upcase,
+                                       description: "On which device to run the app",
+                                       # default_value: "iPhone 6",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :exclude,
+                                       env_name: "XBLUEPILL_exclude".upcase,
+                                       description: "Exclude a testcase in the set of tests to run (takes priority over include)",
+                                       # default_value: [],
+                                       optional: true,
+                                       type: Array),
+
+          FastlaneCore::ConfigItem.new(key: :include,
+                                       env_name: "XBLUEPILL_include".upcase,
+                                       description: "Include a testcase in the set of tests to run (unless specified in exclude)",
+                                       # default_value: [],
+                                       optional: true,
+                                       type: Array),
+
+          FastlaneCore::ConfigItem.new(key: :headless,
+                                       env_name: "XBLUEPILL_headless".upcase,
+                                       description: "Run in headless mode (no GUI)",
+                                       # default_value: false,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :xcode_path,
+                                       env_name: "XBLUEPILL_xcode_path".upcase,
+                                       description: "Path to xcode",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :json_output,
+                                       env_name: "XBLUEPILL_json_output".upcase,
+                                       description: "Print test timing information in JSON format",
+                                       # default_value: false,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :junit_output,
+                                       env_name: "XBLUEPILL_junit_output".upcase,
+                                       description: "Print results in JUnit format",
+                                       # default_value: true,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :list_tests,
+                                       env_name: "XBLUEPILL_list_tests".upcase,
+                                       description: "Only list tests in bundle",
+                                       # default_value: true,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :num_sims,
+                                       env_name: "XBLUEPILL_num_sims".upcase,
+                                       description: "Number of simulators to run in parallel. (bluepill only)",
+                                       # default_value: 4,
+                                       optional: true,
+                                       type: Integer),
+
+          FastlaneCore::ConfigItem.new(key: :plain_output,
+                                       env_name: "XBLUEPILL_plain_output".upcase,
+                                       description: "Print results in plain text",
+                                       # default_value: true,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :printf_config,
+                                       env_name: "XBLUEPILL_printf_config".upcase,
+                                       description: "Print a configuration file suitable for passing back using the -c option",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :error_retries,
+                                       env_name: "XBLUEPILL_error_retries".upcase,
+                                       description: "Number of times to recover from simulator/app crashing/hanging and continue running",
+                                       # default_value: 5,
+                                       optional: true,
+                                       type: Integer),
+
+          FastlaneCore::ConfigItem.new(key: :failure_tolerance,
+                                       env_name: "XBLUEPILL_failure_tolerance".upcase,
+                                       description: "Number of times to retry on test failures",
+                                       # default_value: 0,
+                                       optional: true,
+                                       type: Integer),
+
+          FastlaneCore::ConfigItem.new(key: :only_retry_failed,
+                                       env_name: "XBLUEPILL_only_retry_failed".upcase,
+                                       description: "When failure-tolerance > 0, only retry tests that failed",
+                                       # default_value: false,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :runtime,
+                                       env_name: "XBLUEPILL_runtime".upcase,
+                                       description: "What runtime to use",
+                                       # default_value: "iOS 11.1",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :stuck_timeout,
+                                       env_name: "XBLUEPILL_stuck_timeout".upcase,
+                                       description: "Timeout in seconds for a test that seems stuck (no output)",
+                                       # default_value: "300s",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :test_timeout,
+                                       env_name: "XBLUEPILL_test_timeout".upcase,
+                                       description: "Timeout in seconds for a test that is producing output",
+                                       # default_value: "300s",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :test_bundle_path,
+                                       env_name: "XBLUEPILL_test_bundle_path".upcase,
+                                       description: "The path to the test bundle to execute (single .xctest)",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :additional_unit_xctests,
+                                       env_name: "XBLUEPILL_additional_unit_xctests".upcase,
+                                       description: "Additional XCTest bundles that is not Plugin folder",
+                                       optional: true,
+                                       type: Array),
+
+          FastlaneCore::ConfigItem.new(key: :additional_ui_xctests,
+                                       env_name: "XBLUEPILL_additional_ui_xctests".upcase,
+                                       description: "Additional XCTUITest bundles that is not Plugin folder",
+                                       optional: true,
+                                       type: Array),
+
+          FastlaneCore::ConfigItem.new(key: :repeat_count,
+                                       env_name: "XBLUEPILL_repeat_count".upcase,
+                                       description: "Number of times we'll run the entire test suite (used for load testing)",
+                                       # default_value: 1,
+                                       optional: true,
+                                       type: Integer),
+
+          FastlaneCore::ConfigItem.new(key: :no_split,
+                                       env_name: "XBLUEPILL_no_split".upcase,
+                                       description: "Test bundles you don't want to be packed into different groups to run in parallel",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :quiet,
+                                       env_name: "XBLUEPILL_quiet".upcase,
+                                       description: "Turn off all output except fatal errors",
+                                       # default_value: true,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :reuse_simulator,
+                                       env_name: "XBLUEPILL_reuse_simulator".upcase,
+                                       description: "Enable reusing simulators between test bundles",
+                                       # default_value: false,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :diagnostics,
+                                       env_name: "XBLUEPILL_diagnostics".upcase,
+                                       description: "Enable collection of diagnostics in outputDir in case of test failures",
+                                       # default_value: false,
+                                       optional: true,
+                                       type: TrueClass),
+
+          FastlaneCore::ConfigItem.new(key: :help,
+                                       env_name: "XBLUEPILL_help".upcase,
+                                       description: "Help",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :runner_app_path,
+                                       env_name: "XBLUEPILL_runner_app_path".upcase,
+                                       description: "The test runner for UI tests",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :screenshots_directory,
+                                       env_name: "XBLUEPILL_screenshots_directory".upcase,
+                                       description: "Directory where simulator screenshots for failed ui tests will be stored",
+                                       optional: true,
+                                       type: String),
+
+          FastlaneCore::ConfigItem.new(key: :video_paths,
+                                       env_name: "XBLUEPILL_video_paths".upcase,
+                                       description: "A list of videos that will be saved in the simulators",
+                                       optional: true,
+                                       type: Array),
+
+          FastlaneCore::ConfigItem.new(key: :image_paths,
+                                       env_name: "XBLUEPILL_image_paths".upcase,
+                                       description: "A list of images that will be saved in the simulators",
+                                       optional: true,
+                                       type: Array)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/xbluepill/helper/xbluepill_helper.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class XbluepillHelper
+      # class methods that you define here become available in your action
+      # as `Helper::XbluepillHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the xbluepill plugin helper!")
+      end
+    end
+  end
+end

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

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

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-xbluepill
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- UladzimirKisialiou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.49.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-require_tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.78.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.78.0
+description: 
+email: uladzimir_kisialiou@epam.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/xbluepill.rb
+- lib/fastlane/plugin/xbluepill/actions/xbluepill_action.rb
+- lib/fastlane/plugin/xbluepill/helper/xbluepill_helper.rb
+- lib/fastlane/plugin/xbluepill/version.rb
+homepage: https://github.com/kisialiu/fastlane-plugin-xbluepill
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: It is a fastlane plugin that allows to use bluepill (linkedin library) as
+  a fastlane command
+test_files: []