pantograph 0.1.0

data/pantograph/lib/pantograph/setup/setup_ios.rb

@@ -0,0 +1,412 @@
+module Pantograph
+  class SetupIos < Setup
+    # Reference to the iOS project `project.rb`
+    attr_accessor :project
+
+    # App Identifier of the current app
+    attr_accessor :app_identifier
+
+    # Scheme of the Xcode project
+    attr_accessor :scheme
+
+    # If the current setup requires a login, this is where we'll store the team ID
+    attr_accessor :itc_team_id
+    attr_accessor :adp_team_id
+
+    attr_accessor :app_exists_on_itc
+
+    attr_accessor :automatic_versioning_enabled
+
+    def setup_ios
+      require 'spaceship'
+
+      self.platform = :ios
+
+      welcome_to_pantograph
+
+      self.pantfile_content = pantfile_template_content
+
+      if preferred_setup_method
+        self.send(preferred_setup_method)
+
+        return
+      end
+
+      options = {
+        "📸  Automate screenshots" => :ios_screenshots,
+        "👩‍✈️  Automate beta distribution to TestFlight" => :ios_testflight,
+        "🚀  Automate App Store distribution" => :ios_app_store,
+        "🛠  Manual setup - manually setup your project to automate your tasks" => :ios_manual
+      }
+
+      selected = UI.select("What would you like to use pantograph for?", options.keys)
+      @method_to_use = options[selected]
+
+      begin
+        self.send(@method_to_use)
+      rescue => ex
+        # If it's already manual, and it has failed
+        # we need to re-raise the exception, as something definitely is wrong
+        raise ex if @method_to_use == :ios_manual
+
+        # If we're here, that means something else failed. We now show the
+        # error message and fallback to `:ios_manual`
+        UI.error("--------------------")
+        UI.error("pantograph init failed")
+        UI.error("--------------------")
+
+        UI.verbose(ex.backtrace.join("\n"))
+        if ex.kind_of?(Spaceship::Client::BasicPreferredInfoError) || ex.kind_of?(Spaceship::Client::UnexpectedResponse)
+          UI.error(ex.preferred_error_info)
+        else
+          UI.error(ex.to_s)
+        end
+
+        UI.important("Something failed while running `pantograph init`")
+        UI.important("Tried using Apple ID with email '#{self.user}'")
+        UI.important("You can either retry, or fallback to manual setup which will create a basic Pantfile")
+        if UI.confirm("Would you like to fallback to a manual Pantfile?")
+          self.ios_manual
+        else
+          self.send(@method_to_use)
+        end
+        # the second time, we're just failing, and don't use a `begin` `rescue` block any more
+      end
+    end
+
+    # Different iOS flows
+    def ios_testflight
+      UI.header("Setting up pantograph for iOS TestFlight distribution")
+      find_and_setup_xcode_project
+      apple_xcode_project_versioning_enabled
+      ask_for_credentials(adp: true, itc: true)
+      verify_app_exists_adp!
+      verify_app_exists_itc!
+
+      lane = ["desc \"Push a new beta build to TestFlight\"",
+              "lane :beta do",
+              increment_build_number_if_applicable,
+              "  build_app(#{project_prefix}scheme: \"#{self.scheme}\")",
+              "  upload_to_testflight",
+              "end"]
+
+      self.append_lane(lane)
+
+      self.lane_to_mention = "beta"
+      finish_up
+    end
+
+    def ios_app_store
+      UI.header("Setting up pantograph for iOS App Store distribution")
+      find_and_setup_xcode_project
+      apple_xcode_project_versioning_enabled
+      ask_for_credentials(adp: true, itc: true)
+      verify_app_exists_adp!
+      verify_app_exists_itc!
+
+      if self.app_exists_on_itc
+        UI.header("Manage app metadata?")
+        UI.message("Would you like to have pantograph manage your app's metadata?")
+        UI.message("If you enable this feature, pantograph will download your existing metadata and screenshots.")
+        UI.message("This way, you'll be able to edit your app's metadata in local `.txt` files.")
+        UI.message("After editing the local `.txt` files, just run pantograph and all changes will be pushed up.")
+        UI.message("If you don't want to use this feature, you can still use pantograph to upload and distribute new builds to the App Store")
+      end
+
+      lane = ["desc \"Push a new release build to the App Store\"",
+              "lane :release do",
+              increment_build_number_if_applicable,
+              "  build_app(#{project_prefix}scheme: \"#{self.scheme}\")"]
+      if include_metadata
+        lane << "  upload_to_app_store"
+      else
+        lane << "  upload_to_app_store(skip_metadata: true, skip_screenshots: true)"
+      end
+      lane << "end"
+
+      append_lane(lane)
+      self.lane_to_mention = "release"
+      finish_up
+    end
+
+    def ios_screenshots
+      UI.header("Setting up pantograph to automate iOS screenshots")
+
+      UI.message("pantograph uses UI Tests to automate generating localized screenshots of your iOS app")
+      UI.message("pantograph will now create 2 helper files that are needed to get the setup running")
+      UI.message("For more information on how this works and best practices, check out")
+      UI.message("\thttps://docs.pantograph.tools/getting-started/ios/screenshots/".cyan)
+      continue_with_enter
+
+      begin
+        find_and_setup_xcode_project(ask_for_scheme: false) # to get the bundle identifier
+      rescue => ex
+        # If this fails, it's no big deal, since we really just want the bundle identifier
+        # so instead, we'll just ask the user
+        UI.verbose(ex.to_s)
+      end
+
+      continue_with_enter
+
+      available_schemes = self.project.schemes
+      ui_testing_scheme = UI.select("Which is your UI Testing scheme? If you can't find it in this list, make sure it's marked as `Shared` in the Xcode scheme list", available_schemes)
+
+      UI.header("Automatically upload to iTC?")
+      UI.message("Would you like pantograph to automatically upload all generated screenshots to App Store Connect")
+      UI.message("after generating them?")
+      UI.message("If you enable this feature you'll need to provide your App Store Connect credentials so pantograph can upload the screenshots to App Store Connect")
+      automatic_upload = UI.confirm("Enable automatic upload of localized screenshots to App Store Connect?")
+      if automatic_upload
+        ask_for_credentials(adp: true, itc: true)
+        verify_app_exists_itc!
+      end
+
+      lane = ["desc \"Generate new localized screenshots\"",
+              "lane :screenshots do",
+              "  capture_screenshots(#{project_prefix}scheme: \"#{ui_testing_scheme}\")"]
+
+      if automatic_upload
+        lane << "  upload_to_app_store(skip_binary_upload: true, skip_metadata: true)"
+      end
+      lane << "end"
+
+      append_lane(lane)
+
+      self.lane_to_mention = "screenshots"
+      finish_up
+    end
+
+    def ios_manual
+      UI.header("Setting up pantograph so you can manually configure it")
+
+      append_lane(["desc \"Description of what the lane does\"",
+                   "lane :custom_lane do",
+                   "  # add actions here: https://docs.pantograph.tools/actions",
+                   "end"])
+      self.lane_to_mention = "custom_lane"
+
+      finish_up
+    end
+
+    # Helpers
+
+    # Every installation setup that needs an Xcode project should
+    # call this method
+    def find_and_setup_xcode_project(ask_for_scheme: true)
+      UI.message("Parsing your local Xcode project to find the available schemes and the app identifier")
+      config = {} # this is needed as the first method call will store information in there
+      if self.project_path.end_with?("xcworkspace")
+        config[:workspace] = self.project_path
+      else
+        config[:project] = self.project_path
+      end
+
+      PantographCore::Project.detect_projects(config)
+      self.project = PantographCore::Project.new(config)
+
+      if ask_for_scheme
+        self.scheme = self.project.select_scheme(preferred_to_include: self.project.project_name)
+      end
+
+      self.app_identifier = self.project.default_app_identifier # These two vars need to be accessed in order to be set
+      if self.app_identifier.to_s.length == 0
+        ask_for_bundle_identifier
+      end
+    end
+
+    def ask_for_bundle_identifier
+      loop do
+        return if self.app_identifier.to_s.length > 0
+        self.app_identifier = UI.input("Bundle identifier of your app: ")
+      end
+    end
+
+    def ask_for_credentials(itc: true, adp: false)
+      UI.header("Login with your Apple ID")
+      UI.message("To use App Store Connect and Apple Developer Portal features as part of pantograph,")
+      UI.message("we will ask you for your Apple ID username and password")
+      UI.message("This is necessary for certain pantograph features, for example:")
+      UI.message("")
+      UI.message("- Create and manage your provisioning profiles on the Developer Portal")
+      UI.message("- Upload and manage TestFlight and App Store builds on App Store Connect")
+      UI.message("- Manage your App Store Connect app metadata and screenshots")
+      UI.message("")
+      UI.message("Your Apple ID credentials will only be stored in your Keychain, on your local machine")
+      UI.message("For more information, check out")
+      UI.message("\thttps://github.com/pantograph/pantograph/tree/master/credentials_manager".cyan)
+      UI.message("")
+
+      if self.user.to_s.length == 0
+        UI.important("Please enter your Apple ID developer credentials")
+        self.user = UI.input("Apple ID Username:")
+      end
+      UI.message("Logging in...")
+
+      # Disable the warning texts and information that's not relevant during onboarding
+      ENV["PANTOGRAPH_HIDE_LOGIN_INFORMATION"] = 1.to_s
+      ENV["PANTOGRAPH_HIDE_TEAM_INFORMATION"] = 1.to_s
+
+      if itc
+        Spaceship::Tunes.login(self.user)
+        Spaceship::Tunes.select_team
+        self.itc_team_id = Spaceship::Tunes.client.team_id
+
+      end
+
+      if adp
+        Spaceship::Portal.login(self.user)
+        Spaceship::Portal.select_team
+        self.adp_team_id = Spaceship::Portal.client.team_id
+
+      end
+
+      UI.success("✅  Logging in with your Apple ID was successful")
+    end
+
+    def apple_xcode_project_versioning_enabled
+      self.automatic_versioning_enabled = false
+
+      paths = self.project.project_paths
+      return false if paths.count == 0
+
+      result = Pantograph::Actions::GetBuildNumberAction.run({
+        project: paths.first, # most of the times, there will only be one project in there
+        hide_error_when_versioning_disabled: true
+      })
+
+      if result.kind_of?(String) && result.to_f > 0
+        self.automatic_versioning_enabled = true
+      end
+      return self.automatic_versioning_enabled
+    end
+
+    def show_information_about_version_bumps
+      UI.important("It looks like your project isn't set up to do automatic version incrementing")
+      UI.important("To enable pantograph to handle automatic version incrementing for you, please follow this guide:")
+      UI.message("\thttps://developer.apple.com/library/content/qa/qa1827/_index.html".cyan)
+      UI.important("Afterwards check out the pantograph docs on how to set up automatic build increments")
+      UI.message("\thttps://docs.pantograph.tools/getting-started/ios/beta-deployment/#best-practices".cyan)
+    end
+
+    def verify_app_exists_adp!
+      UI.user_error!("No app identifier provided") if self.app_identifier.to_s.length == 0
+      UI.message("Checking if the app '#{self.app_identifier}' exists in your Apple Developer Portal...")
+      app = Spaceship::Portal::App.find(self.app_identifier)
+      if app.nil?
+        UI.error("It looks like the app '#{self.app_identifier}' isn't available on the #{'Apple Developer Portal'.bold.underline}")
+        UI.error("for the team ID '#{self.adp_team_id}' on Apple ID '#{self.user}'")
+
+        if UI.confirm("Do you want pantograph to create the App ID for you on the Apple Developer Portal?")
+          create_app_online!(mode: :adp)
+        else
+          UI.important("Alright, we won't create the app for you. Be aware, the build is probably going to fail when you try it")
+        end
+      else
+        UI.success("✅  Your app '#{self.app_identifier}' is available in your Apple Developer Portal")
+      end
+    end
+
+    def verify_app_exists_itc!
+      UI.user_error!("No app identifier provided") if self.app_identifier.to_s.length == 0
+      UI.message("Checking if the app '#{self.app_identifier}' exists on App Store Connect...")
+      app = Spaceship::Tunes::Application.find(self.app_identifier)
+      if app.nil?
+        UI.error("Looks like the app '#{self.app_identifier}' isn't available on #{'App Store Connect'.bold.underline}")
+        UI.error("for the team ID '#{self.itc_team_id}' on Apple ID '#{self.user}'")
+        if UI.confirm("Would you like pantograph to create the App on App Store Connect for you?")
+          create_app_online!(mode: :itc)
+          self.app_exists_on_itc = true
+        else
+          UI.important("Alright, we won't create the app for you. Be aware, the build is probably going to fail when you try it")
+        end
+      else
+        UI.success("✅  Your app '#{self.app_identifier}' is available on App Store Connect")
+        self.app_exists_on_itc = true
+      end
+    end
+
+    def finish_up
+      # iOS specific things first
+      if !self.automatic_versioning_enabled && @method_to_use != :ios_manual
+        self.show_information_about_version_bumps
+      end
+
+      super
+    end
+
+    # Returns the `workspace` or `project` key/value pair for
+    # gym, but only if necessary
+    #     (when there are multiple projects in the current directory)
+    # it's a prefix, and not a suffix, as Swift cares about the order of parameters
+    def project_prefix
+      return "" unless self.had_multiple_projects_to_choose_from
+
+      if self.project_path.end_with?(".xcworkspace")
+        return "workspace: \"#{self.project_path}\", "
+      else
+        return "project: \"#{self.project_path}\", "
+      end
+    end
+
+    def increment_build_number_if_applicable
+      return nil unless self.automatic_versioning_enabled
+      return nil if self.project.project_paths.first.to_s.length == 0
+
+      project_path = self.project.project_paths.first
+      # Convert the absolute path to a relative path
+      project_path_name = Pathname.new(project_path)
+      current_path_name = Pathname.new(File.expand_path("."))
+
+      relative_project_path = project_path_name.relative_path_from(current_path_name)
+
+      return "  increment_build_number(xcodeproj: \"#{relative_project_path}\")"
+    end
+
+    def create_app_online!(mode: nil)
+      # mode is either :adp or :itc
+      require 'produce'
+      produce_options = {
+        username: self.user,
+        team_id: self.adp_team_id,
+        itc_team_id: self.itc_team_id,
+        platform: "ios",
+        app_identifier: self.app_identifier
+      }
+      if mode == :adp
+        produce_options[:skip_itc] = true
+      else
+        produce_options[:skip_devcenter] = true
+      end
+
+      # The retrying system allows people to correct invalid inputs
+      # e.g. the app's name is already taken
+      loop do
+        # Creating config in the loop so user will be reprompted
+        # for app name if app name is taken or too long
+        Produce.config = PantographCore::Configuration.create(
+          Produce::Options.available_options,
+          produce_options
+        )
+
+        begin
+          Produce::Manager.start_producing
+          UI.success("✅  Successfully created app")
+          return # success
+        rescue => ex
+          # show the user facing error, and inform them of what went wrong
+          if ex.kind_of?(Spaceship::Client::BasicPreferredInfoError) || ex.kind_of?(Spaceship::Client::UnexpectedResponse)
+            UI.error(ex.preferred_error_info)
+          else
+            UI.error(ex.to_s)
+          end
+          UI.error(ex.backtrace.join("\n")) if PantographCore::Globals.verbose?
+          UI.important("It looks like something went wrong when we tried to create your app on the Apple Developer Portal")
+          unless UI.confirm("Would you like to try again (y)? If you enter (n), pantograph will fall back to the manual setup")
+            raise ex
+          end
+        end
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/pantograph/lib/pantograph/shells.rb

