fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/cocoapods.rb

@@ -0,0 +1,148 @@
+module Fastlane
+  module Actions
+    class CocoapodsAction < Action
+      def self.run(params)
+        Actions.verify_gem!('cocoapods')
+        cmd = []
+
+        unless params[:podfile].nil?
+          if params[:podfile].end_with?('Podfile')
+            podfile_folder = File.dirname(params[:podfile])
+          else
+            podfile_folder = params[:podfile]
+          end
+          cmd << ["cd '#{podfile_folder}' &&"]
+        end
+
+        cmd << ['bundle exec'] if params[:use_bundle_exec] && shell_out_should_use_bundle_exec?
+        cmd << ['pod install']
+
+        cmd << '--no-clean' unless params[:clean]
+        cmd << '--no-integrate' unless params[:integrate]
+        cmd << '--repo-update' if params[:repo_update]
+        cmd << '--silent' if params[:silent]
+        cmd << '--verbose' if params[:verbose]
+        cmd << '--no-ansi' unless params[:ansi]
+
+        Actions.sh(cmd.join(' '), error_callback: lambda { |result|
+          if !params[:repo_update] && params[:try_repo_update_on_error]
+            cmd << '--repo-update'
+            Actions.sh(cmd.join(' '), error_callback: lambda { |retry_result|
+              call_error_callback(params, retry_result)
+            })
+          else
+            call_error_callback(params, result)
+          end
+        })
+      end
+
+      def self.call_error_callback(params, result)
+        if params[:error_callback]
+          Dir.chdir(FastlaneCore::FastlaneFolder.path) do
+            params[:error_callback].call(result)
+          end
+        else
+          UI.shell_error!(result)
+        end
+      end
+
+      def self.description
+        "Runs `pod install` for the project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repo_update,
+                                       env_name: "FL_COCOAPODS_REPO_UPDATE",
+                                       description: "Add `--repo-update` flag to `pod install` command",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :silent,
+                                       env_name: "FL_COCOAPODS_SILENT",
+                                       description: "Execute command without logging output",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: "FL_COCOAPODS_VERBOSE",
+                                       description: "Show more debugging information",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :ansi,
+                                       env_name: "FL_COCOAPODS_ANSI",
+                                       description: "Show output with ANSI codes",
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :use_bundle_exec,
+                                       env_name: "FL_COCOAPODS_USE_BUNDLE_EXEC",
+                                       description: "Use bundle exec when there is a Gemfile presented",
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :podfile,
+                                       env_name: "FL_COCOAPODS_PODFILE",
+                                       description: "Explicitly specify the path to the Cocoapods' Podfile. You can either set it to the Podfile's path or to the folder containing the Podfile file",
+                                       optional: true,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Could not find Podfile") unless File.exist?(value) || Helper.test?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :error_callback,
+                                       description: 'A callback invoked with the command output if there is a non-zero exit status',
+                                       optional: true,
+                                       is_string: false,
+                                       type: :string_callback,
+                                       default_value: nil),
+          FastlaneCore::ConfigItem.new(key: :try_repo_update_on_error,
+                                       env_name: "FL_COCOAPODS_TRY_REPO_UPDATE_ON_ERROR",
+                                       description: 'Retry with --repo-update if action was finished with error',
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       type: Boolean),
+
+          # Deprecated
+          FastlaneCore::ConfigItem.new(key: :clean,
+                                       env_name: "FL_COCOAPODS_CLEAN",
+                                       description: "(Option removed from cocoapods) Remove SCM directories",
+                                       deprecated: true,
+                                       is_string: false,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :integrate,
+                                       env_name: "FL_COCOAPODS_INTEGRATE",
+                                       description: "(Option removed from cocoapods) Integrate the Pods libraries into the Xcode project(s)",
+                                       deprecated: true,
+                                       is_string: false,
+                                       default_value: true)
+        ]
+        # Please don't add a version parameter to the `cocoapods` action. If you need to specify a version when running
+        # `cocoapods`, please start using a Gemfile and lock the version there
+        # More information https://docs.fastlane.tools/getting-started/ios/setup/#use-a-gemfile
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.authors
+        ["KrauseFx", "tadpol", "birmacher", "Liquidsoul"]
+      end
+
+      def self.details
+        "If you use [CocoaPods](http://cocoapods.org) you can use the `cocoapods` integration to run `pod install` before building your app."
+      end
+
+      def self.example_code
+        [
+          'cocoapods',
+          'cocoapods(
+            clean: true,
+            podfile: "./CustomPodfile"
+          )'
+        ]
+      end
+
+      def self.category
+        :building
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/commit_github_file.rb

