fastlane-plugin-match_import 0.1.2

data/lib/fastlane/plugin/match_import/commands_generator.rb

@@ -0,0 +1,159 @@
+require 'commander'
+require 'fastlane_core/configuration/configuration'
+
+require_relative '../match_import'
+
+HighLine.track_eof = false
+module Fastlane
+  module MatchImport
+    class CommandsGenerator
+      include Commander::Methods
+
+      def self.start
+        self.new.run
+      end
+
+      def run
+        program :name, 'match_import'
+        program :version, Fastlane::MatchImport::VERSION
+        program :description, Fastlane::MatchImport::DESCRIPTION
+        program :help, 'Author', 'Sergii Batsevych <serbats@ukr.net>'
+        program :help, 'Website', 'https://fastlane.tools'
+        program :help, 'GitHub', 'https://github.com/serbats/fastlane-plugin-match_import'
+        program :help_formatter, :compact
+
+        global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+
+        command :import do |c|
+          c.syntax = 'match_import import'
+          c.description = Fastlane::MatchImport::DESCRIPTION
+
+          FastlaneCore::CommanderGenerator.new.generate(Fastlane::MatchImport::CustomFileOptions.available_options, command: c)
+
+          c.action do |args, options|
+            if args.count > 0
+              FastlaneCore::UI.user_error!("Please run `match_import import --file_name='*.txt' --source_path='testDir' --destination_path='repoDir'`")
+            end
+
+            params = FastlaneCore::Configuration.create(Fastlane::MatchImport::CustomFileOptions.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+
+            Match::Encryption.register_backend(type: "git", encryption_class: MatchImport::Encryption::OpenSSL)
+            Match::Encryption.register_backend(type: "s3", encryption_class: MatchImport::Encryption::OpenSSL)
+
+            Fastlane::MatchImport::Runner.new.run(params)
+          end
+        end
+
+        command :export do |c|
+          c.syntax = 'match_import export'
+          c.description = Fastlane::MatchImport::DESCRIPTION
+
+          FastlaneCore::CommanderGenerator.new.generate(Fastlane::MatchImport::CustomFileOptions.available_options, command: c)
+
+          c.action do |args, options|
+            if args.count > 0
+              FastlaneCore::UI.user_error!("Please run `match_import export --file_name='*.txt' --source_path='repoDir' --destination_path='testDir'`")
+            end
+
+            params = FastlaneCore::Configuration.create(Fastlane::MatchImport::CustomFileOptions.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+
+            Match::Encryption.register_backend(type: "git", encryption_class: MatchImport::Encryption::OpenSSL)
+            Match::Encryption.register_backend(type: "s3", encryption_class: MatchImport::Encryption::OpenSSL)
+
+            Fastlane::MatchImport::Runner.new.run_export(params)
+          end
+        end
+
+        command :remove do |c|
+          c.syntax = 'match_import remove'
+          c.description = Fastlane::MatchImport::DESCRIPTION
+
+          FastlaneCore::CommanderGenerator.new.generate(Fastlane::MatchImport::CustomFileOptions.available_options, command: c)
+
+          c.action do |args, options|
+            if args.count > 0
+              FastlaneCore::UI.user_error!("Please run `match_import remove --file_name='*.txt' --source_path='repoDir'`")
+            end
+
+            params = FastlaneCore::Configuration.create(Fastlane::MatchImport::CustomFileOptions.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+
+            Match::Encryption.register_backend(type: "git", encryption_class: MatchImport::Encryption::OpenSSL)
+            Match::Encryption.register_backend(type: "s3", encryption_class: MatchImport::Encryption::OpenSSL)
+
+            Fastlane::MatchImport::Runner.new.run_remove(params)
+          end
+        end
+
+        command :import_apns do |c|
+          c.syntax = 'match_import import_apns'
+          c.description = Fastlane::MatchImport::DESCRIPTION
+
+          FastlaneCore::CommanderGenerator.new.generate(Fastlane::MatchImport::APNSFileOptions.available_options, command: c)
+
+          c.action do |args, options|
+            if args.count > 0
+              FastlaneCore::UI.user_error!("Please run `match_import import_apns --type='development' --cert_file_name='PushDev.cer' --p12_file_name='PushDev.p12'`")
+            end
+
+            params = FastlaneCore::Configuration.create(Fastlane::MatchImport::APNSFileOptions.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+
+            Match::Encryption.register_backend(type: "git", encryption_class: MatchImport::Encryption::OpenSSL)
+            Match::Encryption.register_backend(type: "s3", encryption_class: MatchImport::Encryption::OpenSSL)
+
+            Fastlane::MatchImport::RunnerAPNS.new.run(params)
+          end
+        end
+
+        command :export_apns do |c|
+          c.syntax = 'match_import export_apns'
+          c.description = Fastlane::MatchImport::DESCRIPTION
+
+          FastlaneCore::CommanderGenerator.new.generate(Fastlane::MatchImport::APNSExportFileOptions.available_options, command: c)
+
+          c.action do |args, options|
+            if args.count > 0
+              FastlaneCore::UI.user_error!("Please run `match_import export_apns --type='development' --keychain_name='FastlaneKeychain' --keychain_password='password' --destination_path='testDir'`")
+            end
+
+            params = FastlaneCore::Configuration.create(Fastlane::MatchImport::APNSExportFileOptions.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+
+            Match::Encryption.register_backend(type: "git", encryption_class: MatchImport::Encryption::OpenSSL)
+            Match::Encryption.register_backend(type: "s3", encryption_class: MatchImport::Encryption::OpenSSL)
+
+            Fastlane::MatchImport::RunnerAPNS.new.run_export(params)
+          end
+        end
+
+        command :remove_invalid_apns do |c|
+          c.syntax = 'match_import remove_invalid_apns'
+          c.description = Fastlane::MatchImport::DESCRIPTION
+
+          FastlaneCore::CommanderGenerator.new.generate(Fastlane::MatchImport::APNSRemoveInvalidFileOptions.available_options, command: c)
+
+          c.action do |args, options|
+            if args.count > 0
+              FastlaneCore::UI.user_error!("Please run `match_import remove_invalid_apns --type='development'`")
+            end
+
+            params = FastlaneCore::Configuration.create(Fastlane::MatchImport::APNSRemoveInvalidFileOptions.available_options, options.__hash__)
+            params.load_configuration_file("Matchfile")
+
+            Match::Encryption.register_backend(type: "git", encryption_class: MatchImport::Encryption::OpenSSL)
+            Match::Encryption.register_backend(type: "s3", encryption_class: MatchImport::Encryption::OpenSSL)
+
+            Fastlane::MatchImport::RunnerAPNS.new.run_remove_invalid(params)
+          end
+        end
+
+        default_command(:import)
+
+        run!
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/match_import/custom_file_options.rb

@@ -0,0 +1,43 @@
+
+require 'fastlane_core'
+require 'match'
+
+module Fastlane
+  module MatchImport
+    class CustomFileOptions
+      def self.exclude_match_options
+        # [:type, :output_path, :keychain_name, :keychain_password]
+        # Don't know how to exclude unused options and don't get error like:
+        # Could not find option 'type' in the list of available options
+        []
+      end
+
+      def self.available_options
+        all = Fastlane::MatchImport::Options.available_options
+
+        exclude_match_options.each do |key|
+          (i = all.find_index { |item| item.key == key }) && all.delete_at(i)
+        end
+
+        return all + custom_options
+      end
+
+      def self.custom_options
+        [
+          FastlaneCore::ConfigItem.new(key: :file_name,
+                                     env_name: "MATCH_IMPORT_FILENAME",
+                                     description: "File to import. Could contain mask like '*.txt'",
+                                     optional: false),
+          FastlaneCore::ConfigItem.new(key: :destination_path,
+                                     env_name: "MATCH_IMPORT_DESTINATION_PATH",
+                                     description: "Path to copy imported file to",
+                                     optional: true),
+          FastlaneCore::ConfigItem.new(key: :source_path,
+                                     env_name: "MATCH_IMPORT_SOURCE_PATH",
+                                     description: "Path to take importing file from",
+                                     optional: true)
+        ]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/match_import/encryption/openssl.rb

@@ -0,0 +1,18 @@
+require 'match'
+
+module Fastlane
+  module MatchImport
+    module Encryption
+      class OpenSSL < Match::Encryption::OpenSSL
+        def iterate(source_path)
+          super
+          # apns *.cer and *.p12 are encrypted/decrypted by 'super' call
+          Dir[File.join(source_path, "customImport/customImport/customImport", "custom", "**", "*")].each do |path|
+            next if File.directory?(path)
+            yield(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/match_import/helper/match_import_helper.rb

@@ -0,0 +1,16 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
+
+  module Helper
+    class MatchImportHelper
+      # class methods that you define here become available in your action
+      # as `Helper::MatchImportHelper.your_method`
+      #
+      def self.show_message
+        UI.message("Hello from the match_import plugin helper!")
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/match_import/options.rb

@@ -0,0 +1,26 @@
+
+require 'fastlane_core'
+require 'match'
+
+module Fastlane
+  module MatchImport
+    class Options
+      def self.exclude_match_options
+        # [:output_path, :additional_cert_types, :readonly, :generate_apple_certs, :skip_provisioning_profiles, :force, :force_for_new_devices, :skip_confirmation, :template_name]
+        # Don't know how to exclude unused options and don't get error like:
+        # Could not find option 'type' in the list of available options
+        []
+      end
+
+      def self.available_options
+        all = Match::Options.available_options
+
+        exclude_match_options.each do |key|
+          (i = all.find_index { |item| item.key == key }) && all.delete_at(i)
+        end
+
+        return all
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/match_import/runner.rb

@@ -0,0 +1,153 @@
+require 'fastlane_core/print_table'
+
+module Fastlane
+  module MatchImport
+    class Runner
+      attr_accessor :files_to_commit
+      attr_accessor :storage
+
+      def run(params)
+        self.files_to_commit = []
+
+        FastlaneCore::PrintTable.print_values(config: params,
+                                              hide_keys: [],
+                                              title: "Summary for match_import #{Fastlane::MatchImport::VERSION}")
+
+        MatchImport::Utils.update_optional_values_depending_on_storage_type(params)
+
+        # Get and verify custom file path
+        file_path = MatchImport::Utils.ensure_valid_file_path(params[:file_name], params[:source_path], "File to import")
+        # Verify destination path is one level dir. Othervise encrypt/decript won't work
+        destination_path = MatchImport::Utils.ensure_valid_one_level_path(params[:destination_path])
+
+        # Choose the right storage and encryption implementations
+        storage = MatchImport::Utils.storage(params, false)
+
+        # Init the encryption only after the `storage.download` was called to have the right working directory
+        encryption = MatchImport::Utils.encryption(params, storage)
+
+        storage_workspace = storage.prefixed_working_directory
+
+        # Hack to avoid conflicts with "fastlane match" encryption.
+        # It uses pattern: [File.join(source_path, "**", "*.{cer,p12,mobileprovision,provisionprofile}")]
+        # To avoid conflicts we use three level deep folder.
+        output_dir = File.join(storage_workspace, "customImport/customImport/customImport", "custom")
+        output_dir = File.join(output_dir, destination_path) if destination_path
+
+        # Make dir if doesn't exist
+        FileUtils.mkdir_p(output_dir)
+        # dest_path = File.join(output_dir, params[:file_name])
+        dest_path = output_dir
+
+        # Copy file
+        # IO.copy_stream(file_path, dest_path)
+
+        Dir[file_path].each do |file|
+          dest_file = File.join(dest_path, File.basename(file))
+          if File.file?(dest_file) && FileUtils.compare_file(file, dest_file)
+            UI.success("File '#{file}' already exist at destination and is unchanged")
+          else
+            self.files_to_commit << dest_path
+
+            FileUtils.cp(file, dest_path)
+            UI.success("Finish copying '#{file}' to '#{dest_path}'") if FastlaneCore::Globals.verbose?
+          end
+        end
+
+        if self.files_to_commit.count > 0
+          encryption.encrypt_files if encryption
+          storage.save_changes!(files_to_commit: self.files_to_commit)
+        end
+      end
+
+      def run_export(params)
+        FastlaneCore::PrintTable.print_values(config: params,
+                                              hide_keys: [],
+                                              title: "Summary for match_import #{Fastlane::MatchImport::VERSION}")
+
+        MatchImport::Utils.update_optional_values_depending_on_storage_type(params)
+
+        # Verify source path is one level dir. Othervise encrypt/decript won't work
+        source_path = MatchImport::Utils.ensure_valid_one_level_path(params[:source_path])
+
+        # Choose the right storage and encryption implementations
+        storage = MatchImport::Utils.storage(params, true)
+
+        # Init the encryption only after the `storage.download` was called to have the right working directory
+        MatchImport::Utils.encryption(params, storage)
+
+        storage_workspace = storage.prefixed_working_directory
+
+        # Hack to avoid conflicts with "fastlane match" encryption.
+        # It uses pattern: [File.join(source_path, "**", "*.{cer,p12,mobileprovision,provisionprofile}")]
+        # To avoid conflicts we use three level deep folder.
+        input_dir = File.join(storage_workspace, "customImport/customImport/customImport", "custom")
+        source_path = source_path.nil? ? input_dir : File.join(input_dir, source_path)
+
+        # Get and verify custom file path
+        file_path =  MatchImport::Utils.ensure_valid_file_path(params[:file_name], source_path, "File to export")
+
+        output_dir = params[:destination_path].nil? ? '.' : params[:destination_path]
+
+        # Make dir if doesn't exist
+        FileUtils.mkdir_p(output_dir)
+        # dest_path = File.join(output_dir, params[:file_name])
+        dest_path = output_dir
+
+        # Copy file
+        # IO.copy_stream(file_path, dest_path)
+
+        Dir[file_path].each do |file|
+          dest_file = File.join(dest_path, File.basename(file))
+          if File.file?(dest_file) && FileUtils.compare_file(file, dest_file)
+            UI.success("File '#{file}' already exist at destination and is unchanged")
+          else
+            FileUtils.cp(file, dest_path)
+            UI.success("Finish copying '#{file}' to '#{dest_path}'") if FastlaneCore::Globals.verbose?
+          end
+        end
+      end
+
+      def run_remove(params)
+        self.files_to_commit = []
+
+        FastlaneCore::PrintTable.print_values(config: params,
+                                              hide_keys: [],
+                                              title: "Summary for match_import #{Fastlane::MatchImport::VERSION}")
+
+        MatchImport::Utils.update_optional_values_depending_on_storage_type(params)
+
+        # Verify source path is one level dir. Othervise encrypt/decript won't work
+        source_path = MatchImport::Utils.ensure_valid_one_level_path(params[:source_path])
+
+        # Choose the right storage and encryption implementations
+        storage = MatchImport::Utils.storage(params, false)
+
+        storage_workspace = storage.prefixed_working_directory
+
+        # Hack to avoid conflicts with "fastlane match" encryption.
+        # It uses pattern: [File.join(source_path, "**", "*.{cer,p12,mobileprovision,provisionprofile}")]
+        # To avoid conflicts we use three level deep folder.
+        input_dir = File.join(storage_workspace, "customImport/customImport/customImport", "custom")
+        source_path = source_path.nil? ? input_dir : File.join(input_dir, source_path)
+
+        # Get and verify custom file path
+        file_path = MatchImport::Utils.ensure_valid_file_path(params[:file_name], source_path, "File to remove")
+
+        # Copy file
+        # IO.copy_stream(file_path, dest_path)
+
+        Dir[file_path].each do |file|
+          self.files_to_commit << file
+
+          FileUtils.rm(file)
+          UI.success("Finish removing '#{file}'") if FastlaneCore::Globals.verbose?
+        end
+
+        if self.files_to_commit.count > 0
+          storage.save_changes!(files_to_commit: self.files_to_commit)
+        end
+      end
+    end
+  end
+end