secure-keys 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6946af00c20082e078ea40c755f0738199bc46640496cf42eb95fa57c9c87483
-  data.tar.gz: bb59bb065970abcd05a903030d48c8cd0164b5b8ee74b4f43b7368877abde082
+  metadata.gz: cdab80c05ee6ac029d64ec53aef700bc77e9126398f886f6fc7e0ae529297535
+  data.tar.gz: 38176c478f562dfcacd51e62b051f49705cec3cc66a586e20487038965a9976e
 SHA512:
-  metadata.gz: f7b7aab488356cbc4afa09de94c9f36de7911820d10aaa52b7896f5edf645051c245fb8eb89866fae9a0ac32c0eecf450fd473423698346a17609f9faf07cf9a
-  data.tar.gz: ccb083a8d120236864b12557205f28c4798d264cdc8008605c0899e23590dbd98dee1b32a93277b46bd867eb5c4293ff1c48796d7567c3122daf03e5713dd0bf
+  metadata.gz: 77e197f322a085f56ce57eef897fdcc156c2c5fe3be9decd1464b396080cfbab2acb39def1787c872b7980c8fb6b9530b6487ccbd2b8b87e93beff57a64f1d51
+  data.tar.gz: ffc4ba7aedeff64d0d30f214564b2ec48f4658d4a5eef8e428877b7d98ab896d5a108e0a9e50bdd9668cfa62496d0b9929b6efab50f42814ff4ae1871dc22b14

data/README.md

@@ -1,5 +1,5 @@
 <div style="display: flex; gap: 10px; padding-bottom: 20px;">
-  <img src="https://img.shields.io/badge/version-1.1.3-cyan" alt="SecureKeys Version 1.1.3">
+  <img src="https://img.shields.io/badge/version-1.1.4-cyan" alt="SecureKeys version">
 
   <img src="https://img.shields.io/badge/iOS-^13.0-blue" alt="iOS version 13.0">
 
@@ -137,13 +137,13 @@ secure-keys --help
 
 Usage: secure-keys [--options]
 
-    -h, --help                                  Use the provided commands to select the params
-        --add-xcframework-to-target TARGET      Add the xcframework to the target
-    -d, --delimiter DELIMITER                   The delimiter to use for the key access (default: ",")
-    -i, --identifier IDENTIFIER                 The identifier to use for the key access (default: "secure-keys")
-        --verbose                               Enable verbose mode (default: false)
-    -v, --version                               Show the secure-keys version
-    -x, --xcodeproj XCODEPROJ                   The Xcode project path (default: the first found Xcode project)
+    -h, --help                       Use the provided commands to select the params
+        --xcframework                Add the xcframework to the target
+    -d, --delimiter DELIMITER        The delimiter to use for the key access (default: ",")
+        --[no-]generate              Generate the SecureKeys.xcframework
+    -i, --identifier IDENTIFIER      The identifier to use for the key access (default: "secure-keys")
+        --verbose                    Enable verbose mode (default: false)
+    -v, --version                    Show the secure-keys version
 ```
 
 To avoid defining the `SECURE_KEYS_IDENTIFIER` and `SECURE_KEYS_DELIMITER` env variables, you can use the `--identifier` and `--delimiter` options.
@@ -188,22 +188,68 @@ let apiKey: String = .key(for: .apiKey)
 
 ### Automatically
 
-From the `secure-keys` command, you can use the `--add-xcframework-to-target` option to add the `SecureKeys.xcframework` to the iOS project.
+> [!IMPORTANT]
+> You can see more information about the command using the `--help` option.
+
+```bash
+secure-keys --xcframework --help
+
+# Output
+Usage: secure-keys --xcframework [--options]
+
+    -h, --help                       Use the provided commands to select the params
+        --[no-]add                   Add the SecureKeys XCFramework to the Xcode project (default: true)
+    -t, --target TARGET              The target to add the xcframework
+    -r, --replace                    Replace the existing xcframework in the Xcode project (default: false)
+    -x, --xcodeproj XCODEPROJ        The Xcode project path (default: the first found Xcode project)
+```
+
+From the `secure-keys` command, you can use the `--xcframework` option to add the `SecureKeys.xcframework` to the iOS project.
+
+```bash
+secure-keys --xcframework --target "YourTargetName" --add
+```
+
+If you want to add the `SecureKeys.xcframework` to an iOS that already contains the `SecureKeys` source code, you can use the `--replace` option.
+
+```bash
+secure-keys --xcframework --target "YourTargetName" --replace
+```
+
+> [!IMPORTANT]
+> If you don't need to generate the `SecureKeys.xcframework` every time, you can use the `--no-generate` option.
 
 ```bash