@@ -0,0 +1,6 @@
+module Pantograph
+  SHELLS = [
+    :bash,
+    :zsh
+  ]
+end

data/pantograph/lib/pantograph/supported_platforms.rb

@@ -0,0 +1,28 @@
+module Pantograph
+  class SupportedPlatforms
+    class << self
+      attr_accessor :extra
+      attr_reader :default
+
+      def extra=(value)
+        value ||= []
+        UI.important("Setting '#{value}' as extra SupportedPlatforms")
+        @extra = value
+      end
+    end
+
+    @default = [:ios, :mac, :android]
+    @extra = []
+
+    def self.all
+      (@default + @extra).flatten
+    end
+
+    # this will log a warning if the passed platform is not supported
+    def self.verify!(platform)
+      unless all.include?(platform.to_s.to_sym)
+        UI.important("Platform '#{platform}' is not officially supported. Currently supported platforms are #{self.all}.")
+      end
+    end
+  end
+end

data/pantograph/lib/pantograph/tools.rb

@@ -0,0 +1,10 @@
+module Pantograph
+  TOOLS = [
+    :pantograph
+  ]
+
+  # a list of all the config files we currently expect
+  TOOL_CONFIG_FILES = [
+    "Pantfile"
+  ]
+end

data/pantograph/lib/pantograph/version.rb

