fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/automatic_code_signing.rb

@@ -0,0 +1,220 @@
+require 'xcodeproj'
+module Fastlane
+  module Actions
+    class AutomaticCodeSigningAction < Action
+      def self.run(params)
+        FastlaneCore::PrintTable.print_values(config: params, title: "Summary for Automatic Codesigning")
+        path = params[:path]
+        path = File.join(File.expand_path(path), "project.pbxproj")
+
+        project = Xcodeproj::Project.open(params[:path])
+        UI.user_error!("Could not find path to project config '#{path}'. Pass the path to your project (not workspace)!") unless File.exist?(path)
+        UI.message("Updating the Automatic Codesigning flag to #{params[:use_automatic_signing] ? 'enabled' : 'disabled'} for the given project '#{path}'")
+
+        unless project.root_object.attributes["TargetAttributes"]
+          UI.user_error!("Seems to be a very old project file format - please open your project file in a more recent version of Xcode")
+          return false
+        end
+
+        target_dictionary = project.targets.map { |f| { name: f.name, uuid: f.uuid, build_configuration_list: f.build_configuration_list } }
+        target_attributes = project.root_object.attributes["TargetAttributes"]
+        changed_targets = []
+
+        # make sure TargetAttributes exist for all targets
+        target_dictionary.each do |props|
+          unless target_attributes.key?(props[:uuid])
+            target_attributes[props[:uuid]] = {}
+          end
+        end
+
+        target_attributes.each do |target, sett|
+          found_target = target_dictionary.detect { |h| h[:uuid] == target }
+          if params[:targets]
+            # get target name
+            unless params[:targets].include?(found_target[:name])
+              UI.important("Skipping #{found_target[:name]} not selected (#{params[:targets].join(',')})")
+              next
+            end
+          end
+
+          style_value = params[:use_automatic_signing] ? 'Automatic' : 'Manual'
+          build_configuration_list = found_target[:build_configuration_list]
+          build_configuration_list.set_setting("CODE_SIGN_STYLE", style_value)
+          sett["ProvisioningStyle"] = style_value
+
+          if params[:team_id]
+            sett["DevelopmentTeam"] = params[:team_id]
+            build_configuration_list.set_setting("DEVELOPMENT_TEAM", params[:team_id])
+            UI.important("Set Team id to: #{params[:team_id]} for target: #{found_target[:name]}")
+          end
+          if params[:code_sign_identity]
+            build_configuration_list.set_setting("CODE_SIGN_IDENTITY", params[:code_sign_identity])
+
+            # We also need to update the value if it was overriden for a specific SDK
+            build_configuration_list.build_configurations.each do |build_configuration|
+              codesign_build_settings_keys = build_configuration.build_settings.keys.select { |key| key.to_s.match(/CODE_SIGN_IDENTITY.*/) }
+              codesign_build_settings_keys.each do |setting|
+                build_configuration_list.set_setting(setting, params[:code_sign_identity])
+              end
+            end
+            UI.important("Set Code Sign identity to: #{params[:code_sign_identity]} for target: #{found_target[:name]}")
+          end
+          if params[:profile_name]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE_SPECIFIER", params[:profile_name])
+            UI.important("Set Provisioning Profile name to: #{params[:profile_name]} for target: #{found_target[:name]}")
+          end
+          # Since Xcode 8, this is no longer needed, you simply use PROVISIONING_PROFILE_SPECIFIER
+          if params[:profile_uuid]
+            build_configuration_list.set_setting("PROVISIONING_PROFILE", params[:profile_uuid])
+            UI.important("Set Provisioning Profile UUID to: #{params[:profile_uuid]} for target: #{found_target[:name]}")
+          end
+          if params[:bundle_identifier]
+            build_configuration_list.set_setting("PRODUCT_BUNDLE_IDENTIFIER", params[:bundle_identifier])
+            UI.important("Set Bundle identifier to: #{params[:bundle_identifier]} for target: #{found_target[:name]}")
+          end
+
+          changed_targets << found_target[:name]
+        end
+        project.save
+
+        if changed_targets.empty?
+          UI.important("None of the specified targets has been modified")
+          UI.important("available targets:")
+          target_dictionary.each do |target|
+            UI.important("\t* #{target[:name]}")
+          end
+        else
+          UI.success("Successfully updated project settings to use Code Sign Style = '#{params[:use_automatic_signing] ? 'Automatic' : 'Manual'}'")
+          UI.success("Modified Targets:")
+          changed_targets.each do |target|
+            UI.success("\t * #{target}")
+          end
+        end
+
+        params[:use_automatic_signing]
+      end
+
+      def self.alias_used(action_alias, params)
+        params[:use_automatic_signing] = true if action_alias == "enable_automatic_code_signing"
+      end
+
+      def self.aliases
+        ["enable_automatic_code_signing", "disable_automatic_code_signing"]
+      end
+
+      def self.description
+        "Configures Xcode's Codesigning options"
+      end
+
+      def self.details
+        "Configures Xcode's Codesigning options of all targets in the project"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_PROJECT_SIGNING_PROJECT_PATH",
+                                       description: "Path to your Xcode project",
+                                       code_gen_sensitive: true,
+                                       default_value: Dir['*.xcodeproj'].first,
+                                       default_value_dynamic: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Path is invalid") unless File.exist?(File.expand_path(value))
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :use_automatic_signing,
+                                       env_name: "FL_PROJECT_USE_AUTOMATIC_SIGNING",
+                                       description: "Defines if project should use automatic signing",
+                                       is_string: false,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :team_id,
+                                       env_name: "FASTLANE_TEAM_ID",
+                                       optional: true,
+                                       description: "Team ID, is used when upgrading project",
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :targets,
+                                       env_name: "FL_PROJECT_SIGNING_TARGETS",
+                                       optional: true,
+                                       type: Array,
+                                       description: "Specify targets you want to toggle the signing mech. (default to all targets)",
+                                       is_string: false),
+          FastlaneCore::ConfigItem.new(key: :code_sign_identity,
+                                       env_name: "FL_CODE_SIGN_IDENTITY",
+                                       description: "Code signing identity type (iPhone Developer, iPhone Distribution)",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :profile_name,
+                                       env_name: "FL_PROVISIONING_PROFILE_SPECIFIER",
+                                       description: "Provisioning profile name to use for code signing",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :profile_uuid,
+                                       env_name: "FL_PROVISIONING_PROFILE",
+                                       description: "Provisioning profile UUID to use for code signing",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :bundle_identifier,
+                                       env_name: "FL_APP_IDENTIFIER",
+                                       description: "Application Product Bundle Identifier",
+                                       optional: true,
+                                       is_string: true)
+        ]
+      end
+
+      def self.output
+      end
+
+      def self.example_code
+        [
+          '# enable automatic code signing
+          enable_automatic_code_signing',
+          'enable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          '# disable automatic code signing
+          disable_automatic_code_signing',
+          'disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj"
+          )',
+          '# also set team id
+          disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            team_id: "XXXX"
+          )',
+          '# Only specific targets
+          disable_automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: false,
+            targets: ["demo"]
+          )
+          ',
+          ' # via generic action
+          automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: false
+          )',
+          'automatic_code_signing(
+            path: "demo-project/demo/demo.xcodeproj",
+            use_automatic_signing: true
+          )'
+
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+
+      def self.return_value
+        "The current status (boolean) of codesigning after modification"
+      end
+
+      def self.authors
+        ["mathiasAichinger", "hjanuschka", "p4checo", "portellaa", "aeons"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/backup_file.rb

@@ -0,0 +1,41 @@
+module Fastlane
+  module Actions
+    class BackupFileAction < Action
+      def self.run(params)
+        path = params[:path]
+        FileUtils.cp(path, "#{path}.back", { preserve: true })
+        UI.message("Successfully created a backup 💾")
+      end
+
+      def self.description
+        'This action backs up your file to "[path].back"'
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.author
+        "gin0606"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       description: "Path to the file you want to backup",
+                                       optional: false)
+        ]
+      end
+
+      def self.example_code
+        [
+          'backup_file(path: "/path/to/file")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/backup_xcarchive.rb

@@ -0,0 +1,135 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      BACKUP_XCARCHIVE_FILE = :BACKUP_XCARCHIVE_FILE
+    end
+
+    class BackupXcarchiveAction < Action
+      require 'fileutils'
+
+      def self.run(params)
+        # Get params
+        xcarchive = params[:xcarchive]
+        base_destination = params[:destination]
+        zipped = params[:zip]
+        zip_filename = params[:zip_filename]
+        versioned = params[:versioned]
+
+        # Prepare destionation folder
+        full_destination = base_destination
+
+        if versioned
+          date = Time.now.strftime("%Y-%m-%d")
+          version = `agvtool what-marketing-version -terse1`
+          subfolder = "#{date} #{version.strip}"
+          full_destination = File.expand_path(subfolder, base_destination)
+        end
+
+        FileUtils.mkdir(full_destination) unless File.exist?(full_destination)
+
+        # Save archive to destination
+        if zipped
+          Dir.mktmpdir("backup_xcarchive") do |dir|
+            UI.message("Compressing #{xcarchive}")
+            xcarchive_folder = File.expand_path(File.dirname(xcarchive))
+            xcarchive_file = File.basename(xcarchive)
+            zip_file = if zip_filename
+                         File.join(dir, "#{zip_filename}.xcarchive.zip")
+                       else
+                         File.join(dir, "#{xcarchive_file}.zip")
+                       end
+
+            # Create zip
+            Actions.sh(%(cd "#{xcarchive_folder}" && zip -r -X "#{zip_file}" "#{xcarchive_file}" > /dev/null))
+
+            # Moved to its final destination
+            FileUtils.mv(zip_file, full_destination)
+
+            Actions.lane_context[SharedValues::BACKUP_XCARCHIVE_FILE] = "#{full_destination}/#{File.basename(zip_file)}"
+          end
+        else
+          # Copy xcarchive file
+          FileUtils.cp_r(xcarchive, full_destination)
+
+          Actions.lane_context[SharedValues::BACKUP_XCARCHIVE_FILE] = "#{full_destination}/#{File.basename(xcarchive)}"
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Save your [zipped] xcarchive elsewhere from default path"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :xcarchive,
+                                       description: 'Path to your xcarchive file. Optional if you use the `xcodebuild` action',
+                                       default_value: Actions.lane_context[SharedValues::XCODEBUILD_ARCHIVE],
+                                       default_value_dynamic: true,
+                                       optional: false,
+                                       env_name: 'BACKUP_XCARCHIVE_ARCHIVE',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find xcarchive file at path '#{value}'") if !Helper.test? && !File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       description: 'Where your archive will be placed',
+                                       optional: false,
+                                       env_name: 'BACKUP_XCARCHIVE_DESTINATION',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find the destination folder at '#{value}'") if !Helper.test? && !File.directory?(value) && !File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :zip,
+                                       description: 'Enable compression of the archive',
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true,
+                                       env_name: 'BACKUP_XCARCHIVE_ZIP'),
+          FastlaneCore::ConfigItem.new(key: :zip_filename,
+                                       description: 'Filename of the compressed archive. Will be appended by `.xcarchive.zip`. Default value is the output xcarchive filename',
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       env_name: 'BACKUP_XCARCHIVE_ZIP_FILENAME'),
+          FastlaneCore::ConfigItem.new(key: :versioned,
+                                       description: 'Create a versioned (date and app version) subfolder where to put the archive',
+                                       is_string: false,
+                                       default_value: true,
+                                       optional: true,
+                                       env_name: 'BACKUP_XCARCHIVE_VERSIONED')
+        ]
+      end
+
+      def self.output
+        [
+          ['BACKUP_XCARCHIVE_FILE', 'Path to your saved xcarchive (compressed) file']
+        ]
+      end
+
+      def self.author
+        ['dral3x']
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.example_code
+        [
+          'backup_xcarchive(
+            xcarchive: "/path/to/file.xcarchive", # Optional if you use the `xcodebuild` action
+            destination: "/somewhere/else/", # Where the backup should be created
+            zip_filename: "file.xcarchive", # The name of the backup file
+            zip: false, # Enable compression of the archive. Defaults to `true`.
+            versioned: true # Create a versioned (date and app version) subfolder where to put the archive
+          )'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/badge.rb

