fastlane_iac_publish 0.1.0

data/fastlane/lib/fastlane/actions/debug.rb

@@ -0,0 +1,32 @@
+module Fastlane
+  module Actions
+    class DebugAction < Action
+      def self.run(params)
+        puts("Lane Context".green)
+        puts(Actions.lane_context)
+      end
+
+      def self.description
+        "Print out an overview of the lane context values"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.example_code
+        [
+          'debug'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/default_platform.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      DEFAULT_PLATFORM = :DEFAULT_PLATFORM
+    end
+
+    class DefaultPlatformAction < Action
+      def self.run(params)
+        UI.user_error!("You forgot to pass the default platform") if params.first.nil?
+
+        platform = params.first.to_sym
+
+        SupportedPlatforms.verify!(platform)
+
+        Actions.lane_context[SharedValues::DEFAULT_PLATFORM] = platform
+      end
+
+      def self.description
+        "Defines a default platform to not have to specify the platform"
+      end
+
+      def self.output
+        [
+          ['DEFAULT_PLATFORM', 'The default platform']
+        ]
+      end
+
+      def self.example_code
+        [
+          'default_platform(:android)'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.author
+        "KrauseFx"
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/delete_keychain.rb

@@ -0,0 +1,68 @@
+require 'shellwords'
+
+module Fastlane
+  module Actions
+    class DeleteKeychainAction < Action
+      def self.run(params)
+        original = Actions.lane_context[Actions::SharedValues::ORIGINAL_DEFAULT_KEYCHAIN]
+
+        if params[:keychain_path]
+          if File.exist?(params[:keychain_path])
+            keychain_path = params[:keychain_path]
+          else
+            UI.user_error!("Unable to find the specified keychain.")
+          end
+        elsif params[:name]
+          keychain_path = FastlaneCore::Helper.keychain_path(params[:name])
+        else
+          UI.user_error!("You either have to set :name or :keychain_path")
+        end
+
+        Fastlane::Actions.sh("security default-keychain -s #{original}", log: false) unless original.nil?
+        Fastlane::Actions.sh("security delete-keychain #{keychain_path.shellescape}", log: false)
+      end
+
+      def self.details
+        "Keychains can be deleted after being created with `create_keychain`"
+      end
+
+      def self.description
+        "Delete keychains and remove them from the search list"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :name,
+                                       env_name: "KEYCHAIN_NAME",
+                                       description: "Keychain name",
+                                       conflicting_options: [:keychain_path],
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :keychain_path,
+                                       env_name: "KEYCHAIN_PATH",
+                                       description: "Keychain path",
+                                       conflicting_options: [:name],
+                                       optional: true)
+        ]
+      end
+
+      def self.example_code
+        [
+          'delete_keychain(name: "KeychainName")',
+          'delete_keychain(keychain_path: "/keychains/project.keychain")'
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.authors
+        ["gin0606", "koenpunt"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/deliver.rb

@@ -0,0 +1,14 @@
+module Fastlane
+  module Actions
+    require 'fastlane/actions/upload_to_app_store'
+    class DeliverAction < UploadToAppStoreAction
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Alias for the `upload_to_app_store` action"
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/deploygate.rb

@@ -0,0 +1,210 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      DEPLOYGATE_URL = :DEPLOYGATE_URL
+      DEPLOYGATE_REVISION = :DEPLOYGATE_REVISION # auto increment revision number
+      DEPLOYGATE_APP_INFO = :DEPLOYGATE_APP_INFO # contains app revision, bundle identifier, etc.
+    end
+
+    class DeploygateAction < Action
+      DEPLOYGATE_URL_BASE = 'https://deploygate.com'
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.upload_build(api_token, user_name, binary, options)
+        require 'faraday'
+        require 'faraday_middleware'
+
+        connection = Faraday.new(url: DEPLOYGATE_URL_BASE, request: { timeout: 120 }) do |builder|
+          builder.request(:multipart)
+          builder.request(:json)
+          builder.response(:json, content_type: /\bjson$/)
+          builder.use(FaradayMiddleware::FollowRedirects)
+          builder.adapter(:net_http)
+        end
+
+        options.update({
+          token: api_token,
+          file: Faraday::UploadIO.new(binary, 'application/octet-stream'),
+          message: options[:message] || ''
+        })
+        options[:disable_notify] = 'yes' if options[:disable_notify]
+
+        connection.post("/api/users/#{user_name}/apps", options)
+      rescue Faraday::Error::TimeoutError
+        UI.crash!("Timed out while uploading build. Check https://deploygate.com/ to see if the upload was completed.")
+      end
+
+      def self.run(options)
+        # Available options: https://deploygate.com/docs/api
+        UI.success('Starting with app upload to DeployGate... this could take some time ⏳')
+
+        api_token = options[:api_token]
+        user_name = options[:user]
+        binary = options[:ipa] || options[:apk]
+        upload_options = options.values.select do |key, _|
+          [:message, :distribution_key, :release_note, :disable_notify, :distribution_name].include?(key)
+        end
+
+        UI.user_error!('missing `ipa` and `apk`. deploygate action needs least one.') unless binary
+
+        return binary if Helper.test?
+
+        response = self.upload_build(api_token, user_name, binary, upload_options)
+        if parse_response(response)
+          UI.message("DeployGate URL: #{Actions.lane_context[SharedValues::DEPLOYGATE_URL]}")
+          UI.success("Build successfully uploaded to DeployGate as revision \##{Actions.lane_context[SharedValues::DEPLOYGATE_REVISION]}!")
+        else
+          UI.user_error!("Error when trying to upload app to DeployGate")
+        end
+      end
+
+      def self.parse_response(response)
+        if response.body && response.body.key?('error')
+
+          if response.body['error']
+            UI.error("Error uploading to DeployGate: #{response.body['message']}")
+            help_message(response)
+            return
+          else
+            res = response.body['results']
+            url = DEPLOYGATE_URL_BASE + res['path']
+
+            Actions.lane_context[SharedValues::DEPLOYGATE_URL] = url
+            Actions.lane_context[SharedValues::DEPLOYGATE_REVISION] = res['revision']
+            Actions.lane_context[SharedValues::DEPLOYGATE_APP_INFO] = res
+          end
+        else
+          UI.error("Error uploading to DeployGate: #{response.body}")
+          return
+        end
+        true
+      end
+      private_class_method :parse_response
+
+      def self.help_message(response)
+        message =
+          case response.body['message']
+          when 'you are not authenticated'
+            'Invalid API Token specified.'
+          when 'application create error: permit'
+            'Access denied: May be trying to upload to wrong user or updating app you join as a tester?'
+          when 'application create error: limit'
+            'Plan limit: You have reached to the limit of current plan or your plan was expired.'
+          end
+        UI.error(message) if message
+      end
+      private_class_method :help_message
+
+      def self.description
+        "Upload a new build to [DeployGate](https://deploygate.com/)"
+      end
+
+      def self.details
+        [
+          "You can retrieve your username and API token on [your settings page](https://deploygate.com/settings).",
+          "More information about the available options can be found in the [DeployGate Push API document](https://deploygate.com/docs/api)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "DEPLOYGATE_API_TOKEN",
+                                       description: "Deploygate API Token",
+                                       sensitive: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API Token for DeployGate given, pass using `api_token: 'token'`") unless value.to_s.length > 0
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :user,
+                                       env_name: "DEPLOYGATE_USER",
+                                       description: "Target username or organization name",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No User for DeployGate given, pass using `user: 'user'`") unless value.to_s.length > 0
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :ipa,
+                                       env_name: "DEPLOYGATE_IPA_PATH",
+                                       description: "Path to your IPA file. Optional if you use the _gym_ or _xcodebuild_ action",
+                                       default_value: Actions.lane_context[SharedValues::IPA_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find ipa file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :apk,
+                                       env_name: "DEPLOYGATE_APK_PATH",
+                                       description: "Path to your APK file",
+                                       default_value: Actions.lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH],
+                                       default_value_dynamic: true,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find apk file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :message,
+                                       env_name: "DEPLOYGATE_MESSAGE",
+                                       description: "Release Notes",
+                                       default_value: "No changelog provided"),
+          FastlaneCore::ConfigItem.new(key: :distribution_key,
+                                       optional: true,
+                                       env_name: "DEPLOYGATE_DISTRIBUTION_KEY",
+                                       sensitive: true,
+                                       description: "Target Distribution Key"),
+          FastlaneCore::ConfigItem.new(key: :release_note,
+                                       optional: true,
+                                       env_name: "DEPLOYGATE_RELEASE_NOTE",
+                                       description: "Release note for distribution page"),
+          FastlaneCore::ConfigItem.new(key: :disable_notify,
+                                       optional: true,
+                                       is_string: false,
+                                       default_value: false,
+                                       env_name: "DEPLOYGATE_DISABLE_NOTIFY",
+                                       description: "Disables Push notification emails"),
+          FastlaneCore::ConfigItem.new(key: :distribution_name,
+                                       optional: true,
+                                       is_string: true,
+                                       env_name: "DEPLOYGATE_DISTRIBUTION_NAME",
+                                       description: "Target Distribution Name")
+        ]
+      end
+
+      def self.output
+        [
+          ['DEPLOYGATE_URL', 'URL of the newly uploaded build'],
+          ['DEPLOYGATE_REVISION', 'auto incremented revision number'],
+          ['DEPLOYGATE_APP_INFO', 'Contains app revision, bundle identifier, etc.']
+        ]
+      end
+
+      def self.example_code
+        [
+          'deploygate(
+            api_token: "...",
+            user: "target username or organization name",
+            ipa: "./ipa_file.ipa",
+            message: "Build #{lane_context[SharedValues::BUILD_NUMBER]}",
+            distribution_key: "(Optional) Target Distribution Key",
+            distribution_name: "(Optional) Target Distribution Name"
+          )',
+          'deploygate(
+            api_token: "...",
+            user: "target username or organization name",
+            apk: "./apk_file.apk",
+            message: "Build #{lane_context[SharedValues::BUILD_NUMBER]}",
+            distribution_key: "(Optional) Target Distribution Key",
+            distribution_name: "(Optional) Target Distribution Name"
+          )'
+        ]
+      end
+
+      def self.category
+        :beta
+      end
+
+      def self.authors
+        ["tnj", "tomorrowkey"]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/device_grid/README.md