@@ -0,0 +1,5 @@
+module Pantograph
+  VERSION             = '0.1.0'.freeze
+  DESCRIPTION         = 'The easiest way to automate your apps'.freeze
+  RUBOCOP_REQUIREMENT = '0.49.1'.freeze
+end

data/pantograph/lib/pantograph.rb

@@ -0,0 +1,51 @@
+require 'pantograph_core'
+
+require 'pantograph/version'
+require 'pantograph/features'
+require 'pantograph/shells'
+require 'pantograph/tools'
+require 'pantograph/documentation/actions_list'
+require 'pantograph/actions/actions_helper' # has to be before pant_file
+require 'pantograph/pant_file'
+require 'pantograph/runner'
+require 'pantograph/setup/setup'
+require 'pantograph/lane'
+require 'pantograph/junit_generator'
+require 'pantograph/lane_manager'
+require 'pantograph/lane_manager_base'
+require 'pantograph/action'
+require 'pantograph/action_collector'
+require 'pantograph/supported_platforms'
+require 'pantograph/configuration_helper'
+require 'pantograph/one_off'
+require 'pantograph/server/socket_server_action_command_executor'
+require 'pantograph/server/socket_server'
+require 'pantograph/command_line_handler'
+require 'pantograph/documentation/docs_generator'
+require 'pantograph/other_action'
+require 'pantograph/plugins/plugins'
+require 'pantograph/pantograph_require'
+
+module Pantograph
+  Helper = PantographCore::Helper # you gotta love Ruby: Helper.* should use the Helper class contained in PantographCore
+  UI = PantographCore::UI
+  ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+
+  class << self
+    def load_actions
+      Pantograph::Actions.load_default_actions
+      Pantograph::Actions.load_helpers
+
+      if PantographCore::PantographFolder.path
+        actions_path = File.join(PantographCore::PantographFolder.path, 'actions')
+        @external_actions = Pantograph::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
+      end
+    end
+
+    attr_reader :external_actions
+
+    def plugin_manager
+      @plugin_manager ||= Pantograph::PluginManager.new
+    end
+  end
+end

