fastlane-plugin-match_import_multiple 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4b052227308ac34eb0e6f3b05c963c1ab386c7506ff8c4be155982e44983763
+  data.tar.gz: 898a6d58c6bc0f12909ea7a30238168f615634f52262a976259478c1a73ae53d
+SHA512:
+  metadata.gz: a0d5310bb184ba21c31df014c4cc6584eef5f67d27a62c54f546b1f211532827329b8956da9a2c1b7353bf18a96029aff9bf3bb573fcb0e91430112faa4cbe93
+  data.tar.gz: 7d01e6f41d0d22fe2a71242afe07374dd32daa7f360ca53b5a8a93fd720f3926ad6109af7a0dc28437867b823b6fe2030a37e1e384714d9bab2e2e61ab97147e

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Bogdan Matran <bogdancristian.matran@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# match_import_multiple plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-match_import_multiple)
+
+## About match_import_multiple
+
+Wraps _match_'s `Importer` so a single invocation can register many provisioning profiles for the same certificate. _match_'s built-in `match import` only accepts one `.mobileprovision` (or `.provisionprofile`) per call, which means teams managing many bundle identifiers under the same signing certificate have to run the import once per profile — repeating the same App Store Connect login, the same git/S3 storage round trip, and the same Matchfile configuration each time.
+
+This plugin keeps the same UX as upstream `fastlane match import` (cert → p12 → profile prompts, `Matchfile` auto-loaded, all _match_ options forwarded as-is) and only changes the profile argument, which now accepts an `Array` of paths or a comma-separated `String`. The action loops over the profiles and delegates each one to the unmodified upstream `Match::Importer#import_cert`, so behavior stays consistent with stock _fastlane_ and future _fastlane_ releases require no code changes here.
+
+## Installation
+
+Add the plugin to your project's `fastlane/Pluginfile`:
+
+```ruby
+gem 'fastlane-plugin-match_import_multiple',
+    git: 'https://github.com/BogdanMatran/fastlane-plugin-match_import_multiple.git',
+    branch: 'main'
+```
+
+Then make sure your project's `Gemfile` evaluates the `Pluginfile`:
+
+```ruby
+# Gemfile
+source "https://rubygems.org"
+gem 'fastlane'
+
+plugins_path = File.join(File.dirname(__FILE__), 'fastlane', 'Pluginfile')
+eval_gemfile(plugins_path) if File.exist?(plugins_path)
+```
+
+Install:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### From a `Fastfile`
+
+```ruby
+lane :import_profiles do
+  match_import_multiple(
+    type: "appstore",
+    cert_path: "./assets/dist.cer",
+    p12_path:  "./assets/dist.p12",
+    profile_paths: [
+      "./assets/AppStore_app.mobileprovision",
+      "./assets/AppStore_app.ShareExtension.mobileprovision",
+      "./assets/AppStore_app.NotificationExtension.mobileprovision"
+    ]
+  )
+end
+```
+
+`git_url`, `username`, `team_id`, and other _match_ options are picked up from your project's `Matchfile` and `Appfile` automatically — exactly like with `fastlane match import`.
+
+Run it:
+
+```bash
+bundle exec fastlane import_profiles
+```
+
+### From the CLI (no lane needed)
+
+```bash
+bundle exec fastlane run match_import_multiple \
+  type:appstore \
+  cert_path:./assets/dist.cer \
+  p12_path:./assets/dist.p12 \
+  profile_paths:./assets/profile1.mobileprovision,./assets/profile2.mobileprovision
+```
+
+`profile_paths` accepts a comma-separated string on the CLI; arrays are normalized internally.
+
+### Interactive (mirrors upstream `fastlane match import`)
+
+If you omit any of `cert_path`, `p12_path`, or `profile_paths`, the plugin prompts for them in the same order as `fastlane match import`:
+
+```bash
+bundle exec fastlane run match_import_multiple type:appstore
+# Certificate (.cer) path: ./assets/dist.cer
+# Private key (.p12) path: ./assets/dist.p12
+# Provisioning profile (.mobileprovision or .provisionprofile) path(s),
+#   comma-separated, or leave empty to skip: ./a.mobileprovision,./b.mobileprovision
+```
+
+## Parameters
+
+| Parameter        | Type            | Description                                                                                          |
+| ---------------- | --------------- | ---------------------------------------------------------------------------------------------------- |
+| `profile_paths`  | `Array[String]` or comma-separated `String` | Provisioning profile paths to import. Prompts interactively if omitted. |
+| `cert_path`      | `String`        | Path to the `.cer` certificate (shared across all profiles). Prompts interactively if omitted.       |
+| `p12_path`       | `String`        | Path to the `.p12` private key (shared across all profiles). Prompts interactively if omitted.       |
+| _all match opts_ | varies          | Every option that `fastlane match import` accepts (`type`, `git_url`, `storage_mode`, `api_key_path`, `username`, `team_id`, `skip_certificate_matching`, `force_legacy_encryption`, etc.) is forwarded as-is. |
+
+## Behavior notes
+
+- **One commit per profile.** Each profile triggers its own `Match::Importer#import_cert` call, which clones the certs repo, copies the profile, and pushes a commit. Importing _N_ profiles produces _N_ commits in the certs repo. This keeps the plugin a thin wrapper around upstream and resilient to future _match_ changes.
+- **`app_identifier` is not required for import.** _match_'s option list declares `app_identifier` as required, but the import flow reads bundle ids from each `.mobileprovision` file directly. The plugin avoids forcing the prompt by passing the configuration straight through to `Match::Importer`, the same way upstream `match import` does.
+- **`Matchfile` is auto-loaded** by the plugin, mirroring upstream's behavior. You don't need to repeat `git_url`, `type`, `storage_mode`, etc. in the action call if your `Matchfile` already sets them.
+
+## Run tests for this plugin
+
+```
+bundle install
+bundle exec rake
+```
+
+This runs RSpec specs and RuboCop. To auto-fix style issues:
+
+```
+bundle exec rubocop -a
+```
+
+## Troubleshooting
+
+If you have trouble using _fastlane_ plugins, check the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/match_import_multiple/actions/match_import_multiple_action.rb