@@ -0,0 +1,157 @@
+# fastlane danger Device Grid
+
+Ever dream of testing your app straight from a pull request? Well now you can! With [_fastlane_](https://fastlane.tools), [danger](https://github.com/danger/danger) and [appetize.io](https://appetize.io/), you can stream your latest changes right from the browser.
+
+No more manually installing and testing your app just to review a PR.
+
+![assets/GridExampleScreenshot.png](assets/GridExampleScreenshot.png)
+
+[View Example Pull Request](https://github.com/Themoji/ios/pull/12#issuecomment-215836315)
+
+## Requirements
+
+- [_fastlane_](https://fastlane.tools)
+- [danger](https://github.com/danger/danger)
+- [appetize.io](https://appetize.io/) account
+- A Continuous Integration system
+
+## Getting started
+
+### Install fastlane and danger
+
+Create a `Gemfile` in your project's directory with the following content
+
+```ruby
+gem "fastlane"
+gem "danger"
+gem "danger-device_grid"
+```
+
+and run
+
+```
+bundle install
+```
+
+### Setup _fastlane_
+
+Skip this step if you're already using _fastlane_ (which you should)
+
+```
+fastlane init
+```
+
+### Setup `danger`
+
+```
+danger init
+```
+
+Follow the `danger` guide to authenticate with GitHub
+
+### Configure `danger`
+
+Edit `Dangerfile` and replace the content with
+
+```ruby
+puts("Running fastlane to generate and upload an ipa file...")
+
+options = {
+  xcodebuild: {
+      workspace: "YourApp.xcworkspace",
+      scheme: "YourScheme"
+    }
+}
+
+require 'fastlane'
+result = Fastlane::OneOff.run(action: "build_and_upload_to_appetize",
+                          parameters: options)
+
+device_grid.run(
+  public_key: result,
+  languages: ["en", "de"],
+  devices: ["iphone5s", "iphone6splus", "ipadair"]
+)
+```
+
+Make sure to fill in your actual workspace and scheme, or use the `project` parameter `project: "YourApp.xcworkspace"`.
+
+### Try it
+
+Push everything to GitHub in its own branch and create a PR to trigger your CI system. 
+
+### Make use of deep linking
+
+When you submit a PR you usually know what part of your app should be reviewed. Make it easier for everyone by providing a deep link, launching the app at the right point. To do so, use emojis (what else):
+
+Add this to the bottom of your PR-body:
+
+```
+:link: com.krausefx.app://bacons/show/937
+```
+
+### Make use of `NSUserDefaults`
+
+To do a runtime check if if the app is running on `Appetize`, just use:
+
+```objective-c
+[[NSUserDefaults standardUserDefaults] objectForKey:@"isAppetize"]
+```
+
+### Generate `appetize` stream, without the grid
+
+Add the following to your `Fastfile` to build and upload your app to `appetize`. 
+
+```ruby
+desc "Build your app and upload it to Appetize to stream it in your browser"
+lane :upload_to_appetize do
+  build_and_upload_to_appetize(
+    xcodebuild: {
+      workspace: "YourApp.xcworkspace",
+      scheme: "YourScheme"
+    }
+  )
+end
+```
+
+Run the newly created lane using
+
+```
+fastlane upload_to_appetize
+```
+
+### Manual way using `appetize_viewing_url_generator`
+
+If you want even more control over the way your app is built, you can also manually generate your `.app` and then upload it to `appetize`.
+
+Use the `appetize` action together with `appetize_viewing_url_generator`. Make sure to build with the `iphonesimulator` SDK, since `appetize` runs iOS simulators to stream your application.
+
+```ruby
+tmp_path = "/tmp/fastlane_build"
+xcodebuild(
+  workspace: "Themoji.xcworkspace",
+  sdk: "iphonesimulator",
+  scheme: "Themoji",
+  derivedDataPath: tmp_path
+)
+
+app_path = Dir[File.join(tmp_path, "**", "*.app")].last
+UI.user_error!("Couldn't find app") unless app_path
+
+zipped_bundle = zip(path: app_path, output_path: File.join(tmp_path, "Result.zip"))
+
+appetize(
+  path: zipped_bundle,
+  api_token: 'yourapitoken' # get it from https://appetize.io/docs#request-api-token
+)
+
+url = appetize_viewing_url_generator(scale: "75", color: "black", public_key: "123123")
+UI.message("Generated URL: #{url}")
+```
+
+#### Disclaimer
+
+All product names, logos, and brands are property of their respective owners.  
+The used device frames were provided by Facebook via the [Facebook Design Resources](https://facebook.github.io/design/devices.html). _fastlane_ is in no way affiliated with Facebook.
+
+> While Facebook has redrawn and shares these assets for the benefit of the design community, Facebook does not own any of the underlying product or user interface designs. By accessing these assets, you agree to obtain all necessary permissions from the underlying rights holders and/or adhere to any applicable brand use guidelines before using them. Facebook disclaims all express or implied warranties with respect to these assets, including non-infringement of intellectual property rights.