data/pantograph_core/README.md

@@ -0,0 +1,79 @@
+PantographCore
+============
+
+[![Twitter: @PantographTools](https://img.shields.io/badge/contact-@PantographTools-blue.svg?style=flat)](https://twitter.com/PantographTools)
+[![License](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://github.com/pantograph/pantograph/blob/master/LICENSE)
+
+All shared code of the pantograph tools is stored in this repository.
+
+Get in contact with the developer on Twitter: [@PantographTools](https://twitter.com/PantographTools)
+
+# Features
+
+This gem contains all shared classes and code:
+
+- Checking for updates for a specific gem and showing an update message
+- All output of all tools with different logging levels
+- Finding of the current Xcode and iTunes Transporter path
+- More helper methods and classes
+
+You can hide the inline changelog by setting the `PANTOGRAPH_HIDE_CHANGELOG` environment variable
+
+## Output environment variables
+
+- To hide timestamps in each row, set the `PANTOGRAPH_HIDE_TIMESTAMP` environment variable to true.
+- To disable output formatting, set the `PANTOGRAPH_DISABLE_OUTPUT_FORMAT` environment variable to true.
+
+## Interacting with the user
+
+Instead of using `puts`, `raise` and `gets`, please use the helper class `UI` across all pantograph tools:
+
+```ruby
+UI.message("Neutral message (usually white)")
+UI.success("Successfully finished processing (usually green)")
+UI.error("Wahaha, what's going on here! (usually red)")
+UI.important("Make sure to use Windows (usually yellow)")
+
+UI.header("Inputs") # a big box
+
+name = UI.input("What's your name? ")
+if UI.confirm("Are you '#{name}'?")
+  UI.success("Oh yeah")
+else
+  UI.error("Wups, invalid")
+end
+
+UI.password("Your password please: ") # password inputs are hidden
+
+###### A "Dropdown" for the user
+project = UI.select("Select your project: ", ["Test Project", "Test Workspace"])
+
+UI.success("Okay #{name}, you selected '#{project}'")
+
+###### To run a command use
+PantographCore::CommandExecutor.execute(command: "ls",
+                                    print_all: true,
+                                        error: proc do |error_output|
+                                          # handle error here
+                                        end)
+
+###### or if you just want to receive a simple value use this only if the command doesn't take long
+diff = Helper.backticks("git diff")
+
+###### pantograph "crash" because of a user error everything that is caused by the user and is not unexpected
+UI.user_error!("You don't have a project in the current directory")
+
+###### an actual crash when something unexpected happened
+UI.crash!("Network timeout")
+
+###### a deprecation message
+UI.deprecated("The '--key' parameter is deprecated")
+```
+
+# Code of Conduct
+Help us keep _pantograph_ open and inclusive. Please read and follow our [Code of Conduct](https://github.com/pantograph/pantograph/blob/master/CODE_OF_CONDUCT.md).
+
+# License
+This project is licensed under the terms of the MIT license. See the LICENSE file.
+
+> This project and all pantograph tools are in no way affiliated with Apple Inc. This project is open source under the MIT license, which means you have full access to the source code and can modify it to fit your own needs. All pantograph tools run on your own computer or server, so your credentials or other sensitive information will never leave your own computer. You are responsible for how you use pantograph tools.

data/pantograph_core/lib/assets/XMLTemplate.xml.erb

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://apple.com/itunes/importer" version="software5.4">
+  <software_assets apple_id="<%= @data[:apple_id] %>" app_platform="<%= @data[:platform] %>">
+    <asset type="<%= @data[:archive_type] %>">
+      <data_file>
+        <size><%= @data[:file_size] %></size>
+        <file_name><%= @data[:ipa_path] %></file_name>
+        <checksum type="md5"><%= @data[:md5] %></checksum>
+      </data_file>
+    </asset>
+  </software_assets>
+</package>

data/pantograph_core/lib/pantograph_core/analytics/action_completion_context.rb

@@ -0,0 +1,34 @@
+# require_relative 'app_identifier_guesser'
+
+module PantographCore
+  class ActionCompletionStatus
+    SUCCESS = 'success'
+    FAILED = 'failed' # pantograph crashes unrelated to user_error!
+    USER_ERROR = 'user_error' # Anytime a user_error! is triggered
+    INTERRUPTED = 'interrupted'
+  end
+
+  class ActionCompletionContext
+    attr_accessor :p_hash
+    attr_accessor :action_name
+    attr_accessor :status
+    attr_accessor :pantograph_client_language
+
+    def initialize(p_hash: nil, action_name: nil, status: nil, pantograph_client_language: nil)
+      @p_hash = p_hash
+      @action_name = action_name
+      @status = status
+      @pantograph_client_language = pantograph_client_language
+    end
+
+    def self.context_for_action_name(action_name, pantograph_client_language: :ruby, args: nil, status: nil)
+      # app_id_guesser = PantographCore::AppIdentifierGuesser.new(args: args)
+      return self.new(
+        action_name: action_name,
+        p_hash: 'unknown',
+        status: status,
+        pantograph_client_language: pantograph_client_language
+      )
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/analytics/action_launch_context.rb

@@ -0,0 +1,38 @@
+require_relative '../helper'
+# require_relative 'app_identifier_guesser'
+
+module PantographCore
+  class ActionLaunchContext
+    UNKNOWN_P_HASH = 'unknown'
+
+    attr_accessor :action_name
+    attr_accessor :p_hash
+    attr_accessor :platform
+    attr_accessor :pantograph_client_language # example: ruby pantfile
+
+    def initialize(action_name: nil, p_hash: UNKNOWN_P_HASH, platform: nil, pantograph_client_language: nil)
+      @action_name = action_name
+      @p_hash = p_hash
+      @platform = platform
+      @pantograph_client_language = pantograph_client_language
+    end
+
+    def self.context_for_action_name(action_name, pantograph_client_language: :ruby, args: nil)
+      # app_id_guesser = PantographCore::AppIdentifierGuesser.new(args: args)
+      return self.new(
+        action_name: action_name,
+        p_hash: UNKNOWN_P_HASH,
+        # platform: nil,
+        pantograph_client_language: pantograph_client_language
+      )
+    end
+
+    def build_tool_version
+      if platform == :android
+        return 'android'
+      else
+        return "Xcode #{Helper.xcode_version}"
+      end
+    end
+  end
+end