@@ -0,0 +1,155 @@
+module Fastlane
+  module Actions
+    class BadgeAction < Action
+      def self.run(params)
+        UI.important('The badge action has been deprecated,')
+        UI.important('please checkout the badge plugin here:')
+        UI.important('https://github.com/HazAT/fastlane-plugin-badge')
+        Actions.verify_gem!('badge')
+        require 'badge'
+        options = {
+          dark: params[:dark],
+          custom: params[:custom],
+          no_badge: params[:no_badge],
+          shield: params[:shield],
+          alpha: params[:alpha],
+          shield_io_timeout: params[:shield_io_timeout],
+          glob: params[:glob],
+          alpha_channel: params[:alpha_channel],
+          shield_gravity: params[:shield_gravity],
+          shield_no_resize: params[:shield_no_resize]
+        }
+        begin
+          Badge::Runner.new.run(params[:path], options)
+        rescue => e
+          # We want to catch this error and raise our own so that we are not counting this as a crash in our metrics
+          UI.verbose(e.backtrace.join("\n"))
+          UI.user_error!("Something went wrong while running badge: #{e}")
+        end
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Automatically add a badge to your app icon"
+      end
+
+      def self.details
+        [
+          "Please use the [badge plugin](https://github.com/HazAT/fastlane-plugin-badge) instead.",
+          "This action will add a light/dark badge onto your app icon.",
+          "You can also provide your custom badge/overlay or add a shield for more customization.",
+          "More info: [https://github.com/HazAT/badge](https://github.com/HazAT/badge)",
+          "**Note**: If you want to reset the badge back to default, you can use `sh 'git checkout -- <path>/Assets.xcassets/'`."
+        ].join("\n")
+      end
+
+      def self.example_code
+        [
+          'badge(dark: true)',
+          'badge(alpha: true)',
+          'badge(custom: "/Users/xxx/Desktop/badge.png")',
+          'badge(shield: "Version-0.0.3-blue", no_badge: true)'
+        ]
+      end
+
+      def self.category
+        :deprecated
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :dark,
+                                       env_name: "FL_BADGE_DARK",
+                                       description: "Adds a dark flavored badge ontop of your icon",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("dark is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :custom,
+                                       env_name: "FL_BADGE_CUSTOM",
+                                       description: "Add your custom overlay/badge image",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("custom should be a valid file path") unless value && File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :no_badge,
+                                       env_name: "FL_BADGE_NO_BADGE",
+                                       description: "Hides the beta badge",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("no_badge is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shield,
+                                       env_name: "FL_BADGE_SHIELD",
+                                       description: "Add a shield to your app icon from shields.io",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :alpha,
+                                       env_name: "FL_BADGE_ALPHA",
+                                       description: "Adds and alpha badge instead of the default beta one",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("alpha is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "FL_BADGE_PATH",
+                                       description: "Sets the root path to look for AppIcons",
+                                       optional: true,
+                                       is_string: true,
+                                       default_value: '.',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("path needs to be a valid directory") if Dir[value].empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shield_io_timeout,
+                                       env_name: "FL_BADGE_SHIELD_IO_TIMEOUT",
+                                       description: "Set custom duration for the timeout of the shields.io request in seconds",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("shield_io_timeout needs to be an integer > 0") if value.to_i < 1
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :glob,
+                                       env_name: "FL_BADGE_GLOB",
+                                       description: "Glob pattern for finding image files",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :alpha_channel,
+                                       env_name: "FL_BADGE_ALPHA_CHANNEL",
+                                       description: "Keeps/adds an alpha channel to the icon (useful for android icons)",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("alpha_channel is only a flag and should always be true") unless value == true
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :shield_gravity,
+                                       env_name: "FL_BADGE_SHIELD_GRAVITY",
+                                       description: "Position of shield on icon. Default: North - Choices include: NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast",
+                                       optional: true,
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :shield_no_resize,
+                                       env_name: "FL_BADGE_SHIELD_NO_RESIZE",
+                                       description: "Shield image will no longer be resized to aspect fill the full icon. Instead it will only be shrunk to not exceed the icon graphic",
+                                       optional: true,
+                                       is_string: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("shield_no_resize is only a flag and should always be true") unless value == true
+                                       end)
+        ]
+      end
+
+      def self.authors
+        ["DanielGri"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac, :android].include?(platform)
+      end
+    end
+  end
+end