-secure-keys --add-xcframework-to-target "YourTargetName"
+secure-keys --no-generate --xcframework --target "YourTargetName"
 ```
 
 Also, you can specify your Xcode project path using the `--xcodeproj` option.
 
 ```bash
-secure-keys --add-xcframework-to-target "YourTargetName" --xcodeproj "/path/to/your/project.xcodeproj"
+secure-keys --xcframework --target "YourTargetName" --xcodeproj "/path/to/your/project.xcodeproj"
 ```
 
 > [!IMPORTANT]
 > By default, the xcodeproj path would be the first found Xcode project.
 
-This command will generate the `SecureKeys.xcframework` and add it to the iOS project.
+If you don't want to use the CLI options, you can configure some env variable to interact with the `secure-keys` command.
+
+```bash
+# e.g (Large version)
+export SECURE_KEYS_XCFRAMEWORK_TARGET="YourTargetName"
+export SECURE_KEYS_XCFRAMEWORK_ADD=true
+export SECURE_KEYS_XCFRAMEWORK_REPLACE=true
+export SECURE_KEYS_XCFRAMEWORK_XCODEPROJ="/path/to/your/project.xcodeproj"
+
+# e.g (Short version)
+export XCFRAMEWORK_TARGET="YourTargetName"
+export XCFRAMEWORK_ADD=true
+export XCFRAMEWORK_REPLACE=true
+export XCFRAMEWORK_XCODEPROJ="/path/to/your/project.xcodeproj"
+
+# Run the command
+secure-keys --xcframework
+```
 
 ### Manually
 

data/bin/secure-keys

@@ -5,4 +5,4 @@ require 'dotenv/load'
 require_relative '../lib/keys'
 
 # Generate the keys
-SecureKeys::Generator.new.setup
+SecureKeys.run

data/lib/core/console/arguments/handler.rb

@@ -10,21 +10,37 @@ module SecureKeys
           # Configure the default arguments
           @arguments = {
             delimiter: nil,
+            generate: true,
             identifier: nil,
-            target: nil,
             verbose: false,
-            xcodeproj: nil,
           }
 
           # Fetch the argument value by key
           # from CLI arguments or environment variables
           #
-          # @param key [Symbol] the argument key
+          # @param key [Array|Symbol] the argument key
           # @param default [String] the default value
           #
           # @return [String] the argument value
           def self.fetch(key:, default: nil)
-            @arguments[key.to_sym] || ENV.fetch("secure_keys_#{key}".upcase, nil) || default
+            keys = Array(key).map(&:to_sym)
+            joined_keys = keys.join('_').upcase
+            @arguments.dig(*keys) || ENV["SECURE_KEYS_#{joined_keys}"] || ENV[joined_keys] || default
+          end
+
+          # Set the value of the key
+          # @param key [Symbol] the key to be updated
+          # @param value [String] the value to be updated
+          def self.set(key:, value:)
+            @arguments[key.to_sym] = value
+          end
+
+          # Append the argument value by key
+          # @param key [Symbol] the argument key
+          # @param value [String] the argument value
+          def self.deep_merge(key:, value:)
+            @arguments[key.to_sym] ||= {} # Initialize the key if it doesn't exist
+            @arguments[key.to_sym].merge!(value)
           end
         end
       end

data/lib/core/console/arguments/parser.rb

@@ -3,6 +3,7 @@
 require 'optparse'
 require_relative '../../globals/globals'
 require_relative './handler'
+require_relative './xcframework/parser'
 
 module SecureKeys
   module Core
@@ -16,7 +17,8 @@ module SecureKeys
 
             # Configure the arguement parser
             configure!
-            parse!(into: Handler.arguments)
+            order!(into: Handler.arguments)
+            configure_sub_arguments
           end
 
           private
@@ -28,10 +30,12 @@ module SecureKeys
               exit(0)
             end
 
-            on('--add-xcframework-to-target TARGET', String, 'Add the xcframework to the target') do |target|
-              Handler.arguments[:target] = target
+            on('--xcframework', 'Add the xcframework to the target') do
+              XCFramework::Parser.new
             end
+
             on('-d', '--delimiter DELIMITER', String, "The delimiter to use for the key access (default: \"#{Globals.default_key_delimiter}\")")
+            on('--[no-]generate', TrueClass, 'Generate the SecureKeys.xcframework')
             on('-i', '--identifier IDENTIFIER', String, "The identifier to use for the key access (default: \"#{Globals.default_key_access_identifier}\")")
             on('--verbose', TrueClass, 'Enable verbose mode (default: false)')
 
@@ -39,7 +43,11 @@ module SecureKeys
               puts "secure-keys version: v#{SecureKeys::VERSION}"
               exit(0)
             end
-            on('-x', '--xcodeproj XCODEPROJ', String, 'The Xcode project path (default: the first found Xcode project)')
+          end
+
+          # Configure the sub arguments
+          def configure_sub_arguments
+            Handler.set(key: :xcframework, value: XCFramework::Handler.arguments)
           end
         end
       end

data/lib/core/console/arguments/xcframework/handler.rb

@@ -0,0 +1,23 @@
+module SecureKeys
+  module Core
+    module Console
+      module Argument
+        module XCFramework
+          class Handler
+            class << self
+              attr_reader :arguments
+            end
+
+            # Configure the default arguments
+            @arguments = {
+              add: true,
+              replace: false,
+              target: nil,
+              xcodeproj: nil,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/console/arguments/xcframework/parser.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require_relative '../../../globals/globals'
+require_relative './handler'
+
+module SecureKeys
+  module Core
+    module Console
+      module Argument
+        module XCFramework
+          class Parser < OptionParser
+            # Initialize the argument parser with the default options
+            def initialize
+              super('Usage: secure-keys --xcframework [--options]')
+              separator('')
+
+              # Configure the arguement parser
+              configure!
+              order!(into: Handler.arguments)
+            end
+
+            private
+
+            # Configure the argument parser
+            def configure!
+              on('-h', '--help', 'Use the provided commands to select the params') do
+                puts self
+                exit(0)
+              end
+
+              on('--[no-]add', TrueClass, 'Add the SecureKeys XCFramework to the Xcode project (default: true)')
+              on('-t', '--target TARGET', String, 'The target to add the xcframework')
+              on('-r', '--replace', TrueClass, 'Replace the existing xcframework in the Xcode project (default: false)')
+              on('-x', '--xcodeproj XCODEPROJ', String, 'The Xcode project path (default: the first found Xcode project)')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/console/logger.rb

@@ -54,7 +54,7 @@ module SecureKeys
         # Log a verbose message
         # @param message [String] the message to log
         def verbose(message:)
-          logger.debug(message.to_s) if AWSTracker::Global.verbose?
+          logger.debug(message.to_s) if Globals.verbose?
         end
 
         # Crash the terminal with a message

data/lib/core/environment/ci.rb

@@ -8,19 +8,10 @@ module SecureKeys
         # @param key [String] the key of the environment variable to fetch
         # @return [String] the value of the environment variable
         def fetch(key:)
-          ENV[formatted_key(key:)]
+          ENV[key]
         rescue StandardError
           puts "❌ Error fetching the key: #{key} from ENV variables"
         end
-
-        private
-
-        # Formats the key to match the format of the environment variables.
-        # @param key [String] the key to format
-        # @return [String] the formatted key
-        def formatted_key(key:)
-          key.gsub('-', '_').uppercase
-        end
       end
     end
   end

data/lib/core/generator.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require_relative './globals/globals'
+require_relative './environment/ci'
+require_relative './environment/keychain'
+require_relative './utils/swift/writer'
+require_relative './utils/swift/package'
+require_relative './utils/swift/swift'
+require_relative './utils/swift/xcframework'
+require_relative './utils/openssl/cipher'
+
+module SecureKeys
+  module Core
+    class Generator
+      private
+
+      attr_accessor :cipher, :secrets_source, :secret_keys, :mapped_keys, :xcframework
+
+      public
+
+      def initialize
+        # Configure cipher
+        self.cipher = OpenSSL::Cipher.new
+        self.secrets_source = Globals.secret_keys_source
+
+        # Define the keys that we want to map
+        self.secret_keys = secrets_source.fetch(key: Globals.key_access_identifier)
+                                         .to_s
+                                         .split(Globals.key_delimiter)
+                                         .map(&:strip)
+
+        # Add the keys that we want to map
+        self.mapped_keys = secret_keys.map do |key|
+          encrypted_data = cipher.encrypt(value: secrets_source.fetch(key:))
+          { name: key.camelize, **encrypted_data }
+        end
+
+        # Configure the XCFramework
+        self.xcframework = Swift::XCFramework.new
+      end
+
+      def generate
+        if Globals.generate_xcframework?
+          pre_actions
+          generate_swift_package
+          write_keys
+          xcframework.generate
+        end
+
+        xcframework.configure_xcframework_to_xcodeproj
+        post_actions if Globals.generate_xcframework?
+      end
+
+      private
+
+      def generate_swift_package
+        package = Swift::Package.new
+        package.generate
+      end
+
+      def write_keys
+        writer = Swift::Writer.new(mapped_keys:,
+                                   secure_key_bytes: cipher.secure_key_bytes)
+        writer.write
+      end
+
+      def pre_actions
+        # Remove the keys directory
+        system("rm -rf #{Swift::KEYS_DIRECTORY}")
+      end
+
+      def post_actions
+        # Remove the keys directory
+        system("rm -rf #{Swift::SWIFT_PACKAGE_DIRECTORY}")
+
+        # Remove the build directory
+        system("rm -rf #{Swift::KEYS_DIRECTORY}/#{Swift::BUILD_DIRECTORY}")
+      end
+    end
+  end
+end

data/lib/core/globals/globals.rb

@@ -15,7 +15,7 @@ module SecureKeys
 
       # Check for Jenkins, Travis CI, ... environment variables
       %w[JENKINS_HOME JENKINS_URL TRAVIS CI APPCENTER_BUILD_ID TEAMCITY_VERSION GO_PIPELINE_NAME bamboo_buildKey GITLAB_CI XCS TF_BUILD GITHUB_ACTION GITHUB_ACTIONS BITRISE_IO BUDDY CODEBUILD_BUILD_ARN].any? do |current|
-        ENV[current].to_s.eql?('true')
+        ENV[current].to_s.to_boolean
       end
     end
 
@@ -28,17 +28,39 @@ module SecureKeys
     # Check if the current instance is verbose
     # @return [Bool] true if the current instance is verbose
     def verbose?
-      Core::Console::Argument::Handler.fetch(key: :verbose,
-                                             default: ENV.fetch('VERBOSE', false))
+      Core::Console::Argument::Handler.fetch(key: :verbose)
                                       .to_s
-                                      .downcase
-                                      .eql?('true')
+                                      .to_boolean
+    end
+
+    # Check if the SecureKeys XCFramework should be generated
+    # @return [Bool] true if the SecureKeys XCFramework should be generated
+    def generate_xcframework?
+      Core::Console::Argument::Handler.fetch(key: :generate)
+                                      .to_s
+                                      .to_boolean
+    end
+
+    # Check if the SecureKeys XCFramework should be replaced
+    # @return [Bool] true if the SecureKeys XCFramework should be replaced
+    def replace_xcframework?
+      Core::Console::Argument::Handler.fetch(key: %i[xcframework replace])
+                                      .to_s
+                                      .to_boolean
+    end
+
+    # Check if the SecureKeys XCFramework should be added
+    # @return [Bool] true if the SecureKeys XCFramework should be added
+    def add_xcframework?
+      Core::Console::Argument::Handler.fetch(key: %i[xcframework add])
+                                      .to_s
+                                      .to_boolean
     end
 
     # Returns the Xcode project path
     # @return [String] Xcode project path
     def xcodeproj_path
-      Core::Console::Argument::Handler.fetch(key: :xcodeproj,
+      Core::Console::Argument::Handler.fetch(key: %i[xcframework xcodeproj],
                                              default: Dir.glob('**/*.xcodeproj').first)
     end
 
@@ -48,6 +70,14 @@ module SecureKeys
       Dir.glob("**/#{Swift::KEYS_DIRECTORY}/#{Swift::XCFRAMEWORK_DIRECTORY}").first
     end
 
+    # Determine the secret keys source based on the environment
+    # @return [Object] secret keys source
+    def secret_keys_source
+      return SecureKeys::Core::Environment::CI.new if ci?
+
+      SecureKeys::Core::Environment::Keychain.new
+    end
+
     # Returns the supported iOS platforms
     # @return [Array] supported iOS platforms
     def ios_platforms

data/lib/core/utils/extensions/kernel.rb

@@ -0,0 +1,13 @@
+require_relative './string/to_bool'
+require_relative './string/camelize'
+
+module Kernel
+  include BooleanCasting
+  include Camelize
+
+  String.include(BooleanCasting)
+  String.singleton_class.include(BooleanCasting)
+
+  String.include(Camelize)
+  String.singleton_class.include(Camelize)
+end

data/lib/core/utils/extensions/string/camelize.rb

@@ -0,0 +1,11 @@
+# Adds some useful methods to the String class
+module Camelize
+  # Convert a string to camel case format
+  # @return [String] the camel case formatted string
+  def camelize
+    words = split(/(?<=[a-z])(?=[A-Z])|[-_\s]+/) # Split at lowercase-to-uppercase transitions or explicit separators
+            .map(&:downcase) # Convert everything to lowercase for consistency
+
+    words.map.with_index { |word, index| index.zero? ? word : word.capitalize }.join
+  end
+end

data/lib/core/utils/extensions/string/to_bool.rb

@@ -0,0 +1,16 @@
+# Adds some useful methods to the String class
+module BooleanCasting
+  # Casts a string to a boolean
+  # @return [Boolean] the boolean value of the string
+  def to_bool
+    return self if [true, false].include?(self)
+    return false if nil? || empty?
+    return false if self =~ /^(false|f|no|n|0)$/i
+    return true if self =~ /^(true|t|yes|y|1)$/i
+
+    # If the string is not a boolean, return false by default
+    false
+  end
+  alias to_b to_bool
+  alias to_boolean to_bool
+end

data/lib/core/utils/swift/writer.rb

@@ -30,8 +30,6 @@ module SecureKeys
         end
       end
 
-      private
-
       # Generate the formatted keys content using Swift code format
       # @return [String] The formatted keys content
       def formatted_keys
@@ -44,7 +42,7 @@ module SecureKeys
             /// The decrypted value of the key
             public var decryptedValue: String {
                 switch self {
-                    #{mapped_keys.map { |key| switch_case_key_declaration_template(name: key[:name], value: key[:value], iv: key[:iv], tag: key[:tag]) }.join("\t\t\t")}
+                    #{mapped_keys.map { |key| switch_case_key_declaration_template(name: key[:name], value: key[:value], iv: key[:iv], tag: key[:tag]) }.join("\t\t")}
                     case .unknown: fatalError("Unknown key \\(rawValue)")
                 }
             }
@@ -61,25 +59,7 @@ module SecureKeys
         import Foundation
         import CryptoKit
 
-        // MARK: - Global methods
-
-        /// Fetch the decrypted value of the key
-        ///
-        /// - Parameter:
-        ///    - key: The key to fetch the decrypted value for
-        ///
-        /// - Returns: The decrypted value of the key
-        @available(iOS 13.0, *)
-        public func key(for key: SecureKey) -> String { key.decryptedValue }
-
-        /// Fetch the decrypted value of the key
-        ///
-        /// - Parameter:
-        ///    - key: The key to fetch the decrypted value for
-        ///
-        /// - Returns: The decrypted value of the key
-        @available(iOS 13.0, *)
-        public func key(_ key: SecureKey) -> String { key.decryptedValue }
+        #{key_swift_global_helper_functions}
 
         // MARK: - SecureKey enum
 
@@ -92,50 +72,95 @@ module SecureKeys
             #{content}
         }
 
-        // MARK: - Decrypt keys from array extension
+        #{key_array_decrypt_swift_extension}
 
-        @available(iOS 13.0, *)
-        extension Array where Element == UInt8 {
+        #{key_string_swift_extension}
 
-            // MARK: - Methods
+        // swiftlint:enable all
+        SWIFT
+      end
 
-            func decrypt(key: [UInt8], iv: [UInt8], tag: [UInt8]) -> String {
-                guard let sealedBox = try? AES.GCM.SealedBox(nonce: AES.GCM.Nonce(data: Data(iv)),
-                                                             ciphertext: Data(self),
-                                                             tag: Data(tag)),
-                      let decryptedData = try? AES.GCM.open(sealedBox, using: SymmetricKey(data: Data(key))),
-                      let decryptedKey = String(data: decryptedData, encoding: .utf8) else {
-                    fatalError("Failed to decrypt the key")
-                }
-                return decryptedKey
-            }
-        }
+      private
 
-        // MARK: - String extension for secure keys
+      # Generate the key global helper functions
+      # @return [String] The key global helper functions
+      def key_swift_global_helper_functions
+        <<~SWIFT
+          // MARK: - Global methods
+
+          /// Fetch the decrypted value of the key
+          ///
+          /// - Parameter:
+          ///    - key: The key to fetch the decrypted value for
+          ///
+          /// - Returns: The decrypted value of the key
+          @available(iOS 13.0, *)
+          public func key(for key: SecureKey) -> String { key.decryptedValue }
+
+          /// Fetch the decrypted value of the key
+          ///
+          /// - Parameter:
+          ///    - key: The key to fetch the decrypted value for
+          ///
+          /// - Returns: The decrypted value of the key
+          @available(iOS 13.0, *)
+          public func key(_ key: SecureKey) -> String { key.decryptedValue }
+        SWIFT
+      end
 
-        @available(iOS 13.0, *)
-        extension String {
+      # Generate the key array decrypt extension
+      # @return [String] The key array decrypt extension
+      def key_array_decrypt_swift_extension
+        <<~SWIFT
+          // MARK: - Decrypt keys from array extension
+
+          @available(iOS 13.0, *)
+          extension Array where Element == UInt8 {
+
+              // MARK: - Methods
+
+              func decrypt(key: [UInt8], iv: [UInt8], tag: [UInt8]) -> String {
+                  guard let sealedBox = try? AES.GCM.SealedBox(nonce: AES.GCM.Nonce(data: Data(iv)),
+                                                              ciphertext: Data(self),
+                                                              tag: Data(tag)),
+                        let decryptedData = try? AES.GCM.open(sealedBox, using: SymmetricKey(data: Data(key))),
+                        let decryptedKey = String(data: decryptedData, encoding: .utf8) else {
+                      fatalError("Failed to decrypt the key")
+                  }
+                  return decryptedKey
+              }
+          }
+        SWIFT
+      end
+
+      # Generate the key string extension
+      # @return [String] The key string extension
+      def key_string_swift_extension
+        <<~SWIFT
+          // MARK: - String extension for secure keys
 
-            // MARK: - Methods
+          @available(iOS 13.0, *)
+          extension String {
 
-            /// Fetch the key from the secure keys enum
-            public var secretKey: SecureKey { SecureKey(rawValue: self) ?? .unknown }
+              // MARK: - Methods
 
-            /// Fetch the decrypted value of the key
-            ///
-            /// - Parameters:
-            ///    - key: The key to fetch the decrypted value for
-            ///
-            /// - Returns: The decrypted value of the key
-            public static func key(for key: SecureKey) -> String { key.decryptedValue }
-        }
+              /// Fetch the key from the secure keys enum
+              public var secretKey: SecureKey { SecureKey(rawValue: self) ?? .unknown }
 
-        // swiftlint:enable all
+              /// Fetch the decrypted value of the key
+              ///
+              /// - Parameters:
+              ///    - key: The key to fetch the decrypted value for
+              ///
+              /// - Returns: The decrypted value of the key
+              public static func key(for key: SecureKey) -> String { key.decryptedValue }
+          }
         SWIFT
       end
 
       # Generate the case key declaration template
       # @param name [String] The name of the key
+      # @return [String] The case key declaration template
       def case_key_declaration_template(name:)
         <<~SWIFT
         case #{name}
@@ -144,6 +169,10 @@ module SecureKeys
 
       # Generate the switch case key declaration template
       # @param name [String] The name of the key
+      # @param value [String] The value of the key
+      # @param iv [String] The IV of the key
+      # @param tag [String] The tag of the key
+      # @return [String] The switch case key declaration template
       def switch_case_key_declaration_template(name:, value:, iv:, tag:) # rubocop:disable Naming/MethodParameterName
         <<~SWIFT
         case .#{name}: #{value}.decrypt(key: #{secure_key_bytes}, iv: #{iv}, tag: #{tag})

data/lib/core/utils/swift/xcframework.rb

@@ -22,7 +22,12 @@ module SecureKeys
           end
         end
         generate_key_xcframework
-        add_xcframework_to_xcodeproj_target_if_needed
+      end
+
+      # Configure the XCFramework to the Xcode project
+      def configure_xcframework_to_xcodeproj
+        remove_xcframework_from_xcodeproj_target_if_needed if Globals.replace_xcframework?
+        add_xcframework_to_xcodeproj_target_if_needed if Globals.replace_xcframework? || Globals.add_xcframework?
       end
 
       private
@@ -85,7 +90,7 @@ module SecureKeys
       # Add the XCFramework to the Xcode project target if needed
       # @param target_name [String] The target name to add the XCFramework
       def add_xcframework_to_xcodeproj_target_if_needed(target_name: nil)
-        target_name ||= Core::Console::Argument::Handler.fetch(key: :target)
+        target_name ||= Core::Console::Argument::Handler.fetch(key: %i[xcframework target])
         return if target_name.to_s.empty?
 
         Core::Console::Logger.important(message: "Adding the XCFramework to the target '#{target_name}'")
@@ -97,6 +102,21 @@ module SecureKeys
         xcodeproj.save
         Core::Console::Logger.success(message: "The XCFramework was added to the target '#{target_name}'")
       end
+
+      # Remove the XCFramework from the Xcode project target if needed
+      # @param target_name [String] The target name to remove the XCFramework
+      def remove_xcframework_from_xcodeproj_target_if_needed(target_name: nil)
+        target_name ||= Core::Console::Argument::Handler.fetch(key: %i[xcframework target])
+        return if target_name.to_s.empty?
+
+        Core::Console::Logger.important(message: "Removing the XCFramework from the target '#{target_name}'")
+        xcodeproj = Xcodeproj.xcodeproj
+        xcodeproj_target = Xcodeproj.xcodeproj_target_by_target_name(xcodeproj:, target_name:)
+        Xcodeproj.remove_xcframework(xcodeproj:, xcodeproj_target:, xcframework_path: Xcodeproj.xcframework_relative_path)
+
+        xcodeproj.save
+        Core::Console::Logger.success(message: "The XCFramework was removed from the target '#{target_name}'")
+      end
     end
   end
 end

data/lib/core/utils/swift/xcodeproj.rb

@@ -42,14 +42,27 @@ module SecureKeys
       # Get the Xcodeproj
       # @return [Xcodeproj] The Xcodeproj
       def xcodeproj
-        ::Xcodeproj::Project.open(SecureKeys::Globals.xcodeproj_path)
+        ::Xcodeproj::Project.open(Globals.xcodeproj_path)
+      end
+
+      # Remove all references to SecureKeys.xcframework from the Xcodeproj
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to remove the XCFramework
+      # @param xcodeproj_target [Xcodeproj::Project::Object::PBXNativeTarget] The target where the XCFramework is linked
+      # @param xcframework_path [String] The XCFramework path to remove
+      def remove_xcframework(xcodeproj:, xcodeproj_target:, xcframework_path:)
+        xcframework_filename = File.basename(xcframework_path)
+
+        remove_xcframework_from_build_phase(xcodeproj_target:, xcframework_filename:)
+        remove_xcframework_file_references(xcodeproj:, xcframework_filename:)
+        remove_xcframework_from_groups(xcodeproj:, xcframework_filename:)
+        remove_xcframework_from_search_paths(xcodeproj_target:, xcframework_filename:)
       end
 
       # Get the XCFramework relative path
       # @return [Pathname] The XCFramework relative path
       def xcframework_relative_path
-        Pathname.new(SecureKeys::Globals.secure_keys_xcframework_path)
-                .relative_path_from(Pathname.new(SecureKeys::Globals.xcodeproj_path).dirname)
+        Pathname.new(Globals.secure_keys_xcframework_path)
+                .relative_path_from(Pathname.new(Globals.xcodeproj_path).dirname)
       end
 
       # Check if the Xcode project has the secure keys XCFramework
@@ -60,10 +73,63 @@ module SecureKeys
           target.frameworks_build_phase.files.any? do |file|
             return false if file.file_ref.nil?
 
-            file.file_ref.path.include?(SecureKeys::Globals.secure_keys_xcframework_path)
+            file.file_ref.path.include?(Globals.secure_keys_xcframework_path)
           end
         end
       end
+
+      # Remove the XCFramework from the "Link Binary With Libraries" build phase
+      # @param xcodeproj_target [Xcodeproj::Project::Object::PBXNativeTarget] The target where the XCFramework is linked
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_from_build_phase(xcodeproj_target:, xcframework_filename:)
+        build_phase_files = xcodeproj_target.frameworks_build_phase.files.select do |file|
+          file.file_ref&.path&.include?(xcframework_filename)
+        end
+
+        build_phase_files.each do |file|
+          file.remove_from_project
+          Core::Console::Logger.verbose(message: "Removed #{xcframework_filename} from Link Binary With Libraries in target #{xcodeproj_target.name}")
+        end
+      end
+
+      # Remove the XCFramework from the file references
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to remove the XCFramework
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_file_references(xcodeproj:, xcframework_filename:)
+        file_references = xcodeproj.files.select { |file| file.path&.include?(xcframework_filename) }
+        file_references.each do |file_ref|
+          file_ref.remove_from_project
+          Core::Console::Logger.verbose(message: "Removed #{xcframework_filename} file reference")
+        end
+
+        # Ensure no orphaned references remain
+        xcodeproj.objects.select { |obj| obj.isa == 'PBXFileReference' && obj.path&.include?(xcframework_filename) }.each(&:remove_from_project)
+        xcodeproj.objects.select { |obj| obj.isa == 'PBXBuildFile' && obj.file_ref&.path&.include?(xcframework_filename) }.each(&:remove_from_project)
+      end
+
+      # Remove the XCFramework from groups (e.g., Frameworks Group)
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to remove the XCFramework
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_from_groups(xcodeproj:, xcframework_filename:)
+        frameworks_group = xcodeproj.frameworks_group
+        group_references = frameworks_group.files.select { |file| file.path&.include?(xcframework_filename) }
+
+        group_references.each do |file_ref|
+          frameworks_group.remove_reference(file_ref)
+          Core::Console::Logger.verbose(message: "Removed #{xcframework_filename} from Frameworks group")
+        end
+      end
+
+      # Remove the XCFramework from FRAMEWORK_SEARCH_PATHS
+      # @param xcodeproj_target [Xcodeproj::Project::Object::PBXNativeTarget] The target where the XCFramework is linked
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_from_search_paths(xcodeproj_target:, xcframework_filename:)
+        xcodeproj_target.build_configurations.each do |config|
+          framework_search_paths = config.build_settings['FRAMEWORK_SEARCH_PATHS'] || []
+          new_search_paths = framework_search_paths.reject { |path| path.include?(xcframework_filename) }
+          config.build_settings['FRAMEWORK_SEARCH_PATHS'] = new_search_paths unless framework_search_paths == new_search_paths
+        end
+      end
     end
   end
 end

data/lib/keys.rb

@@ -1,84 +1,18 @@
 #!/usr/bin/env ruby
 
+require_relative './core/utils/extensions/kernel'
+require_relative './core/generator'
 require_relative './core/globals/globals'
-require_relative './core/environment/ci'
-require_relative './core/environment/keychain'
-require_relative './core/utils/swift/writer'
-require_relative './core/utils/swift/package'
-require_relative './core/utils/swift/swift'
-require_relative './core/utils/swift/xcframework'
-require_relative './core/utils/openssl/cipher'
+require_relative './core/console/logger'
 require_relative './core/console/arguments/parser'
+require_relative './core/utils/swift/xcframework'
 
 module SecureKeys
-  class Generator
-    private
-
-    attr_accessor :cipher, :secrets_source, :secret_keys, :mapped_keys
-
-    public
-
-    def initialize
-      # Configure the argument parser
-      SecureKeys::Core::Console::Argument::Parser.new
-
-      puts "🔔 You're using a custom delimiter '#{SecureKeys::Globals.key_delimiter}'" unless SecureKeys::Globals.key_delimiter.eql?(SecureKeys::Globals.default_key_delimiter)
-      puts "🔔 You're using a custom key access identifier '#{SecureKeys::Globals.key_access_identifier}'" unless SecureKeys::Globals.key_access_identifier.eql?(SecureKeys::Globals.default_key_access_identifier)
-
-      # Configure cipher
-      self.cipher = SecureKeys::OpenSSL::Cipher.new
-
-      # Configure the secret source based on the environment
-      if SecureKeys::Globals.ci?
-        self.secrets_source = SecureKeys::Core::Environment::CI.new
-      else
-        self.secrets_source = SecureKeys::Core::Environment::Keychain.new
-      end
-
-      # Define the keys that we want to map
-      self.secret_keys = secrets_source.fetch(key: SecureKeys::Globals.key_access_identifier)
-                                       .to_s
-                                       .split(SecureKeys::Globals.key_delimiter)
-                                       .map(&:strip)
-
-      # Add the keys that we want to map
-      self.mapped_keys = secret_keys.map do |key|
-        encrypted_data = cipher.encrypt(value: secrets_source.fetch(key:))
-        # Convert the first key chart to downcase
-        key[0] = key[0].downcase
-        { name: key, **encrypted_data }
-      end
-    end
-
-    def setup
-      pre_actions
-
-      package = SecureKeys::Swift::Package.new
-      package.generate
-
-      writer = SecureKeys::Swift::Writer.new(mapped_keys: mapped_keys,
-                                             secure_key_bytes: cipher.secure_key_bytes)
-      writer.write
-
-      xcframework = SecureKeys::Swift::XCFramework.new
-      xcframework.generate
-
-      post_actions
-    end
-
-    private
-
-    def pre_actions
-      # Remove the keys directory
-      system("rm -rf #{SecureKeys::Swift::KEYS_DIRECTORY}")
-    end
-
-    def post_actions
-      # Remove the keys directory
-      system("rm -rf #{SecureKeys::Swift::SWIFT_PACKAGE_DIRECTORY}")
+  def self.run
+    # Configure the argument parser
+    Core::Console::Argument::Parser.new
 
-      # Remove the build directory
-      system("rm -rf #{SecureKeys::Swift::KEYS_DIRECTORY}/#{SecureKeys::Swift::BUILD_DIRECTORY}")
-    end
+    # Generate the keys
+    Core::Generator.new.generate
   end
 end

data/lib/version.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 module SecureKeys
-  VERSION = '1.1.3'.freeze
+  VERSION = '1.1.4'.freeze
   SUMMARY = 'Secure Keys is a simple tool for managing your secret keys'.freeze
   DESCRIPTION = 'Secure Keys is a simple tool to manage your secret keys in your iOS project'.freeze
   HOMEPAGE_URI = 'https://github.com/derian-cordoba/secure-keys'.freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: secure-keys
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Derian Córdoba
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-26 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -230,11 +230,17 @@ extra_rdoc_files: []
 files:
 - "./lib/core/console/arguments/handler.rb"
 - "./lib/core/console/arguments/parser.rb"
+- "./lib/core/console/arguments/xcframework/handler.rb"
+- "./lib/core/console/arguments/xcframework/parser.rb"
 - "./lib/core/console/logger.rb"
 - "./lib/core/console/shell.rb"
 - "./lib/core/environment/ci.rb"
 - "./lib/core/environment/keychain.rb"
+- "./lib/core/generator.rb"
 - "./lib/core/globals/globals.rb"
+- "./lib/core/utils/extensions/kernel.rb"
+- "./lib/core/utils/extensions/string/camelize.rb"
+- "./lib/core/utils/extensions/string/to_bool.rb"
 - "./lib/core/utils/openssl/cipher.rb"
 - "./lib/core/utils/swift/package.rb"
 - "./lib/core/utils/swift/swift.rb"