fastlane-plugin-react_native_release 0.3.0 → 0.8.0

data/lib/fastlane/plugin/react_native_release/actions/create_changelog.rb

@@ -0,0 +1,92 @@
+require 'fastlane/action'
+
+module Fastlane
+  module Actions
+    class CreateChangelogAction < Action
+      def self.run(params)
+        title = params[:title]
+        commit_message = params[:commit_message]
+        # Determine our local branch name, set the upstream, and pull.
+        # We need to pull since another build may have already finished and created a changelog
+        local_branch ||= other_action.git_branch.gsub(/origin/, '')
+        sh("git branch --set-upstream-to=origin/#{local_branch} #{local_branch}")
+        other_action.git_pull 
+
+        # Get release notes since last version
+        # This exports a slack and a regular markdown format
+        notes = other_action.conventional_changelog(title: title, format: 'slack')
+        notesMD = other_action.conventional_changelog(title: title, format: 'markdown')
+
+        # Prepend new Changelog to existing one
+        UI.message("pre-pending to CHANGELOG")
+        UI.message(notes)
+        new_file = '../CHANGELOG.md.new'
+        original_file = '../CHANGELOG.md'
+
+        open(new_file, 'w') do |nf|
+          notesMD.split("\n").each { |line| nf.puts line }
+          nf.puts "\n"
+          
+          File.foreach(original_file) do |li|
+            nf.puts li
+          end
+        end
+
+        File.delete original_file
+        File.rename new_file, original_file
+
+        # Commit it
+        other_action.git_commit(
+          path: [File.join(Dir.pwd, original_file)],
+          message: commit_message,
+          skip_git_hooks: true
+        )
+
+        { plain: notes, markdown: notesMD }
+      end
+
+      #####################################################
+      # @!group documentation
+      #####################################################
+
+      def self.description
+        "Determines if a release should happen based on conventional commits."
+      end
+
+      def self.details
+        "If using conventional commits, only continues to release if there are features / fixes."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :title,
+                                       env_name: "FL_CREATE_CHANGELOG_TITLE",
+                                       description: "What title should we use for the CHANGELOG?",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :commit_message,
+                                       env_name: "FL_CREATE_CHANGELOG_COMMIT_MESSAGE",
+                                       description: "What should the commit message be?",
+                                       type: String,
+                                       default_value: "chore(changelog): Update CHANGELOG [skip ci]")
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["cball"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/create_fastlane_session.rb

@@ -0,0 +1,75 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class CreateFastlaneSessionAction < Action
+      def self.run(params)
+        username = params[:username]
+        key = Helper::ReactNativeReleaseHelper::FASTLANE_SESSION_CRYPTEX_KEY
+        fastlane_key = Helper::ReactNativeReleaseHelper::FASTLANE_CRYPTEX_KEY
+        fastlane_session_cookie_path = "#{File.expand_path('~')}/.fastlane/spaceship/#{username}/cookie"
+
+        UI.message "Generating a new fastlane session."
+        UI.message "Please enter the 6 digit 2FA code if one is sent to your device otherwise the script will continue automatically."
+        
+        sh("fastlane spaceauth -u #{username.shellescape}")
+
+        # store the session
+        other_action.cryptex(
+          type: "import",
+          in: fastlane_session_cookie_path,
+          key: key
+        )
+
+        # store the username that created the session in fastlane_vars
+        existing_fastlane_vars = other_action.cryptex(
+          type: 'export_env',
+          key: fastlane_key,
+        )
+
+        other_action.cryptex(
+          type: "import_env",
+          key: fastlane_key,
+          # PILOT_USERNAME needs to be set to the same username as the session above
+          hash: existing_fastlane_vars.merge({ 'PILOT_USERNAME' => username })
+        )
+
+        UI.success "Uploaded session for #{username} to #{key}."
+      end
+
+      def self.description
+        "Simplify 2FA authentication for App Store Connect"
+      end
+
+      def self.authors
+        ["cball", "isaiahgrey93"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        "Creates a cookie for authenticating with App Store connecting. Handles generating, encrypting, and storing the cookie."
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :username,
+                                       env_name: "FL_CREATE_FASTLANE_SESSION_USERNAME",
+                                       description: "Enter the Apple username to generate a App Store Connect session",
+                                       type: String)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        [:ios, :android].include?(platform)
+      end
+
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/decrypt_android_keystore.rb

@@ -0,0 +1,131 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class DecryptAndroidKeystoreAction < Action
+      def self.run(params)
+        key = Helper::ReactNativeReleaseHelper::ANDROID_KEYSTORE_CRYPTEX_KEY
+        file = Helper::ReactNativeReleaseHelper::ANDROID_KEYSTORE_PATH
+
+        begin
+          env_file_exists = File.exists?(file)
+
+          if (env_file_exists && UI.confirm("This will overwrite your existing .env file. Proceed?"))
+            self.export_and_decrypt_keystore(file,key)
+            
+          elsif(env_file_exists)
+            UI.abort_with_message!("Stepping away...")
+          else
+            self.export_and_decrypt_keystore(file,key)
+          end
+        # If we don't have a keystore, cryptex will throw an exception.
+        rescue => ex
+          UI.abort_with_message!('Error decrypting keystore. Does it exist in the repo?')
+        end
+
+        UI.success("Decrypted #{key} to keystore.")
+      end
+
+      def self.export_and_decrypt_keystore(file,key)
+        other_action.cryptex(
+          type: "export",
+          out: file,
+          key: key,
+          verbose: true
+        )
+         # There is currently a bug where the keystore needs to be in multiple paths
+         # Optimized for the CI process to be running from the lane in android directory
+         sh("cp ./app/android.keystore ./")
+      end
+
+      # Creates a new android keystore based on the provided params. Wraps Cryptex.
+      def self.create_keystore_with_params(params)
+        begin
+          other_action.cryptex_generate_keystore(
+            destination: params[:destination],
+            password: params[:password],
+            fullname: params[:fullname],
+            city: params[:city],
+            alias: params[:alias]
+          )
+        rescue => ex
+          UI.abort_with_message!("Could not create keystore. Do you already have one with this alias?")
+        end
+
+        params[:destination]
+      end
+
+      # Saves a keystore to the repo. Note this will overwrite it!
+      def self.encrypt_keystore(keystore_path)
+        key = Helper::ReactNativeReleaseHelper::ANDROID_KEYSTORE_CRYPTEX_KEY
+
+        other_action.cryptex(
+          type: "import",
+          in: keystore_path,
+          key: key
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Decrypts app env vars and sets the values in the root .env file"
+      end
+
+      def self.details
+        # Optional:
+        # this is your chance to provide a more detailed description of this action
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :encrypt_in_repo,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_ENCRYPT_IN_REPO",
+                                       description: "If the new keystore should be encrypted and saved",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_PASSWORD",
+                                       description: "Password for the Keystore",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :alias,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_ALIAS",
+                                       description: "ALIAS for the Keystore",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_DESTINATION",
+                                       description: "Where to put decrypted keystore",
+                                       default_value: "../android/app/android.keystore"),
+          FastlaneCore::ConfigItem.new(key: :fullname,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_FULLNAME",
+                                       description: "Fullname of keystore owner",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :city,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_CITY",
+                                       description: "City of keystore owner",
+                                       type: String),
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["cball", "isaiahgrey93", "cmejet"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/decrypt_app_vars.rb

@@ -0,0 +1,117 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class DecryptAppVarsAction < Action
+      def self.run(params)
+        is_ci = ENV['CI'] === 'true'
+        namespace = params[:namespace]
+        write_env = params[:write_env]
+        skip_confirmation= params[:skip_confirmation]
+        default_cryptex_app_key = Helper::ReactNativeReleaseHelper::APP_CRYPTEX_KEY
+        cryptex_app_key = Helper::ReactNativeReleaseHelper.app_key_for(namespace)
+        is_same_key = default_cryptex_app_key == cryptex_app_key
+        message = ''
+
+        if(!skip_confirmation)
+          if is_same_key
+            message = "This will decrypt values from #{cryptex_app_key}. Proceed?"
+          else
+            message = "This will decrypt and merge values from #{cryptex_app_key} into #{default_cryptex_app_key}. Proceed?"
+          end
+        
+
+          if !is_ci && !UI.confirm(message)
+            UI.abort_with_message!("Stepping away...")
+          end
+        end
+
+        app_vars = other_action.cryptex(
+          type: "export_env",
+          key: default_cryptex_app_key
+        )
+
+        namespaced_vars = other_action.cryptex(
+          type: "export_env",
+          key: cryptex_app_key
+        )
+
+        merged_vars = app_vars.merge(namespaced_vars)
+        has_env_file = File.exists?(Helper::ReactNativeReleaseHelper::APP_ENV_PATH)
+        should_write_env = write_env && (is_ci || skip_confirmation || !has_env_file || UI.confirm("It looks like you already have an .env file. Overwrite it?"))
+
+        # write an env file with the merged values
+        if (should_write_env)
+          # TODO: handle running action from root and from ios/android folders. This will not work properly in the root as is.
+          open('../.env', 'w') do |f|
+            merged_vars.each {|key, value| f.puts "#{key}=#{value}" }
+          end
+
+          UI.success('.env written')
+        else
+          UI.success('not writing .env')
+        end
+
+        merged_vars
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Decrypts app env vars and sets the values in the root .env file"
+      end
+
+      def self.details
+        # Optional:
+        # this is your chance to provide a more detailed description of this action
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :namespace,
+                                       env_name: "FL_DECRYPT_APP_VARS_NAMESPACE", # The name of the environment variable
+                                       description: "What namespace should we use? (alpha, beta, release, ENTER = root)", # a short description of this parameter
+                                       type: String,
+                                       verify_block: lambda do |value|
+                                        unless Helper::ReactNativeReleaseHelper::VALID_NAMESPACES.include?(value)
+                                          UI.user_error!("Invalid namespace #{value}. Valid targets are #{Helper::ReactNativeReleaseHelper::VALID_NAMESPACES.join(', ')}") 
+                                          next
+                                        end
+                                      end),
+          FastlaneCore::ConfigItem.new(key: :write_env,
+                                       env_name: "FL_DECRYPT_APP_VARS_WRITE_ENV", # The name of the environment variable
+                                       description: "If we should write an .env file", # a short description of this parameter
+                                       type: Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :skip_confirmation,
+                                       env_name: "FL_ENCRYPT_APP_VARS_SKIP_CONFIRMATION", # The name of the environment variable
+                                       description: "Allows commands to be run from within CLI and skip the UI.message confirmation dialog", # a short description of this parameter
+                                       type: Boolean,
+                                       short_option:'s',
+                                       default_value: false,
+                                       optional: true)
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["cball", "isaiahgrey93", "cmejet"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/decrypt_fastlane_vars.rb

@@ -0,0 +1,101 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class DecryptFastlaneVarsAction < Action
+      def self.run(params)
+
+        is_ci = ENV['CI'] === 'true'
+        write_env = params[:write_env]
+
+        env = other_action.cryptex(
+          type: "export_env",
+          key: Helper::ReactNativeReleaseHelper::FASTLANE_CRYPTEX_KEY,
+          set_env: params[:set_env]
+        )
+
+        should_write_env = write_env && !is_ci
+
+
+        UI.success('Successfully decrypted fastlane vars.')
+
+        # write fastlane env files
+        if (should_write_env)
+
+          UI.success('Writing fastlane vars to <root>/fastlane/.env.')
+          
+          open('./fastlane/.env', 'w') do |f|
+            env.each {|key, value| f.puts "#{key}=#{value}" }
+          end
+ 
+          UI.success('Writing fastlane vars to <root>/ios/fastlane/.env.')
+          
+          open('./ios/fastlane/.env', 'w') do |f|
+            env.each {|key, value| f.puts "#{key}=#{value}" }
+          end
+ 
+          UI.success('Writing fastlane vars to <root>/android/fastlane/.env.')
+          
+          open('./android/fastlane/.env', 'w') do |f|
+            env.each {|key, value| f.puts "#{key}=#{value}" }
+          end
+
+          UI.success('Fastlane .env files were successfully written.')
+        else
+          UI.success('Fastlane .env not generated.')
+        end
+
+        env
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Decrypts fastlane ENV vars from the encrypted repo. Optionally sets them in ENV."
+      end
+
+      def self.details
+        # Optional:
+        # this is your chance to provide a more detailed description of this action
+      end
+
+      def self.available_options
+        # Define all options your action supports. 
+        
+        # Below a few examples
+        [
+          FastlaneCore::ConfigItem.new(key: :set_env,
+                                       env_name: "FL_DECRYPT_FASTLANE_VARS_SET_ENV", # The name of the environment variable
+                                       description: "Sets the decrypted values in env", # a short description of this parameter
+                                       type: Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :write_env,
+                                       env_name: "FL_DECRYPT_FASTLANE_VARS_WRITE_ENV", # The name of the environment variable
+                                       description: "If we should write fastlane .env files", # a short description of this parameter
+                                       type: Boolean,
+                                       default_value: true)
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["cball", "isaiahgrey93"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end