@@ -0,0 +1,186 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      COMMIT_GITHUB_FILE_HTML_LINK = :COMMIT_GITHUB_FILE_HTML_LINK
+      COMMIT_GITHUB_FILE_SHA = :COMMIT_GITHUB_FILE_SHA
+      COMMIT_GITHUB_FILE_JSON = :COMMIT_GITHUB_FILE_JSON
+    end
+
+    class CommitGithubFileAction < Action
+      def self.run(params)
+        repo_name = params[:repository_name]
+        branch = params[:branch] ||= 'master'
+        commit_message = params[:message]
+
+        file_path = params[:path]
+        file_name = File.basename(file_path)
+        expanded_file_path = File.expand_path(file_path)
+
+        UI.important("Creating commit on #{repo_name} on branch \"#{branch}\" for file \"#{file_path}\"")
+
+        api_file_path = file_path
+        api_file_path = "/#{api_file_path}" unless api_file_path.start_with?('/')
+        api_file_path = api_file_path[0..-2] if api_file_path.end_with?('/')
+
+        payload = {
+          path: api_file_path,
+          message: commit_message || "Updated : #{file_name}",
+          content: Base64.encode64(File.open(expanded_file_path).read),
+          branch: branch
+        }
+
+        UI.message("Committing #{api_file_path}")
+        GithubApiAction.run({
+          server_url: params[:server_url],
+          api_token: params[:api_token],
+          secure: params[:secure],
+          http_method: "PUT",
+          path: File.join("repos", params[:repository_name], "contents", api_file_path),
+          body: payload,
+          error_handlers: {
+            422 => proc do |result|
+              json = result[:json]
+              UI.error(json || result[:body])
+              error = if json['message'] == "Invalid request.\n\n\"sha\" wasn't supplied."
+                        "File already exists - please remove from repo before uploading or rename this upload"
+                      else
+                        "Uprocessable error"
+                      end
+              UI.user_error!(error)
+            end
+          }
+        }) do |result|
+          UI.success("Successfully commited file to GitHub")
+          json = result[:json]
+          html_url = json['commit']['html_url']
+          download_url = json['content']['download_url']
+          commit_sha = json['commit']['sha']
+
+          UI.important("Commit: \"#{html_url}\"")
+          UI.important("SHA: \"#{commit_sha}\"")
+          UI.important("Download at: \"#{download_url}\"")
+
+          Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_HTML_LINK] = html_url
+          Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_SHA] = commit_sha
+          Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_JSON] = json
+        end
+
+        Actions.lane_context[SharedValues::COMMIT_GITHUB_FILE_JSON]
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "This will commit a file directly on GitHub via the API"
+      end
+
+      def self.details
+        [
+          "Commits a file directly to GitHub. You must provide your GitHub Personal token (get one from [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new)), the repository name and the relative file path from the root git project.",
+          "Out parameters provide the commit sha created, which can be used for later usage for examples such as releases, the direct download link and the full response JSON.",
+          "Documentation: [https://developer.github.com/v3/repos/contents/#create-a-file](https://developer.github.com/v3/repos/contents/#create-a-file)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :repository_name,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_REPOSITORY_NAME",
+                                       description: "The path to your repo, e.g. 'fastlane/fastlane'",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please only pass the path, e.g. 'fastlane/fastlane'") if value.include?("github.com")
+                                         UI.user_error!("Please only pass the path, e.g. 'fastlane/fastlane'") if value.split('/').count != 2
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :server_url,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_SERVER_URL",
+                                       description: "The server url. e.g. 'https://your.internal.github.host/api/v3' (Default: 'https://api.github.com')",
+                                       default_value: "https://api.github.com",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please include the protocol in the server url, e.g. https://your.github.server/api/v3") unless value.include?("//")
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_API_TOKEN",
+                                       description: "Personal API Token for GitHub - generate one at https://github.com/settings/tokens",
+                                       sensitive: true,
+                                       is_string: true,
+                                       code_gen_sensitive: true,
+                                       default_value: ENV["GITHUB_API_TOKEN"],
+                                       default_value_dynamic: true,
+                                       optional: false),
+          FastlaneCore::ConfigItem.new(key: :branch,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_BRANCH",
+                                       description: "The branch that the file should be committed on (default: master)",
+                                       default_value: 'master',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: 'FL_COMMIT_GITHUB_FILE_PATH',
+                                       description: 'The relative path to your file from project root e.g. assets/my_app.xcarchive',
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         value = File.expand_path(value)
+                                         UI.user_error!("File not found at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_MESSAGE",
+                                       description: "The commit message. Defaults to the file name",
+                                       default_value_dynamic: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :secure,
+                                       env_name: "FL_COMMIT_GITHUB_FILE_SECURE",
+                                       description: "Optionally disable secure requests (ssl_verify_peer)",
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.output
+        [
+          ['COMMIT_GITHUB_FILE_HTML_LINK', 'Link to your committed file'],
+          ['COMMIT_GITHUB_FILE_SHA', 'Commit SHA generated'],
+          ['COMMIT_GITHUB_FILE_JSON', 'The whole commit JSON object response']
+        ]
+      end
+
+      def self.return_type
+        :hash_of_strings
+      end
+
+      def self.return_value
+        [
+          "A hash containing all relevant information for this commit",
+          "Access things like 'html_url', 'sha', 'message'"
+        ].join("\n")
+      end
+
+      def self.authors
+        ["tommeier"]
+      end
+
+      def self.example_code
+        [
+          'response = commit_github_file(
+            repository_name: "fastlane/fastlane",
+            server_url: "https://api.github.com",
+            api_token: ENV["GITHUB_TOKEN"],
+            message: "Add my new file",
+            branch: "master",
+            path: "assets/my_new_file.xcarchive"
+          )'
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.category
+        :source_control
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/commit_version_bump.rb

@@ -0,0 +1,301 @@
+require 'pathname'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      MODIFIED_FILES = :MODIFIED_FILES
+    end
+
+    class << self
+      # Add an array of paths relative to the repo root or absolute paths that have been modified by
+      # an action.
+      #
+      # :files: An array of paths relative to the repo root or absolute paths
+      def add_modified_files(files)
+        modified_files = lane_context[SharedValues::MODIFIED_FILES] || Set.new
+        modified_files += files
+        lane_context[SharedValues::MODIFIED_FILES] = modified_files
+      end
+    end
+
+    # Commits the current changes in the repo as a version bump, checking to make sure only files which contain version information have been changed.
+    class CommitVersionBumpAction < Action
+      def self.run(params)
+        require 'xcodeproj'
+        require 'set'
+        require 'shellwords'
+
+        xcodeproj_path = params[:xcodeproj] ? File.expand_path(File.join('.', params[:xcodeproj])) : nil
+
+        # find the repo root path
+        repo_path = Actions.sh('git rev-parse --show-toplevel').strip
+        repo_pathname = Pathname.new(repo_path)
+
+        if xcodeproj_path
+          # ensure that the xcodeproj passed in was OK
+          UI.user_error!("Could not find the specified xcodeproj: #{xcodeproj_path}") unless File.directory?(xcodeproj_path)
+        else
+          # find an xcodeproj (ignoring dependencies)
+          xcodeproj_paths = Fastlane::Helper::XcodeprojHelper.find(repo_path)
+
+          # no projects found: error
+          UI.user_error!('Could not find a .xcodeproj in the current repository\'s working directory.') if xcodeproj_paths.count == 0
+
+          # too many projects found: error
+          if xcodeproj_paths.count > 1
+            relative_projects = xcodeproj_paths.map { |e| Pathname.new(e).relative_path_from(repo_pathname).to_s }.join("\n")
+            UI.user_error!("Found multiple .xcodeproj projects in the current repository's working directory. Please specify your app's main project: \n#{relative_projects}")
+          end
+
+          # one project found: great
+          xcodeproj_path = xcodeproj_paths.first
+        end
+
+        # find the pbxproj path, relative to git directory
+        pbxproj_pathname = Pathname.new(File.join(xcodeproj_path, 'project.pbxproj'))
+        pbxproj_path = pbxproj_pathname.relative_path_from(repo_pathname).to_s
+
+        # find the info_plist files
+        project = Xcodeproj::Project.open(xcodeproj_path)
+        info_plist_files = project.objects.select do |object|
+          object.isa == 'XCBuildConfiguration'
+        end.map(&:to_hash).map do |object_hash|
+          object_hash['buildSettings']
+        end.select do |build_settings|
+          build_settings.key?('INFOPLIST_FILE')
+        end.map do |build_settings|
+          build_settings['INFOPLIST_FILE']
+        end.uniq.map do |info_plist_path|
+          Pathname.new(File.expand_path(File.join(xcodeproj_path, '..', info_plist_path))).relative_path_from(repo_pathname).to_s
+        end
+
+        # Removes .plist files that matched the given expression in the 'ignore' parameter
+        ignore_expression = params[:ignore]
+        if ignore_expression
+          info_plist_files.reject! do |info_plist_file|
+            info_plist_file.match(ignore_expression)
+          end
+        end
+
+        extra_files = params[:include]
+        extra_files += modified_files_relative_to_repo_root(repo_path)
+
+        # create our list of files that we expect to have changed, they should all be relative to the project root, which should be equal to the git workdir root
+        expected_changed_files = extra_files
+        expected_changed_files << pbxproj_path
+        expected_changed_files << info_plist_files
+
+        if params[:settings]
+          settings_plists_from_param(params[:settings]).each do |file|
+            settings_file_pathname = Pathname.new(settings_bundle_file_path(project, file))
+            expected_changed_files << settings_file_pathname.relative_path_from(repo_pathname).to_s
+          end
+        end
+
+        expected_changed_files.flatten!.uniq!
+
+        # get the list of files that have actually changed in our git workdir
+        git_dirty_files = Actions.sh('git diff --name-only HEAD').split("\n") + Actions.sh('git ls-files --other --exclude-standard').split("\n")
+
+        # little user hint
+        UI.user_error!("No file changes picked up. Make sure you run the `increment_build_number` action first.") if git_dirty_files.empty?
+
+        # check if the files changed are the ones we expected to change (these should be only the files that have version info in them)
+        changed_files_as_expected = Set.new(git_dirty_files.map(&:downcase)).subset?(Set.new(expected_changed_files.map(&:downcase)))
+        unless changed_files_as_expected
+          unless params[:force]
+            error = [
+              "Found unexpected uncommitted changes in the working directory. Expected these files to have ",
+              "changed: \n#{expected_changed_files.join("\n")}.\nBut found these actual changes: ",
+              "#{git_dirty_files.join("\n")}.\nMake sure you have cleaned up the build artifacts and ",
+              "are only left with the changed version files at this stage in your lane, and don't touch the ",
+              "working directory while your lane is running. You can also use the :force option to bypass this ",
+              "check, and always commit a version bump regardless of the state of the working directory."
+            ].join("\n")
+            UI.user_error!(error)
+          end
+        end
+
+        # get the absolute paths to the files
+        git_add_paths = expected_changed_files.map do |path|
+          updated = path.gsub("$(SRCROOT)", ".").gsub("${SRCROOT}", ".")
+          File.expand_path(File.join(repo_pathname, updated))
+        end
+
+        # then create a commit with a message
+        Actions.sh("git add #{git_add_paths.map(&:shellescape).join(' ')}")
+
+        begin
+          command = build_git_command(params)
+
+          Actions.sh(command)
+
+          UI.success("Committed \"#{params[:message]}\" 💾.")
+        rescue => ex
+          UI.error(ex)
+          UI.important("Didn't commit any changes.")
+        end
+      end
+
+      def self.description
+        "Creates a 'Version Bump' commit. Run after `increment_build_number`"
+      end
+
+      def self.output
+        [
+          ['MODIFIED_FILES', 'The list of paths of modified files']
+        ]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "FL_COMMIT_BUMP_MESSAGE",
+                                       description: "The commit message when committing the version bump",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :xcodeproj,
+                                       env_name: "FL_BUILD_NUMBER_PROJECT",
+                                       description: "The path to your project file (Not the workspace). If you have only one, this is optional",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Please pass the path to the project, not the workspace") if value.end_with?(".xcworkspace")
+                                         UI.user_error!("Could not find Xcode project") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :force,
+                                       env_name: "FL_FORCE_COMMIT",
+                                       description: "Forces the commit, even if other files than the ones containing the version number have been modified",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :settings,
+                                       env_name: "FL_COMMIT_INCLUDE_SETTINGS",
+                                       description: "Include Settings.bundle/Root.plist with version bump",
+                                       optional: true,
+                                       default_value: false,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :ignore,
+                                       description: "A regular expression used to filter matched plist files to be modified",
+                                       optional: true,
+                                       default_value: nil,
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :include,
+                                       description: "A list of extra files to be included in the version bump (string array or comma-separated string)",
+                                       optional: true,
+                                       default_value: [],
+                                       type: Array),
+          FastlaneCore::ConfigItem.new(key: :no_verify,
+                                      env_name: "FL_GIT_PUSH_USE_NO_VERIFY",
+                                      description: "Whether or not to use --no-verify",
+                                      type: Boolean,
+                                      default_value: false)
+        ]
+      end
+
+      def self.details
+        list = <<-LIST.markdown_list
+          All `.plist` files
+          The `.xcodeproj/project.pbxproj` file
+        LIST
+
+        [
+          "This action will create a 'Version Bump' commit in your repo. Useful in conjunction with `increment_build_number`.",
+          "It checks the repo to make sure that only the relevant files have changed. These are the files that `increment_build_number` (`agvtool`) touches:".markdown_preserve_newlines,
+          list,
+          "Then commits those files to the repo.",
+          "Customize the message with the `:message` option. It defaults to 'Version Bump'.",
+          "If you have other uncommitted changes in your repo, this action will fail. If you started off in a clean repo, and used the _ipa_ and or _sigh_ actions, then you can use the [clean_build_artifacts](https://docs.fastlane.tools/actions/clean_build_artifacts/) action to clean those temporary files up before running this action."
+        ].join("\n")
+      end
+
+      def self.author
+        "lmirosevic"
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'commit_version_bump',
+          'commit_version_bump(
+            message: "Version Bump",                    # create a commit with a custom message
+            xcodeproj: "./path/to/MyProject.xcodeproj", # optional, if you have multiple Xcode project files, you must specify your main project here
+          )',
+          'commit_version_bump(
+            settings: true # Include Settings.bundle/Root.plist
+          )',
+          'commit_version_bump(
+            settings: "About.plist" # Include Settings.bundle/About.plist
+          )',
+          'commit_version_bump(
+            settings: %w[About.plist Root.plist] # Include more than one plist from Settings.bundle
+          )',
+          'commit_version_bump(
+            include: %w[package.json custom.cfg] # include other updated files as part of the version bump
+          )',
+          'commit_version_bump(
+            ignore: /OtherProject/ # ignore files matching a regular expression
+          )',
+          'commit_version_bump(
+            no_verify: true           # optional, default: false
+          )'
+        ]
+      end
+
+      def self.category
+        :source_control
+      end
+
+      class << self
+        def settings_plists_from_param(param)
+          if param.kind_of?(String)
+            # commit_version_bump settings: "About.plist"
+            return [param]
+          elsif param.kind_of?(Array)
+            # commit_version_bump settings: ["Root.plist", "About.plist"]
+            return param
+          else
+            # commit_version_bump settings: true # Root.plist
+            return ["Root.plist"]
+          end
+        end
+
+        def settings_bundle_file_path(project, settings_file_name)
+          settings_bundle = project.files.find { |f| f.path =~ /Settings.bundle/ }
+          raise "No Settings.bundle in project" if settings_bundle.nil?
+
+          return File.join(settings_bundle.real_path, settings_file_name)
+        end
+
+        def modified_files_relative_to_repo_root(repo_root)
+          return [] if Actions.lane_context[SharedValues::MODIFIED_FILES].nil?
+
+          root_pathname = Pathname.new(repo_root)
+          all_modified_files = Actions.lane_context[SharedValues::MODIFIED_FILES].map do |path|
+            next path unless path =~ %r{^/}
+            Pathname.new(path).relative_path_from(root_pathname).to_s
+          end
+          return all_modified_files.uniq
+        end
+
+        def build_git_command(params)
+          build_number = Actions.lane_context[Actions::SharedValues::BUILD_NUMBER]
+
+          params[:message] ||= (build_number ? "Version Bump to #{build_number}" : "Version Bump")
+
+          command = [
+            'git',
+            'commit',
+            '-m',
+            "'#{params[:message]}'"
+          ]
+
+          command << '--no-verify' if params[:no_verify]
+
+          return command.join(' ')
+        end
+      end
+    end
+  end
+end