@@ -0,0 +1,144 @@
+require 'fastlane/action'
+require 'fastlane_core/configuration/configuration'
+require_relative '../helper/match_import_multiple_helper'
+
+module Fastlane
+  module Actions
+    class MatchImportMultipleAction < Action
+      def self.run(params)
+        require 'match/importer'
+
+        # Mirror what `fastlane match import` does after building its Configuration:
+        # load Matchfile defaults so storage/type/etc are picked up automatically.
+        begin
+          params.load_configuration_file("Matchfile")
+        rescue StandardError
+          # Matchfile is optional
+        end
+
+        importer = ::Match::Importer.new
+
+        # Same prompt order as upstream `fastlane match import`: cert -> p12 -> profile(s).
+        cert_path = importer.ensure_valid_file_path(params[:cert_path], "Certificate", ".cer")
+        p12_path  = importer.ensure_valid_file_path(params[:p12_path], "Private key", ".p12")
+
+        profile_paths = resolve_profile_paths(params[:profile_paths])
+        UI.user_error!("No provisioning profiles provided") if profile_paths.empty?
+
+        profile_paths.each_with_index do |profile_path, idx|
+          UI.message("Importing profile #{idx + 1}/#{profile_paths.length}: #{profile_path}")
+          importer.import_cert(
+            params,
+            cert_path: cert_path,
+            p12_path: p12_path,
+            profile_path: profile_path
+          )
+        end
+
+        UI.success("Imported #{profile_paths.length} provisioning profile(s) into the match repo")
+      end
+
+      # Mirrors upstream match's interactive UX:
+      #   - Array given           -> use as-is
+      #   - String (single/CSV)   -> split on commas
+      #   - nil                   -> prompt the user (comma-separated input)
+      # Each path is normalized to an absolute path and verified to exist.
+      def self.resolve_profile_paths(value)
+        raw = case value
+              when Array
+                value
+              when String
+                value.split(",")
+              when nil
+                UI.input("Provisioning profile (.mobileprovision or .provisionprofile) path(s), comma-separated, or leave empty to skip:").split(",")
+              else
+                UI.user_error!("Invalid profile_paths value: #{value.inspect}")
+              end
+
+        raw.map { |entry| entry.to_s.strip }.reject(&:empty?).map do |path|
+          absolute = File.absolute_path(path)
+          UI.user_error!("Provisioning profile does not exist at path: #{absolute}") unless File.exist?(absolute)
+          absolute
+        end
+      end
+
+      def self.description
+        "Import multiple provisioning profiles into a match repo in a single invocation"
+      end
+
+      def self.details
+        <<~DETAILS
+          Wraps fastlane match's Importer so you can pass an array of provisioning
+          profile paths together with a single shared certificate and private key.
+          Iterates over the profiles and delegates to the unmodified upstream
+          Match::Importer#import_cert. All match options (storage backend, type,
+          team, App Store Connect API key, encryption settings, Matchfile, etc.)
+          are forwarded as-is.
+        DETAILS
+      end
+
+      def self.authors
+        ["Bogdan Matran"]
+      end
+
+      def self.return_value
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :mac].include?(platform)
+      end
+
+      def self.available_options
+        require 'match/options'
+
+        plugin_options = [
+          FastlaneCore::ConfigItem.new(
+            key: :profile_paths,
+            description: "Array (or comma-separated string) of provisioning profile paths to import. Prompts interactively if omitted, mirroring `fastlane match import`",
+            skip_type_validation: true,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :cert_path,
+            description: "Path to the .cer certificate (shared across all profiles). Prompts interactively if omitted",
+            type: String,
+            optional: true,
+            verify_block: proc { |value| UI.user_error!("Certificate not found at path: #{value}") if value && !File.exist?(value) }
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :p12_path,
+            description: "Path to the .p12 private key (shared across all profiles). Prompts interactively if omitted",
+            type: String,
+            optional: true,
+            verify_block: proc { |value| UI.user_error!("Private key not found at path: #{value}") if value && !File.exist?(value) }
+          )
+        ]
+
+        reserved_keys = plugin_options.map(&:key)
+        match_options = ::Match::Options.available_options.reject { |opt| reserved_keys.include?(opt.key) }
+
+        plugin_options + match_options
+      end
+
+      def self.example_code
+        [
+          'match_import_multiple(
+            type: "appstore",
+            git_url: "git@github.com:your-org/certs.git",
+            cert_path: "./assets/dist.cer",
+            p12_path: "./assets/dist.p12",
+            profile_paths: [
+              "./assets/AppStore_app1.mobileprovision",
+              "./assets/AppStore_app2.mobileprovision",
+              "./assets/AppStore_app3.mobileprovision"
+            ]
+          )'
+        ]
+      end
+
+      def self.category
+        :code_signing
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/match_import_multiple/helper/match_import_multiple_helper.rb

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

data/lib/fastlane/plugin/match_import_multiple/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module MatchImportMultiple
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/match_import_multiple.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/match_import_multiple/version'
+
+module Fastlane
+  module MatchImportMultiple
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::MatchImportMultiple.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-match_import_multiple
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bogdan Matran
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-07 00:00:00.000000000 Z
+dependencies: []
+description: Wraps fastlane match's Importer to accept an array of provisioning profile
+  paths so you can register many profiles for the same certificate in one command,
+  instead of running fastlane match import once per profile.
+email: bogdancristian.matran@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/match_import_multiple.rb
+- lib/fastlane/plugin/match_import_multiple/actions/match_import_multiple_action.rb
+- lib/fastlane/plugin/match_import_multiple/helper/match_import_multiple_helper.rb
+- lib/fastlane/plugin/match_import_multiple/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Import multiple provisioning profiles into a match repo in a single invocation
+test_files: []